WPrefs.app/Menu.c

   1 /* Menu.c- menu definition
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 1998 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #include "WPrefs.h"
  25 #include <assert.h>
  26 #include <ctype.h>
  27
  28 #include <X11/keysym.h>
  29
  30 typedef struct _Panel {
  31     WMFrame *frame;
  32     char *sectionName;
  33
  34     CallbackRec callbacks;
  35     WMWindow *win;
  36
  37     WMPopUpButton *cmd1P;
  38     WMPopUpButton *cmd2P;
  39
  40     WMTextField *tit1T;
  41     WMTextField *tit2T;
  42
  43     WMBrowser *browser;
  44
  45     WMFrame *labF;
  46     WMTextField *labT;
  47
  48     WMFrame *cmdF;
  49     WMPopUpButton *cmdP;
  50
  51     WMButton *noconfirmB;
  52
  53     WMFrame *proF;
  54     WMTextField *proT;
  55     WMLabel *infoL;
  56
  57     WMFrame *pathF;
  58     WMTextField *pathT;
  59     WMLabel *pathL;
  60
  61     WMFrame *shoF;
  62     WMTextField *shoT;
  63     WMButton *shoB;
  64
  65     WMButton *guruB;
  66
  67     /**/
  68     proplist_t menu;
  69     proplist_t editedItem;
  70
  71     proplist_t itemClipboard;          /* for copy/paste */
  72
  73     char capturing;                    /* shortcut capture */
  74     char unsaved;                      /* if there are unsaved changes */
  75     char dontSave;
  76 } _Panel;
  77
  78
  79
  80 #define ICON_FILE       "menus"
  81
  82
  83
  84 extern char *OpenMenuGuru(WMWindow *mainWindow);
  85
  86
  87
  88
  89 /* must match the indexes of the commands popup */
  90 enum {
  91     CAddCommand = 0,
  92         CAddSubmenu = 1,
  93         CAddExternal = 2,
  94         CAddWorkspace = 3,
  95         CRemove = 4,
  96         CCut = 5,
  97         CCopy = 6,
  98         CPaste = 7
  99 };
 100
 101
 102 enum {
 103     CpExec = 0,
 104         CpArrange = 1,
 105         CpHide = 2,
 106         CpShow = 3,
 107         CpExit = 4,
 108         CpShutdown = 5,
 109         CpRestart = 6,
 110         CpRestartWM = 7,
 111         CpSaveSession = 8,
 112         CpClearSession = 9,
 113         CpRefresh = 10,
 114         CpInfo = 11,
 115         CpLegal = 12
 116 };
 117
 118 enum {
 119     TNothing,
 120         TExec,
 121         TSimpleCommand,
 122         TRestart,
 123         TRestartWM,
 124         TExit,
 125         TExternalMenu,
 126         TWSMenu
 127 };
 128
 129
 130
 131 static void showData(_Panel *panel);
 132
 133
 134 static Bool
 135 isMenu(proplist_t item)
 136 {
 137     if (PLGetNumberOfElements(item)==1)
 138         return True;
 139
 140     return PLIsArray(PLGetArrayElement(item, 1));
 141 }
 142
 143
 144 static void
 145 splitOpenMenuParameter(char *str, char **dirs, char **prog)
 146 {
 147     char *p;
 148
 149     if (!(p = strstr(str, " WITH "))) {
 150         *dirs = wstrdup(str);
 151         *prog = NULL;
 152     } else {
 153         int i, j;
 154
 155         i = strlen(str);
 156         j = strlen(p);
 157         *dirs = wmalloc(i-j+1);
 158         strncpy(*dirs, str, i-j+1);
 159         (*dirs)[i-j] = 0;
 160
 161         p += 6;
 162         while (isspace(*p)) p++;
 163         if (*p!=0) {
 164             *prog = wmalloc(j);
 165             strcpy(*prog, p);
 166         } else {
 167             *prog = NULL;
 168         }
 169     }
 170 }
 171
 172
 173 static void
 174 changeItemTitle(proplist_t item, char *title)
 175 {
 176     proplist_t tmp;
 177
 178     tmp = PLGetArrayElement(item, 0);
 179     PLRelease(tmp);
 180     PLRemoveArrayElement(item, 0);
 181     PLInsertArrayElement(item, title?PLMakeString(title):PLMakeString(""), 0);
 182 }
 183
 184
 185 static void
 186 removeParameter(proplist_t item)
 187 {
 188     proplist_t tmp;
 189     int index;
 190
 191     if (strcmp(PLGetString(PLGetArrayElement(item, 1)), "SHORTCUT")==0) {
 192         index = 4;
 193     } else {
 194         index = 2;
 195     }
 196     tmp = PLGetArrayElement(item, index);
 197     PLRemoveArrayElement(item, index);
 198     if (tmp)
 199         PLRelease(tmp);
 200 }
 201
 202
 203 static void
 204 changeItemParameter(proplist_t item, char *param)
 205 {
 206     proplist_t tmp;
 207     int index;
 208
 209     if (strcmp(PLGetString(PLGetArrayElement(item, 1)), "SHORTCUT")==0) {
 210         index = 4;
 211     } else {
 212         index = 2;
 213     }
 214     tmp = PLGetArrayElement(item, index);
 215     PLRemoveArrayElement(item, index);
 216     PLRelease(tmp);
 217     tmp = param?PLMakeString(param):PLMakeString("");
 218     PLInsertArrayElement(item, tmp, index);
 219 }
 220
 221
 222 static void
 223 changeItemShortcut(proplist_t item, char *shortcut)
 224 {
 225     proplist_t tmp;
 226
 227     if (strcmp(PLGetString(PLGetArrayElement(item, 1)), "SHORTCUT")==0) {
 228         if (shortcut) {
 229             tmp = PLGetArrayElement(item, 2);
 230             PLRemoveArrayElement(item, 2);
 231             PLRelease(tmp);
 232             PLInsertArrayElement(item, PLMakeString(shortcut), 2);
 233         } else {
 234             /* remove SHORTCUT keyword */
 235             tmp = PLGetArrayElement(item, 1);
 236             PLRemoveArrayElement(item, 1);
 237             PLRelease(tmp);
 238             /* remove the shortcut */
 239             tmp = PLGetArrayElement(item, 1);
 240             PLRemoveArrayElement(item, 1);
 241             PLRelease(tmp);
 242         }
 243     } else {
 244         if (shortcut) {
 245             PLInsertArrayElement(item, PLMakeString("SHORTCUT"), 1);
 246             PLInsertArrayElement(item, PLMakeString(shortcut), 2);
 247         } else {
 248             /* do nothing */
 249         }
 250     }
 251 }
 252
 253
 254 static void
 255 changeItemCommand(proplist_t item, char *command)
 256 {
 257     proplist_t tmp;
 258
 259     tmp = PLGetArrayElement(item, 1);
 260     if (strcmp(PLGetString(tmp), "SHORTCUT")==0) {
 261         PLRelease(tmp);
 262         PLRemoveArrayElement(item, 3);
 263         PLInsertArrayElement(item, PLMakeString(command), 3);
 264     } else {
 265         PLRelease(tmp);
 266         PLRemoveArrayElement(item, 1);
 267         PLInsertArrayElement(item, PLMakeString(command), 1);
 268     }
 269 }
 270
 271
 272 static char*
 273 getItemTitle(proplist_t item)
 274 {
 275     return PLGetString(PLGetArrayElement(item, 0));
 276 }
 277
 278
 279 static char*
 280 getItemParameter(proplist_t item)
 281 {
 282     proplist_t tmp;
 283
 284     tmp = PLGetArrayElement(item, 1);
 285     if (strcmp(PLGetString(tmp), "SHORTCUT")==0) {
 286         tmp = PLGetArrayElement(item, 4);
 287         return tmp ? PLGetString(tmp) : NULL;
 288     } else {
 289         tmp = PLGetArrayElement(item, 2);
 290         return tmp ? PLGetString(tmp) : NULL;
 291     }
 292 }
 293
 294
 295
 296 static char*
 297 getItemShortcut(proplist_t item)
 298 {
 299     proplist_t tmp;
 300
 301     tmp = PLGetArrayElement(item, 1);
 302     if (strcmp(PLGetString(tmp), "SHORTCUT")==0) {
 303         return PLGetString(PLGetArrayElement(item, 2));
 304     } else {
 305         return NULL;
 306     }
 307 }
 308
 309
 310
 311 static char*
 312 getItemCommand(proplist_t item)
 313 {
 314     proplist_t tmp;
 315     char *str;
 316
 317     tmp = PLGetArrayElement(item, 1);
 318     if (!tmp)
 319         return "";
 320     if (strcmp(PLGetString(tmp), "SHORTCUT")==0) {
 321         str = PLGetString(PLGetArrayElement(item,3));
 322     } else {
 323         str = PLGetString(tmp);
 324     }
 325     return str;
 326 }
 327
 328
 329 static void
 330 updateForItemType(_Panel *panel, int type)
 331 {
 332     if (type==TNothing) {
 333         WMUnmapWidget(panel->labF);
 334     } else {
 335         WMMapWidget(panel->labF);
 336     }
 337     if (type==TExternalMenu || type==TNothing) {
 338         WMUnmapWidget(panel->cmdF);
 339     } else {
 340         WMMapWidget(panel->cmdF);
 341     }
 342     if (type==TNothing || type==TWSMenu || type==TExternalMenu) {
 343         WMUnmapWidget(panel->shoF);
 344     } else {
 345         WMMapWidget(panel->shoF);
 346     }
 347     if (type==TExec || type==TRestart || type==TExternalMenu) {
 348         WMMapWidget(panel->proF);
 349     } else {
 350         WMUnmapWidget(panel->proF);
 351     }
 352     if (type==TExternalMenu) {
 353         WMMapWidget(panel->pathF);
 354     } else {
 355         WMUnmapWidget(panel->pathF);
 356     }
 357     if (type==TExit) {
 358         WMMapWidget(panel->noconfirmB);
 359     } else {
 360         WMUnmapWidget(panel->noconfirmB);
 361     }
 362     if (type==TWSMenu) {
 363         WMMapWidget(panel->infoL);
 364     } else {
 365         WMUnmapWidget(panel->infoL);
 366     }
 367     if (type==TExternalMenu) {
 368         WMMapWidget(panel->guruB);
 369     } else {
 370         WMUnmapWidget(panel->guruB);
 371     }
 372     if (type == TRestart) {
 373         WMSetFrameTitle(panel->proF, _("Window Manager"));
 374     } else if (type == TExternalMenu) {
 375         WMSetFrameTitle(panel->proF, _("Program to open files"));
 376     } else {
 377         WMSetFrameTitle(panel->proF, _("Program to Run"));
 378     }
 379 }
 380
 381
 382 proplist_t
 383 getItemOfSelectedEntry(WMBrowser *bPtr)
 384 {
 385     proplist_t item;
 386     proplist_t menu;
 387     int i;
 388
 389     i = WMGetBrowserSelectedColumn(bPtr);
 390     menu = (proplist_t)WMGetHangedData(WMGetBrowserListInColumn(bPtr, i));
 391
 392     i = WMGetBrowserSelectedRowInColumn(bPtr, i);
 393     item = PLGetArrayElement(menu, i+1);
 394
 395     return item;
 396 }
 397
 398
 399 static void
 400 performCommand(WMWidget *w, void *data)
 401 {
 402     _Panel *panel = (_Panel*)data;
 403     WMPopUpButton *pop = (WMPopUpButton*)w;
 404     proplist_t menuItem = NULL;
 405     proplist_t menu;
 406     int column;
 407     int row;
 408     static int cmdIndex=0;
 409     WMList *list;
 410     char *title = NULL;
 411
 412     column = WMGetBrowserFirstVisibleColumn(panel->browser);
 413     if (pop == panel->cmd2P) {
 414         column++;
 415     }
 416
 417     if (column >= WMGetBrowserNumberOfColumns(panel->browser))
 418         return;
 419
 420     list = WMGetBrowserListInColumn(panel->browser, column);
 421     menu = WMGetHangedData(list);
 422
 423     row = WMGetBrowserSelectedRowInColumn(panel->browser, column);
 424
 425     switch (WMGetPopUpButtonSelectedItem(pop)) {
 426      case CAddCommand:
 427         title = wmalloc(strlen(_("New Command %i"))+6);
 428         sprintf(title, _("New Command %i"), cmdIndex++);
 429         menuItem = PLMakeArrayFromElements(PLMakeString(title),
 430                                            PLMakeString("EXEC"),
 431                                            PLMakeString(""),
 432                                            NULL);
 433         break;
 434      case CAddSubmenu:
 435         title = wstrdup(_("New Submenu"));
 436         menuItem = PLMakeArrayFromElements(PLMakeString(title),
 437                                            NULL);
 438         break;
 439      case CAddExternal:
 440         title = wstrdup(_("External Menu"));
 441         menuItem = PLMakeArrayFromElements(PLMakeString(title),
 442                                            PLMakeString("OPEN_MENU"),
 443                                            PLMakeString(""),
 444                                            NULL);
 445         break;
 446      case CAddWorkspace:
 447         title = wstrdup(_("Workspaces"));
 448         menuItem = PLMakeArrayFromElements(PLMakeString(title),
 449                                            PLMakeString("WORKSPACE_MENU"),
 450                                            NULL);
 451         WMSetPopUpButtonItemEnabled(panel->cmd1P, CAddWorkspace, False);
 452         WMSetPopUpButtonItemEnabled(panel->cmd2P, CAddWorkspace, False);
 453         break;
 454      case CRemove:
 455         if (row < 0)
 456             return;
 457         WMRemoveBrowserItem(panel->browser, column, row);
 458         menuItem = PLGetArrayElement(menu, row+1);
 459         if (strcmp(getItemCommand(menuItem), "WORKSPACE_MENU")==0) {
 460             WMSetPopUpButtonItemEnabled(panel->cmd1P, CAddWorkspace, True);
 461             WMSetPopUpButtonItemEnabled(panel->cmd2P, CAddWorkspace, True);
 462         }
 463         PLRemoveArrayElement(menu, row+1);
 464         PLRelease(menuItem);
 465         updateForItemType(panel, TNothing);
 466         panel->editedItem = NULL;
 467         panel->unsaved = 1;
 468         return;
 469      case CCut:
 470         if (row < 0)
 471             return;
 472         if (panel->itemClipboard
 473             && strcmp(getItemCommand(panel->itemClipboard), "WORKSPACE_MENU")==0){
 474             WMSetPopUpButtonItemEnabled(panel->cmd1P, CAddWorkspace, True);
 475             WMSetPopUpButtonItemEnabled(panel->cmd2P, CAddWorkspace, True);
 476         }
 477         if (panel->itemClipboard)
 478             PLRelease(panel->itemClipboard);
 479
 480         WMRemoveBrowserItem(panel->browser, column, row);
 481         menuItem = PLGetArrayElement(menu, row+1);
 482         PLRemoveArrayElement(menu, row+1);
 483         updateForItemType(panel, TNothing);
 484
 485         panel->itemClipboard = menuItem;
 486
 487         WMSetPopUpButtonItemEnabled(panel->cmd1P, CPaste, True);
 488         WMSetPopUpButtonItemEnabled(panel->cmd2P, CPaste, True);
 489         panel->unsaved = 1;
 490         return;
 491      case CCopy:
 492         if (row < 0)
 493             return;
 494         if (panel->itemClipboard
 495             && strcmp(getItemCommand(panel->itemClipboard), "WORKSPACE_MENU")==0){
 496             WMSetPopUpButtonItemEnabled(panel->cmd1P, CAddWorkspace, True);
 497             WMSetPopUpButtonItemEnabled(panel->cmd2P, CAddWorkspace, True);
 498         }
 499         if (panel->itemClipboard)
 500             PLRelease(panel->itemClipboard);
 501         panel->itemClipboard = NULL;
 502         menuItem = PLGetArrayElement(menu, row+1);
 503         if (strcmp(getItemCommand(menuItem), "WORKSPACE_MENU")==0)
 504             return;
 505         panel->itemClipboard = PLDeepCopy(menuItem);
 506
 507         WMSetPopUpButtonItemEnabled(panel->cmd1P, CPaste, True);
 508         WMSetPopUpButtonItemEnabled(panel->cmd2P, CPaste, True);
 509         return;
 510      case CPaste:
 511         menuItem = panel->itemClipboard;
 512         title = wstrdup(getItemTitle(menuItem));
 513         panel->itemClipboard = NULL;
 514         WMSetPopUpButtonItemEnabled(panel->cmd1P, CPaste, False);
 515         WMSetPopUpButtonItemEnabled(panel->cmd2P, CPaste, False);
 516         break;
 517     }
 518
 519     if (row>=0) row++;
 520     WMInsertBrowserItem(panel->browser, column, row, title, isMenu(menuItem));
 521     if (row<0)
 522         PLAppendArrayElement(menu, menuItem);
 523     else
 524         PLInsertArrayElement(menu, menuItem, row+1);
 525     free(title);
 526     panel->unsaved = 1;
 527 }
 528
 529
 530 static void
 531 browserClick(WMWidget *w, void *data)
 532 {
 533     _Panel *panel = (_Panel*)data;
 534     proplist_t item;
 535     char *command;
 536
 537     /* stop shortcut capture */
 538     panel->capturing = 0;
 539
 540     item = getItemOfSelectedEntry(panel->browser);
 541
 542     panel->editedItem = item;
 543
 544     /* set title */
 545     WMSetTextFieldText(panel->labT, getItemTitle(item));
 546
 547     if (isMenu(item)) {
 548         updateForItemType(panel, TNothing);
 549
 550         WMSetPopUpButtonEnabled(panel->cmd2P, True);
 551         return;
 552     } else {
 553         int column = WMGetBrowserSelectedColumn(panel->browser);
 554
 555         if (column == WMGetBrowserNumberOfColumns(panel->browser)-1
 556             && column > 0)
 557             WMSetPopUpButtonEnabled(panel->cmd2P, True);
 558         else
 559             WMSetPopUpButtonEnabled(panel->cmd2P, False);
 560
 561         if (column==WMGetBrowserFirstVisibleColumn(panel->browser)) {
 562             /* second column is empty, because selected item is not a submenu */
 563             WMSetTextFieldText(panel->tit2T, NULL);
 564         }
 565     }
 566
 567     command = getItemCommand(item);
 568
 569     WMSetTextFieldText(panel->shoT, getItemShortcut(item));
 570
 571     if (strcmp(command, "OPEN_MENU")==0) {
 572         char *p, *c;
 573
 574         splitOpenMenuParameter(getItemParameter(item), &p, &c);
 575         WMSetTextFieldText(panel->pathT, p);
 576         WMSetTextFieldText(panel->proT, c);
 577         if (p)
 578             free(p);
 579         if (c)
 580             free(c);
 581         updateForItemType(panel, TExternalMenu);
 582     } else if (strcmp(command, "EXEC")==0) {
 583         WMSetTextFieldText(panel->proT, getItemParameter(item));
 584         WMSetPopUpButtonSelectedItem(panel->cmdP, CpExec);
 585         updateForItemType(panel, TExec);
 586     } else if (strcmp(command, "WORKSPACE_MENU")==0) {
 587         updateForItemType(panel, TWSMenu);
 588     } else if (strcmp(command, "EXIT")==0) {
 589         WMSetPopUpButtonSelectedItem(panel->cmdP, CpExit);
 590         updateForItemType(panel, TExit);
 591     } else if (strcmp(command, "SHUTDOWN")==0) {
 592         WMSetPopUpButtonSelectedItem(panel->cmdP, CpShutdown);
 593         updateForItemType(panel, TExit);
 594     } else if (strcmp(command, "RESTARTW")==0) {
 595         WMSetPopUpButtonSelectedItem(panel->cmdP, CpRestartWM);
 596         updateForItemType(panel, TRestartWM);
 597     } else if (strcmp(command, "RESTART")==0) {
 598         WMSetPopUpButtonSelectedItem(panel->cmdP, CpRestart);
 599         WMSetTextFieldText(panel->proT, getItemParameter(item));
 600         updateForItemType(panel, TRestart);
 601     } else {
 602         /* simple commands */
 603         if (strcmp(command, "ARRANGE_ICONS")==0)
 604             WMSetPopUpButtonSelectedItem(panel->cmdP, CpArrange);
 605         else if (strcmp(command, "HIDE_OTHERS")==0)
 606             WMSetPopUpButtonSelectedItem(panel->cmdP, CpHide);
 607         else if (strcmp(command, "SHOW_ALL")==0)
 608             WMSetPopUpButtonSelectedItem(panel->cmdP, CpShow);
 609         else if (strcmp(command, "SAVE_SESSION")==0)
 610             WMSetPopUpButtonSelectedItem(panel->cmdP, CpSaveSession);
 611         else if (strcmp(command, "CLEAR_SESSION")==0)
 612             WMSetPopUpButtonSelectedItem(panel->cmdP, CpClearSession);
 613         else if (strcmp(command, "REFRESH")==0)
 614             WMSetPopUpButtonSelectedItem(panel->cmdP, CpRefresh);
 615         else if (strcmp(command, "INFO_PANEL")==0)
 616             WMSetPopUpButtonSelectedItem(panel->cmdP, CpInfo);
 617         else if (strcmp(command, "LEGAL_PANEL")==0)
 618             WMSetPopUpButtonSelectedItem(panel->cmdP, CpLegal);
 619         updateForItemType(panel, TSimpleCommand);
 620     }
 621 }
 622
 623
 624 static void
 625 fillBrowserColumn(WMBrowser *bPtr, int column)
 626 {
 627     _Panel *panel = (_Panel*)WMGetHangedData(bPtr);
 628     proplist_t menuItem;
 629     proplist_t menuList = NULL;
 630     int i;
 631
 632     if (column > 0) {
 633         menuList = getItemOfSelectedEntry(panel->browser);
 634         if (column > WMGetBrowserFirstVisibleColumn(bPtr))
 635             WMSetTextFieldText(panel->tit2T, getItemTitle(menuList));
 636         else
 637             WMSetTextFieldText(panel->tit1T, getItemTitle(menuList));
 638     } else {
 639         WMSetTextFieldText(panel->tit1T, getItemTitle(panel->menu));
 640         menuList = panel->menu;
 641     }
 642
 643     WMHangData(WMGetBrowserListInColumn(bPtr, column), menuList);
 644     for (i=1; i<PLGetNumberOfElements(menuList); i++) {
 645         menuItem = PLGetArrayElement(menuList, i);
 646         WMInsertBrowserItem(bPtr, column, -1, getItemTitle(menuItem),
 647                             isMenu(menuItem));
 648     }
 649 }
 650
 651
 652
 653
 654 static void
 655 changedItem(void *observerData, WMNotification *notification)
 656 {
 657     _Panel *panel = (_Panel*)observerData;
 658     WMTextField *t = (WMTextField*)WMGetNotificationObject(notification);
 659     proplist_t item = panel->editedItem;
 660     WMList *list;
 661     WMListItem *litem;
 662     char *command;
 663     char *str;
 664
 665     if (!item)
 666         return;
 667
 668     panel->unsaved = 1;
 669     if (!isMenu(item)) {
 670         command = getItemCommand(item);
 671
 672         if (t == panel->shoT) {
 673             str = WMGetTextFieldText(t);
 674             if (strlen(str)==0) {
 675                 free(str);
 676                 str = NULL;
 677             }
 678             changeItemShortcut(item, str);
 679             if (str)
 680                 free(str);
 681         } else if (t == panel->labT) {
 682             int column;
 683
 684             str = WMGetTextFieldText(t);
 685             if (!str)
 686                 str = wstrdup("");
 687             changeItemTitle(item, str);
 688             column = WMGetBrowserSelectedColumn(panel->browser);
 689             list = WMGetBrowserListInColumn(panel->browser, column);
 690             litem = WMGetListSelectedItem(list);
 691
 692             free(litem->text);
 693             litem->text = str;
 694
 695             WMRedisplayWidget(list);
 696         } else if (strcmp(command, "EXEC")==0
 697                    || strcmp(command, "RESTART")==0) {
 698             if (t == panel->proT) {
 699                 str = WMGetTextFieldText(t);
 700
 701                 changeItemParameter(item, str);
 702
 703                 free(str);
 704             }
 705         } else if (strcmp(command, "OPEN_MENU")==0) {
 706             char *text;
 707             char *str2;
 708
 709             str = WMGetTextFieldText(panel->pathT);
 710             str2 = WMGetTextFieldText(panel->proT);
 711             text = wmalloc(strlen(str)+strlen(str2)+16);
 712             strcpy(text, str);
 713             free(str);
 714             if (strlen(str2)>0) {
 715                 strcat(text, " WITH ");
 716                 strcat(text, str2);
 717             }
 718             free(str2);
 719             changeItemParameter(item, text);
 720             free(text);
 721         }
 722     }
 723 }
 724
 725
 726 static void
 727 changedTitle(void *observerData, WMNotification *notification)
 728 {
 729     _Panel *panel = (_Panel*)observerData;
 730     WMTextField *t = (WMTextField*)WMGetNotificationObject(notification);
 731     proplist_t menu;
 732     WMList *list;
 733     int column;
 734     char *txt;
 735
 736     column = WMGetBrowserFirstVisibleColumn(panel->browser);
 737     if (panel->tit2T == t)
 738         column++;
 739
 740     list = WMGetBrowserListInColumn(panel->browser, column);
 741     if (!list) {
 742         return;
 743     }
 744
 745     menu = (proplist_t)WMGetHangedData(list);
 746
 747     txt = WMGetTextFieldText(t);
 748     changeItemTitle(menu, txt);
 749
 750     if (column > 0) {
 751         WMListItem *litem;
 752
 753         list = WMGetBrowserListInColumn(panel->browser, column-1);
 754         litem = WMGetListSelectedItem(list);
 755
 756         free(litem->text);
 757         litem->text = txt;
 758
 759         WMRedisplayWidget(list);
 760     } else {
 761         free(txt);
 762     }
 763     panel->unsaved = 1;
 764 }
 765
 766
 767 static void
 768 changedCommand(WMWidget *w, void *data)
 769 {
 770     _Panel *panel = (_Panel*)data;
 771     int i;
 772     char *tmp;
 773
 774     panel->unsaved = 1;
 775     i = WMGetPopUpButtonSelectedItem(panel->cmdP);
 776     changeItemParameter(panel->editedItem, "");
 777     switch (i) {
 778      case CpExec:
 779         if (strcmp(getItemCommand(panel->editedItem), "EXEC")!=0) {
 780             changeItemCommand(panel->editedItem, "EXEC");
 781             tmp = WMGetTextFieldText(panel->proT);
 782             changeItemParameter(panel->editedItem, tmp);
 783             free(tmp);
 784             updateForItemType(panel, TExec);
 785         }
 786         break;
 787      case CpArrange:
 788         if (strcmp(getItemCommand(panel->editedItem), "ARRANGE_ICONS")!=0) {
 789             changeItemCommand(panel->editedItem, "ARRANGE_ICONS");
 790             updateForItemType(panel, TSimpleCommand);
 791         }
 792         break;
 793      case CpHide:
 794         if (strcmp(getItemCommand(panel->editedItem), "HIDE_OTHERS")!=0) {
 795             changeItemCommand(panel->editedItem, "HIDE_OTHERS");
 796             updateForItemType(panel, TSimpleCommand);
 797         }
 798         break;
 799      case CpShow:
 800         if (strcmp(getItemCommand(panel->editedItem), "SHOW_ALL")!=0) {
 801             changeItemCommand(panel->editedItem, "SHOW_ALL");
 802             updateForItemType(panel, TSimpleCommand);
 803         }
 804         break;
 805      case CpExit:
 806         if (strcmp(getItemCommand(panel->editedItem), "EXIT")!=0) {
 807             changeItemCommand(panel->editedItem, "EXIT");
 808             updateForItemType(panel, TExit);
 809         }
 810         /* fall through */
 811      case CpShutdown:
 812         if (strcmp(getItemCommand(panel->editedItem), "SHUTDOWN")!=0) {
 813             changeItemCommand(panel->editedItem, "SHUTDOWN");
 814             updateForItemType(panel, TExit);
 815         }
 816         if (WMGetButtonSelected(panel->noconfirmB))
 817             changeItemParameter(panel->editedItem, "QUICK");
 818         else
 819             changeItemParameter(panel->editedItem, "");
 820         break;
 821      case CpRestartWM:
 822         changeItemCommand(panel->editedItem, "RESTARTW");
 823         updateForItemType(panel, TRestartWM);
 824         break;
 825      case CpRestart:
 826         changeItemCommand(panel->editedItem, "RESTART");
 827         updateForItemType(panel, TRestart);
 828         tmp = WMGetTextFieldText(panel->proT);
 829         changeItemParameter(panel->editedItem, tmp);
 830         free(tmp);
 831         break;
 832      case CpSaveSession:
 833         if (strcmp(getItemCommand(panel->editedItem), "SAVE_SESSION")!=0) {
 834             changeItemCommand(panel->editedItem, "SAVE_SESSION");
 835             updateForItemType(panel, TSimpleCommand);
 836         }
 837         break;
 838      case CpClearSession:
 839         if (strcmp(getItemCommand(panel->editedItem), "CLEAR_SESSION")!=0) {
 840             changeItemCommand(panel->editedItem, "CLEAR_SESSION");
 841             updateForItemType(panel, TSimpleCommand);
 842         }
 843         break;
 844      case CpRefresh:
 845         if (strcmp(getItemCommand(panel->editedItem), "REFRESH")!=0) {
 846             changeItemCommand(panel->editedItem, "REFRESH");
 847             updateForItemType(panel, TSimpleCommand);
 848         }
 849         break;
 850      case CpInfo:
 851         if (strcmp(getItemCommand(panel->editedItem), "INFO_PANEL")!=0) {
 852             changeItemCommand(panel->editedItem, "INFO_PANEL");
 853             updateForItemType(panel, TSimpleCommand);
 854         }
 855         break;
 856      case CpLegal:
 857         if (strcmp(getItemCommand(panel->editedItem), "LEGAL_PANEL")!=0) {
 858             changeItemCommand(panel->editedItem, "LEGAL_PANEL");
 859             updateForItemType(panel, TSimpleCommand);
 860         }
 861         break;
 862     }
 863 }
 864
 865
 866
 867
 868
 869 static char*
 870 captureShortcut(Display *dpy, _Panel *panel)
 871 {
 872     XEvent ev;
 873     KeySym ksym;
 874     char buffer[64];
 875     char *key = NULL;
 876
 877     while (panel->capturing) {
 878         XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
 879         WMNextEvent(dpy, &ev);
 880         if (ev.type==KeyPress && ev.xkey.keycode!=0) {
 881             ksym = XKeycodeToKeysym(dpy, ev.xkey.keycode, 0);
 882             if (!IsModifierKey(ksym)) {
 883                 key=XKeysymToString(ksym);
 884                 panel->capturing = 0;
 885                 break;
 886             }
 887         }
 888         WMHandleEvent(&ev);
 889     }
 890
 891     if (!key)
 892         return NULL;
 893
 894     buffer[0] = 0;
 895
 896     if (ev.xkey.state & ControlMask) {
 897         strcat(buffer, "Control+");
 898     }
 899     if (ev.xkey.state & ShiftMask) {
 900         strcat(buffer, "Shift+");
 901     }
 902     if (ev.xkey.state & Mod1Mask) {
 903         strcat(buffer, "Mod1+");
 904     }
 905     if (ev.xkey.state & Mod2Mask) {
 906         strcat(buffer, "Mod2+");
 907     }
 908     if (ev.xkey.state & Mod3Mask) {
 909         strcat(buffer, "Mod3+");
 910     }
 911     if (ev.xkey.state & Mod4Mask) {
 912         strcat(buffer, "Mod4+");
 913     }
 914     if (ev.xkey.state & Mod5Mask) {
 915         strcat(buffer, "Mod5+");
 916     }
 917     strcat(buffer, key);
 918
 919     return wstrdup(buffer);
 920 }
 921
 922
 923 static void
 924 captureClick(WMWidget *w, void *data)
 925 {
 926     _Panel *panel = (_Panel*)data;
 927     Display *dpy = WMScreenDisplay(WMWidgetScreen(panel->win));
 928     char *shortcut;
 929
 930     if (!panel->capturing) {
 931         panel->capturing = 1;
 932         WMSetButtonText(w, _("Cancel"));
 933         XGrabKeyboard(dpy, WMWidgetXID(panel->win), True, GrabModeAsync,
 934                       GrabModeAsync, CurrentTime);
 935         shortcut = captureShortcut(dpy, panel);
 936         if (shortcut) {
 937             WMSetTextFieldText(panel->shoT, shortcut);
 938             changeItemShortcut(panel->editedItem, shortcut);
 939             panel->unsaved = 1;
 940         }
 941         free(shortcut);
 942     }
 943     panel->capturing = 0;
 944     WMSetButtonText(w, _("Capture"));
 945     XUngrabKeyboard(dpy, CurrentTime);
 946 }
 947
 948
 949
 950 static void
 951 scrolledBrowser(void *observerData, WMNotification *notification)
 952 {
 953     _Panel *panel = (_Panel*)observerData;
 954     int column;
 955     WMList *list;
 956     proplist_t item;
 957
 958     column = WMGetBrowserFirstVisibleColumn(panel->browser);
 959
 960     list = WMGetBrowserListInColumn(panel->browser, column);
 961     item = WMGetHangedData(list);
 962     WMSetTextFieldText(panel->tit1T, getItemTitle(item));
 963
 964     list = WMGetBrowserListInColumn(panel->browser, column+1);
 965     if (list) {
 966         item = WMGetHangedData(list);
 967         WMSetTextFieldText(panel->tit2T, getItemTitle(item));
 968     }
 969 }
 970
 971
 972 static void
 973 confirmClicked(WMWidget *w, void *data)
 974 {
 975     _Panel *panel = (_Panel*)data;
 976
 977     if (WMGetButtonSelected(panel->noconfirmB)) {
 978         changeItemParameter(panel->editedItem, "QUICK");
 979     } else {
 980         changeItemParameter(panel->editedItem, "");
 981     }
 982     panel->unsaved = 1;
 983 }
 984
 985
 986
 987 static void
 988 openGuru(WMWidget *w, void *data)
 989 {
 990     _Panel *panel = (_Panel*)data;
 991     char *def;
 992     char *path, *cmd;
 993
 994     def = OpenMenuGuru(GetWindow(panel));
 995     if (def) {
 996         changeItemParameter(panel->editedItem, def);
 997         splitOpenMenuParameter(def, &path, &cmd);
 998         free(def);
 999         WMSetTextFieldText(panel->pathT, path);
1000         if (path)
1001             free(path);
1002
1003         WMSetTextFieldText(panel->proT, cmd);
1004         if (cmd)
1005             free(cmd);
1006         panel->unsaved = 1;
1007     }
1008 }
1009
1010
1011 static void
1012 createPanel(_Panel *p)
1013 {
1014     _Panel *panel = (_Panel*)p;
1015
1016
1017     panel->frame = WMCreateFrame(panel->win);
1018     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
1019     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
1020
1021     panel->cmd1P = WMCreatePopUpButton(panel->frame);
1022     WMSetPopUpButtonAction(panel->cmd1P, performCommand, panel);
1023     WMResizeWidget(panel->cmd1P, 144, 20);
1024     WMMoveWidget(panel->cmd1P, 15, 15);
1025     WMSetPopUpButtonPullsDown(panel->cmd1P, True);
1026     WMSetPopUpButtonText(panel->cmd1P, _("Commands"));
1027     WMAddPopUpButtonItem(panel->cmd1P, _("Add Command"));
1028     WMAddPopUpButtonItem(panel->cmd1P, _("Add Submenu"));
1029     WMAddPopUpButtonItem(panel->cmd1P, _("Add External Menu"));
1030     WMAddPopUpButtonItem(panel->cmd1P, _("Add Workspace Menu"));
1031     WMAddPopUpButtonItem(panel->cmd1P, _("Remove Item"));
1032     WMAddPopUpButtonItem(panel->cmd1P, _("Cut Item"));
1033     WMAddPopUpButtonItem(panel->cmd1P, _("Copy Item"));
1034     WMAddPopUpButtonItem(panel->cmd1P, _("Paste Item"));
1035
1036     panel->cmd2P = WMCreatePopUpButton(panel->frame);
1037     WMSetPopUpButtonAction(panel->cmd2P, performCommand, panel);
1038     WMResizeWidget(panel->cmd2P, 144, 20);
1039     WMMoveWidget(panel->cmd2P, 164, 15);
1040     WMSetPopUpButtonPullsDown(panel->cmd2P, True);
1041     WMSetPopUpButtonText(panel->cmd2P, _("Commands"));
1042     WMAddPopUpButtonItem(panel->cmd2P, _("Add Command"));
1043     WMAddPopUpButtonItem(panel->cmd2P, _("Add Submenu"));
1044     WMAddPopUpButtonItem(panel->cmd2P, _("Add External Menu"));
1045     WMAddPopUpButtonItem(panel->cmd2P, _("Add Workspace Menu"));
1046     WMAddPopUpButtonItem(panel->cmd2P, _("Remove Item"));
1047     WMAddPopUpButtonItem(panel->cmd2P, _("Cut Item"));
1048     WMAddPopUpButtonItem(panel->cmd2P, _("Copy Item"));
1049     WMAddPopUpButtonItem(panel->cmd2P, _("Paste Item"));
1050
1051     panel->tit1T = WMCreateTextField(panel->frame);
1052     WMResizeWidget(panel->tit1T, 144, 20);
1053     WMMoveWidget(panel->tit1T, 15, 40);
1054     WMAddNotificationObserver(changedTitle, panel, WMTextDidChangeNotification,
1055                               panel->tit1T);
1056
1057     panel->tit2T = WMCreateTextField(panel->frame);
1058     WMResizeWidget(panel->tit2T, 144, 20);
1059     WMMoveWidget(panel->tit2T, 164, 40);
1060     WMAddNotificationObserver(changedTitle, panel, WMTextDidChangeNotification,
1061                               panel->tit2T);
1062
1063     panel->browser = WMCreateBrowser(panel->frame);
1064     WMSetBrowserTitled(panel->browser, False);
1065     WMResizeWidget(panel->browser, 295, 160);
1066     WMMoveWidget(panel->browser, 15, 65);
1067     WMSetBrowserFillColumnProc(panel->browser, fillBrowserColumn);
1068     WMHangData(panel->browser, panel);
1069     WMSetBrowserPathSeparator(panel->browser, "\r");
1070     WMSetBrowserAction(panel->browser, browserClick, panel);
1071     WMAddNotificationObserver(scrolledBrowser, panel,
1072                               WMBrowserDidScrollNotification, panel->browser);
1073     /**/
1074
1075     panel->labF = WMCreateFrame(panel->frame);
1076     WMResizeWidget(panel->labF, 190, 50);
1077     WMMoveWidget(panel->labF, 320, 10);
1078     WMSetFrameTitle(panel->labF, _("Label"));
1079
1080     panel->labT = WMCreateTextField(panel->labF);
1081     WMResizeWidget(panel->labT, 170, 20);
1082     WMMoveWidget(panel->labT, 10, 20);
1083     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1084                               panel->labT);
1085
1086     WMMapSubwidgets(panel->labF);
1087
1088     panel->cmdF = WMCreateFrame(panel->frame);
1089     WMResizeWidget(panel->cmdF, 190, 50);
1090     WMMoveWidget(panel->cmdF, 320, 65);
1091     WMSetFrameTitle(panel->cmdF, _("Command"));
1092
1093     panel->cmdP = WMCreatePopUpButton(panel->cmdF);
1094     WMResizeWidget(panel->cmdP, 170, 20);
1095     WMMoveWidget(panel->cmdP, 10, 20);
1096     WMAddPopUpButtonItem(panel->cmdP, _("Run Program"));
1097     WMAddPopUpButtonItem(panel->cmdP, _("Arrange Icons"));
1098     WMAddPopUpButtonItem(panel->cmdP, _("Hide Others"));
1099     WMAddPopUpButtonItem(panel->cmdP, _("Show All Windows"));
1100     WMAddPopUpButtonItem(panel->cmdP, _("Exit WindowMaker"));
1101     WMAddPopUpButtonItem(panel->cmdP, _("Exit X Session"));
1102     WMAddPopUpButtonItem(panel->cmdP, _("Start window manager"));
1103     WMAddPopUpButtonItem(panel->cmdP, _("Restart WindowMaker"));
1104     WMAddPopUpButtonItem(panel->cmdP, _("Save Session"));
1105     WMAddPopUpButtonItem(panel->cmdP, _("Clear Session"));
1106     WMAddPopUpButtonItem(panel->cmdP, _("Refresh Screen"));
1107     WMAddPopUpButtonItem(panel->cmdP, _("Info Panel"));
1108     WMAddPopUpButtonItem(panel->cmdP, _("Legal Panel"));
1109     WMSetPopUpButtonAction(panel->cmdP, changedCommand, panel);
1110
1111     WMMapSubwidgets(panel->cmdF);
1112
1113     panel->infoL = WMCreateLabel(panel->frame);
1114     WMResizeWidget(panel->infoL, 190, 50);
1115     WMMoveWidget(panel->infoL, 320, 65);
1116     WMSetLabelText(panel->infoL, _("Open workspace menu"));
1117     WMSetLabelRelief(panel->infoL, WRGroove);
1118     WMSetLabelTextAlignment(panel->infoL, WACenter);
1119
1120     panel->noconfirmB = WMCreateSwitchButton(panel->frame);
1121     WMResizeWidget(panel->noconfirmB, 190, 50);
1122     WMMoveWidget(panel->noconfirmB, 320, 120);
1123     WMSetButtonText(panel->noconfirmB, _("No confirmation panel"));
1124     WMSetButtonAction(panel->noconfirmB, confirmClicked, panel);
1125
1126     panel->pathF = WMCreateFrame(panel->frame);
1127     WMResizeWidget(panel->pathF, 190, 50);
1128     WMMoveWidget(panel->pathF, 320, 65);
1129     WMSetFrameTitle(panel->pathF, _("Menu Path/Directory List"));
1130
1131     panel->pathT = WMCreateTextField(panel->pathF);
1132     WMResizeWidget(panel->pathT, 170, 20);
1133     WMMoveWidget(panel->pathT, 10, 20);
1134     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1135                               panel->pathT);
1136
1137     WMMapSubwidgets(panel->pathF);
1138
1139     panel->proF = WMCreateFrame(panel->frame);
1140     WMResizeWidget(panel->proF, 190, 50);
1141     WMMoveWidget(panel->proF, 320, 120);
1142     WMSetFrameTitle(panel->proF, _("Program to Run"));
1143
1144     panel->proT = WMCreateTextField(panel->proF);
1145     WMResizeWidget(panel->proT, 170, 20);
1146     WMMoveWidget(panel->proT, 10, 20);
1147     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1148                               panel->proT);
1149
1150     WMMapSubwidgets(panel->proF);
1151
1152     panel->shoF = WMCreateFrame(panel->frame);
1153     WMResizeWidget(panel->shoF, 190, 50);
1154     WMMoveWidget(panel->shoF, 320, 175);
1155     WMSetFrameTitle(panel->shoF, _("Shortcut"));
1156
1157     panel->shoT = WMCreateTextField(panel->shoF);
1158     WMResizeWidget(panel->shoT, 95, 20);
1159     WMMoveWidget(panel->shoT, 10, 20);
1160     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1161                               panel->shoT);
1162
1163     panel->shoB = WMCreateCommandButton(panel->shoF);
1164     WMResizeWidget(panel->shoB, 70, 24);
1165     WMMoveWidget(panel->shoB, 110, 18);
1166     WMSetButtonText(panel->shoB, _("Capture"));
1167     WMSetButtonAction(panel->shoB, captureClick, panel);
1168
1169     WMMapSubwidgets(panel->shoF);
1170
1171     panel->guruB = WMCreateCommandButton(panel->frame);
1172     WMResizeWidget(panel->guruB, 180, 24);
1173     WMMoveWidget(panel->guruB, 325, 190);
1174     WMSetButtonText(panel->guruB, _("Ask help to the Guru"));
1175     WMSetButtonAction(panel->guruB, openGuru, panel);
1176
1177     WMRealizeWidget(panel->frame);
1178     WMMapSubwidgets(panel->frame);
1179
1180     showData(panel);
1181 }
1182
1183
1184
1185
1186 static proplist_t
1187 preProcessMenu(proplist_t menu, int *hasWSMenu)
1188 {
1189     proplist_t pmenu;
1190     proplist_t item;
1191     int i;
1192
1193     pmenu = PLDeepCopy(menu);
1194     if (PLGetNumberOfElements(pmenu)==1) {
1195         return pmenu;
1196     }
1197     for (i=1; i<PLGetNumberOfElements(pmenu); i++) {
1198         item = PLGetArrayElement(pmenu, i);
1199         if (isMenu(item)) {
1200             PLInsertArrayElement(pmenu, preProcessMenu(item, hasWSMenu), i);
1201             PLRemoveArrayElement(pmenu, i+1);
1202             PLRelease(item);
1203         } else if (strcmp(getItemCommand(item), "RESTART")==0) {
1204             if (getItemShortcut(item)) {
1205                 if (PLGetNumberOfElements(item) == 4) {
1206                     changeItemCommand(item, "RESTARTW");
1207                     PLAppendArrayElement(item, PLMakeString(""));
1208                 }
1209             } else {
1210                 if (PLGetNumberOfElements(item) == 2) {
1211                     changeItemCommand(item, "RESTARTW");
1212                     PLAppendArrayElement(item, PLMakeString(""));
1213                 }
1214             }
1215         } else {
1216             if (strcmp(getItemCommand(item),"WORKSPACE_MENU")==0)
1217                 *hasWSMenu = 1;
1218             if (getItemShortcut(item)) {
1219                 if (PLGetNumberOfElements(item) == 4)
1220                     PLAppendArrayElement(item, PLMakeString(""));
1221             } else {
1222                 if (PLGetNumberOfElements(item) == 2)
1223                     PLAppendArrayElement(item, PLMakeString(""));
1224             }
1225         }
1226     }
1227
1228     return pmenu;
1229 }
1230
1231
1232
1233 static proplist_t
1234 postProcessMenu(proplist_t menu)
1235 {
1236     proplist_t pmenu;
1237     proplist_t item;
1238     int i;
1239     int count;
1240
1241     pmenu = PLDeepCopy(menu);
1242     if (PLGetNumberOfElements(pmenu)==1) {
1243         return pmenu;
1244     }
1245     count = PLGetNumberOfElements(pmenu);
1246     for (i=1; i<count; i++) {
1247         char *cmd;
1248         item = PLGetArrayElement(pmenu, i);
1249         if (isMenu(item)) {
1250             PLInsertArrayElement(pmenu, postProcessMenu(item), i);
1251             PLRemoveArrayElement(pmenu, i+1);
1252             PLRelease(item);
1253         } else {
1254             cmd = getItemCommand(item);
1255             if (strcmp(cmd, "RESTARTW")==0) {
1256                 changeItemCommand(item, "RESTART");
1257                 removeParameter(item);
1258             } else if (strcmp(cmd, "EXEC")==0 || strcmp(cmd, "OPEN_MENU")==0) {
1259                 /* do nothing */
1260             } else if (strcmp(cmd, "RESTART")==0 || strcmp(cmd, "SHUTDOWN")==0
1261                        || strcmp(cmd, "EXIT")==0) {
1262                 char *tmp = getItemParameter(item);
1263                 if (tmp && strlen(tmp)==0)
1264                     removeParameter(item);
1265             } else {
1266                 removeParameter(item);
1267             }
1268         }
1269     }
1270
1271     return pmenu;
1272 }
1273
1274
1275 static void
1276 showData(_Panel *panel)
1277 {
1278     char *gspath;
1279     char *menuPath;
1280     proplist_t menu, pmenu, plPath;
1281     char buffer[512];
1282     int hasWSMenu=0;
1283
1284     gspath = wusergnusteppath();
1285
1286     menuPath = wmalloc(strlen(gspath)+32);
1287     strcpy(menuPath, gspath);
1288     free(gspath);
1289     strcat(menuPath, "/Defaults/WMRootMenu");
1290
1291     menu = PLGetProplistWithPath(menuPath);
1292
1293     if (!menu || !PLIsArray(menu)) {
1294         sprintf(buffer, _("The format of the current menu in ~/G/D/WMRootMenu "
1295                 "is not supported by WPrefs. A new menu will be created.\n"
1296                 "You can also replace ~/G/D/WMRootMenu with ~/G/L/W/plmenu "
1297                 "to get the default menu."));
1298         if (WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
1299                             _("Warning"), buffer, _("OK"), _("Cancel"),
1300                             NULL)==WAPRDefault) {
1301             panel->dontSave = 0;
1302         } else {
1303             WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
1304                             _("Warning"), _("Any changes made in this section will not be saved"),
1305                             _("OK"), NULL, NULL);
1306             panel->dontSave = 1;
1307         }
1308
1309         pmenu = PLMakeArrayFromElements(PLMakeString("Applications"),
1310                                         NULL);
1311     } else {
1312         pmenu = preProcessMenu(menu, &hasWSMenu);
1313     }
1314     plPath = PLMakeString(menuPath);
1315     free(menuPath);
1316     PLSetFilename(pmenu, plPath);
1317     PLRelease(plPath);
1318
1319     if (menu)
1320         PLRelease(menu);
1321
1322     if (panel->itemClipboard) {
1323         PLRelease(panel->itemClipboard);
1324         panel->itemClipboard = NULL;
1325     }
1326     panel->menu = pmenu;
1327     panel->editedItem = NULL;
1328     panel->capturing = 0;
1329
1330     WMSetPopUpButtonItemEnabled(panel->cmd1P, CPaste, False);
1331     WMSetPopUpButtonItemEnabled(panel->cmd2P, CPaste, False);
1332     if (hasWSMenu) {
1333         WMSetPopUpButtonItemEnabled(panel->cmd1P, CAddWorkspace, False);
1334         WMSetPopUpButtonItemEnabled(panel->cmd2P, CAddWorkspace, False);
1335     }
1336     WMLoadBrowserColumnZero(panel->browser);
1337
1338     updateForItemType(panel, TNothing);
1339 }
1340
1341
1342 static void
1343 storeData(_Panel *panel)
1344 {
1345     proplist_t menu;
1346
1347     if (!panel->unsaved || panel->dontSave)
1348         return;
1349     panel->unsaved = 0;
1350
1351     menu = postProcessMenu(panel->menu);
1352
1353     PLSetFilename(menu, PLGetFilename(panel->menu));
1354
1355     PLSave(menu, YES);
1356
1357     PLRelease(menu);
1358 }
1359
1360
1361 Panel*
1362 InitMenu(WMScreen *scr, WMWindow *win)
1363 {
1364     _Panel *panel;
1365
1366     panel = wmalloc(sizeof(_Panel));
1367     memset(panel, 0, sizeof(_Panel));
1368
1369     panel->sectionName = _("Applications Menu Definition");
1370
1371     panel->win = win;
1372
1373     panel->callbacks.createWidgets = createPanel;
1374     panel->callbacks.updateDomain = storeData;
1375
1376     AddSection(panel, ICON_FILE);
1377
1378     return panel;
1379 }