WPrefs.app/Menu.c

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