WPrefs.app/Menu.c

   1 /* Menu.c- menu definition
   2  *
   3  *  WPrefs - WindowMaker 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         return;
 550     }
 551
 552     if (WMGetBrowserSelectedColumn(panel->browser)==
 553         WMGetBrowserFirstVisibleColumn(panel->browser)) {
 554         /* second column is empty, because selected item is not a submenu */
 555         WMSetTextFieldText(panel->tit2T, NULL);
 556     }
 557
 558     command = getItemCommand(item);
 559
 560     WMSetTextFieldText(panel->shoT, getItemShortcut(item));
 561
 562     if (strcmp(command, "OPEN_MENU")==0) {
 563         char *p, *c;
 564
 565         splitOpenMenuParameter(getItemParameter(item), &p, &c);
 566         WMSetTextFieldText(panel->pathT, p);
 567         WMSetTextFieldText(panel->proT, c);
 568         if (p)
 569             free(p);
 570         if (c)
 571             free(c);
 572         updateForItemType(panel, TExternalMenu);
 573     } else if (strcmp(command, "EXEC")==0) {
 574         WMSetTextFieldText(panel->proT, getItemParameter(item));
 575         WMSetPopUpButtonSelectedItem(panel->cmdP, CpExec);
 576         updateForItemType(panel, TExec);
 577     } else if (strcmp(command, "WORKSPACE_MENU")==0) {
 578         updateForItemType(panel, TWSMenu);
 579     } else if (strcmp(command, "EXIT")==0) {
 580         WMSetPopUpButtonSelectedItem(panel->cmdP, CpExit);
 581         updateForItemType(panel, TExit);
 582     } else if (strcmp(command, "SHUTDOWN")==0) {
 583         WMSetPopUpButtonSelectedItem(panel->cmdP, CpShutdown);
 584         updateForItemType(panel, TExit);
 585     } else if (strcmp(command, "RESTARTW")==0) {
 586         WMSetPopUpButtonSelectedItem(panel->cmdP, CpRestartWM);
 587         updateForItemType(panel, TRestartWM);
 588     } else if (strcmp(command, "RESTART")==0) {
 589         WMSetPopUpButtonSelectedItem(panel->cmdP, CpRestart);
 590         WMSetTextFieldText(panel->proT, getItemParameter(item));
 591         updateForItemType(panel, TRestart);
 592     } else {
 593         /* simple commands */
 594         if (strcmp(command, "ARRANGE_ICONS")==0)
 595             WMSetPopUpButtonSelectedItem(panel->cmdP, CpArrange);
 596         else if (strcmp(command, "HIDE_OTHERS")==0)
 597             WMSetPopUpButtonSelectedItem(panel->cmdP, CpHide);
 598         else if (strcmp(command, "SHOW_ALL")==0)
 599             WMSetPopUpButtonSelectedItem(panel->cmdP, CpShow);
 600         else if (strcmp(command, "SAVE_SESSION")==0)
 601             WMSetPopUpButtonSelectedItem(panel->cmdP, CpSaveSession);
 602         else if (strcmp(command, "CLEAR_SESSION")==0)
 603             WMSetPopUpButtonSelectedItem(panel->cmdP, CpClearSession);
 604         else if (strcmp(command, "REFRESH")==0)
 605             WMSetPopUpButtonSelectedItem(panel->cmdP, CpRefresh);
 606         else if (strcmp(command, "INFO_PANEL")==0)
 607             WMSetPopUpButtonSelectedItem(panel->cmdP, CpInfo);
 608         else if (strcmp(command, "LEGAL_PANEL")==0)
 609             WMSetPopUpButtonSelectedItem(panel->cmdP, CpLegal);
 610         updateForItemType(panel, TSimpleCommand);
 611     }
 612 }
 613
 614
 615 static void
 616 fillBrowserColumn(WMBrowser *bPtr, int column)
 617 {
 618     _Panel *panel = (_Panel*)WMGetHangedData(bPtr);
 619     proplist_t menuItem;
 620     proplist_t menuList = NULL;
 621     int i;
 622
 623     if (column > 0) {
 624         menuList = getItemOfSelectedEntry(panel->browser);
 625         if (column > WMGetBrowserFirstVisibleColumn(bPtr))
 626             WMSetTextFieldText(panel->tit2T, getItemTitle(menuList));
 627         else
 628             WMSetTextFieldText(panel->tit1T, getItemTitle(menuList));
 629     } else {
 630         WMSetTextFieldText(panel->tit1T, getItemTitle(panel->menu));
 631         menuList = panel->menu;
 632     }
 633
 634     WMHangData(WMGetBrowserListInColumn(bPtr, column), menuList);
 635     for (i=1; i<PLGetNumberOfElements(menuList); i++) {
 636         menuItem = PLGetArrayElement(menuList, i);
 637         WMInsertBrowserItem(bPtr, column, -1, getItemTitle(menuItem),
 638                             isMenu(menuItem));
 639     }
 640 }
 641
 642
 643
 644
 645 static void
 646 changedItem(void *observerData, WMNotification *notification)
 647 {
 648     _Panel *panel = (_Panel*)observerData;
 649     WMTextField *t = (WMTextField*)WMGetNotificationObject(notification);
 650     proplist_t item = panel->editedItem;
 651     WMList *list;
 652     WMListItem *litem;
 653     char *command;
 654     char *str;
 655
 656     if (!item)
 657         return;
 658
 659     panel->unsaved = 1;
 660     if (!isMenu(item)) {
 661         command = getItemCommand(item);
 662
 663         if (t == panel->shoT) {
 664             str = WMGetTextFieldText(t);
 665             if (strlen(str)==0) {
 666                 free(str);
 667                 str = NULL;
 668             }
 669             changeItemShortcut(item, str);
 670             if (str)
 671                 free(str);
 672         } else if (t == panel->labT) {
 673             int column;
 674
 675             str = WMGetTextFieldText(t);
 676             if (!str)
 677                 str = wstrdup("");
 678             changeItemTitle(item, str);
 679             column = WMGetBrowserSelectedColumn(panel->browser);
 680             list = WMGetBrowserListInColumn(panel->browser, column);
 681             litem = WMGetListSelectedItem(list);
 682
 683             free(litem->text);
 684             litem->text = str;
 685
 686             WMRedisplayWidget(list);
 687         } else if (strcmp(command, "EXEC")==0
 688                    || strcmp(command, "RESTART")==0) {
 689             if (t == panel->proT) {
 690                 str = WMGetTextFieldText(t);
 691
 692                 changeItemParameter(item, str);
 693
 694                 free(str);
 695             }
 696         } else if (strcmp(command, "OPEN_MENU")==0) {
 697             char *text;
 698             char *str2;
 699
 700             str = WMGetTextFieldText(panel->pathT);
 701             str2 = WMGetTextFieldText(panel->proT);
 702             text = wmalloc(strlen(str)+strlen(str2)+16);
 703             strcpy(text, str);
 704             free(str);
 705             if (strlen(str2)>0) {
 706                 strcat(text, " WITH ");
 707                 strcat(text, str2);
 708             }
 709             free(str2);
 710             changeItemParameter(item, text);
 711             free(text);
 712         }
 713     }
 714 }
 715
 716
 717 static void
 718 changedTitle(void *observerData, WMNotification *notification)
 719 {
 720     _Panel *panel = (_Panel*)observerData;
 721     WMTextField *t = (WMTextField*)WMGetNotificationObject(notification);
 722     proplist_t menu;
 723     WMList *list;
 724     int column;
 725     char *txt;
 726
 727     column = WMGetBrowserFirstVisibleColumn(panel->browser);
 728     if (panel->tit2T == t)
 729         column++;
 730
 731     list = WMGetBrowserListInColumn(panel->browser, column);
 732     if (!list) {
 733         return;
 734     }
 735
 736     menu = (proplist_t)WMGetHangedData(list);
 737
 738     txt = WMGetTextFieldText(t);
 739     changeItemTitle(menu, txt);
 740
 741     if (column > 0) {
 742         WMListItem *litem;
 743
 744         list = WMGetBrowserListInColumn(panel->browser, column-1);
 745         litem = WMGetListSelectedItem(list);
 746
 747         free(litem->text);
 748         litem->text = txt;
 749
 750         WMRedisplayWidget(list);
 751     } else {
 752         free(txt);
 753     }
 754     panel->unsaved = 1;
 755 }
 756
 757
 758 static void
 759 changedCommand(WMWidget *w, void *data)
 760 {
 761     _Panel *panel = (_Panel*)data;
 762     int i;
 763     char *tmp;
 764
 765     panel->unsaved = 1;
 766     i = WMGetPopUpButtonSelectedItem(panel->cmdP);
 767     changeItemParameter(panel->editedItem, "");
 768     switch (i) {
 769      case CpExec:
 770         if (strcmp(getItemCommand(panel->editedItem), "EXEC")!=0) {
 771             changeItemCommand(panel->editedItem, "EXEC");
 772             tmp = WMGetTextFieldText(panel->proT);
 773             changeItemParameter(panel->editedItem, tmp);
 774             free(tmp);
 775             updateForItemType(panel, TExec);
 776         }
 777         break;
 778      case CpArrange:
 779         if (strcmp(getItemCommand(panel->editedItem), "ARRANGE_ICONS")!=0) {
 780             changeItemCommand(panel->editedItem, "ARRANGE_ICONS");
 781             updateForItemType(panel, TSimpleCommand);
 782         }
 783         break;
 784      case CpHide:
 785         if (strcmp(getItemCommand(panel->editedItem), "HIDE_OTHERS")!=0) {
 786             changeItemCommand(panel->editedItem, "HIDE_OTHERS");
 787             updateForItemType(panel, TSimpleCommand);
 788         }
 789         break;
 790      case CpShow:
 791         if (strcmp(getItemCommand(panel->editedItem), "SHOW_ALL")!=0) {
 792             changeItemCommand(panel->editedItem, "SHOW_ALL");
 793             updateForItemType(panel, TSimpleCommand);
 794         }
 795         break;
 796      case CpExit:
 797         if (strcmp(getItemCommand(panel->editedItem), "EXIT")!=0) {
 798             changeItemCommand(panel->editedItem, "EXIT");
 799             updateForItemType(panel, TExit);
 800         }
 801         /* fall through */
 802      case CpShutdown:
 803         if (strcmp(getItemCommand(panel->editedItem), "SHUTDOWN")!=0) {
 804             changeItemCommand(panel->editedItem, "SHUTDOWN");
 805             updateForItemType(panel, TExit);
 806         }
 807         if (WMGetButtonSelected(panel->noconfirmB))
 808             changeItemParameter(panel->editedItem, "QUICK");
 809         else
 810             changeItemParameter(panel->editedItem, "");
 811         break;
 812      case CpRestartWM:
 813         changeItemCommand(panel->editedItem, "RESTARTW");
 814         updateForItemType(panel, TRestartWM);
 815         break;
 816      case CpRestart:
 817         changeItemCommand(panel->editedItem, "RESTART");
 818         updateForItemType(panel, TRestart);
 819         tmp = WMGetTextFieldText(panel->proT);
 820         changeItemParameter(panel->editedItem, tmp);
 821         free(tmp);
 822         break;
 823      case CpSaveSession:
 824         if (strcmp(getItemCommand(panel->editedItem), "SAVE_SESSION")!=0) {
 825             changeItemCommand(panel->editedItem, "SAVE_SESSION");
 826             updateForItemType(panel, TSimpleCommand);
 827         }
 828         break;
 829      case CpClearSession:
 830         if (strcmp(getItemCommand(panel->editedItem), "CLEAR_SESSION")!=0) {
 831             changeItemCommand(panel->editedItem, "CLEAR_SESSION");
 832             updateForItemType(panel, TSimpleCommand);
 833         }
 834         break;
 835      case CpRefresh:
 836         if (strcmp(getItemCommand(panel->editedItem), "REFRESH")!=0) {
 837             changeItemCommand(panel->editedItem, "REFRESH");
 838             updateForItemType(panel, TSimpleCommand);
 839         }
 840         break;
 841      case CpInfo:
 842         if (strcmp(getItemCommand(panel->editedItem), "INFO_PANEL")!=0) {
 843             changeItemCommand(panel->editedItem, "INFO_PANEL");
 844             updateForItemType(panel, TSimpleCommand);
 845         }
 846         break;
 847      case CpLegal:
 848         if (strcmp(getItemCommand(panel->editedItem), "LEGAL_PANEL")!=0) {
 849             changeItemCommand(panel->editedItem, "LEGAL_PANEL");
 850             updateForItemType(panel, TSimpleCommand);
 851         }
 852         break;
 853     }
 854 }
 855
 856
 857
 858
 859
 860 static char*
 861 captureShortcut(Display *dpy, _Panel *panel)
 862 {
 863     XEvent ev;
 864     KeySym ksym;
 865     char buffer[64];
 866     char *key = NULL;
 867
 868     while (panel->capturing) {
 869         XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
 870         WMNextEvent(dpy, &ev);
 871         if (ev.type==KeyPress && ev.xkey.keycode!=0) {
 872             ksym = XKeycodeToKeysym(dpy, ev.xkey.keycode, 0);
 873             if (!IsModifierKey(ksym)) {
 874                 key=XKeysymToString(ksym);
 875                 panel->capturing = 0;
 876                 break;
 877             }
 878         }
 879         WMHandleEvent(&ev);
 880     }
 881
 882     if (!key)
 883         return NULL;
 884
 885     buffer[0] = 0;
 886
 887     if (ev.xkey.state & ControlMask) {
 888         strcat(buffer, "Control+");
 889     }
 890     if (ev.xkey.state & ShiftMask) {
 891         strcat(buffer, "Shift+");
 892     }
 893     if (ev.xkey.state & Mod1Mask) {
 894         strcat(buffer, "Mod1+");
 895     }
 896     if (ev.xkey.state & Mod2Mask) {
 897         strcat(buffer, "Mod2+");
 898     }
 899     if (ev.xkey.state & Mod3Mask) {
 900         strcat(buffer, "Mod3+");
 901     }
 902     if (ev.xkey.state & Mod4Mask) {
 903         strcat(buffer, "Mod4+");
 904     }
 905     if (ev.xkey.state & Mod5Mask) {
 906         strcat(buffer, "Mod5+");
 907     }
 908     strcat(buffer, key);
 909
 910     return wstrdup(buffer);
 911 }
 912
 913
 914 static void
 915 captureClick(WMWidget *w, void *data)
 916 {
 917     _Panel *panel = (_Panel*)data;
 918     Display *dpy = WMScreenDisplay(WMWidgetScreen(panel->win));
 919     char *shortcut;
 920
 921     if (!panel->capturing) {
 922         panel->capturing = 1;
 923         WMSetButtonText(w, _("Cancel"));
 924         XGrabKeyboard(dpy, WMWidgetXID(panel->win), True, GrabModeAsync,
 925                       GrabModeAsync, CurrentTime);
 926         shortcut = captureShortcut(dpy, panel);
 927         if (shortcut) {
 928             WMSetTextFieldText(panel->shoT, shortcut);
 929             changeItemShortcut(panel->editedItem, shortcut);
 930             panel->unsaved = 1;
 931         }
 932         free(shortcut);
 933     }
 934     panel->capturing = 0;
 935     WMSetButtonText(w, _("Capture"));
 936     XUngrabKeyboard(dpy, CurrentTime);
 937 }
 938
 939
 940
 941 static void
 942 scrolledBrowser(void *observerData, WMNotification *notification)
 943 {
 944     _Panel *panel = (_Panel*)observerData;
 945     int column;
 946     WMList *list;
 947     proplist_t item;
 948
 949     column = WMGetBrowserFirstVisibleColumn(panel->browser);
 950
 951     list = WMGetBrowserListInColumn(panel->browser, column);
 952     item = WMGetHangedData(list);
 953     WMSetTextFieldText(panel->tit1T, getItemTitle(item));
 954
 955     list = WMGetBrowserListInColumn(panel->browser, column+1);
 956     if (list) {
 957         item = WMGetHangedData(list);
 958         WMSetTextFieldText(panel->tit2T, getItemTitle(item));
 959     }
 960 }
 961
 962
 963 static void
 964 confirmClicked(WMWidget *w, void *data)
 965 {
 966     _Panel *panel = (_Panel*)data;
 967
 968     if (WMGetButtonSelected(panel->noconfirmB)) {
 969         changeItemParameter(panel->editedItem, "QUICK");
 970     } else {
 971         changeItemParameter(panel->editedItem, "");
 972     }
 973     panel->unsaved = 1;
 974 }
 975
 976
 977
 978 static void
 979 openGuru(WMWidget *w, void *data)
 980 {
 981     _Panel *panel = (_Panel*)data;
 982     char *def;
 983     char *path, *cmd;
 984
 985     def = OpenMenuGuru(GetWindow(panel));
 986     if (def) {
 987         changeItemParameter(panel->editedItem, def);
 988         splitOpenMenuParameter(def, &path, &cmd);
 989         free(def);
 990         WMSetTextFieldText(panel->pathT, path);
 991         if (path)
 992             free(path);
 993
 994         WMSetTextFieldText(panel->proT, cmd);
 995         if (cmd)
 996             free(cmd);
 997         panel->unsaved = 1;
 998     }
 999 }
1000
1001
1002 static void
1003 createPanel(_Panel *p)
1004 {
1005     _Panel *panel = (_Panel*)p;
1006
1007
1008     panel->frame = WMCreateFrame(panel->win);
1009     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
1010     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
1011
1012     panel->cmd1P = WMCreatePopUpButton(panel->frame);
1013     WMSetPopUpButtonAction(panel->cmd1P, performCommand, panel);
1014     WMResizeWidget(panel->cmd1P, 144, 20);
1015     WMMoveWidget(panel->cmd1P, 15, 15);
1016     WMSetPopUpButtonPullsDown(panel->cmd1P, True);
1017     WMSetPopUpButtonText(panel->cmd1P, _("Commands"));
1018     WMAddPopUpButtonItem(panel->cmd1P, _("Add Command"));
1019     WMAddPopUpButtonItem(panel->cmd1P, _("Add Submenu"));
1020     WMAddPopUpButtonItem(panel->cmd1P, _("Add External Menu"));
1021     WMAddPopUpButtonItem(panel->cmd1P, _("Add Workspace Menu"));
1022     WMAddPopUpButtonItem(panel->cmd1P, _("Remove Item"));
1023     WMAddPopUpButtonItem(panel->cmd1P, _("Cut Item"));
1024     WMAddPopUpButtonItem(panel->cmd1P, _("Copy Item"));
1025     WMAddPopUpButtonItem(panel->cmd1P, _("Paste Item"));
1026
1027     panel->cmd2P = WMCreatePopUpButton(panel->frame);
1028     WMSetPopUpButtonAction(panel->cmd2P, performCommand, panel);
1029     WMResizeWidget(panel->cmd2P, 144, 20);
1030     WMMoveWidget(panel->cmd2P, 164, 15);
1031     WMSetPopUpButtonPullsDown(panel->cmd2P, True);
1032     WMSetPopUpButtonText(panel->cmd2P, _("Commands"));
1033     WMAddPopUpButtonItem(panel->cmd2P, _("Add Command"));
1034     WMAddPopUpButtonItem(panel->cmd2P, _("Add Submenu"));
1035     WMAddPopUpButtonItem(panel->cmd2P, _("Add External Menu"));
1036     WMAddPopUpButtonItem(panel->cmd2P, _("Add Workspace Menu"));
1037     WMAddPopUpButtonItem(panel->cmd2P, _("Remove Item"));
1038     WMAddPopUpButtonItem(panel->cmd2P, _("Cut Item"));
1039     WMAddPopUpButtonItem(panel->cmd2P, _("Copy Item"));
1040     WMAddPopUpButtonItem(panel->cmd2P, _("Paste Item"));
1041
1042     panel->tit1T = WMCreateTextField(panel->frame);
1043     WMResizeWidget(panel->tit1T, 144, 20);
1044     WMMoveWidget(panel->tit1T, 15, 40);
1045     WMAddNotificationObserver(changedTitle, panel, WMTextDidChangeNotification,
1046                               panel->tit1T);
1047
1048     panel->tit2T = WMCreateTextField(panel->frame);
1049     WMResizeWidget(panel->tit2T, 144, 20);
1050     WMMoveWidget(panel->tit2T, 164, 40);
1051     WMAddNotificationObserver(changedTitle, panel, WMTextDidChangeNotification,
1052                               panel->tit2T);
1053
1054     panel->browser = WMCreateBrowser(panel->frame);
1055     WMSetBrowserTitled(panel->browser, False);
1056     WMResizeWidget(panel->browser, 295, 160);
1057     WMMoveWidget(panel->browser, 15, 65);
1058     WMSetBrowserFillColumnProc(panel->browser, fillBrowserColumn);
1059     WMHangData(panel->browser, panel);
1060     WMSetBrowserPathSeparator(panel->browser, "\r");
1061     WMSetBrowserAction(panel->browser, browserClick, panel);
1062     WMAddNotificationObserver(scrolledBrowser, panel,
1063                               WMBrowserDidScrollNotification, panel->browser);
1064     /**/
1065
1066     panel->labF = WMCreateFrame(panel->frame);
1067     WMResizeWidget(panel->labF, 190, 50);
1068     WMMoveWidget(panel->labF, 320, 10);
1069     WMSetFrameTitle(panel->labF, _("Label"));
1070
1071     panel->labT = WMCreateTextField(panel->labF);
1072     WMResizeWidget(panel->labT, 170, 20);
1073     WMMoveWidget(panel->labT, 10, 20);
1074     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1075                               panel->labT);
1076
1077     WMMapSubwidgets(panel->labF);
1078
1079     panel->cmdF = WMCreateFrame(panel->frame);
1080     WMResizeWidget(panel->cmdF, 190, 50);
1081     WMMoveWidget(panel->cmdF, 320, 65);
1082     WMSetFrameTitle(panel->cmdF, _("Command"));
1083
1084     panel->cmdP = WMCreatePopUpButton(panel->cmdF);
1085     WMResizeWidget(panel->cmdP, 170, 20);
1086     WMMoveWidget(panel->cmdP, 10, 20);
1087     WMAddPopUpButtonItem(panel->cmdP, _("Run Program"));
1088     WMAddPopUpButtonItem(panel->cmdP, _("Arrange Icons"));
1089     WMAddPopUpButtonItem(panel->cmdP, _("Hide Others"));
1090     WMAddPopUpButtonItem(panel->cmdP, _("Show All Windows"));
1091     WMAddPopUpButtonItem(panel->cmdP, _("Exit WindowMaker"));
1092     WMAddPopUpButtonItem(panel->cmdP, _("Exit X Session"));
1093     WMAddPopUpButtonItem(panel->cmdP, _("Start window manager"));
1094     WMAddPopUpButtonItem(panel->cmdP, _("Restart WindowMaker"));
1095     WMAddPopUpButtonItem(panel->cmdP, _("Save Session"));
1096     WMAddPopUpButtonItem(panel->cmdP, _("Clear Session"));
1097     WMAddPopUpButtonItem(panel->cmdP, _("Refresh Screen"));
1098     WMAddPopUpButtonItem(panel->cmdP, _("Info Panel"));
1099     WMAddPopUpButtonItem(panel->cmdP, _("Legal Panel"));
1100     WMSetPopUpButtonAction(panel->cmdP, changedCommand, panel);
1101
1102     WMMapSubwidgets(panel->cmdF);
1103
1104     panel->infoL = WMCreateLabel(panel->frame);
1105     WMResizeWidget(panel->infoL, 190, 50);
1106     WMMoveWidget(panel->infoL, 320, 65);
1107     WMSetLabelText(panel->infoL, _("Open workspace menu"));
1108     WMSetLabelRelief(panel->infoL, WRGroove);
1109     WMSetLabelTextAlignment(panel->infoL, WACenter);
1110
1111     panel->noconfirmB = WMCreateSwitchButton(panel->frame);
1112     WMResizeWidget(panel->noconfirmB, 190, 50);
1113     WMMoveWidget(panel->noconfirmB, 320, 120);
1114     WMSetButtonText(panel->noconfirmB, _("No confirmation panel"));
1115     WMSetButtonAction(panel->noconfirmB, confirmClicked, panel);
1116
1117     panel->pathF = WMCreateFrame(panel->frame);
1118     WMResizeWidget(panel->pathF, 190, 50);
1119     WMMoveWidget(panel->pathF, 320, 65);
1120     WMSetFrameTitle(panel->pathF, _("Menu Path/Directory List"));
1121
1122     panel->pathT = WMCreateTextField(panel->pathF);
1123     WMResizeWidget(panel->pathT, 170, 20);
1124     WMMoveWidget(panel->pathT, 10, 20);
1125     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1126                               panel->pathT);
1127
1128     WMMapSubwidgets(panel->pathF);
1129
1130     panel->proF = WMCreateFrame(panel->frame);
1131     WMResizeWidget(panel->proF, 190, 50);
1132     WMMoveWidget(panel->proF, 320, 120);
1133     WMSetFrameTitle(panel->proF, _("Program to Run"));
1134
1135     panel->proT = WMCreateTextField(panel->proF);
1136     WMResizeWidget(panel->proT, 170, 20);
1137     WMMoveWidget(panel->proT, 10, 20);
1138     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1139                               panel->proT);
1140
1141     WMMapSubwidgets(panel->proF);
1142
1143     panel->shoF = WMCreateFrame(panel->frame);
1144     WMResizeWidget(panel->shoF, 190, 50);
1145     WMMoveWidget(panel->shoF, 320, 175);
1146     WMSetFrameTitle(panel->shoF, _("Shortcut"));
1147
1148     panel->shoT = WMCreateTextField(panel->shoF);
1149     WMResizeWidget(panel->shoT, 95, 20);
1150     WMMoveWidget(panel->shoT, 10, 20);
1151     WMAddNotificationObserver(changedItem, panel, WMTextDidChangeNotification,
1152                               panel->shoT);
1153
1154     panel->shoB = WMCreateCommandButton(panel->shoF);
1155     WMResizeWidget(panel->shoB, 70, 24);
1156     WMMoveWidget(panel->shoB, 110, 18);
1157     WMSetButtonText(panel->shoB, _("Capture"));
1158     WMSetButtonAction(panel->shoB, captureClick, panel);
1159
1160     WMMapSubwidgets(panel->shoF);
1161
1162     panel->guruB = WMCreateCommandButton(panel->frame);
1163     WMResizeWidget(panel->guruB, 180, 24);
1164     WMMoveWidget(panel->guruB, 325, 190);
1165     WMSetButtonText(panel->guruB, _("Ask help to the Guru"));
1166     WMSetButtonAction(panel->guruB, openGuru, panel);
1167
1168     WMRealizeWidget(panel->frame);
1169     WMMapSubwidgets(panel->frame);
1170
1171     showData(panel);
1172 }
1173
1174
1175
1176
1177 static proplist_t
1178 preProcessMenu(proplist_t menu, int *hasWSMenu)
1179 {
1180     proplist_t pmenu;
1181     proplist_t item;
1182     int i;
1183
1184     pmenu = PLDeepCopy(menu);
1185     if (PLGetNumberOfElements(pmenu)==1) {
1186         return pmenu;
1187     }
1188     for (i=1; i<PLGetNumberOfElements(pmenu); i++) {
1189         item = PLGetArrayElement(pmenu, i);
1190         if (isMenu(item)) {
1191             PLInsertArrayElement(pmenu, preProcessMenu(item, hasWSMenu), i);
1192             PLRemoveArrayElement(pmenu, i+1);
1193             PLRelease(item);
1194         } else if (strcmp(getItemCommand(item), "RESTART")==0) {
1195             if (getItemShortcut(item)) {
1196                 if (PLGetNumberOfElements(item) == 4) {
1197                     changeItemCommand(item, "RESTARTW");
1198                     PLAppendArrayElement(item, PLMakeString(""));
1199                 }
1200             } else {
1201                 if (PLGetNumberOfElements(item) == 2) {
1202                     changeItemCommand(item, "RESTARTW");
1203                     PLAppendArrayElement(item, PLMakeString(""));
1204                 }
1205             }
1206         } else {
1207             if (strcmp(getItemCommand(item),"WORKSPACE_MENU")==0)
1208                 *hasWSMenu = 1;
1209             if (getItemShortcut(item)) {
1210                 if (PLGetNumberOfElements(item) == 4)
1211                     PLAppendArrayElement(item, PLMakeString(""));
1212             } else {
1213                 if (PLGetNumberOfElements(item) == 2)
1214                     PLAppendArrayElement(item, PLMakeString(""));
1215             }
1216         }
1217     }
1218
1219     return pmenu;
1220 }
1221
1222
1223
1224 static proplist_t
1225 postProcessMenu(proplist_t menu)
1226 {
1227     proplist_t pmenu;
1228     proplist_t item;
1229     int i;
1230     int count;
1231
1232     pmenu = PLDeepCopy(menu);
1233     if (PLGetNumberOfElements(pmenu)==1) {
1234         return pmenu;
1235     }
1236     count = PLGetNumberOfElements(pmenu);
1237     for (i=1; i<count; i++) {
1238         char *cmd;
1239         item = PLGetArrayElement(pmenu, i);
1240         if (isMenu(item)) {
1241             PLInsertArrayElement(pmenu, postProcessMenu(item), i);
1242             PLRemoveArrayElement(pmenu, i+1);
1243             PLRelease(item);
1244         } else {
1245             cmd = getItemCommand(item);
1246             if (strcmp(cmd, "RESTARTW")==0) {
1247                 changeItemCommand(item, "RESTART");
1248                 removeParameter(item);
1249             } else if (strcmp(cmd, "EXEC")==0 || strcmp(cmd, "OPEN_MENU")==0) {
1250                 /* do nothing */
1251             } else if (strcmp(cmd, "RESTART")==0 || strcmp(cmd, "SHUTDOWN")==0
1252                        || strcmp(cmd, "EXIT")==0) {
1253                 char *tmp = getItemParameter(item);
1254                 if (tmp && strlen(tmp)==0)
1255                     removeParameter(item);
1256             } else {
1257                 removeParameter(item);
1258             }
1259         }
1260     }
1261
1262     return pmenu;
1263 }
1264
1265
1266 static void
1267 showData(_Panel *panel)
1268 {
1269     char *gspath;
1270     char *menuPath;
1271     proplist_t menu, pmenu;
1272     char buffer[512];
1273     int hasWSMenu=0;
1274
1275     gspath = wusergnusteppath();
1276
1277     menuPath = wmalloc(strlen(gspath)+32);
1278     strcpy(menuPath, gspath);
1279     free(gspath);
1280     strcat(menuPath, "/Defaults/WMRootMenu");
1281
1282     menu = PLGetProplistWithPath(menuPath);
1283     free(menuPath);
1284
1285     if (!PLIsArray(menu)) {
1286         sprintf(buffer, _("The format of the current menu in ~/G/D/WMRootMenu "
1287                 "is not supported by WPrefs. A new menu will be created.\n"
1288                 "You can also replace ~/G/D/WMRootMenu with ~/G/L/W/plmenu "
1289                 "to get the default menu."));
1290         if (WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
1291                             _("Warning"), buffer, _("OK"), _("Cancel"),
1292                             NULL)==WAPRDefault) {
1293             panel->dontSave = 0;
1294         } else {
1295             WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
1296                             _("Warning"), _("Any changes made in this section will not be saved"),
1297                             _("OK"), NULL, NULL);
1298             panel->dontSave = 1;
1299         }
1300
1301         pmenu = PLMakeArrayFromElements(PLMakeString("Applications"),
1302                                         NULL);
1303     } else {
1304         pmenu = preProcessMenu(menu, &hasWSMenu);
1305     }
1306     PLSetFilename(pmenu, PLGetFilename(menu));
1307     PLRelease(menu);
1308
1309     if (panel->itemClipboard) {
1310         PLRelease(panel->itemClipboard);
1311         panel->itemClipboard = NULL;
1312     }
1313     panel->menu = pmenu;
1314     panel->editedItem = NULL;
1315     panel->capturing = 0;
1316
1317     WMSetPopUpButtonItemEnabled(panel->cmd1P, CPaste, False);
1318     WMSetPopUpButtonItemEnabled(panel->cmd2P, CPaste, False);
1319     if (hasWSMenu) {
1320         WMSetPopUpButtonItemEnabled(panel->cmd1P, CAddWorkspace, False);
1321         WMSetPopUpButtonItemEnabled(panel->cmd2P, CAddWorkspace, False);
1322     }
1323     WMLoadBrowserColumnZero(panel->browser);
1324
1325     updateForItemType(panel, TNothing);
1326 }
1327
1328
1329 static void
1330 storeData(_Panel *panel)
1331 {
1332     proplist_t menu;
1333
1334     if (!panel->unsaved || panel->dontSave)
1335         return;
1336     panel->unsaved = 0;
1337
1338     menu = postProcessMenu(panel->menu);
1339
1340     PLSetFilename(menu, PLGetFilename(panel->menu));
1341
1342     PLSave(menu, YES);
1343
1344     PLRelease(menu);
1345 }
1346
1347
1348 Panel*
1349 InitMenu(WMScreen *scr, WMWindow *win)
1350 {
1351     _Panel *panel;
1352
1353     panel = wmalloc(sizeof(_Panel));
1354     memset(panel, 0, sizeof(_Panel));
1355
1356     panel->sectionName = _("Applications Menu Definition");
1357
1358     panel->win = win;
1359
1360     panel->callbacks.createWidgets = createPanel;
1361     panel->callbacks.updateDomain = storeData;
1362
1363     AddSection(panel, ICON_FILE);
1364
1365     return panel;
1366 }