WPrefs.app/Menu.c

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