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     WMBox *box;
  50     char *sectionName;
  51
  52     char *description;
  53
  54     CallbackRec callbacks;
  55     WMWidget *parent;
  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->parent));
 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->parent), 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->parent);
 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     panel->box = WMCreateBox(panel->parent);
 469     WMSetBoxExpandsToParent(panel->box, 2, 2, 0, 0);
 470
 471     panel->typeP = WMCreatePopUpButton(panel->box);
 472     WMResizeWidget(panel->typeP, 150, 20);
 473     WMMoveWidget(panel->typeP, 10, 10);
 474
 475     WMAddPopUpButtonItem(panel->typeP, _("New Items"));
 476     WMAddPopUpButtonItem(panel->typeP, _("Sample Commands"));
 477     WMAddPopUpButtonItem(panel->typeP, _("Sample Submenus"));
 478
 479     WMSetPopUpButtonAction(panel->typeP, changedItemPad, panel);
 480
 481     WMSetPopUpButtonSelectedItem(panel->typeP, 0);
 482
 483     {
 484         WEditMenu *pad;
 485         WEditMenu *smenu;
 486         ItemData *data;
 487
 488         pad = makeFactoryMenu(panel->box, 150);
 489         WMMoveWidget(pad, 10, 40);
 490
 491         data = putNewItem(panel, pad, ExecInfo, _("Run Program"));
 492         data = putNewItem(panel, pad, CommandInfo, _("Internal Command"));
 493         smenu = putNewSubmenu(pad, _("Submenu"));
 494         data = putNewItem(panel, pad, ExternalInfo, _("External Submenu"));
 495         data = putNewItem(panel, pad, PipeInfo, _("Generated Submenu"));
 496         data = putNewItem(panel, pad, DirectoryInfo, _("Directory Contents"));
 497         data = putNewItem(panel, pad, WSMenuInfo, _("Workspace Menu"));
 498
 499         panel->itemPad[0] = pad;
 500     }
 501
 502     {
 503         WEditMenu *pad;
 504         ItemData *data;
 505         WMScrollView *sview;
 506
 507         sview = WMCreateScrollView(panel->box);
 508         WMResizeWidget(sview, 150, 180);
 509         WMMoveWidget(sview, 10, 40);
 510         WMSetScrollViewHasVerticalScroller(sview, True);
 511
 512         pad = makeFactoryMenu(panel->box, 130);
 513
 514         WMSetScrollViewContentView(sview, WMWidgetView(pad));
 515
 516         data = putNewItem(panel, pad, ExecInfo, _("XTerm"));
 517         data->param.exec.command = "xterm -sb -sl 2000 -bg black -fg white";
 518
 519         data = putNewItem(panel, pad, ExecInfo, _("rxvt"));
 520         data->param.exec.command = "rxvt";
 521
 522         data = putNewItem(panel, pad, ExecInfo, _("ETerm"));
 523         data->param.exec.command = "eterm";
 524
 525         data = putNewItem(panel, pad, ExecInfo, _("Run..."));
 526         data->param.exec.command = "%a(Run,Type command to run)";
 527
 528         data = putNewItem(panel, pad, ExecInfo, _("Netscape"));
 529         data->param.exec.command = "netscape";
 530
 531         data = putNewItem(panel, pad, ExecInfo, _("gimp"));
 532         data->param.exec.command = "gimp";
 533
 534         data = putNewItem(panel, pad, ExecInfo, _("epic"));
 535         data->param.exec.command = "xterm -e epic";
 536
 537         data = putNewItem(panel, pad, ExecInfo, _("ee"));
 538         data->param.exec.command = "ee";
 539
 540         data = putNewItem(panel, pad, ExecInfo, _("xv"));
 541         data->param.exec.command = "xv";
 542
 543         data = putNewItem(panel, pad, ExecInfo, _("Acrobat Reader"));
 544         data->param.exec.command = "acroread || /usr/local/Acrobat4/bin/acroread";
 545
 546         data = putNewItem(panel, pad, ExecInfo, _("ghostview"));
 547         data->param.exec.command = "gv";
 548
 549         data = putNewItem(panel, pad, CommandInfo, _("Exit Window Maker"));
 550         data->param.command.command = 3;
 551
 552         WMMapWidget(pad);
 553
 554         panel->itemPad[1] = sview;
 555     }
 556
 557
 558     {
 559         WEditMenu *pad, *smenu;
 560         ItemData *data;
 561         WMScrollView *sview;
 562
 563         sview = WMCreateScrollView(panel->box);
 564         WMResizeWidget(sview, 150, 180);
 565         WMMoveWidget(sview, 10, 40);
 566         WMSetScrollViewHasVerticalScroller(sview, True);
 567
 568         pad = makeFactoryMenu(panel->box, 130);
 569
 570         WMSetScrollViewContentView(sview, WMWidgetView(pad));
 571
 572         data = putNewItem(panel, pad, ExternalInfo, _("Debian Menu"));
 573         data->param.pipe.command = "/etc/X11/WindowMaker/menu.hook";
 574
 575         data = putNewItem(panel, pad, PipeInfo, _("RedHat Menu"));
 576         data->param.pipe.command = "wmconfig --output wmaker";
 577
 578         data = putNewItem(panel, pad, PipeInfo, _("Menu Conectiva"));
 579         data->param.pipe.command = "wmconfig --output wmaker";
 580
 581         data = putNewItem(panel, pad, DirectoryInfo, _("Themes"));
 582         data->param.directory.command = "setstyle";
 583         data->param.directory.directory = "/usr/share/WindowMaker/Themes /usr/local/share/WindowMaker/Themes $HOME/GNUstep/Library/WindowMaker/Themes";
 584         data->param.directory.stripExt = 1;
 585
 586         data = putNewItem(panel, pad, DirectoryInfo, _("Bg Images (scale)"));
 587         data->param.directory.command = "wmsetbg -u -s";
 588         data->param.directory.directory = "/opt/kde2/share/wallpapers /usr/share/WindowMaker/Backgrounds $HOME/GNUstep/Library/WindowMaker/Backgrounds";
 589         data->param.directory.stripExt = 1;
 590
 591         data = putNewItem(panel, pad, DirectoryInfo, _("Bg Images (tile)"));
 592         data->param.directory.command = "wmsetbg -u -t";
 593         data->param.directory.directory = "/opt/kde2/share/wallpapers /usr/share/WindowMaker/Backgrounds $HOME/GNUstep/Library/WindowMaker/Backgrounds";
 594         data->param.directory.stripExt = 1;
 595
 596         smenu = putNewSubmenu(pad, _("Assorted XTerms"));
 597
 598         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Yellow on Blue"));
 599         data->param.exec.command = "xterm -sb -sl 2000 -bg midnightblue -fg yellow";
 600
 601         data = putNewItem(panel, smenu, ExecInfo, _("XTerm White on Black"));
 602         data->param.exec.command = "xterm -sb -sl 2000 -bg black -fg white";
 603
 604         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Black on White"));
 605         data->param.exec.command = "xterm -sb -sl 2000 -bg white -fg black";
 606
 607         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Black on Beige"));
 608         data->param.exec.command = "xterm -sb -sl 2000 -bg '#bbbb99' -fg black";
 609
 610         data = putNewItem(panel, smenu, ExecInfo, _("XTerm White on Green"));
 611         data->param.exec.command = "xterm -sb -sl 2000 -bg '#228822' -fg white";
 612
 613         data = putNewItem(panel, smenu, ExecInfo, _("XTerm White on Olive"));
 614         data->param.exec.command = "xterm -sb -sl 2000 -bg '#335533' -fg white";
 615
 616         data = putNewItem(panel, smenu, ExecInfo, _("XTerm Blue on Blue"));
 617         data->param.exec.command = "xterm -sb -sl 2000 -bg '#112244' -fg '#88aabb'";
 618
 619         data = putNewItem(panel, smenu, ExecInfo, _("XTerm BIG FONTS"));
 620         data->param.exec.command = "xterm -sb -sl 2000 -bg black -fg white -fn 10x20";
 621
 622         WMMapWidget(pad);
 623
 624         panel->itemPad[2] = sview;
 625     }
 626
 627
 628     width = FRAME_WIDTH - 20 - 150 - 10;
 629
 630     panel->optionsF = WMCreateFrame(panel->box);
 631     WMResizeWidget(panel->optionsF, width, FRAME_HEIGHT - 15);
 632     WMMoveWidget(panel->optionsF, 10 + 150 + 10, 5);
 633
 634     width -= 20;
 635
 636     /* command */
 637
 638     panel->commandF = WMCreateFrame(panel->optionsF);
 639     WMResizeWidget(panel->commandF, width, 50);
 640     WMMoveWidget(panel->commandF, 10, 20);
 641     WMSetFrameTitle(panel->commandF, _("Program to Run"));
 642
 643     panel->commandT = WMCreateTextField(panel->commandF);
 644     WMResizeWidget(panel->commandT, width - 20, 20);
 645     WMMoveWidget(panel->commandT, 10, 20);
 646
 647     WMAddNotificationObserver(dataChanged, panel,
 648                               WMTextDidChangeNotification,
 649                               panel->commandT);
 650
 651 #if 0
 652     panel->xtermC = WMCreateSwitchButton(panel->commandF);
 653     WMResizeWidget(panel->xtermC, width - 20, 20);
 654     WMMoveWidget(panel->xtermC, 10, 50);
 655     WMSetButtonText(panel->xtermC, _("Run the program inside a Xterm"));
 656 #endif
 657     WMMapSubwidgets(panel->commandF);
 658
 659
 660     /* path */
 661
 662     panel->pathF = WMCreateFrame(panel->optionsF);
 663     WMResizeWidget(panel->pathF, width, 150);
 664     WMMoveWidget(panel->pathF, 10, 40);
 665     WMSetFrameTitle(panel->pathF, _("Path for Menu"));
 666
 667     panel->pathT = WMCreateTextField(panel->pathF);
 668     WMResizeWidget(panel->pathT, width - 20, 20);
 669     WMMoveWidget(panel->pathT, 10, 20);
 670
 671     WMAddNotificationObserver(dataChanged, panel,
 672                               WMTextDidChangeNotification,
 673                               panel->pathT);
 674
 675     label = WMCreateLabel(panel->pathF);
 676     WMResizeWidget(label, width - 20, 80);
 677     WMMoveWidget(label, 10, 50);
 678     WMSetLabelText(label, _("Enter the path for a file containing a menu\n"
 679                             "or a list of directories with the programs you\n"
 680                             "want to have listed in the menu. Ex:\n"
 681                             "~/GNUstep/Library/WindowMaker/menu\n"
 682                             "or\n"
 683                             "/usr/X11R6/bin ~/xbin"));
 684
 685     WMMapSubwidgets(panel->pathF);
 686
 687
 688     /* pipe */
 689
 690     panel->pipeF = WMCreateFrame(panel->optionsF);
 691     WMResizeWidget(panel->pipeF, width, 100);
 692     WMMoveWidget(panel->pipeF, 10, 50);
 693     WMSetFrameTitle(panel->pipeF, _("Command"));
 694
 695     panel->pipeT = WMCreateTextField(panel->pipeF);
 696     WMResizeWidget(panel->pipeT, width - 20, 20);
 697     WMMoveWidget(panel->pipeT, 10, 20);
 698
 699     WMAddNotificationObserver(dataChanged, panel,
 700                               WMTextDidChangeNotification,
 701                               panel->pipeT);
 702
 703
 704     label = WMCreateLabel(panel->pipeF);
 705     WMResizeWidget(label, width - 20, 40);
 706     WMMoveWidget(label, 10, 50);
 707     WMSetLabelText(label, _("Enter a command that outputs a menu\n"
 708                             "definition to stdout when invoked."));
 709
 710     WMMapSubwidgets(panel->pipeF);
 711
 712
 713     /* directory menu */
 714
 715     panel->dcommandF = WMCreateFrame(panel->optionsF);
 716     WMResizeWidget(panel->dcommandF, width, 90);
 717     WMMoveWidget(panel->dcommandF, 10, 25);
 718     WMSetFrameTitle(panel->dcommandF, _("Command to Open Files"));
 719
 720     panel->dcommandT = WMCreateTextField(panel->dcommandF);
 721     WMResizeWidget(panel->dcommandT, width - 20, 20);
 722     WMMoveWidget(panel->dcommandT, 10, 20);
 723
 724     WMAddNotificationObserver(dataChanged, panel,
 725                               WMTextDidChangeNotification,
 726                               panel->dcommandT);
 727
 728
 729     label = WMCreateLabel(panel->dcommandF);
 730     WMResizeWidget(label, width - 20, 45);
 731     WMMoveWidget(label, 10, 40);
 732     WMSetLabelText(label, _("Enter the command you want to use to open the\n"
 733                             "files in the directories listed below."));
 734
 735     WMMapSubwidgets(panel->dcommandF);
 736
 737
 738     panel->dpathF = WMCreateFrame(panel->optionsF);
 739     WMResizeWidget(panel->dpathF, width, 80);
 740     WMMoveWidget(panel->dpathF, 10, 125);
 741     WMSetFrameTitle(panel->dpathF, _("Directories with Files"));
 742
 743     panel->dpathT = WMCreateTextField(panel->dpathF);
 744     WMResizeWidget(panel->dpathT, width - 20, 20);
 745     WMMoveWidget(panel->dpathT, 10, 20);
 746
 747     WMAddNotificationObserver(dataChanged, panel,
 748                               WMTextDidChangeNotification,
 749                               panel->dpathT);
 750
 751     panel->dstripB = WMCreateSwitchButton(panel->dpathF);
 752     WMResizeWidget(panel->dstripB, width - 20, 20);
 753     WMMoveWidget(panel->dstripB, 10, 50);
 754     WMSetButtonText(panel->dstripB, _("Strip extensions from file names"));
 755
 756     WMSetButtonAction(panel->dstripB, buttonClicked, panel);
 757
 758     WMMapSubwidgets(panel->dpathF);
 759
 760
 761     /* shortcut */
 762
 763     panel->shortF = WMCreateFrame(panel->optionsF);
 764     WMResizeWidget(panel->shortF, width, 50);
 765     WMMoveWidget(panel->shortF, 10, 160);
 766     WMSetFrameTitle(panel->shortF, _("Keyboard Shortcut"));
 767
 768     panel->shortT = WMCreateTextField(panel->shortF);
 769     WMResizeWidget(panel->shortT, width - 20 - 170, 20);
 770     WMMoveWidget(panel->shortT, 10, 20);
 771
 772     WMAddNotificationObserver(dataChanged, panel,
 773                               WMTextDidChangeNotification,
 774                               panel->shortT);
 775
 776     panel->sgrabB = WMCreateCommandButton(panel->shortF);
 777     WMResizeWidget(panel->sgrabB, 80, 24);
 778     WMMoveWidget(panel->sgrabB, width - 90, 18);
 779     WMSetButtonText(panel->sgrabB, _("Capture"));
 780     WMSetButtonAction(panel->sgrabB, sgrabClicked, panel);
 781
 782     panel->sclearB = WMCreateCommandButton(panel->shortF);
 783     WMResizeWidget(panel->sclearB, 80, 24);
 784     WMMoveWidget(panel->sclearB, width - 175, 18);
 785     WMSetButtonText(panel->sclearB, _("Clear"));
 786     WMSetButtonAction(panel->sclearB, sgrabClicked, panel);
 787
 788     WMMapSubwidgets(panel->shortF);
 789
 790     /* internal command */
 791
 792     panel->icommandL = WMCreateList(panel->optionsF);
 793     WMResizeWidget(panel->icommandL, width, 80);
 794     WMMoveWidget(panel->icommandL, 10, 20);
 795
 796     WMSetListAction(panel->icommandL, icommandLClicked, panel);
 797
 798     WMAddNotificationObserver(dataChanged, panel,
 799                               WMListSelectionDidChangeNotification,
 800                               panel->icommandL);
 801
 802     WMInsertListItem(panel->icommandL, 0, _("Arrange Icons"));
 803     WMInsertListItem(panel->icommandL, 1, _("Hide All Windows Except For The Focused One"));
 804     WMInsertListItem(panel->icommandL, 2, _("Show All Windows"));
 805
 806     WMInsertListItem(panel->icommandL, 3, _("Exit Window Maker"));
 807     WMInsertListItem(panel->icommandL, 4, _("Exit X Session"));
 808     WMInsertListItem(panel->icommandL, 5, _("Restart Window Maker"));
 809     WMInsertListItem(panel->icommandL, 6, _("Start Another Window Manager   : ("));
 810
 811     WMInsertListItem(panel->icommandL, 7, _("Save Current Session"));
 812     WMInsertListItem(panel->icommandL, 8, _("Clear Saved Session"));
 813     WMInsertListItem(panel->icommandL, 9, _("Refresh Screen"));
 814     WMInsertListItem(panel->icommandL, 10, _("Open Info Panel"));
 815     WMInsertListItem(panel->icommandL, 11, _("Open Copyright Panel"));
 816
 817
 818     panel->paramF = WMCreateFrame(panel->optionsF);
 819     WMResizeWidget(panel->paramF, width, 50);
 820     WMMoveWidget(panel->paramF, 10, 105);
 821     WMSetFrameTitle(panel->paramF, _("Window Manager to Start"));
 822
 823     panel->paramT = WMCreateTextField(panel->paramF);
 824     WMResizeWidget(panel->paramT, width - 20, 20);
 825     WMMoveWidget(panel->paramT, 10, 20);
 826
 827     WMAddNotificationObserver(dataChanged, panel,
 828                               WMTextDidChangeNotification,
 829                               panel->paramT);
 830
 831     WMMapSubwidgets(panel->paramF);
 832
 833
 834     panel->quickB = WMCreateSwitchButton(panel->optionsF);
 835     WMResizeWidget(panel->quickB, width, 20);
 836     WMMoveWidget(panel->quickB, 10, 120);
 837     WMSetButtonText(panel->quickB, _("Do not confirm action."));
 838     WMSetButtonAction(panel->quickB, buttonClicked, panel);
 839
 840
 841
 842
 843     label = WMCreateLabel(panel->optionsF);
 844     WMResizeWidget(label, width - 10, FRAME_HEIGHT - 50);
 845     WMMoveWidget(label, 10, 20);
 846     WMSetLabelText(label,
 847                    _("Instructions:\n\n"
 848                      " - drag items from the left to the menu to add new items\n"
 849                      " - drag items out of the menu to remove items\n"
 850                      " - drag items in menu to change their position\n"
 851                      " - drag items with Control pressed to copy them\n"
 852                      " - double click in a menu item to change the label\n"
 853                      " - click on a menu item to change related information"));
 854     WMMapWidget(label);
 855
 856     WMRealizeWidget(panel->box);
 857     WMMapSubwidgets(panel->box);
 858     WMMapWidget(panel->box);
 859
 860
 861     {
 862         int i;
 863         for (i = 0; i < 3; i++)
 864             WMUnmapWidget(panel->itemPad[i]);
 865     }
 866     changedItemPad(panel->typeP, panel);
 867
 868     panel->sections[NoInfo][0] = label;
 869
 870     panel->sections[ExecInfo][0] = panel->commandF;
 871     panel->sections[ExecInfo][1] = panel->shortF;
 872
 873     panel->sections[CommandInfo][0] = panel->icommandL;
 874     panel->sections[CommandInfo][1] = panel->shortF;
 875
 876     panel->sections[ExternalInfo][0] = panel->pathF;
 877
 878     panel->sections[PipeInfo][0] = panel->pipeF;
 879
 880     panel->sections[DirectoryInfo][0] = panel->dpathF;
 881     panel->sections[DirectoryInfo][1] = panel->dcommandF;
 882
 883     panel->currentType = NoInfo;
 884
 885     showData(panel);
 886
 887     {
 888         WMPoint pos;
 889
 890         pos = WMGetViewScreenPosition(WMWidgetView(panel->box));
 891
 892         if (pos.x < 200) {
 893             pos.x += FRAME_WIDTH + 20;
 894         } else {
 895             pos.x = 10;
 896         }
 897
 898         pos.y = WMAX(pos.y - 100, 0);
 899
 900         WEditMenuShowAt(panel->menu, pos.x, pos.y);
 901     }
 902 }
 903
 904
 905
 906
 907 static void
 908 freeItemData(ItemData *data)
 909 {
 910 #define CFREE(d) if (d) wfree(d)
 911
 912     /* TODO */
 913     switch (data->type) {
 914      case CommandInfo:
 915         CFREE(data->param.command.parameter);
 916         CFREE(data->param.command.shortcut);
 917         break;
 918
 919      case ExecInfo:
 920         CFREE(data->param.exec.command);
 921         CFREE(data->param.exec.shortcut);
 922         break;
 923
 924      case PipeInfo:
 925         CFREE(data->param.pipe.command);
 926         break;
 927
 928      case ExternalInfo:
 929         CFREE(data->param.external.path);
 930         break;
 931
 932      case DirectoryInfo:
 933         CFREE(data->param.directory.command);
 934         CFREE(data->param.directory.directory);
 935         break;
 936
 937      default:
 938         break;
 939     }
 940
 941     wfree(data);
 942 #undef CFREE
 943 }
 944
 945
 946 static ItemData*
 947 parseCommand(proplist_t item)
 948 {
 949     ItemData *data = NEW(ItemData);
 950     proplist_t p;
 951     char *command = NULL;
 952     char *parameter = NULL;
 953     char *shortcut = NULL;
 954     int i = 1;
 955
 956
 957     p = PLGetArrayElement(item, i++);
 958     command = PLGetString(p);
 959     if (strcmp(command, "SHORTCUT") == 0) {
 960         p = PLGetArrayElement(item, i++);
 961         shortcut = PLGetString(p);
 962         p = PLGetArrayElement(item, i++);
 963         command = PLGetString(p);
 964     }
 965     p = PLGetArrayElement(item, i++);
 966     if (p)
 967         parameter = PLGetString(p);
 968
 969     if (strcmp(command, "EXEC") == 0 || strcmp(command, "SHEXEC") == 0) {
 970
 971         data->type = ExecInfo;
 972
 973         data->param.exec.command = wstrdup(parameter);
 974         if (shortcut)
 975             data->param.exec.shortcut = wstrdup(shortcut);
 976
 977     } else if (strcmp(command, "OPEN_MENU") == 0) {
 978         char *p;
 979         /*
 980          * dir menu, menu file
 981          * dir WITH
 982          * |pipe (TODO: ||pipe)
 983          */
 984         p = parameter;
 985         while (isspace(*p) && *p) p++;
 986         if (*p == '|') {
 987             data->type = PipeInfo;
 988             data->param.pipe.command = wtrimspace(p+1);
 989         } else {
 990             char *s;
 991
 992             p = wstrdup(p);
 993
 994             s = strstr(p, "WITH");
 995             if (s) {
 996                 char **tokens;
 997                 char **ctokens;
 998                 int tokn;
 999                 int i, j;
1000
1001                 data->type = DirectoryInfo;
1002
1003                 *s = '\0';
1004                 s += 5;
1005                 while (*s && isspace(*s)) s++;
1006                 data->param.directory.command = wstrdup(s);
1007
1008                 wtokensplit(p, &tokens, &tokn);
1009                 wfree(p);
1010
1011                 ctokens = wmalloc(sizeof(char*)*tokn);
1012
1013                 for (i = 0, j = 0; i < tokn; i++) {
1014                     if (strcmp(tokens[i], "-noext") == 0) {
1015                         wfree(tokens[i]);
1016                         data->param.directory.stripExt = 1;
1017                     } else {
1018                         ctokens[j++] = tokens[i];
1019                     }
1020                 }
1021                 data->param.directory.directory = wtokenjoin(ctokens, j);
1022                 wfree(ctokens);
1023
1024                 wtokenfree(tokens, tokn);
1025             } else {
1026                 data->type = ExternalInfo;
1027                 data->param.external.path = p;
1028             }
1029         }
1030     } else if (strcmp(command, "WORKSPACE_MENU") == 0) {
1031         data->type = WSMenuInfo;
1032     } else {
1033         int cmd;
1034
1035         if (strcmp(command, "ARRANGE_ICONS") == 0) {
1036             cmd = 0;
1037         } else if (strcmp(command, "HIDE_OTHERS") == 0) {
1038             cmd = 1;
1039         } else if (strcmp(command, "SHOW_ALL") == 0) {
1040             cmd = 2;
1041         } else if (strcmp(command, "EXIT") == 0) {
1042             cmd = 3;
1043         } else if (strcmp(command, "SHUTDOWN") == 0) {
1044             cmd = 4;
1045         } else if (strcmp(command, "RESTART") == 0) {
1046             if (parameter) {
1047                 cmd = 6;
1048             } else {
1049                 cmd = 5;
1050             }
1051         } else if (strcmp(command, "SAVE_SESSION") == 0) {
1052             cmd = 7;
1053         } else if (strcmp(command, "CLEAR_SESSION") == 0) {
1054             cmd = 8;
1055         } else if (strcmp(command, "REFRESH") == 0) {
1056             cmd = 9;
1057         } else if (strcmp(command, "INFO_PANEL") == 0) {
1058             cmd = 10;
1059         } else if (strcmp(command, "LEGAL_PANEL") == 0) {
1060             cmd = 11;
1061         } else {
1062             wwarning(_("unknown command '%s' in menu"), command);
1063             goto error;
1064         }
1065
1066         data->type = CommandInfo;
1067
1068         data->param.command.command = cmd;
1069         if (shortcut)
1070             data->param.command.shortcut = wstrdup(shortcut);
1071         if (parameter)
1072             data->param.command.parameter = wstrdup(parameter);
1073     }
1074
1075     return data;
1076
1077 error:
1078     wfree(data);
1079
1080     return NULL;
1081 }
1082
1083
1084
1085
1086 static void
1087 updateFrameTitle(_Panel *panel, char *title, InfoType type)
1088 {
1089     if (type != NoInfo) {
1090         char *tmp;
1091
1092         switch (type) {
1093          case ExecInfo:
1094             tmp = wstrconcat(title, _(": Execute Program"));
1095             break;
1096
1097          case CommandInfo:
1098             tmp = wstrconcat(title, _(": Perform Internal Command"));
1099             break;
1100
1101          case ExternalInfo:
1102             tmp = wstrconcat(title, _(": Open a Submenu"));
1103             break;
1104
1105          case PipeInfo:
1106             tmp = wstrconcat(title, _(": Program Generated Submenu"));
1107             break;
1108
1109          case DirectoryInfo:
1110             tmp = wstrconcat(title, _(": Directory Contents Menu"));
1111             break;
1112
1113          case WSMenuInfo:
1114             tmp = wstrconcat(title, _(": Open Workspaces Submenu"));
1115             break;
1116
1117          default:
1118             tmp = NULL;
1119             break;
1120         }
1121         WMSetFrameTitle(panel->optionsF, tmp);
1122         wfree(tmp);
1123     } else {
1124         WMSetFrameTitle(panel->optionsF, NULL);
1125     }
1126 }
1127
1128
1129
1130 static void
1131 changeInfoType(_Panel *panel, char *title, InfoType type)
1132 {
1133     WMWidget **w;
1134
1135     if (panel->currentType != type) {
1136
1137         w = panel->sections[panel->currentType];
1138
1139         while (*w) {
1140             WMUnmapWidget(*w);
1141             w++;
1142         }
1143         WMUnmapWidget(panel->paramF);
1144         WMUnmapWidget(panel->quickB);
1145
1146
1147         w = panel->sections[type];
1148
1149         while (*w) {
1150             WMMapWidget(*w);
1151             w++;
1152         }
1153     }
1154
1155     updateFrameTitle(panel, title, type);
1156
1157     panel->currentType = type;
1158 }
1159
1160
1161
1162
1163 static void
1164 updateMenuItem(_Panel *panel, WEditMenuItem *item, WMWidget *changedWidget)
1165 {
1166     ItemData *data = WGetEditMenuItemData(item);
1167
1168     assert(data != NULL);
1169
1170 #define REPLACE(v, d) if (v) wfree(v); v = d
1171
1172     switch (data->type) {
1173      case ExecInfo:
1174         if (changedWidget == panel->commandT) {
1175             REPLACE(data->param.exec.command,
1176                     WMGetTextFieldText(panel->commandT));
1177         }
1178         if (changedWidget == panel->shortT) {
1179             REPLACE(data->param.exec.shortcut,
1180                     WMGetTextFieldText(panel->shortT));
1181         }
1182         break;
1183
1184      case CommandInfo:
1185         if (changedWidget == panel->icommandL) {
1186             data->param.command.command =
1187                 WMGetListSelectedItemRow(panel->icommandL);
1188         }
1189         switch (data->param.command.command) {
1190          case 3:
1191          case 4:
1192             if (changedWidget == panel->quickB) {
1193                 REPLACE(data->param.command.parameter,
1194                         WMGetButtonSelected(panel->quickB)
1195                         ? wstrdup("QUICK") : NULL);
1196             }
1197             break;
1198
1199          case 6:
1200             if (changedWidget == panel->paramT) {
1201                 REPLACE(data->param.command.parameter,
1202                         WMGetTextFieldText(panel->paramT));
1203             }
1204             break;
1205         }
1206         if (changedWidget == panel->shortT) {
1207             REPLACE(data->param.command.shortcut,
1208                     WMGetTextFieldText(panel->shortT));
1209         }
1210
1211
1212         break;
1213
1214      case PipeInfo:
1215         if (changedWidget == panel->pipeT) {
1216             REPLACE(data->param.pipe.command,
1217                     WMGetTextFieldText(panel->pipeT));
1218         }
1219         break;
1220
1221      case ExternalInfo:
1222         if (changedWidget == panel->pathT) {
1223             REPLACE(data->param.external.path,
1224                     WMGetTextFieldText(panel->pathT));
1225         }
1226         break;
1227
1228      case DirectoryInfo:
1229         if (changedWidget == panel->dpathT) {
1230             REPLACE(data->param.directory.directory,
1231                     WMGetTextFieldText(panel->dpathT));
1232         }
1233         if (changedWidget == panel->dcommandT) {
1234             REPLACE(data->param.directory.command,
1235                     WMGetTextFieldText(panel->dcommandT));
1236         }
1237         if (changedWidget == panel->dstripB) {
1238             data->param.directory.stripExt =
1239                 WMGetButtonSelected(panel->dstripB);
1240         }
1241         break;
1242
1243      default:
1244         assert(0);
1245         break;
1246     }
1247
1248 #undef REPLACE
1249 }
1250
1251
1252
1253 static void
1254 menuItemCloned(WEditMenuDelegate *delegate, WEditMenu *menu,
1255                WEditMenuItem *origItem, WEditMenuItem *newItem)
1256 {
1257     ItemData *data = WGetEditMenuItemData(origItem);
1258     ItemData *newData;
1259
1260     if (!data)
1261         return;
1262
1263 #define DUP(s) (s) ? wstrdup(s) : NULL
1264
1265     newData = NEW(ItemData);
1266
1267     newData->type = data->type;
1268
1269     switch (data->type) {
1270      case ExecInfo:
1271         newData->param.exec.command = DUP(data->param.exec.command);
1272         newData->param.exec.shortcut = DUP(data->param.exec.shortcut);
1273         break;
1274
1275      case CommandInfo:
1276         newData->param.command.command = data->param.command.command;
1277         newData->param.command.parameter = DUP(data->param.command.parameter);
1278         newData->param.command.shortcut = DUP(data->param.command.shortcut);
1279         break;
1280
1281      case PipeInfo:
1282         newData->param.pipe.command = DUP(data->param.pipe.command);
1283         break;
1284
1285      case ExternalInfo:
1286         newData->param.external.path = DUP(data->param.external.path);
1287         break;
1288
1289      case DirectoryInfo:
1290         newData->param.directory.directory = DUP(data->param.directory.directory);
1291         newData->param.directory.command = DUP(data->param.directory.command);
1292         newData->param.directory.stripExt = data->param.directory.stripExt;
1293         break;
1294
1295      default:
1296         break;
1297     }
1298
1299 #undef DUP
1300
1301     WSetEditMenuItemData(newItem, newData, (WMCallback*)freeItemData);
1302 }
1303
1304
1305 static void
1306 menuItemEdited(struct WEditMenuDelegate *delegate, WEditMenu *menu,
1307                WEditMenuItem *item)
1308 {
1309     _Panel *panel = (_Panel*)delegate->data;
1310     WEditMenu *submenu;
1311
1312     updateFrameTitle(panel, WGetEditMenuItemTitle(item), panel->currentType);
1313
1314     submenu = WGetEditMenuSubmenu(menu, item);
1315     if (submenu) {
1316         WSetEditMenuTitle(submenu, WGetEditMenuItemTitle(item));
1317     }
1318 }
1319
1320
1321 static Bool
1322 shouldRemoveItem(struct WEditMenuDelegate *delegate, WEditMenu *menu,
1323                  WEditMenuItem *item)
1324 {
1325     _Panel *panel = (_Panel*)delegate->data;
1326
1327     if (panel->dontAsk)
1328         return True;
1329
1330     if (WGetEditMenuSubmenu(menu, item)) {
1331         int res;
1332
1333         res = WMRunAlertPanel(WMWidgetScreen(menu), NULL,
1334                               _("Remove Submenu"),
1335                               _("Removing this item will destroy all items inside\n"
1336                                 "the submenu. Do you really want to do that?"),
1337                               _("Yes"), _("No"),
1338                               _("Yes, don't ask again."));
1339         switch (res) {
1340          case WAPRDefault:
1341             return True;
1342          case WAPRAlternate:
1343             return False;
1344          case WAPROther:
1345             panel->dontAsk = True;
1346             return True;
1347         }
1348     }
1349     return True;
1350 }
1351
1352
1353 static void
1354 menuItemDeselected(WEditMenuDelegate *delegate, WEditMenu *menu,
1355                    WEditMenuItem *item)
1356 {
1357     _Panel *panel = (_Panel*)delegate->data;
1358
1359     changeInfoType(panel, NULL, NoInfo);
1360 }
1361
1362
1363 static void
1364 menuItemSelected(WEditMenuDelegate *delegate, WEditMenu *menu,
1365                  WEditMenuItem *item)
1366 {
1367     ItemData *data = WGetEditMenuItemData(item);
1368     _Panel *panel = (_Panel*)delegate->data;
1369
1370     panel->currentItem = item;
1371
1372     if (data) {
1373         changeInfoType(panel, WGetEditMenuItemTitle(item), data->type);
1374
1375         switch (data->type) {
1376          case NoInfo:
1377             break;
1378
1379          case ExecInfo:
1380             WMSetTextFieldText(panel->commandT, data->param.exec.command);
1381             WMSetTextFieldText(panel->shortT, data->param.exec.shortcut);
1382             break;
1383
1384          case CommandInfo:
1385             WMSelectListItem(panel->icommandL,
1386                              data->param.command.command);
1387             WMSetListPosition(panel->icommandL,
1388                               data->param.command.command - 2);
1389             WMSetTextFieldText(panel->shortT, data->param.command.shortcut);
1390
1391             switch (data->param.command.command) {
1392              case 3:
1393              case 4:
1394                 WMSetButtonSelected(panel->quickB,
1395                                     data->param.command.parameter!=NULL);
1396                 break;
1397              case 6:
1398                 WMSetTextFieldText(panel->paramT,
1399                                    data->param.command.parameter);
1400                 break;
1401             }
1402
1403             icommandLClicked(panel->icommandL, panel);
1404             break;
1405
1406          case PipeInfo:
1407             WMSetTextFieldText(panel->pipeT, data->param.pipe.command);
1408             break;
1409
1410          case ExternalInfo:
1411             WMSetTextFieldText(panel->pathT, data->param.external.path);
1412             break;
1413
1414          case DirectoryInfo:
1415             WMSetTextFieldText(panel->dpathT, data->param.directory.directory);
1416             WMSetTextFieldText(panel->dcommandT, data->param.directory.command);
1417             WMSetButtonSelected(panel->dstripB, data->param.directory.stripExt);
1418             break;
1419
1420          case WSMenuInfo:
1421             break;
1422
1423          default:
1424             break;
1425         }
1426     }
1427 }
1428
1429
1430
1431 static WEditMenu*
1432 buildSubmenu(_Panel *panel, proplist_t pl)
1433 {
1434     WMScreen *scr = WMWidgetScreen(panel->parent);
1435     WEditMenu *menu;
1436     WEditMenuItem *item;
1437     char *title;
1438     proplist_t tp, bp;
1439     int i;
1440
1441     tp = PLGetArrayElement(pl, 0);
1442     title = PLGetString(tp);
1443
1444     menu = WCreateEditMenu(scr, title);
1445
1446     for (i = 1; i < PLGetNumberOfElements(pl); i++) {
1447         proplist_t pi;
1448
1449         pi = PLGetArrayElement(pl, i);
1450
1451         tp = PLGetArrayElement(pi, 0);
1452         bp = PLGetArrayElement(pi, 1);
1453
1454         title = PLGetString(tp);
1455
1456         if (!bp || PLIsArray(bp)) {            /* it's a submenu */
1457             WEditMenu *submenu;
1458
1459             submenu = buildSubmenu(panel, pi);
1460
1461             item = WAddMenuItemWithTitle(menu, title);
1462
1463             WSetEditMenuSubmenu(menu, item, submenu);
1464         } else {
1465             ItemData *data;
1466
1467             item = WAddMenuItemWithTitle(menu, title);
1468
1469             data = parseCommand(pi);
1470
1471             if (panel->markerPix[data->type])
1472                 WSetEditMenuItemImage(item, panel->markerPix[data->type]);
1473             WSetEditMenuItemData(item, data, (WMCallback*)freeItemData);
1474         }
1475     }
1476
1477     WSetEditMenuAcceptsDrop(menu, True);
1478     WSetEditMenuDelegate(menu, &menuDelegate);
1479
1480     WMRealizeWidget(menu);
1481
1482     return menu;
1483 }
1484
1485
1486
1487 static void
1488 buildMenuFromPL(_Panel *panel, proplist_t pl)
1489 {
1490     panel->menu = buildSubmenu(panel, pl);
1491 }
1492
1493
1494
1495 static proplist_t
1496 getDefaultMenu(_Panel *panel)
1497 {
1498     proplist_t menu, pmenu;
1499     char *menuPath, *gspath;
1500
1501     gspath = wusergnusteppath();
1502
1503     menuPath = wmalloc(strlen(gspath)+128);
1504     /* if there is a localized plmenu for the tongue put it's filename here */
1505     sprintf(menuPath, _("%s/Library/WindowMaker/plmenu"), gspath);
1506
1507     menu = PLGetProplistWithPath(menuPath);
1508     if (!menu) {
1509         wwarning("%s:could not read property list menu", menuPath);
1510
1511         if (strcmp("%s/Library/WindowMaker/plmenu",
1512                    _("%s/Library/WindowMaker/plmenu"))!=0) {
1513
1514             sprintf(menuPath, "%s/Library/WindowMaker/plmenu", gspath);
1515             menu = PLGetProplistWithPath(menuPath);
1516             wwarning("%s:could not read property list menu", menuPath);
1517         }
1518         if (!menu) {
1519             char buffer[512];
1520
1521             sprintf(buffer, _("Could not open default menu from '%s'"),
1522                     menuPath);
1523             WMRunAlertPanel(WMWidgetScreen(panel->parent), panel->parent,
1524                             _("Error"), buffer, _("OK"), NULL, NULL);
1525         }
1526     }
1527
1528     wfree(menuPath);
1529
1530     if (menu) {
1531         pmenu = menu;
1532     } else {
1533         pmenu = NULL;
1534     }
1535
1536     return pmenu;
1537 }
1538
1539
1540 static void
1541 showData(_Panel *panel)
1542 {
1543     char *gspath;
1544     char *menuPath;
1545     proplist_t pmenu;
1546
1547     gspath = wusergnusteppath();
1548
1549     menuPath = wmalloc(strlen(gspath)+32);
1550     strcpy(menuPath, gspath);
1551     strcat(menuPath, "/Defaults/WMRootMenu");
1552
1553     pmenu = PLGetProplistWithPath(menuPath);
1554
1555     if (!pmenu || !PLIsArray(pmenu)) {
1556         int res;
1557
1558         res = WMRunAlertPanel(WMWidgetScreen(panel->parent), panel->parent,
1559                               _("Warning"),
1560                               _("The menu file format currently in use is not supported\n"
1561                                 "by this tool. Do you want to discard the current menu\n"
1562                                 "to use this tool?"),
1563                               _("Yes, Discard and Update"),
1564                               _("No, Keep Current Menu"), NULL);
1565
1566         if (res == WAPRDefault) {
1567             pmenu = getDefaultMenu(panel);
1568
1569             if (!pmenu) {
1570                 pmenu = PLMakeArrayFromElements(PLMakeString("Applications"),
1571                                                 NULL);
1572             }
1573         } else {
1574             panel->dontSave = True;
1575             return;
1576         }
1577     }
1578
1579     panel->menuPath = menuPath;
1580
1581     buildMenuFromPL(panel, pmenu);
1582
1583     PLRelease(pmenu);
1584 }
1585
1586
1587 static Bool
1588 notblank(char *s)
1589 {
1590     if (s) {
1591         while (*s++) {
1592             if (!isspace(*s))
1593                 return True;
1594         }
1595     }
1596     return False;
1597 }
1598
1599
1600 static proplist_t
1601 processData(char *title, ItemData *data)
1602 {
1603     proplist_t item;
1604     char *s1;
1605     static char *pscut = NULL;
1606     static char *pomenu = NULL;
1607     int i;
1608
1609     if (!pscut) {
1610         pscut = PLMakeString("SHORTCUT");
1611         pomenu = PLMakeString("OPEN_MENU");
1612     }
1613
1614     item = PLMakeArrayFromElements(PLMakeString(title), NULL);
1615
1616
1617     switch (data->type) {
1618      case ExecInfo:
1619 #if 1
1620         if (strpbrk(data->param.exec.command, "&$*|><?`=")) {
1621             s1 = "SHEXEC";
1622         } else {
1623             s1 = "EXEC";
1624         }
1625 #else
1626         s1 = "SHEXEC";
1627 #endif
1628
1629         if (notblank(data->param.exec.shortcut)) {
1630             PLAppendArrayElement(item, pscut);
1631             PLAppendArrayElement(item,
1632                                  PLMakeString(data->param.exec.shortcut));
1633         }
1634
1635         PLAppendArrayElement(item, PLMakeString(s1));
1636         PLAppendArrayElement(item, PLMakeString(data->param.exec.command));
1637         break;
1638
1639      case CommandInfo:
1640         if (notblank(data->param.command.shortcut)) {
1641             PLAppendArrayElement(item, pscut);
1642             PLAppendArrayElement(item,
1643                                  PLMakeString(data->param.command.shortcut));
1644         }
1645
1646         i = data->param.command.command;
1647
1648         PLAppendArrayElement(item, PLMakeString(commandNames[i]));
1649
1650         switch (i) {
1651          case 3:
1652          case 4:
1653             if (data->param.command.parameter) {
1654                 PLAppendArrayElement(item,
1655                                      PLMakeString(data->param.command.parameter));
1656             }
1657             break;
1658
1659          case 6: /* restart */
1660             if (data->param.command.parameter) {
1661                 PLAppendArrayElement(item,
1662                                      PLMakeString(data->param.command.parameter));
1663             }
1664             break;
1665         }
1666
1667         break;
1668
1669      case PipeInfo:
1670         PLAppendArrayElement(item, pomenu);
1671         s1 = wstrconcat("| ", data->param.pipe.command);
1672         PLAppendArrayElement(item, PLMakeString(s1));
1673         wfree(s1);
1674         break;
1675
1676      case ExternalInfo:
1677         PLAppendArrayElement(item, pomenu);
1678         PLAppendArrayElement(item, PLMakeString(data->param.external.path));
1679         break;
1680
1681      case DirectoryInfo:
1682         {
1683             int l;
1684             char *tmp;
1685
1686             l = strlen(data->param.directory.directory);
1687             l += strlen(data->param.directory.command);
1688             l += 32;
1689
1690             PLAppendArrayElement(item, pomenu);
1691
1692             tmp = wmalloc(l);
1693             sprintf(tmp, "%s%s WITH %s",
1694                     data->param.directory.stripExt ? "-noext " : "",
1695                     data->param.directory.directory,
1696                     data->param.directory.command);
1697
1698             PLAppendArrayElement(item, PLMakeString(tmp));
1699             wfree(tmp);
1700         }
1701         break;
1702
1703      case WSMenuInfo:
1704         PLAppendArrayElement(item, PLMakeString("WORKSPACE_MENU"));
1705         break;
1706
1707      default:
1708         assert(0);
1709         break;
1710     }
1711
1712     return item;
1713 }
1714
1715
1716 static proplist_t
1717 processSubmenu(WEditMenu *menu)
1718 {
1719     WEditMenuItem *item;
1720     proplist_t pmenu;
1721     proplist_t pl;
1722     char *s;
1723     int i;
1724
1725
1726     s = WGetEditMenuTitle(menu);
1727     pl = PLMakeString(s);
1728
1729     pmenu = PLMakeArrayFromElements(pl, NULL);
1730
1731     i = 0;
1732     while ((item = WGetEditMenuItem(menu, i++))) {
1733         WEditMenu *submenu;
1734
1735         s = WGetEditMenuItemTitle(item);
1736
1737         submenu = WGetEditMenuSubmenu(menu, item);
1738         if (submenu) {
1739             pl = processSubmenu(submenu);
1740         } else {
1741             pl = processData(s, WGetEditMenuItemData(item));
1742         }
1743
1744         PLAppendArrayElement(pmenu, pl);
1745     }
1746
1747     return pmenu;
1748 }
1749
1750
1751
1752 static proplist_t
1753 buildPLFromMenu(_Panel *panel)
1754 {
1755     proplist_t menu;
1756
1757     menu = processSubmenu(panel->menu);
1758
1759     return menu;
1760 }
1761
1762
1763
1764
1765 static void
1766 storeData(_Panel *panel)
1767 {
1768     proplist_t menu;
1769
1770     if (panel->dontSave)
1771         return;
1772
1773     menu = buildPLFromMenu(panel);
1774
1775     PLSetFilename(menu, PLMakeString(panel->menuPath));
1776
1777     PLSave(menu, YES);
1778
1779     PLRelease(menu);
1780 }
1781
1782
1783
1784 static void
1785 showMenus(_Panel *panel)
1786 {
1787     WEditMenuUnhide(panel->menu);
1788 }
1789
1790
1791 static void
1792 hideMenus(_Panel *panel)
1793 {
1794     WEditMenuHide(panel->menu);
1795 }
1796
1797
1798
1799
1800 Panel*
1801 InitMenu(WMScreen *scr, WMWidget *parent)
1802 {
1803     _Panel *panel;
1804
1805     panel = wmalloc(sizeof(_Panel));
1806     memset(panel, 0, sizeof(_Panel));
1807
1808     panel->sectionName = _("Applications Menu Definition");
1809
1810     panel->description = _("Edit the menu for launching applications.");
1811
1812     panel->parent = parent;
1813
1814     panel->callbacks.createWidgets = createPanel;
1815     panel->callbacks.updateDomain = storeData;
1816     panel->callbacks.showPanel = showMenus;
1817     panel->callbacks.hidePanel = hideMenus;
1818
1819
1820     AddSection(panel, ICON_FILE);
1821
1822     return panel;
1823 }
1824