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