WPrefs.app/Menu.c

   1 /* Menu.c- menu definition
   2  *
   3  *  WPrefs - Window Maker Preferences Program
   4  *
   5  *  Copyright (c) 2000 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 #include <X11/cursorfont.h>
  30
  31
  32 #include "editmenu.h"
  33
  34
  35 typedef enum {
  36     NoInfo,
  37     ExecInfo,
  38     CommandInfo,
  39     ExternalInfo,
  40     PipeInfo,
  41     DirectoryInfo,
  42     WSMenuInfo,
  43     LastInfo
  44 } InfoType;
  45
  46 #define MAX_SECTION_SIZE 4
  47
  48 typedef struct _Panel {
  49     WMFrame *frame;
  50     char *sectionName;
  51
  52     char *description;
  53
  54     CallbackRec callbacks;
  55     WMWindow *win;
  56
  57
  58     WMFont *boldFont;
  59     WMFont *normalFont;
  60     WMColor *white;
  61     WMColor *gray;
  62     WMColor *black;
  63
  64     WMPixmap *markerPix[LastInfo];
  65
  66     WMPopUpButton *typeP;
  67
  68     WMWidget *itemPad[3];
  69     int currentPad;
  70
  71     WEditMenu *menu;
  72     char *menuPath;
  73
  74     WMFrame *optionsF;
  75
  76     WMFrame *commandF;
  77     WMTextField *commandT;             /* command to run */
  78     WMButton *xtermC;                  /* inside xterm? */
  79
  80     WMFrame *pathF;
  81     WMTextField *pathT;
  82
  83     WMFrame *pipeF;
  84     WMTextField *pipeT;
  85
  86     WMFrame *dpathF;
  87     WMTextField *dpathT;
  88
  89     WMFrame *dcommandF;
  90     WMTextField *dcommandT;
  91
  92     WMButton *dstripB;
  93
  94     WMFrame *shortF;
  95     WMTextField *shortT;
  96     WMButton *sgrabB;
  97     WMButton *sclearB;
  98
  99     WMList *icommandL;
 100
 101     WMFrame *paramF;
 102     WMTextField *paramT;
 103
 104     WMButton *quickB;
 105
 106     Bool dontAsk;                      /* whether to comfirm submenu remove */
 107     Bool dontSave;
 108
 109     Bool capturing;
 110
 111
 112     /* about the currently selected item */
 113     WEditMenuItem *currentItem;
 114     InfoType currentType;
 115     WMWidget *sections[LastInfo][MAX_SECTION_SIZE];
 116 } _Panel;
 117
 118
 119 typedef struct {
 120     InfoType type;
 121     union {
 122         struct {
 123             int command;
 124             char *parameter;
 125             char *shortcut;
 126         } command;
 127         struct {
 128             char *command;
 129             char *shortcut;
 130         } exec;
 131         struct {
 132             char *path;
 133         } external;
 134         struct {
 135             char *command;
 136         } pipe;
 137         struct {
 138             char *directory;
 139             char *command;
 140             unsigned stripExt:1;
 141         } directory;
 142     } param;
 143 } ItemData;
 144
 145
 146
 147 static char *commandNames[] = {
 148     "ARRANGE_ICONS",
 149         "HIDE_OTHERS",
 150         "SHOW_ALL",
 151         "EXIT",
 152         "SHUTDOWN",
 153         "RESTART",
 154         "RESTART",
 155         "SAVE_SESSION",
 156         "CLEAR_SESSION",
 157         "REFRESH",
 158         "INFO_PANEL",
 159         "LEGAL_PANEL"
 160 };
 161
 162
 163
 164 #define NEW(type) memset(wmalloc(sizeof(type)), 0, sizeof(type))
 165
 166
 167 #define ICON_FILE       "menus"
 168
 169
 170
 171 static void showData(_Panel *panel);
 172
 173
 174 static void updateMenuItem(_Panel *panel, WEditMenuItem *item,
 175                            WMWidget *changedWidget);
 176
 177 static void menuItemSelected(struct WEditMenuDelegate *delegate,
 178                              WEditMenu *menu, WEditMenuItem *item);
 179
 180 static void menuItemDeselected(struct WEditMenuDelegate *delegate,
 181                                WEditMenu *menu, WEditMenuItem *item);
 182
 183 static void menuItemCloned(struct WEditMenuDelegate *delegate, WEditMenu *menu,
 184                            WEditMenuItem *origItem, WEditMenuItem *newItem);
 185
 186 static void menuItemEdited(struct WEditMenuDelegate *delegate, WEditMenu *menu,
 187                            WEditMenuItem *item);
 188
 189 static Bool shouldRemoveItem(struct WEditMenuDelegate *delegate,
 190                              WEditMenu *menu, WEditMenuItem *item);
 191
 192
 193 static void freeItemData(ItemData *data);
 194
 195
 196
 197 static WEditMenuDelegate menuDelegate = {
 198     NULL,
 199         menuItemCloned,
 200         menuItemEdited,
 201         menuItemSelected,
 202         menuItemDeselected,
 203         shouldRemoveItem
 204 };
 205
 206
 207 static void
 208 dataChanged(void *self, WMNotification *notif)
 209 {
 210     _Panel *panel = (_Panel*)self;
 211     WEditMenuItem *item = panel->currentItem;
 212     WMWidget *w = (WMWidget*)WMGetNotificationObject(notif);
 213
 214     updateMenuItem(panel, item, w);
 215 }
 216
 217
 218 static void
 219 buttonClicked(WMWidget *w, void *data)
 220 {
 221     _Panel *panel = (_Panel*)data;
 222     WEditMenuItem *item = panel->currentItem;
 223
 224     updateMenuItem(panel, item, w);
 225 }
 226
 227
 228 static void
 229 icommandLClicked(WMWidget *w, void *data)
 230 {
 231     _Panel *panel = (_Panel*)data;
 232     int cmd;
 233
 234     cmd = WMGetListSelectedItemRow(w);
 235     if (cmd == 3 || cmd == 4) {
 236         WMMapWidget(panel->quickB);
 237     } else {
 238         WMUnmapWidget(panel->quickB);
 239     }
 240     if (cmd == 6) {
 241         WMMapWidget(panel->paramF);
 242     } else {
 243         WMUnmapWidget(panel->paramF);
 244     }
 245 }
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255 static char*
 256 captureShortcut(Display *dpy, _Panel *panel)
 257 {
 258     XEvent ev;
 259     KeySym ksym;
 260     char buffer[64];
 261     char *key = NULL;
 262
 263     while (panel->capturing) {
 264         XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
 265         WMNextEvent(dpy, &ev);
 266         if (ev.type==KeyPress && ev.xkey.keycode!=0) {
 267             ksym = XKeycodeToKeysym(dpy, ev.xkey.keycode, 0);
 268             if (!IsModifierKey(ksym)) {
 269                 key=XKeysymToString(ksym);
 270                 panel->capturing = 0;
 271                 break;
 272             }
 273         }
 274         WMHandleEvent(&ev);
 275     }
 276
 277     if (!key)
 278         return NULL;
 279
 280     buffer[0] = 0;
 281
 282     if (ev.xkey.state & ControlMask) {
 283         strcat(buffer, "Control+");
 284     }
 285     if (ev.xkey.state & ShiftMask) {
 286         strcat(buffer, "Shift+");
 287     }
 288     if (ev.xkey.state & Mod1Mask) {
 289         strcat(buffer, "Mod1+");
 290     }
 291     if (ev.xkey.state & Mod2Mask) {
 292         strcat(buffer, "Mod2+");
 293     }
 294     if (ev.xkey.state & Mod3Mask) {
 295         strcat(buffer, "Mod3+");
 296     }
 297     if (ev.xkey.state & Mod4Mask) {
 298         strcat(buffer, "Mod4+");
 299     }
 300     if (ev.xkey.state & Mod5Mask) {
 301         strcat(buffer, "Mod5+");
 302     }
 303     strcat(buffer, key);
 304
 305     return wstrdup(buffer);
 306 }
 307
 308
 309
 310 static void
 311 sgrabClicked(WMWidget *w, void *data)
 312 {
 313     _Panel *panel = (_Panel*)data;
 314     Display *dpy = WMScreenDisplay(WMWidgetScreen(panel->win));
 315     char *shortcut;
 316
 317
 318     if (w == panel->sclearB) {
 319         WMSetTextFieldText(panel->shortT, "");
 320         updateMenuItem(panel, panel->currentItem, panel->shortT);
 321         return;
 322     }
 323
 324     if (!panel->capturing) {
 325         panel->capturing = 1;
 326         WMSetButtonText(w, _("Cancel"));
 327         XGrabKeyboard(dpy, WMWidgetXID(panel->win), True, GrabModeAsync,
 328                       GrabModeAsync, CurrentTime);
 329         shortcut = captureShortcut(dpy, panel);
 330         if (shortcut) {
 331             WMSetTextFieldText(panel->shortT, shortcut);
 332             updateMenuItem(panel, panel->currentItem, panel->shortT);
 333             wfree(shortcut);
 334         }
 335     }
 336     panel->capturing = 0;
 337     WMSetButtonText(w, _("Capture"));
 338     XUngrabKeyboard(dpy, CurrentTime);
 339 }
 340
 341
 342 static void
 343 changedItemPad(WMWidget *w, void *data)
 344 {
 345     _Panel *panel = (_Panel*)data;
 346     int padn = WMGetPopUpButtonSelectedItem(w);
 347
 348     WMUnmapWidget(panel->itemPad[panel->currentPad]);
 349     WMMapWidget(panel->itemPad[padn]);
 350
 351     panel->currentPad = padn;
 352 }
 353
 354
 355 static WEditMenu*
 356 putNewSubmenu(WEditMenu *menu, char *title)
 357 {
 358     WEditMenu *tmp;
 359     WEditMenuItem *item;
 360
 361     item = WAddMenuItemWithTitle(menu, title);
 362
 363     tmp = WCreateEditMenu(WMWidgetScreen(menu), title);
 364     WSetEditMenuAcceptsDrop(tmp, True);
 365     WSetEditMenuDelegate(tmp, &menuDelegate);
 366     WSetEditMenuSubmenu(menu, item, tmp);
 367
 368     return tmp;
 369 }
 370
 371
 372 static ItemData*
 373 putNewItem(_Panel *panel, WEditMenu *menu, int type, char *title)
 374 {
 375     WEditMenuItem *item;
 376     ItemData *data;
 377
 378     item = WAddMenuItemWithTitle(menu, title);
 379
 380     data = NEW(ItemData);
 381     data->type = type;
 382     WSetEditMenuItemData(item, data, (WMCallback*)freeItemData);
 383     WSetEditMenuItemImage(item, panel->markerPix[type]);
 384
 385     return data;
 386 }
 387
 388
 389 static WEditMenu*
 390 makeFactoryMenu(WMWidget *parent, int width)
 391 {
 392     WEditMenu *pad;
 393
 394     pad = WCreateEditMenuPad(parent);
 395     WMResizeWidget(pad, width, 10);
 396     WSetEditMenuMinSize(pad, wmksize(width, 0));
 397     WSetEditMenuMaxSize(pad, wmksize(width, 0));
 398     WSetEditMenuSelectable(pad, False);
 399     WSetEditMenuEditable(pad, False);
 400     WSetEditMenuIsFactory(pad, True);
 401     WSetEditMenuDelegate(pad, &menuDelegate);
 402
 403     return pad;
 404 }
 405
 406
 407 static void
 408 createPanel(_Panel *p)
 409 {
 410     _Panel *panel = (_Panel*)p;
 411     WMScreen *scr = WMWidgetScreen(panel->win);
 412     WMColor *black = WMBlackColor(scr);
 413     WMColor *white = WMWhiteColor(scr);
 414     WMColor *gray = WMGrayColor(scr);
 415     WMFont *bold = WMBoldSystemFontOfSize(scr, 12);
 416     WMFont *font = WMSystemFontOfSize(scr, 12);
 417     WMLabel *label;
 418     int width;
 419
 420
 421     menuDelegate.data = panel;
 422
 423
 424     panel->boldFont = bold;
 425     panel->normalFont = font;
 426
 427     panel->black = black;
 428     panel->white = white;
 429     panel->gray = gray;
 430
 431     {
 432         Pixmap pix;
 433         Display *dpy = WMScreenDisplay(scr);
 434         GC gc;
 435         WMPixmap *pixm;
 436
 437         pixm = WMCreatePixmap(scr, 7, 7, WMScreenDepth(scr), True);
 438
 439         pix = WMGetPixmapXID(pixm);
 440
 441         XDrawLine(dpy, pix, WMColorGC(black), 0, 3, 6, 3);
 442         XDrawLine(dpy, pix, WMColorGC(black), 3, 0, 3, 6);
 443         /*
 444         XDrawLine(dpy, pix, WMColorGC(black), 1, 0, 3, 3);
 445         XDrawLine(dpy, pix, WMColorGC(black), 1, 6, 3, 3);
 446         XDrawLine(dpy, pix, WMColorGC(black), 0, 0, 0, 6);
 447          */
 448
 449         pix = WMGetPixmapMaskXID(pixm);
 450
 451         gc = XCreateGC(dpy, pix, 0, NULL);
 452
 453         XSetForeground(dpy, gc, 0);
 454         XFillRectangle(dpy, pix, gc, 0, 0, 7, 7);
 455
 456         XSetForeground(dpy, gc, 1);
 457         XDrawLine(dpy, pix, gc, 0, 3, 6, 3);
 458         XDrawLine(dpy, pix, gc, 3, 0, 3, 6);
 459
 460         panel->markerPix[ExternalInfo] = pixm;
 461         panel->markerPix[PipeInfo] = pixm;
 462         panel->markerPix[DirectoryInfo] = pixm;
 463         panel->markerPix[WSMenuInfo] = pixm;
 464
 465         XFreeGC(dpy, gc);
 466     }
 467
 468
 469     panel->frame = WMCreateFrame(panel->win);
 470     WMResizeWidget(panel->frame, FRAME_WIDTH, FRAME_HEIGHT);
 471     WMMoveWidget(panel->frame, FRAME_LEFT, FRAME_TOP);
 472
 473     panel->typeP = WMCreatePopUpButton(panel->frame);
 474     WMResizeWidget(panel->typeP, 150, 20);
 475     WMMoveWidget(panel->typeP, 10, 10);
 476
 477     WMAddPopUpButtonItem(panel->typeP, _("New Items"));
 478     WMAddPopUpButtonItem(panel->typeP, _("Sample Commands"));
 479     WMAddPopUpButtonItem(panel->typeP, _("Sample Submenus"));
 480
 481     WMSetPopUpButtonAction(panel->typeP, changedItemPad, panel);
 482
 483     WMSetPopUpButtonSelectedItem(panel->typeP, 0);
 484
 485     {
 486         WEditMenu *pad;
 487         WEditMenu *smenu;
 488         ItemData *data;
 489
 490         pad = makeFactoryMenu(panel->frame, 150);
 491         WMMoveWidget(pad, 10, 40);
 492
 493         data = putNewItem(panel, pad, ExecInfo, "Run Program");
 494         data = putNewItem(panel, pad, CommandInfo, "Internal Command");
 495         smenu = putNewSubmenu(pad, "Submenu");
 496         data = putNewItem(panel, pad, ExternalInfo, "External Submenu");
 497         data = putNewItem(panel, pad, PipeInfo, "Generated Submenu");
 498         data = putNewItem(panel, pad, DirectoryInfo, "Directory Contents");
 499         data = putNewItem(panel, pad, WSMenuInfo, "Workspace Menu");
 500
 501         panel->itemPad[0] = pad;
 502     }
 503
 504     {
 505         WEditMenu *pad;
 506         ItemData *data;
 507         WMScrollView *sview;
 508
 509         sview = WMCreateScrollView(panel->frame);
 510         WMResizeWidget(sview, 150, 180);
 511         WMMoveWidget(sview, 10, 40);
 512         WMSetScrollViewHasVerticalScroller(sview, True);
 513
 514         pad = makeFactoryMenu(panel->frame, 130);
 515
 516         WMSetScrollViewContentView(sview, WMWidgetView(pad));
 517
 518         data = putNewItem(panel, pad, ExecInfo, _("XTerm"));
 519         data->param.exec.command = "xterm -sb -sl 2000 -bg black -fg white";
 520
 521         data = putNewItem(panel, pad, ExecInfo, _("rxvt"));
 522         data->param.exec.command = "rxvt";
 523
 524         data = putNewItem(panel, pad, ExecInfo, _("ETerm"));
 525         data->param.exec.command = "eterm";
 526
 527         data = putNewItem(panel, pad, ExecInfo, _("Run..."));
 528         data->param.exec.command = "%a(Run,Type command to run)";
 529
 530         data = putNewItem(panel, pad, ExecInfo, _("Netscape"));
 531         data->param.exec.command = "netscape";
 532
 533         data = putNewItem(panel, pad, ExecInfo, _("gimp"));
 534         data->param.exec.command = "gimp";
 535
 536         data = putNewItem(panel, pad, ExecInfo, _("epic"));
 537         data->param.exec.command = "xterm -e epic";
 538
 539         data = putNewItem(panel, pad, ExecInfo, _("ee"));
 540         data->param.exec.command = "ee";
 541
 542         data = putNewItem(panel, pad, ExecInfo, _("xv"));
 543         data->param.exec.command = "xv";
 544
 545         data = putNewItem(panel, pad, ExecInfo, _("Acrobat Reader"));
 546         data->param.exec.command = "acroread || /usr/local/Acrobat4/bin/acroread";
 547
 548         data = putNewItem(panel, pad, ExecInfo, _("ghostview"));
 549         data->param.exec.command = "gv";
 550
 551         data = putNewItem(panel, pad, CommandInfo, _("Exit Window Maker"));
 552         data->param.command.command = 3;
 553
 554         WMMapWidget(pad);
 555
 556         panel->itemPad[1] = sview;
 557     }
 558
 559
 560     {
 561         WEditMenu *pad, *smenu;
 562         ItemData *data;
 563         WMScrollView *sview;
 564
 565         sview = WMCreateScrollView(panel->frame);
 566         WMResizeWidget(sview, 150, 180);
 567         WMMoveWidget(sview, 10, 40);
 568         WMSetScrollViewHasVerticalScroller(sview, True);
 569
 570         pad = makeFactoryMenu(panel->frame, 130);
 571
 572         WMSetScrollViewContentView(sview, WMWidgetView(pad));
 573
 574         data = putNewItem(panel, pad, ExternalInfo, _("Debian Menu"));
 575         data->param.pipe.command = "/etc/X11/WindowMaker/menu.hook";
 576
 577         data = putNewItem(panel, pad, PipeInfo, _("RedHat Menu"));
 578         data->param.pipe.command = "wmconfig --output wmaker";
 579
 580         data = putNewItem(panel, pad, PipeInfo, _("Menu Conectiva"));
 581         data->param.pipe.command = "wmconfig --output wmaker";
 582
 583         data = putNewItem(panel, pad, DirectoryInfo, _("Themes"));
 584         data->param.directory.command = "setstyle";
 585         data->param.directory.directory = "/usr/share/WindowMaker/Themes /usr/local/share/WindowMaker/Themes $HOME/GNUstep/Library/WindowMaker/Themes";
 586         data->param.directory.stripExt = 1;
 587
 588         data = putNewItem(panel, pad, DirectoryInfo, _("Bg Images (scale)"));
 589         data->param.directory.command = "wmsetbg -u -s";
 590         data->param.directory.directory = "/opt/kde2/share/wallpapers /usr/share/WindowMaker/Backgrounds $HOME/GNUstep/Library/WindowMaker/Backgrounds";
 591         data->param.directory.stripExt = 1;
 592
 593         data = putNewItem(panel, pad, DirectoryInfo, _("Bg Images (tile)"));
 594         data->param.directory.command = "wmsetbg -u -t";
 595         data->param.directory.directory = "/opt/kde2/share/wallpapers /usr/share/WindowMaker/Backgrounds $HOME/GNUstep/Library/WindowMaker/Backgrounds";
 596         data->param.directory.stripExt = 1;
 597
 598         smenu = putNewSubmenu(pad, _("Assorted XTerms"));
 599
 600         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Yellow on Blue"));
 601         data->param.exec.command = "xterm -sb -sl 2000 -bg midnightblue -fg yellow";
 602
 603         data = putNewItem(panel, smenu, ExecInfo, _("XTerm White on Black"));
 604         data->param.exec.command = "xterm -sb -sl 2000 -bg black -fg white";
 605
 606         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Black on White"));
 607         data->param.exec.command = "xterm -sb -sl 2000 -bg white -fg black";
 608
 609         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Black on Beige"));
 610         data->param.exec.command = "xterm -sb -sl 2000 -bg '#bbbb99' -fg black";
 611
 612         data = putNewItem(panel, smenu, ExecInfo, _("XTerm White on Green"));
 613         data->param.exec.command = "xterm -sb -sl 2000 -bg '#228822' -fg white";
 614
 615         data = putNewItem(panel, smenu, ExecInfo, _("XTerm White on Olive"));
 616         data->param.exec.command = "xterm -sb -sl 2000 -bg '#335533' -fg white";
 617
 618         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Blue on Blue"));
 619         data->param.exec.command = "xterm -sb -sl 2000 -bg '#112244' -fg '#88aabb'";
 620
 621         data = putNewItem(panel, smenu, ExecInfo, _("XTerm BIG FONTS"));
 622         data->param.exec.command = "xterm -sb -sl 2000 -bg black -fg white -fn 10x20";
 623
 624         WMMapWidget(pad);
 625
 626         panel->itemPad[2] = sview;
 627     }
 628
 629
 630     width = FRAME_WIDTH - 20 - 150 - 10;
 631
 632     panel->optionsF = WMCreateFrame(panel->frame);
 633     WMResizeWidget(panel->optionsF, width, FRAME_HEIGHT - 15);
 634     WMMoveWidget(panel->optionsF, 10 + 150 + 10, 5);
 635
 636     width -= 20;
 637
 638     /* command */
 639
 640     panel->commandF = WMCreateFrame(panel->optionsF);
 641     WMResizeWidget(panel->commandF, width, 50);
 642     WMMoveWidget(panel->commandF, 10, 20);
 643     WMSetFrameTitle(panel->commandF, _("Program to Run"));
 644
 645     panel->commandT = WMCreateTextField(panel->commandF);
 646     WMResizeWidget(panel->commandT, width - 20, 20);
 647     WMMoveWidget(panel->commandT, 10, 20);
 648
 649     WMAddNotificationObserver(dataChanged, panel,
 650                               WMTextDidChangeNotification,
 651                               panel->commandT);
 652
 653 #if 0
 654     panel->xtermC = WMCreateSwitchButton(panel->commandF);
 655     WMResizeWidget(panel->xtermC, width - 20, 20);
 656     WMMoveWidget(panel->xtermC, 10, 50);
 657     WMSetButtonText(panel->xtermC, _("Run the program inside a Xterm"));
 658 #endif
 659     WMMapSubwidgets(panel->commandF);
 660
 661
 662     /* path */
 663
 664     panel->pathF = WMCreateFrame(panel->optionsF);
 665     WMResizeWidget(panel->pathF, width, 150);
 666     WMMoveWidget(panel->pathF, 10, 40);
 667     WMSetFrameTitle(panel->pathF, _("Path for Menu"));
 668
 669     panel->pathT = WMCreateTextField(panel->pathF);
 670     WMResizeWidget(panel->pathT, width - 20, 20);
 671     WMMoveWidget(panel->pathT, 10, 20);
 672
 673     WMAddNotificationObserver(dataChanged, panel,
 674                               WMTextDidChangeNotification,
 675                               panel->pathT);
 676
 677     label = WMCreateLabel(panel->pathF);
 678     WMResizeWidget(label, width - 20, 80);
 679     WMMoveWidget(label, 10, 50);
 680     WMSetLabelText(label, _("Enter the path for a file containing a menu\n"
 681                             "or a list of directories with the programs you\n"
 682                             "want to have listed in the menu. Ex:\n"
 683                             "~/GNUstep/Library/WindowMaker/menu\n"
 684                             "or\n"
 685                             "/usr/X11R6/bin ~/xbin"));
 686
 687     WMMapSubwidgets(panel->pathF);
 688
 689
 690     /* pipe */
 691
 692     panel->pipeF = WMCreateFrame(panel->optionsF);
 693     WMResizeWidget(panel->pipeF, width, 100);
 694     WMMoveWidget(panel->pipeF, 10, 50);
 695     WMSetFrameTitle(panel->pipeF, _("Command"));
 696
 697     panel->pipeT = WMCreateTextField(panel->pipeF);
 698     WMResizeWidget(panel->pipeT, width - 20, 20);
 699     WMMoveWidget(panel->pipeT, 10, 20);
 700
 701     WMAddNotificationObserver(dataChanged, panel,
 702                               WMTextDidChangeNotification,
 703                               panel->pipeT);
 704
 705
 706     label = WMCreateLabel(panel->pipeF);
 707     WMResizeWidget(label, width - 20, 40);
 708     WMMoveWidget(label, 10, 50);
 709     WMSetLabelText(label, _("Enter a command that outputs a menu\n"
 710                             "definition to stdout when invoked."));
 711
 712     WMMapSubwidgets(panel->pipeF);
 713
 714
 715     /* directory menu */
 716
 717     panel->dcommandF = WMCreateFrame(panel->optionsF);
 718     WMResizeWidget(panel->dcommandF, width, 90);
 719     WMMoveWidget(panel->dcommandF, 10, 25);
 720     WMSetFrameTitle(panel->dcommandF, _("Command to Open Files"));
 721
 722     panel->dcommandT = WMCreateTextField(panel->dcommandF);
 723     WMResizeWidget(panel->dcommandT, width - 20, 20);
 724     WMMoveWidget(panel->dcommandT, 10, 20);
 725
 726     WMAddNotificationObserver(dataChanged, panel,
 727                               WMTextDidChangeNotification,
 728                               panel->dcommandT);
 729
 730
 731     label = WMCreateLabel(panel->dcommandF);
 732     WMResizeWidget(label, width - 20, 45);
 733     WMMoveWidget(label, 10, 40);
 734     WMSetLabelText(label, _("Enter the command you want to use to open the\n"
 735                             "files in the directories listed below."));
 736
 737     WMMapSubwidgets(panel->dcommandF);
 738
 739
 740     panel->dpathF = WMCreateFrame(panel->optionsF);
 741     WMResizeWidget(panel->dpathF, width, 80);
 742     WMMoveWidget(panel->dpathF, 10, 125);
 743     WMSetFrameTitle(panel->dpathF, _("Directories with Files"));
 744
 745     panel->dpathT = WMCreateTextField(panel->dpathF);
 746     WMResizeWidget(panel->dpathT, width - 20, 20);
 747     WMMoveWidget(panel->dpathT, 10, 20);
 748
 749     WMAddNotificationObserver(dataChanged, panel,
 750                               WMTextDidChangeNotification,
 751                               panel->dpathT);
 752
 753     panel->dstripB = WMCreateSwitchButton(panel->dpathF);
 754     WMResizeWidget(panel->dstripB, width - 20, 20);
 755     WMMoveWidget(panel->dstripB, 10, 50);
 756     WMSetButtonText(panel->dstripB, _("Strip extensions from file names"));
 757
 758     WMSetButtonAction(panel->dstripB, buttonClicked, panel);
 759
 760     WMMapSubwidgets(panel->dpathF);
 761
 762
 763     /* shortcut */
 764
 765     panel->shortF = WMCreateFrame(panel->optionsF);
 766     WMResizeWidget(panel->shortF, width, 50);
 767     WMMoveWidget(panel->shortF, 10, 160);
 768     WMSetFrameTitle(panel->shortF, _("Keyboard Shortcut"));
 769
 770     panel->shortT = WMCreateTextField(panel->shortF);
 771     WMResizeWidget(panel->shortT, width - 20 - 170, 20);
 772     WMMoveWidget(panel->shortT, 10, 20);
 773
 774     WMAddNotificationObserver(dataChanged, panel,
 775                               WMTextDidChangeNotification,
 776                               panel->shortT);
 777
 778     panel->sgrabB = WMCreateCommandButton(panel->shortF);
 779     WMResizeWidget(panel->sgrabB, 80, 24);
 780     WMMoveWidget(panel->sgrabB, width - 90, 18);
 781     WMSetButtonText(panel->sgrabB, _("Capture"));
 782     WMSetButtonAction(panel->sgrabB, sgrabClicked, panel);
 783
 784     panel->sclearB = WMCreateCommandButton(panel->shortF);
 785     WMResizeWidget(panel->sclearB, 80, 24);
 786     WMMoveWidget(panel->sclearB, width - 175, 18);
 787     WMSetButtonText(panel->sclearB, _("Clear"));
 788     WMSetButtonAction(panel->sclearB, sgrabClicked, panel);
 789
 790     WMMapSubwidgets(panel->shortF);
 791
 792     /* internal command */
 793
 794     panel->icommandL = WMCreateList(panel->optionsF);
 795     WMResizeWidget(panel->icommandL, width, 80);
 796     WMMoveWidget(panel->icommandL, 10, 20);
 797
 798     WMSetListAction(panel->icommandL, icommandLClicked, panel);
 799
 800     WMAddNotificationObserver(dataChanged, panel,
 801                               WMListSelectionDidChangeNotification,
 802                               panel->icommandL);
 803
 804     WMInsertListItem(panel->icommandL, 0, _("Arrange Icons"));
 805     WMInsertListItem(panel->icommandL, 1, _("Hide All Windows Except For The Focused One"));
 806     WMInsertListItem(panel->icommandL, 2, _("Show All Windows"));
 807
 808     WMInsertListItem(panel->icommandL, 3, _("Exit Window Maker"));
 809     WMInsertListItem(panel->icommandL, 4, _("Exit X Session"));
 810     WMInsertListItem(panel->icommandL, 5, _("Restart Window Maker"));
 811     WMInsertListItem(panel->icommandL, 6, _("Start Another Window Manager   : ("));
 812
 813     WMInsertListItem(panel->icommandL, 7, _("Save Current Session"));
 814     WMInsertListItem(panel->icommandL, 8, _("Clear Saved Session"));
 815     WMInsertListItem(panel->icommandL, 9, _("Refresh Screen"));
 816     WMInsertListItem(panel->icommandL, 10, _("Open Info Panel"));
 817     WMInsertListItem(panel->icommandL, 11, _("Open Copyright Panel"));
 818
 819
 820     panel->paramF = WMCreateFrame(panel->optionsF);
 821     WMResizeWidget(panel->paramF, width, 50);
 822     WMMoveWidget(panel->paramF, 10, 105);
 823     WMSetFrameTitle(panel->paramF, _("Window Manager to Start"));
 824
 825     panel->paramT = WMCreateTextField(panel->paramF);
 826     WMResizeWidget(panel->paramT, width - 20, 20);
 827     WMMoveWidget(panel->paramT, 10, 20);
 828
 829     WMAddNotificationObserver(dataChanged, panel,
 830                               WMTextDidChangeNotification,
 831                               panel->paramT);
 832
 833     WMMapSubwidgets(panel->paramF);
 834
 835
 836     panel->quickB = WMCreateSwitchButton(panel->optionsF);
 837     WMResizeWidget(panel->quickB, width, 20);
 838     WMMoveWidget(panel->quickB, 10, 120);
 839     WMSetButtonText(panel->quickB, _("Do not confirm action."));
 840     WMSetButtonAction(panel->quickB, buttonClicked, panel);
 841
 842
 843
 844
 845     label = WMCreateLabel(panel->optionsF);
 846     WMResizeWidget(label, width - 20, FRAME_HEIGHT - 50);
 847     WMMoveWidget(label, 10, 20);
 848     WMSetLabelText(label,
 849                    _("Instructions:\n\n"
 850                      " - drag items from the left to the menu to add new items\n"
 851                      " - drag items out of the menu to remove items\n"
 852                      " - drag items in menu to change their position\n"
 853                      " - drag items with Control pressed to copy them\n"
 854                      " - double click in a menu item to change the label\n"
 855                      " - click on a menu item to change related information"));
 856     WMMapWidget(label);
 857
 858     WMRealizeWidget(panel->frame);
 859     WMMapSubwidgets(panel->frame);
 860     WMMapWidget(panel->frame);
 861
 862
 863     {
 864         int i;
 865         for (i = 0; i < 3; i++)
 866             WMUnmapWidget(panel->itemPad[i]);
 867     }
 868     changedItemPad(panel->typeP, panel);
 869
 870     panel->sections[NoInfo][0] = label;
 871
 872     panel->sections[ExecInfo][0] = panel->commandF;
 873     panel->sections[ExecInfo][1] = panel->shortF;
 874
 875     panel->sections[CommandInfo][0] = panel->icommandL;
 876     panel->sections[CommandInfo][1] = panel->shortF;
 877
 878     panel->sections[ExternalInfo][0] = panel->pathF;
 879
 880     panel->sections[PipeInfo][0] = panel->pipeF;
 881
 882     panel->sections[DirectoryInfo][0] = panel->dpathF;
 883     panel->sections[DirectoryInfo][1] = panel->dcommandF;
 884
 885     panel->currentType = NoInfo;
 886
 887     showData(panel);
 888
 889     {
 890         WMPoint pos;
 891
 892         pos = WMGetViewScreenPosition(WMWidgetView(panel->frame));
 893
 894         if (pos.x < 200) {
 895             pos.x += FRAME_WIDTH + 20;
 896         } else {
 897             pos.x = 10;
 898         }
 899
 900         pos.y = WMAX(pos.y - 100, 0);
 901
 902         WEditMenuShowAt(panel->menu, pos.x, pos.y);
 903     }
 904 }
 905
 906
 907
 908
 909 static void
 910 freeItemData(ItemData *data)
 911 {
 912 #define CFREE(d) if (d) wfree(d)
 913
 914     /* TODO */
 915     switch (data->type) {
 916      case CommandInfo:
 917         CFREE(data->param.command.parameter);
 918         CFREE(data->param.command.shortcut);
 919         break;
 920
 921      case ExecInfo:
 922         CFREE(data->param.exec.command);
 923         CFREE(data->param.exec.shortcut);
 924         break;
 925
 926      case PipeInfo:
 927         CFREE(data->param.pipe.command);
 928         break;
 929
 930      case ExternalInfo:
 931         CFREE(data->param.external.path);
 932         break;
 933
 934      case DirectoryInfo:
 935         CFREE(data->param.directory.command);
 936         CFREE(data->param.directory.directory);
 937         break;
 938
 939      default:
 940         break;
 941     }
 942
 943     wfree(data);
 944 #undef CFREE
 945 }
 946
 947
 948 static ItemData*
 949 parseCommand(proplist_t item)
 950 {
 951     ItemData *data = NEW(ItemData);
 952     proplist_t p;
 953     char *command = NULL;
 954     char *parameter = NULL;
 955     char *shortcut = NULL;
 956     int i = 1;
 957
 958
 959     p = PLGetArrayElement(item, i++);
 960     command = PLGetString(p);
 961     if (strcmp(command, "SHORTCUT") == 0) {
 962         p = PLGetArrayElement(item, i++);
 963         shortcut = PLGetString(p);
 964         p = PLGetArrayElement(item, i++);
 965         command = PLGetString(p);
 966     }
 967     p = PLGetArrayElement(item, i++);
 968     if (p)
 969         parameter = PLGetString(p);
 970
 971     if (strcmp(command, "EXEC") == 0 || strcmp(command, "SHEXEC") == 0) {
 972
 973         data->type = ExecInfo;
 974
 975         data->param.exec.command = wstrdup(parameter);
 976         if (shortcut)
 977             data->param.exec.shortcut = wstrdup(shortcut);
 978
 979     } else if (strcmp(command, "OPEN_MENU") == 0) {
 980         char *p;
 981         /*
 982          * dir menu, menu file
 983          * dir WITH
 984          * |pipe (TODO: ||pipe)
 985          */
 986         p = parameter;
 987         while (isspace(*p) && *p) p++;
 988         if (*p == '|') {
 989             data->type = PipeInfo;
 990             data->param.pipe.command = wtrimspace(p+1);
 991         } else {
 992             char *s;
 993
 994             p = wstrdup(p);
 995
 996             s = strstr(p, "WITH");
 997             if (s) {
 998                 char **tokens;
 999                 char **ctokens;
1000                 int tokn;
1001                 int i, j;
1002
1003                 data->type = DirectoryInfo;
1004
1005                 *s = '\0';
1006                 s += 5;
1007                 while (*s && isspace(*s)) s++;
1008                 data->param.directory.command = wstrdup(s);
1009
1010                 wtokensplit(p, &tokens, &tokn);
1011                 wfree(p);
1012
1013                 ctokens = wmalloc(sizeof(char*)*tokn);
1014
1015                 for (i = 0, j = 0; i < tokn; i++) {
1016                     if (strcmp(tokens[i], "-noext") == 0) {
1017                         wfree(tokens[i]);
1018                         data->param.directory.stripExt = 1;
1019                     } else {
1020                         ctokens[j++] = tokens[i];
1021                     }
1022                 }
1023                 data->param.directory.directory = wtokenjoin(ctokens, j);
1024                 wfree(ctokens);
1025
1026                 wtokenfree(tokens, tokn);
1027             } else {
1028                 data->type = ExternalInfo;
1029                 data->param.external.path = p;
1030             }
1031         }
1032     } else if (strcmp(command, "WORKSPACE_MENU") == 0) {
1033         data->type = WSMenuInfo;
1034     } else {
1035         int cmd;
1036
1037         if (strcmp(command, "ARRANGE_ICONS") == 0) {
1038             cmd = 0;
1039         } else if (strcmp(command, "HIDE_OTHERS") == 0) {
1040             cmd = 1;
1041         } else if (strcmp(command, "SHOW_ALL") == 0) {
1042             cmd = 2;
1043         } else if (strcmp(command, "EXIT") == 0) {
1044             cmd = 3;
1045         } else if (strcmp(command, "SHUTDOWN") == 0) {
1046             cmd = 4;
1047         } else if (strcmp(command, "RESTART") == 0) {
1048             if (parameter) {
1049                 cmd = 6;
1050             } else {
1051                 cmd = 5;
1052             }
1053         } else if (strcmp(command, "SAVE_SESSION") == 0) {
1054             cmd = 7;
1055         } else if (strcmp(command, "CLEAR_SESSION") == 0) {
1056             cmd = 8;
1057         } else if (strcmp(command, "REFRESH") == 0) {
1058             cmd = 9;
1059         } else if (strcmp(command, "INFO_PANEL") == 0) {
1060             cmd = 10;
1061         } else if (strcmp(command, "LEGAL_PANEL") == 0) {
1062             cmd = 11;
1063         } else {
1064             wwarning(_("unknown command '%s' in menu"), command);
1065             goto error;
1066         }
1067
1068         data->type = CommandInfo;
1069
1070         data->param.command.command = cmd;
1071         if (shortcut)
1072             data->param.command.shortcut = wstrdup(shortcut);
1073         if (parameter)
1074             data->param.command.parameter = wstrdup(parameter);
1075     }
1076
1077     return data;
1078
1079 error:
1080     wfree(data);
1081
1082     return NULL;
1083 }
1084
1085
1086
1087
1088 static void
1089 updateFrameTitle(_Panel *panel, char *title, InfoType type)
1090 {
1091     if (type != NoInfo) {
1092         char *tmp;
1093
1094         switch (type) {
1095          case ExecInfo:
1096             tmp = wstrconcat(title, _(": Execute Program"));
1097             break;
1098
1099          case CommandInfo:
1100             tmp = wstrconcat(title, _(": Perform Internal Command"));
1101             break;
1102
1103          case ExternalInfo:
1104             tmp = wstrconcat(title, _(": Open a Submenu"));
1105             break;
1106
1107          case PipeInfo:
1108             tmp = wstrconcat(title, _(": Program Generated Submenu"));
1109             break;
1110
1111          case DirectoryInfo:
1112             tmp = wstrconcat(title, _(": Directory Contents Menu"));
1113             break;
1114
1115          case WSMenuInfo:
1116             tmp = wstrconcat(title, _(": Open Workspaces Submenu"));
1117             break;
1118
1119          default:
1120             tmp = NULL;
1121             break;
1122         }
1123         WMSetFrameTitle(panel->optionsF, tmp);
1124         wfree(tmp);
1125     } else {
1126         WMSetFrameTitle(panel->optionsF, NULL);
1127     }
1128 }
1129
1130
1131
1132 static void
1133 changeInfoType(_Panel *panel, char *title, InfoType type)
1134 {
1135     WMWidget **w;
1136
1137     if (panel->currentType != type) {
1138
1139         w = panel->sections[panel->currentType];
1140
1141         while (*w) {
1142             WMUnmapWidget(*w);
1143             w++;
1144         }
1145         WMUnmapWidget(panel->paramF);
1146         WMUnmapWidget(panel->quickB);
1147
1148
1149         w = panel->sections[type];
1150
1151         while (*w) {
1152             WMMapWidget(*w);
1153             w++;
1154         }
1155     }
1156
1157     updateFrameTitle(panel, title, type);
1158
1159     panel->currentType = type;
1160 }
1161
1162
1163
1164
1165 static void
1166 updateMenuItem(_Panel *panel, WEditMenuItem *item, WMWidget *changedWidget)
1167 {
1168     ItemData *data = WGetEditMenuItemData(item);
1169
1170     assert(data != NULL);
1171
1172 #define REPLACE(v, d) if (v) wfree(v); v = d
1173
1174     switch (data->type) {
1175      case ExecInfo:
1176         if (changedWidget == panel->commandT) {
1177             REPLACE(data->param.exec.command,
1178                     WMGetTextFieldText(panel->commandT));
1179         }
1180         if (changedWidget == panel->shortT) {
1181             REPLACE(data->param.exec.shortcut,
1182                     WMGetTextFieldText(panel->shortT));
1183         }
1184         break;
1185
1186      case CommandInfo:
1187         if (changedWidget == panel->icommandL) {
1188             data->param.command.command =
1189                 WMGetListSelectedItemRow(panel->icommandL);
1190         }
1191         switch (data->param.command.command) {
1192          case 3:
1193          case 4:
1194             if (changedWidget == panel->quickB) {
1195                 REPLACE(data->param.command.parameter,
1196                         WMGetButtonSelected(panel->quickB)
1197                         ? wstrdup("QUICK") : NULL);
1198             }
1199             break;
1200
1201          case 6:
1202             if (changedWidget == panel->paramT) {
1203                 REPLACE(data->param.command.parameter,
1204                         WMGetTextFieldText(panel->paramT));
1205             }
1206             break;
1207         }
1208         if (changedWidget == panel->shortT) {
1209             REPLACE(data->param.command.shortcut,
1210                     WMGetTextFieldText(panel->shortT));
1211         }
1212
1213
1214         break;
1215
1216      case PipeInfo:
1217         if (changedWidget == panel->pipeT) {
1218             REPLACE(data->param.pipe.command,
1219                     WMGetTextFieldText(panel->pipeT));
1220         }
1221         break;
1222
1223      case ExternalInfo:
1224         if (changedWidget == panel->pathT) {
1225             REPLACE(data->param.external.path,
1226                     WMGetTextFieldText(panel->pathT));
1227         }
1228         break;
1229
1230      case DirectoryInfo:
1231         if (changedWidget == panel->dpathT) {
1232             REPLACE(data->param.directory.directory,
1233                     WMGetTextFieldText(panel->dpathT));
1234         }
1235         if (changedWidget == panel->dcommandT) {
1236             REPLACE(data->param.directory.command,
1237                     WMGetTextFieldText(panel->dcommandT));
1238         }
1239         if (changedWidget == panel->dstripB) {
1240             data->param.directory.stripExt =
1241                 WMGetButtonSelected(panel->dstripB);
1242         }
1243         break;
1244
1245      default:
1246         assert(0);
1247         break;
1248     }
1249
1250 #undef REPLACE
1251 }
1252
1253
1254
1255 static void
1256 menuItemCloned(WEditMenuDelegate *delegate, WEditMenu *menu,
1257                WEditMenuItem *origItem, WEditMenuItem *newItem)
1258 {
1259     ItemData *data = WGetEditMenuItemData(origItem);
1260     ItemData *newData;
1261
1262     if (!data)
1263         return;
1264
1265 #define DUP(s) (s) ? wstrdup(s) : NULL
1266
1267     newData = NEW(ItemData);
1268
1269     newData->type = data->type;
1270
1271     switch (data->type) {
1272      case ExecInfo:
1273         newData->param.exec.command = DUP(data->param.exec.command);
1274         newData->param.exec.shortcut = DUP(data->param.exec.shortcut);
1275         break;
1276
1277      case CommandInfo:
1278         newData->param.command.command = data->param.command.command;
1279         newData->param.command.parameter = DUP(data->param.command.parameter);
1280         newData->param.command.shortcut = DUP(data->param.command.shortcut);
1281         break;
1282
1283      case PipeInfo:
1284         newData->param.pipe.command = DUP(data->param.pipe.command);
1285         break;
1286
1287      case ExternalInfo:
1288         newData->param.external.path = DUP(data->param.external.path);
1289         break;
1290
1291      case DirectoryInfo:
1292         newData->param.directory.directory = DUP(data->param.directory.directory);
1293         newData->param.directory.command = DUP(data->param.directory.command);
1294         newData->param.directory.stripExt = data->param.directory.stripExt;
1295         break;
1296
1297      default:
1298         break;
1299     }
1300
1301 #undef DUP
1302
1303     WSetEditMenuItemData(newItem, newData, (WMCallback*)freeItemData);
1304 }
1305
1306
1307 static void
1308 menuItemEdited(struct WEditMenuDelegate *delegate, WEditMenu *menu,
1309                WEditMenuItem *item)
1310 {
1311     _Panel *panel = (_Panel*)delegate->data;
1312     WEditMenu *submenu;
1313
1314     updateFrameTitle(panel, WGetEditMenuItemTitle(item), panel->currentType);
1315
1316     submenu = WGetEditMenuSubmenu(menu, item);
1317     if (submenu) {
1318         WSetEditMenuTitle(submenu, WGetEditMenuItemTitle(item));
1319     }
1320 }
1321
1322
1323 static Bool
1324 shouldRemoveItem(struct WEditMenuDelegate *delegate, WEditMenu *menu,
1325                  WEditMenuItem *item)
1326 {
1327     _Panel *panel = (_Panel*)delegate->data;
1328
1329     if (panel->dontAsk)
1330         return True;
1331
1332     if (WGetEditMenuSubmenu(menu, item)) {
1333         int res;
1334
1335         res = WMRunAlertPanel(WMWidgetScreen(menu), NULL,
1336                               _("Remove Submenu"),
1337                               _("Removing this item will destroy all items inside\n"
1338                                 "the submenu. Do you really want to do that?"),
1339                               _("Yes"), _("No"),
1340                               _("Yes, don't ask again."));
1341         switch (res) {
1342          case WAPRDefault:
1343             return True;
1344          case WAPRAlternate:
1345             return False;
1346          case WAPROther:
1347             panel->dontAsk = True;
1348             return True;
1349         }
1350     }
1351     return True;
1352 }
1353
1354
1355 static void
1356 menuItemDeselected(WEditMenuDelegate *delegate, WEditMenu *menu,
1357                    WEditMenuItem *item)
1358 {
1359     _Panel *panel = (_Panel*)delegate->data;
1360
1361     changeInfoType(panel, NULL, NoInfo);
1362 }
1363
1364
1365 static void
1366 menuItemSelected(WEditMenuDelegate *delegate, WEditMenu *menu,
1367                  WEditMenuItem *item)
1368 {
1369     ItemData *data = WGetEditMenuItemData(item);
1370     _Panel *panel = (_Panel*)delegate->data;
1371
1372     panel->currentItem = item;
1373
1374     if (data) {
1375         changeInfoType(panel, WGetEditMenuItemTitle(item), data->type);
1376
1377         switch (data->type) {
1378          case NoInfo:
1379             break;
1380
1381          case ExecInfo:
1382             WMSetTextFieldText(panel->commandT, data->param.exec.command);
1383             WMSetTextFieldText(panel->shortT, data->param.exec.shortcut);
1384             break;
1385
1386          case CommandInfo:
1387             WMSelectListItem(panel->icommandL,
1388                              data->param.command.command);
1389             WMSetListPosition(panel->icommandL,
1390                               data->param.command.command - 2);
1391             WMSetTextFieldText(panel->shortT, data->param.command.shortcut);
1392
1393             switch (data->param.command.command) {
1394              case 3:
1395              case 4:
1396                 WMSetButtonSelected(panel->quickB,
1397                                     data->param.command.parameter!=NULL);
1398                 break;
1399              case 6:
1400                 WMSetTextFieldText(panel->paramT,
1401                                    data->param.command.parameter);
1402                 break;
1403             }
1404
1405             icommandLClicked(panel->icommandL, panel);
1406             break;
1407
1408          case PipeInfo:
1409             WMSetTextFieldText(panel->pipeT, data->param.pipe.command);
1410             break;
1411
1412          case ExternalInfo:
1413             WMSetTextFieldText(panel->pathT, data->param.external.path);
1414             break;
1415
1416          case DirectoryInfo:
1417             WMSetTextFieldText(panel->dpathT, data->param.directory.directory);
1418             WMSetTextFieldText(panel->dcommandT, data->param.directory.command);
1419             WMSetButtonSelected(panel->dstripB, data->param.directory.stripExt);
1420             break;
1421
1422          case WSMenuInfo:
1423             break;
1424
1425          default:
1426             break;
1427         }
1428     }
1429 }
1430
1431
1432
1433 static WEditMenu*
1434 buildSubmenu(_Panel *panel, proplist_t pl)
1435 {
1436     WMScreen *scr = WMWidgetScreen(panel->win);
1437     WEditMenu *menu;
1438     WEditMenuItem *item;
1439     char *title;
1440     proplist_t tp, bp;
1441     int i;
1442
1443     tp = PLGetArrayElement(pl, 0);
1444     title = PLGetString(tp);
1445
1446     menu = WCreateEditMenu(scr, title);
1447
1448     for (i = 1; i < PLGetNumberOfElements(pl); i++) {
1449         proplist_t pi;
1450
1451         pi = PLGetArrayElement(pl, i);
1452
1453         tp = PLGetArrayElement(pi, 0);
1454         bp = PLGetArrayElement(pi, 1);
1455
1456         title = PLGetString(tp);
1457
1458         if (PLIsArray(bp)) {           /* it's a submenu */
1459             WEditMenu *submenu;
1460
1461             submenu = buildSubmenu(panel, pi);
1462
1463             item = WAddMenuItemWithTitle(menu, title);
1464
1465             WSetEditMenuSubmenu(menu, item, submenu);
1466         } else {
1467             ItemData *data;
1468
1469             item = WAddMenuItemWithTitle(menu, title);
1470
1471             data = parseCommand(pi);
1472
1473             if (panel->markerPix[data->type])
1474                 WSetEditMenuItemImage(item, panel->markerPix[data->type]);
1475             WSetEditMenuItemData(item, data, (WMCallback*)freeItemData);
1476         }
1477     }
1478
1479     WSetEditMenuAcceptsDrop(menu, True);
1480     WSetEditMenuDelegate(menu, &menuDelegate);
1481
1482     WMRealizeWidget(menu);
1483
1484     return menu;
1485 }
1486
1487
1488
1489 static void
1490 buildMenuFromPL(_Panel *panel, proplist_t pl)
1491 {
1492     panel->menu = buildSubmenu(panel, pl);
1493 }
1494
1495
1496
1497 static proplist_t
1498 getDefaultMenu(_Panel *panel)
1499 {
1500     proplist_t menu, pmenu;
1501     char *menuPath, *gspath;
1502
1503     gspath = wusergnusteppath();
1504
1505     menuPath = wmalloc(strlen(gspath)+128);
1506     /* if there is a localized plmenu for the tongue put it's filename here */
1507     sprintf(menuPath, _("%s/Library/WindowMaker/plmenu"), gspath);
1508
1509     menu = PLGetProplistWithPath(menuPath);
1510     if (!menu) {
1511         wwarning("%s:could not read property list menu", menuPath);
1512
1513         if (strcmp("%s/Library/WindowMaker/plmenu",
1514                    _("%s/Library/WindowMaker/plmenu"))!=0) {
1515
1516             sprintf(menuPath, "%s/Library/WindowMaker/plmenu", gspath);
1517             menu = PLGetProplistWithPath(menuPath);
1518             wwarning("%s:could not read property list menu", menuPath);
1519         }
1520         if (!menu) {
1521             char buffer[512];
1522
1523             sprintf(buffer, _("Could not open default menu from '%s'"),
1524                     menuPath);
1525             WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
1526                             _("Error"), buffer, _("OK"), NULL, NULL);
1527         }
1528     }
1529
1530     wfree(menuPath);
1531
1532     if (menu) {
1533         pmenu = menu;
1534     } else {
1535         pmenu = NULL;
1536     }
1537
1538     return pmenu;
1539 }
1540
1541
1542 static void
1543 showData(_Panel *panel)
1544 {
1545     char *gspath;
1546     char *menuPath;
1547     proplist_t pmenu;
1548
1549     gspath = wusergnusteppath();
1550
1551     menuPath = wmalloc(strlen(gspath)+32);
1552     strcpy(menuPath, gspath);
1553     strcat(menuPath, "/Defaults/WMRootMenu");
1554
1555     pmenu = PLGetProplistWithPath(menuPath);
1556
1557     if (!pmenu || !PLIsArray(pmenu)) {
1558         int res;
1559
1560         res = WMRunAlertPanel(WMWidgetScreen(panel->win), panel->win,
1561                               _("Warning"),
1562                               _("The menu file format currently in use is not supported\n"
1563                                 "by this tool. Do you want to discard the current menu\n"
1564                                 "to use this tool?"),
1565                               _("Yes, Discard and Update"),
1566                               _("No, Keep Current Menu"), NULL);
1567
1568         if (res == WAPRDefault) {
1569             pmenu = getDefaultMenu(panel);
1570
1571             if (!pmenu) {
1572                 pmenu = PLMakeArrayFromElements(PLMakeString("Applications"),
1573                                                 NULL);
1574             }
1575         } else {
1576             panel->dontSave = True;
1577             return;
1578         }
1579     }
1580
1581     panel->menuPath = menuPath;
1582
1583     buildMenuFromPL(panel, pmenu);
1584
1585     PLRelease(pmenu);
1586 }
1587
1588
1589 static Bool
1590 notblank(char *s)
1591 {
1592     if (s) {
1593         while (*s++) {
1594             if (!isspace(*s))
1595                 return True;
1596         }
1597     }
1598     return False;
1599 }
1600
1601
1602 static proplist_t
1603 processData(char *title, ItemData *data)
1604 {
1605     proplist_t item;
1606     char *s1;
1607     static char *pscut = NULL;
1608     static char *pomenu = NULL;
1609     int i;
1610
1611     if (!pscut) {
1612         pscut = PLMakeString("SHORTCUT");
1613         pomenu = PLMakeString("OPEN_MENU");
1614     }
1615
1616     item = PLMakeArrayFromElements(PLMakeString(title), NULL);
1617
1618
1619     switch (data->type) {
1620      case ExecInfo:
1621 #if 1
1622         if (strpbrk(data->param.exec.command, "&$*|><?`=")) {
1623             s1 = "SHEXEC";
1624         } else {
1625             s1 = "EXEC";
1626         }
1627 #else
1628         s1 = "SHEXEC";
1629 #endif
1630
1631         if (notblank(data->param.exec.shortcut)) {
1632             PLAppendArrayElement(item, pscut);
1633             PLAppendArrayElement(item,
1634                                  PLMakeString(data->param.exec.shortcut));
1635         }
1636
1637         PLAppendArrayElement(item, PLMakeString(s1));
1638         PLAppendArrayElement(item, PLMakeString(data->param.exec.command));
1639         break;
1640
1641      case CommandInfo:
1642         if (notblank(data->param.command.shortcut)) {
1643             PLAppendArrayElement(item, pscut);
1644             PLAppendArrayElement(item,
1645                                  PLMakeString(data->param.command.shortcut));
1646         }
1647
1648         i = data->param.command.command;
1649
1650         PLAppendArrayElement(item, PLMakeString(commandNames[i]));
1651
1652         switch (i) {
1653          case 3:
1654          case 4:
1655             if (data->param.command.parameter) {
1656                 PLAppendArrayElement(item,
1657                                      PLMakeString(data->param.command.parameter));
1658             }
1659             break;
1660
1661          case 6: /* restart */
1662             if (data->param.command.parameter) {
1663                 PLAppendArrayElement(item,
1664                                      PLMakeString(data->param.command.parameter));
1665             }
1666             break;
1667         }
1668
1669         break;
1670
1671      case PipeInfo:
1672         PLAppendArrayElement(item, pomenu);
1673         s1 = wstrconcat("| ", data->param.pipe.command);
1674         PLAppendArrayElement(item, PLMakeString(s1));
1675         wfree(s1);
1676         break;
1677
1678      case ExternalInfo:
1679         PLAppendArrayElement(item, pomenu);
1680         PLAppendArrayElement(item, PLMakeString(data->param.external.path));
1681         break;
1682
1683      case DirectoryInfo:
1684         {
1685             int l;
1686             char *tmp;
1687
1688             l = strlen(data->param.directory.directory);
1689             l += strlen(data->param.directory.command);
1690             l += 32;
1691
1692             PLAppendArrayElement(item, pomenu);
1693
1694             tmp = wmalloc(l);
1695             sprintf(tmp, "%s%s WITH %s",
1696                     data->param.directory.stripExt ? "-noext " : "",
1697                     data->param.directory.directory,
1698                     data->param.directory.command);
1699
1700             PLAppendArrayElement(item, PLMakeString(tmp));
1701             wfree(tmp);
1702         }
1703         break;
1704
1705      case WSMenuInfo:
1706         PLAppendArrayElement(item, PLMakeString("WORKSPACE_MENU"));
1707         break;
1708
1709      default:
1710         assert(0);
1711         break;
1712     }
1713
1714     return item;
1715 }
1716
1717
1718 static proplist_t
1719 processSubmenu(WEditMenu *menu)
1720 {
1721     WEditMenuItem *item;
1722     proplist_t pmenu;
1723     proplist_t pl;
1724     char *s;
1725     int i;
1726
1727
1728     s = WGetEditMenuTitle(menu);
1729     pl = PLMakeString(s);
1730
1731     pmenu = PLMakeArrayFromElements(pl, NULL);
1732
1733     i = 0;
1734     while ((item = WGetEditMenuItem(menu, i++))) {
1735         WEditMenu *submenu;
1736
1737         s = WGetEditMenuItemTitle(item);
1738
1739         submenu = WGetEditMenuSubmenu(menu, item);
1740         if (submenu) {
1741             pl = processSubmenu(submenu);
1742         } else {
1743             pl = processData(s, WGetEditMenuItemData(item));
1744         }
1745
1746         PLAppendArrayElement(pmenu, pl);
1747     }
1748
1749     return pmenu;
1750 }
1751
1752
1753
1754 static proplist_t
1755 buildPLFromMenu(_Panel *panel)
1756 {
1757     proplist_t menu;
1758
1759     menu = processSubmenu(panel->menu);
1760
1761     return menu;
1762 }
1763
1764
1765
1766
1767 static void
1768 storeData(_Panel *panel)
1769 {
1770     proplist_t menu;
1771
1772     if (panel->dontSave)
1773         return;
1774
1775     menu = buildPLFromMenu(panel);
1776
1777     PLSetFilename(menu, PLMakeString(panel->menuPath));
1778
1779     PLSave(menu, YES);
1780
1781     PLRelease(menu);
1782 }
1783
1784
1785
1786 static void
1787 showMenus(_Panel *panel)
1788 {
1789     WEditMenuUnhide(panel->menu);
1790 }
1791
1792
1793 static void
1794 hideMenus(_Panel *panel)
1795 {
1796     WEditMenuHide(panel->menu);
1797 }
1798
1799
1800
1801
1802 Panel*
1803 InitMenu(WMScreen *scr, WMWindow *win)
1804 {
1805     _Panel *panel;
1806
1807     panel = wmalloc(sizeof(_Panel));
1808     memset(panel, 0, sizeof(_Panel));
1809
1810     panel->sectionName = _("Applications Menu Definition");
1811
1812     panel->description = _("Edit the menu for launching applications.");
1813
1814     panel->win = win;
1815
1816     panel->callbacks.createWidgets = createPanel;
1817     panel->callbacks.updateDomain = storeData;
1818     panel->callbacks.showPanel = showMenus;
1819     panel->callbacks.hidePanel = hideMenus;
1820
1821
1822     AddSection(panel, ICON_FILE);
1823
1824     return panel;
1825 }
1826