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