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