src/dialog.c

   1 /* dialog.c - dialog windows for internal use
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   6  *  Copyright (c) 1998-2003 Dan Pascu
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  21  *  USA.
  22  */
  23
  24 #include "wconfig.h"
  25
  26 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28 #include <X11/keysym.h>
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <dirent.h>
  37 #include <limits.h>
  38
  39 #ifdef HAVE_MALLOC_H
  40 #include <malloc.h>
  41 #endif
  42
  43 #include <signal.h>
  44 #ifdef __FreeBSD__
  45 #include <sys/signal.h>
  46 #endif
  47
  48
  49 #ifndef PATH_MAX
  50 #define PATH_MAX DEFAULT_PATH_MAX
  51 #endif
  52
  53 #include "WindowMaker.h"
  54 #include "GNUstep.h"
  55 #include "screen.h"
  56 #include "dialog.h"
  57 #include "funcs.h"
  58 #include "stacking.h"
  59 #include "framewin.h"
  60 #include "window.h"
  61 #include "actions.h"
  62 #include "defaults.h"
  63 #include "xinerama.h"
  64
  65
  66
  67 extern WPreferences wPreferences;
  68
  69
  70 static WMPoint
  71 getCenter(WScreen *scr, int width, int height)
  72 {
  73     return wGetPointToCenterRectInHead(scr, wGetHeadForPointerLocation(scr),
  74                                        width, height);
  75 }
  76
  77
  78 int
  79 wMessageDialog(WScreen *scr, char *title, char *message,
  80                char *defBtn, char *altBtn, char *othBtn)
  81 {
  82     WMAlertPanel *panel;
  83     Window parent;
  84     WWindow *wwin;
  85     int result;
  86     WMPoint center;
  87
  88     panel = WMCreateAlertPanel(scr->wmscreen, NULL, title, message,
  89                                defBtn, altBtn, othBtn);
  90
  91     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 400, 180, 0, 0, 0);
  92
  93     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
  94
  95
  96     center = getCenter(scr, 400, 180);
  97     wwin = wManageInternalWindow(scr, parent, None, NULL, center.x, center.y,
  98                                  400, 180);
  99     wwin->client_leader = WMWidgetXID(panel->win);
 100
 101     WMMapWidget(panel->win);
 102
 103     wWindowMap(wwin);
 104
 105     WMRunModalLoop(WMWidgetScreen(panel->win), WMWidgetView(panel->win));
 106
 107     result = panel->result;
 108
 109     WMUnmapWidget(panel->win);
 110
 111     wUnmanageWindow(wwin, False, False);
 112
 113     WMDestroyAlertPanel(panel);
 114
 115     XDestroyWindow(dpy, parent);
 116
 117     return result;
 118 }
 119
 120
 121 void
 122 toggleSaveSession(WMWidget *w, void *data)
 123 {
 124     wPreferences.save_session_on_exit = WMGetButtonSelected((WMButton *) w);
 125 }
 126
 127
 128 int
 129 wExitDialog(WScreen *scr, char *title, char *message,
 130             char *defBtn, char *altBtn, char *othBtn)
 131 {
 132     WMAlertPanel *panel;
 133     WMButton *saveSessionBtn;
 134     Window parent;
 135     WWindow *wwin;
 136     WMPoint center;
 137     int result;
 138
 139     panel = WMCreateAlertPanel(scr->wmscreen, NULL, title, message,
 140                                defBtn, altBtn, othBtn);
 141
 142     /* add save session button */
 143     saveSessionBtn = WMCreateSwitchButton(panel->hbox);
 144     WMSetButtonAction(saveSessionBtn, toggleSaveSession, NULL);
 145     WMAddBoxSubview(panel->hbox, WMWidgetView(saveSessionBtn),
 146                     False, True, 200, 0, 0);
 147     WMSetButtonText(saveSessionBtn, _("Save workspace state"));
 148     WMSetButtonSelected(saveSessionBtn, wPreferences.save_session_on_exit);
 149     WMRealizeWidget(saveSessionBtn);
 150     WMMapWidget(saveSessionBtn);
 151
 152     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 400, 180, 0, 0, 0);
 153
 154     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 155
 156     center = getCenter(scr, 400, 180);
 157     wwin = wManageInternalWindow(scr, parent, None, NULL,
 158                                  center.x, center.y, 400, 180);
 159
 160     wwin->client_leader = WMWidgetXID(panel->win);
 161
 162     WMMapWidget(panel->win);
 163
 164     wWindowMap(wwin);
 165
 166     WMRunModalLoop(WMWidgetScreen(panel->win), WMWidgetView(panel->win));
 167
 168     result = panel->result;
 169
 170     WMUnmapWidget(panel->win);
 171
 172     wUnmanageWindow(wwin, False, False);
 173
 174     WMDestroyAlertPanel(panel);
 175
 176     XDestroyWindow(dpy, parent);
 177
 178     return result;
 179 }
 180
 181
 182 int
 183 wInputDialog(WScreen *scr, char *title, char *message, char **text)
 184 {
 185     WWindow *wwin;
 186     Window parent;
 187     WMInputPanel *panel;
 188     char *result;
 189     WMPoint center;
 190
 191     panel = WMCreateInputPanel(scr->wmscreen, NULL, title, message, *text,
 192                                _("OK"), _("Cancel"));
 193
 194
 195     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 320, 160, 0, 0, 0);
 196     XSelectInput(dpy, parent, KeyPressMask|KeyReleaseMask);
 197
 198     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 199
 200     center = getCenter(scr, 320, 160);
 201     wwin = wManageInternalWindow(scr, parent, None, NULL, center.x, center.y,
 202                                  320, 160);
 203
 204     wwin->client_leader = WMWidgetXID(panel->win);
 205
 206     WMMapWidget(panel->win);
 207
 208     wWindowMap(wwin);
 209
 210     WMRunModalLoop(WMWidgetScreen(panel->win), WMWidgetView(panel->win));
 211
 212     if (panel->result == WAPRDefault)
 213         result = WMGetTextFieldText(panel->text);
 214     else
 215         result = NULL;
 216
 217     wUnmanageWindow(wwin, False, False);
 218
 219     WMDestroyInputPanel(panel);
 220
 221     XDestroyWindow(dpy, parent);
 222
 223     if (result==NULL)
 224         return False;
 225     else {
 226         if (*text)
 227             wfree(*text);
 228         *text = result;
 229
 230         return True;
 231     }
 232 }
 233
 234
 235 /*
 236  *****************************************************************
 237  * Icon Selection Panel
 238  *****************************************************************
 239  */
 240
 241 typedef struct IconPanel {
 242
 243     WScreen *scr;
 244
 245     WMWindow *win;
 246
 247     WMLabel *dirLabel;
 248     WMLabel *iconLabel;
 249
 250     WMList *dirList;
 251     WMList *iconList;
 252     WMFont *normalfont;
 253
 254     WMButton *previewButton;
 255
 256     WMLabel *iconView;
 257
 258     WMLabel *fileLabel;
 259     WMTextField *fileField;
 260
 261     WMButton *okButton;
 262     WMButton *cancelButton;
 263 #if 0
 264     WMButton *chooseButton;
 265 #endif
 266     short done;
 267     short result;
 268     short preview;
 269 } IconPanel;
 270
 271
 272
 273 static void
 274 listPixmaps(WScreen *scr, WMList *lPtr, char *path)
 275 {
 276     struct dirent *dentry;
 277     DIR *dir;
 278     char pbuf[PATH_MAX+16];
 279     char *apath;
 280     IconPanel *panel = WMGetHangedData(lPtr);
 281
 282     panel->preview = False;
 283
 284     apath = wexpandpath(path);
 285     dir = opendir(apath);
 286
 287     if (!dir) {
 288         char *msg;
 289         char *tmp;
 290         tmp = _("Could not open directory ");
 291         msg = wmalloc(strlen(tmp)+strlen(path)+6);
 292         strcpy(msg, tmp);
 293         strcat(msg, path);
 294
 295         wMessageDialog(scr, _("Error"), msg, _("OK"), NULL, NULL);
 296         wfree(msg);
 297         wfree(apath);
 298         return;
 299     }
 300
 301     /* list contents in the column */
 302     while ((dentry = readdir(dir))) {
 303         struct stat statb;
 304
 305         if (strcmp(dentry->d_name, ".")==0 ||
 306             strcmp(dentry->d_name, "..")==0)
 307             continue;
 308
 309         strcpy(pbuf, apath);
 310         strcat(pbuf, "/");
 311         strcat(pbuf, dentry->d_name);
 312
 313         if (stat(pbuf, &statb)<0)
 314             continue;
 315
 316         if (statb.st_mode & (S_IRUSR|S_IRGRP|S_IROTH)
 317             && statb.st_mode & (S_IFREG|S_IFLNK)) {
 318             WMAddListItem(lPtr, dentry->d_name);
 319         }
 320     }
 321     WMSortListItems(lPtr);
 322
 323     closedir(dir);
 324     wfree(apath);
 325     panel->preview = True;
 326 }
 327
 328
 329
 330 static void
 331 setViewedImage(IconPanel *panel, char *file)
 332 {
 333     WMPixmap *pixmap;
 334     RColor color;
 335
 336     color.red = 0xae;
 337     color.green = 0xaa;
 338     color.blue = 0xae;
 339     color.alpha = 0;
 340     pixmap = WMCreateBlendedPixmapFromFile(WMWidgetScreen(panel->win),
 341                                            file, &color);
 342     if (!pixmap) {
 343         WMSetButtonEnabled(panel->okButton, False);
 344
 345         WMSetLabelText(panel->iconView, _("Could not load image file "));
 346
 347         WMSetLabelImage(panel->iconView, NULL);
 348     } else {
 349         WMSetButtonEnabled(panel->okButton, True);
 350
 351         WMSetLabelText(panel->iconView, NULL);
 352         WMSetLabelImage(panel->iconView, pixmap);
 353         WMReleasePixmap(pixmap);
 354     }
 355 }
 356
 357
 358 static void
 359 listCallback(void *self, void *data)
 360 {
 361     WMList *lPtr = (WMList*)self;
 362     IconPanel *panel = (IconPanel*)data;
 363     char *path;
 364
 365     if (lPtr==panel->dirList) {
 366         WMListItem *item = WMGetListSelectedItem(lPtr);
 367
 368         if (item == NULL)
 369             return;
 370         path = item->text;
 371
 372         WMSetTextFieldText(panel->fileField, path);
 373
 374         WMSetLabelImage(panel->iconView, NULL);
 375
 376         WMSetButtonEnabled(panel->okButton, False);
 377
 378         WMClearList(panel->iconList);
 379         listPixmaps(panel->scr, panel->iconList, path);
 380     } else {
 381         char *tmp, *iconFile;
 382         WMListItem *item = WMGetListSelectedItem(panel->dirList);
 383
 384         if (item == NULL)
 385             return;
 386         path = item->text;
 387         tmp = wexpandpath(path);
 388
 389         item = WMGetListSelectedItem(panel->iconList);
 390         if (item == NULL)
 391             return;
 392         iconFile = item->text;
 393
 394         path = wmalloc(strlen(tmp)+strlen(iconFile)+4);
 395         strcpy(path, tmp);
 396         strcat(path, "/");
 397         strcat(path, iconFile);
 398         wfree(tmp);
 399         WMSetTextFieldText(panel->fileField, path);
 400         setViewedImage(panel, path);
 401         wfree(path);
 402     }
 403 }
 404
 405
 406 static void
 407 listIconPaths(WMList *lPtr)
 408 {
 409     char *paths;
 410     char *path;
 411
 412     paths = wstrdup(wPreferences.icon_path);
 413
 414     path = strtok(paths, ":");
 415
 416     do {
 417         char *tmp;
 418
 419         tmp = wexpandpath(path);
 420         /* do not sort, because the order implies the order of
 421          * directories searched */
 422         if (access(tmp, X_OK)==0)
 423             WMAddListItem(lPtr, path);
 424         wfree(tmp);
 425     } while ((path=strtok(NULL, ":"))!=NULL);
 426
 427     wfree(paths);
 428 }
 429
 430
 431 void
 432 drawIconProc(WMList *lPtr, int index, Drawable d, char *text, int state,
 433              WMRect *rect)
 434 {
 435     IconPanel *panel = WMGetHangedData(lPtr);
 436     WScreen *scr = panel->scr;
 437     GC gc = scr->draw_gc;
 438     GC copygc = scr->copy_gc;
 439     char *file, *dirfile;
 440     WMPixmap *pixmap;
 441     WMColor *back;
 442     WMSize size;
 443     WMScreen *wmscr = WMWidgetScreen(panel->win);
 444     RColor color;
 445     int x, y, width, height, len;
 446
 447     if(!panel->preview) return;
 448
 449     x = rect->pos.x;
 450     y = rect->pos.y;
 451     width = rect->size.width;
 452     height = rect->size.height;
 453
 454     back = (state & WLDSSelected) ? scr->white : scr->gray;
 455
 456     dirfile = wexpandpath(WMGetListSelectedItem(panel->dirList)->text);
 457     len = strlen(dirfile)+strlen(text)+4;
 458     file = wmalloc(len);
 459     snprintf(file, len, "%s/%s", dirfile, text);
 460     wfree(dirfile);
 461
 462     color.red = WMRedComponentOfColor(back) >> 8;
 463     color.green = WMGreenComponentOfColor(back) >> 8;
 464     color.blue = WMBlueComponentOfColor(back) >> 8;
 465     color.alpha = WMGetColorAlpha(back) >> 8;
 466
 467     pixmap = WMCreateBlendedPixmapFromFile(wmscr, file, &color);
 468     wfree(file);
 469
 470     if (!pixmap) {
 471         /*WMRemoveListItem(lPtr, index);*/
 472         return;
 473     }
 474
 475     XFillRectangle(dpy, d, WMColorGC(back), x, y, width, height);
 476
 477     XSetClipMask(dpy, gc, None);
 478     /*XDrawRectangle(dpy, d, WMColorGC(white), x+5, y+5, width-10, 54);*/
 479     XDrawLine(dpy, d, WMColorGC(scr->white), x, y+height-1, x+width, y+height-1);
 480
 481     size = WMGetPixmapSize(pixmap);
 482
 483     XSetClipMask(dpy, copygc, WMGetPixmapMaskXID(pixmap));
 484     XSetClipOrigin(dpy, copygc, x + (width-size.width)/2, y+2);
 485     XCopyArea(dpy, WMGetPixmapXID(pixmap), d, copygc, 0, 0,
 486               size.width>100?100:size.width, size.height>64?64:size.height,
 487               x + (width-size.width)/2, y+2);
 488
 489     {
 490         int i,j;
 491         int fheight = WMFontHeight(panel->normalfont);
 492         int tlen = strlen(text);
 493         int twidth = WMWidthOfString(panel->normalfont, text, tlen);
 494         int ofx, ofy;
 495
 496         ofx = x + (width - twidth)/2;
 497         ofy = y + 64 - fheight;
 498
 499         for(i=-1;i<2;i++)
 500             for(j=-1;j<2;j++)
 501                 WMDrawString(wmscr, d, scr->white, panel->normalfont,
 502                              ofx+i, ofy+j, text, tlen);
 503
 504         WMDrawString(wmscr, d, scr->black, panel->normalfont, ofx, ofy,
 505                      text, tlen);
 506     }
 507
 508     WMReleasePixmap(pixmap);
 509     /* I hope it is better to do not use cache / on my box it is fast nuff */
 510     XFlush(dpy);
 511 }
 512
 513
 514 static void
 515 buttonCallback(void *self, void *clientData)
 516 {
 517     WMButton *bPtr = (WMButton*)self;
 518     IconPanel *panel = (IconPanel*)clientData;
 519
 520
 521     if (bPtr==panel->okButton) {
 522         panel->done = True;
 523         panel->result = True;
 524     } else if (bPtr==panel->cancelButton) {
 525         panel->done = True;
 526         panel->result = False;
 527     } else if (bPtr==panel->previewButton) {
 528         /**** Previewer ****/
 529         WMSetButtonEnabled(bPtr, False);
 530         WMSetListUserDrawItemHeight(panel->iconList, 68);
 531         WMSetListUserDrawProc(panel->iconList, drawIconProc);
 532         WMRedisplayWidget(panel->iconList);
 533         /* for draw proc to access screen/gc */
 534         /*** end preview ***/
 535     }
 536 #if 0
 537     else if (bPtr==panel->chooseButton) {
 538         WMOpenPanel *op;
 539
 540         op = WMCreateOpenPanel(WMWidgetScreen(bPtr));
 541
 542         if (WMRunModalFilePanelForDirectory(op, NULL, "/usr/local", NULL, NULL)) {
 543             char *path;
 544             path = WMGetFilePanelFile(op);
 545             WMSetTextFieldText(panel->fileField, path);
 546             setViewedImage(panel, path);
 547             wfree(path);
 548         }
 549         WMDestroyFilePanel(op);
 550     }
 551 #endif
 552 }
 553
 554
 555 static void
 556 keyPressHandler(XEvent *event, void *data)
 557 {
 558     IconPanel *panel = (IconPanel*)data;
 559     char buffer[32];
 560     int count;
 561     KeySym ksym;
 562     int iidx;
 563     int didx;
 564     int item;
 565     WMList *list = NULL;
 566
 567     if (event->type == KeyRelease)
 568         return;
 569
 570     buffer[0] = 0;
 571     count = XLookupString(&event->xkey, buffer, sizeof(buffer), &ksym, NULL);
 572
 573
 574     iidx = WMGetListSelectedItemRow(panel->iconList);
 575     didx = WMGetListSelectedItemRow(panel->dirList);
 576
 577     switch (ksym) {
 578     case XK_Up:
 579         if (iidx > 0)
 580             item = iidx-1;
 581         else
 582             item = iidx;
 583         list = panel->iconList;
 584         break;
 585     case XK_Down:
 586         if (iidx < WMGetListNumberOfRows(panel->iconList) - 1)
 587             item = iidx+1;
 588         else
 589             item = iidx;
 590         list = panel->iconList;
 591         break;
 592     case XK_Home:
 593         item = 0;
 594         list = panel->iconList;
 595         break;
 596     case XK_End:
 597         item = WMGetListNumberOfRows(panel->iconList) - 1;
 598         list = panel->iconList;
 599         break;
 600     case XK_Next:
 601         if (didx < WMGetListNumberOfRows(panel->dirList) - 1)
 602             item = didx + 1;
 603         else
 604             item = didx;
 605         list = panel->dirList;
 606         break;
 607     case XK_Prior:
 608         if (didx > 0)
 609             item = didx - 1;
 610         else
 611             item = 0;
 612         list = panel->dirList;
 613         break;
 614     case XK_Return:
 615         WMPerformButtonClick(panel->okButton);
 616         break;
 617     case XK_Escape:
 618         WMPerformButtonClick(panel->cancelButton);
 619         break;
 620     }
 621
 622     if (list) {
 623         WMSelectListItem(list, item);
 624         WMSetListPosition(list, item - 5);
 625         listCallback(list, panel);
 626     }
 627 }
 628
 629
 630
 631 Bool
 632 wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
 633 {
 634     WWindow *wwin;
 635     Window parent;
 636     IconPanel *panel;
 637     WMColor *color;
 638     WMFont *boldFont;
 639     Bool result;
 640
 641     panel = wmalloc(sizeof(IconPanel));
 642     memset(panel, 0, sizeof(IconPanel));
 643
 644     panel->scr = scr;
 645
 646     panel->win = WMCreateWindow(scr->wmscreen, "iconChooser");
 647     WMResizeWidget(panel->win, 450, 280);
 648
 649     WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask|KeyReleaseMask,
 650                          keyPressHandler, panel);
 651
 652
 653     boldFont = WMBoldSystemFontOfSize(scr->wmscreen, 12);
 654     panel->normalfont = WMSystemFontOfSize(WMWidgetScreen(panel->win), 12);
 655
 656     panel->dirLabel = WMCreateLabel(panel->win);
 657     WMResizeWidget(panel->dirLabel, 200, 20);
 658     WMMoveWidget(panel->dirLabel, 10, 7);
 659     WMSetLabelText(panel->dirLabel, _("Directories"));
 660     WMSetLabelFont(panel->dirLabel, boldFont);
 661     WMSetLabelTextAlignment(panel->dirLabel, WACenter);
 662
 663     WMSetLabelRelief(panel->dirLabel, WRSunken);
 664
 665     panel->iconLabel = WMCreateLabel(panel->win);
 666     WMResizeWidget(panel->iconLabel, 140, 20);
 667     WMMoveWidget(panel->iconLabel, 215, 7);
 668     WMSetLabelText(panel->iconLabel, _("Icons"));
 669     WMSetLabelFont(panel->iconLabel, boldFont);
 670     WMSetLabelTextAlignment(panel->iconLabel, WACenter);
 671
 672     WMReleaseFont(boldFont);
 673
 674     color = WMWhiteColor(scr->wmscreen);
 675     WMSetLabelTextColor(panel->dirLabel, color);
 676     WMSetLabelTextColor(panel->iconLabel, color);
 677     WMReleaseColor(color);
 678
 679     color = WMDarkGrayColor(scr->wmscreen);
 680     WMSetWidgetBackgroundColor(panel->iconLabel, color);
 681     WMSetWidgetBackgroundColor(panel->dirLabel, color);
 682     WMReleaseColor(color);
 683
 684     WMSetLabelRelief(panel->iconLabel, WRSunken);
 685
 686     panel->dirList = WMCreateList(panel->win);
 687     WMResizeWidget(panel->dirList, 200, 170);
 688     WMMoveWidget(panel->dirList, 10, 30);
 689     WMSetListAction(panel->dirList, listCallback, panel);
 690
 691     panel->iconList = WMCreateList(panel->win);
 692     WMResizeWidget(panel->iconList, 140, 170);
 693     WMMoveWidget(panel->iconList, 215, 30);
 694     WMSetListAction(panel->iconList, listCallback, panel);
 695
 696     WMHangData(panel->iconList,panel);
 697
 698     panel->previewButton = WMCreateCommandButton(panel->win);
 699     WMResizeWidget(panel->previewButton, 75, 26);
 700     WMMoveWidget(panel->previewButton, 365, 130);
 701     WMSetButtonText(panel->previewButton, _("Preview"));
 702     WMSetButtonAction(panel->previewButton, buttonCallback, panel);
 703
 704     panel->iconView = WMCreateLabel(panel->win);
 705     WMResizeWidget(panel->iconView, 75, 75);
 706     WMMoveWidget(panel->iconView, 365, 40);
 707     WMSetLabelImagePosition(panel->iconView, WIPOverlaps);
 708     WMSetLabelRelief(panel->iconView, WRSunken);
 709     WMSetLabelTextAlignment(panel->iconView, WACenter);
 710
 711     panel->fileLabel = WMCreateLabel(panel->win);
 712     WMResizeWidget(panel->fileLabel, 80, 20);
 713     WMMoveWidget(panel->fileLabel, 10, 210);
 714     WMSetLabelText(panel->fileLabel, _("File Name:"));
 715
 716     panel->fileField = WMCreateTextField(panel->win);
 717     WMSetViewNextResponder(WMWidgetView(panel->fileField), WMWidgetView(panel->win));
 718     WMResizeWidget(panel->fileField, 345, 20);
 719     WMMoveWidget(panel->fileField, 95, 210);
 720     WMSetTextFieldEditable(panel->fileField, False);
 721
 722     panel->okButton = WMCreateCommandButton(panel->win);
 723     WMResizeWidget(panel->okButton, 80, 26);
 724     WMMoveWidget(panel->okButton, 360, 240);
 725     WMSetButtonText(panel->okButton, _("OK"));
 726     WMSetButtonEnabled(panel->okButton, False);
 727     WMSetButtonAction(panel->okButton, buttonCallback, panel);
 728
 729     panel->cancelButton = WMCreateCommandButton(panel->win);
 730     WMResizeWidget(panel->cancelButton, 80, 26);
 731     WMMoveWidget(panel->cancelButton, 270, 240);
 732     WMSetButtonText(panel->cancelButton, _("Cancel"));
 733     WMSetButtonAction(panel->cancelButton, buttonCallback, panel);
 734 #if 0
 735     panel->chooseButton = WMCreateCommandButton(panel->win);
 736     WMResizeWidget(panel->chooseButton, 110, 26);
 737     WMMoveWidget(panel->chooseButton, 150, 240);
 738     WMSetButtonText(panel->chooseButton, _("Choose File"));
 739     WMSetButtonAction(panel->chooseButton, buttonCallback, panel);
 740 #endif
 741     WMRealizeWidget(panel->win);
 742     WMMapSubwidgets(panel->win);
 743
 744     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 450, 280, 0, 0, 0);
 745
 746     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 747
 748     {
 749         char *tmp;
 750         int len = (instance ? strlen(instance) : 0)
 751             + (class ? strlen(class) : 0) + 32;
 752         WMPoint center;
 753
 754         tmp = wmalloc(len);
 755
 756         if (tmp && (instance || class))
 757             snprintf(tmp, len, "%s [%s.%s]", _("Icon Chooser"), instance, class);
 758         else
 759             strcpy(tmp, _("Icon Chooser"));
 760
 761         center = getCenter(scr, 450, 280);
 762
 763         wwin = wManageInternalWindow(scr, parent, None, tmp, center.x,center.y,
 764                                      450, 280);
 765         wfree(tmp);
 766     }
 767
 768     /* put icon paths in the list */
 769     listIconPaths(panel->dirList);
 770
 771     WMMapWidget(panel->win);
 772
 773     wWindowMap(wwin);
 774
 775     while (!panel->done) {
 776         XEvent event;
 777
 778         WMNextEvent(dpy, &event);
 779         WMHandleEvent(&event);
 780     }
 781
 782     if (panel->result) {
 783         char *defaultPath, *wantedPath;
 784
 785         /* check if the file the user selected is not the one that
 786          * would be loaded by default with the current search path */
 787         *file = WMGetListSelectedItem(panel->iconList)->text;
 788         if (**file==0) {
 789             wfree(*file);
 790             *file = NULL;
 791         } else {
 792             defaultPath = FindImage(wPreferences.icon_path, *file);
 793             wantedPath = WMGetTextFieldText(panel->fileField);
 794             /* if the file is not the default, use full path */
 795             if (strcmp(wantedPath, defaultPath)!=0) {
 796                 *file = wantedPath;
 797             } else {
 798                 *file = wstrdup(*file);
 799                 wfree(wantedPath);
 800             }
 801             wfree(defaultPath);
 802         }
 803     } else {
 804         *file = NULL;
 805     }
 806
 807     result = panel->result;
 808
 809     WMReleaseFont(panel->normalfont);
 810
 811     WMUnmapWidget(panel->win);
 812
 813     WMDestroyWidget(panel->win);
 814
 815     wUnmanageWindow(wwin, False, False);
 816
 817     wfree(panel);
 818
 819     XDestroyWindow(dpy, parent);
 820
 821     return result;
 822 }
 823
 824
 825 /*
 826  ***********************************************************************
 827  * Info Panel
 828  ***********************************************************************
 829  */
 830
 831
 832 typedef struct {
 833     WScreen *scr;
 834
 835     WWindow *wwin;
 836
 837     WMWindow *win;
 838
 839     WMLabel *logoL;
 840     WMLabel *name1L;
 841     WMFrame *lineF;
 842     WMLabel *name2L;
 843
 844     WMLabel *versionL;
 845
 846     WMLabel *infoL;
 847
 848     WMLabel *copyrL;
 849
 850 #ifdef SILLYNESS
 851     WMHandlerID timer;
 852     int cycle;
 853     RImage *icon;
 854     RImage *pic;
 855     WMPixmap *oldPix;
 856     WMFont *oldFont;
 857     char *str;
 858     int x;
 859 #endif
 860 } InfoPanel;
 861
 862
 863
 864 #define COPYRIGHT_TEXT  \
 865     "Copyright \xc2\xa9 1997-2004 Alfredo K. Kojima <kojima@windowmaker.org>\n"\
 866     "Copyright \xc2\xa9 1998-2004 Dan Pascu <dan@windowmaker.org>"
 867
 868
 869
 870 static InfoPanel *thePanel = NULL;
 871
 872 static void
 873 destroyInfoPanel(WCoreWindow *foo, void *data, XEvent *event)
 874 {
 875 #ifdef SILLYNESS
 876     if (thePanel->timer) {
 877         WMDeleteTimerHandler(thePanel->timer);
 878     }
 879     if (thePanel->oldPix) {
 880         WMReleasePixmap(thePanel->oldPix);
 881     }
 882     if (thePanel->oldFont) {
 883         WMReleaseFont(thePanel->oldFont);
 884     }
 885     if (thePanel->icon) {
 886         RReleaseImage(thePanel->icon);
 887     }
 888     if (thePanel->pic) {
 889         RReleaseImage(thePanel->pic);
 890     }
 891 #endif /* SILLYNESS */
 892     WMUnmapWidget(thePanel);
 893
 894     wUnmanageWindow(thePanel->wwin, False, False);
 895
 896     WMDestroyWidget(thePanel->win);
 897
 898     wfree(thePanel);
 899
 900     thePanel = NULL;
 901 }
 902
 903
 904 #ifdef SILLYNESS
 905
 906 extern WMPixmap *DoXThing();
 907 extern Bool InitXThing();
 908
 909 static void
 910 logoPushCallback(void *data)
 911 {
 912     InfoPanel *panel = (InfoPanel*)data;
 913     char buffer[512];
 914     int i;
 915     static int oldi = 0;
 916     int len;
 917     static int jingobeu[] = {
 918         329, 150, -1, 100, 329, 150, -1, 100, 329, 300, -1, 250,
 919         329, 150, -1, 100, 329, 150, -1, 100,  329, 300, -1, 250,
 920         329, 150, 392, 150, 261, 150, 293, 150, 329, 400, -1, 400, 0
 921     };
 922     static int c = 0;
 923
 924     if (panel->x) {
 925         XKeyboardControl kc;
 926         XKeyboardState ksave;
 927         unsigned long mask = KBBellPitch|KBBellDuration|KBBellPercent;
 928
 929         XGetKeyboardControl(dpy, &ksave);
 930
 931         if (panel->x > 0) {
 932             if(jingobeu[panel->x-1]==0) {
 933                 panel->x=-1;
 934             } else if (jingobeu[panel->x-1]<0) {
 935                 panel->x++;
 936                 c=jingobeu[panel->x-1]/50;
 937                 panel->x++;
 938             } else if (c==0) {
 939                 kc.bell_percent=50;
 940                 kc.bell_pitch=jingobeu[panel->x-1];
 941                 panel->x++;
 942                 kc.bell_duration=jingobeu[panel->x-1];
 943                 c=jingobeu[panel->x-1]/50;
 944                 panel->x++;
 945                 XChangeKeyboardControl(dpy, mask, &kc);
 946                 XBell(dpy, 50);
 947                 XFlush(dpy);
 948             } else {
 949                 c--;
 950             }
 951         }
 952         if (!(panel->cycle % 4)) {
 953             WMPixmap *p;
 954
 955             p = DoXThing(panel->wwin);
 956             WMSetLabelImage(panel->logoL, p);
 957         }
 958         kc.bell_pitch = ksave.bell_pitch;
 959         kc.bell_percent = ksave.bell_percent;
 960         kc.bell_duration = ksave.bell_duration;
 961         XChangeKeyboardControl(dpy, mask, &kc);
 962     } else if (panel->cycle < 30) {
 963         RImage *image;
 964         WMPixmap *pix;
 965         RColor gray;
 966
 967         gray.red = 0xae;  gray.green = 0xaa;
 968         gray.blue = 0xae; gray.alpha = 0;
 969
 970         image = RScaleImage(panel->icon, panel->pic->width, panel->pic->height);
 971         RCombineImagesWithOpaqueness(image, panel->pic, panel->cycle*255/30);
 972         pix = WMCreateBlendedPixmapFromRImage(panel->scr->wmscreen, image, &gray);
 973         RReleaseImage(image);
 974         WMSetLabelImage(panel->logoL, pix);
 975         WMReleasePixmap(pix);
 976     }
 977
 978     /* slow down text a little */
 979     i = (int)(panel->cycle * 50.0/85.0)%200;
 980
 981     if (i != oldi) {
 982         len = strlen(panel->str);
 983
 984         strncpy(buffer, panel->str, i<len ? i : len);
 985         if (i >= len)
 986             memset(&buffer[len], ' ', i-len);
 987
 988         strncpy(buffer, panel->str, i<len ? i : len);
 989         if (i >= len)
 990             memset(&buffer[len], ' ', i-len);
 991         buffer[i]=0;
 992
 993         WMSetLabelText(panel->versionL, buffer);
 994
 995         XFlush(WMScreenDisplay(WMWidgetScreen(panel->versionL)));
 996
 997         oldi = i;
 998     }
 999
1000     panel->timer = WMAddTimerHandler(50, logoPushCallback, panel);
1001     panel->cycle++;
1002 }
1003
1004
1005 static void
1006 handleLogoPush(XEvent *event, void *data)
1007 {
1008     InfoPanel *panel = (InfoPanel*)data;
1009     static int broken = 0;
1010     static int clicks = 0;
1011     static char *pic_data[] = {
1012         "45 45 57 1",
1013         "       c None",
1014         ".      c #000000",
1015         "X      c #383C00",
1016         "o      c #515500",
1017         "O      c #616100",
1018         "+      c #616900",
1019         "@      c #696D00",
1020         "#      c #697100",
1021         "$      c #495100",
1022         "%      c #202800",
1023         "&      c #969600",
1024         "*      c #CFCF00",
1025         "=      c #D7DB00",
1026         "-      c #D7D700",
1027         ";      c #C7CB00",
1028         ":      c #A6AA00",
1029         ">      c #494900",
1030         ",      c #8E8E00",
1031         "<      c #DFE700",
1032         "1      c #F7FF00",
1033         "2      c #FFFF00",
1034         "3      c #E7EB00",
1035         "4      c #B6B600",
1036         "5      c #595900",
1037         "6      c #717500",
1038         "7      c #AEB200",
1039         "8      c #CFD300",
1040         "9      c #E7EF00",
1041         "0      c #EFF300",
1042         "q      c #9EA200",
1043         "w      c #F7FB00",
1044         "e      c #F7F700",
1045         "r      c #BEBE00",
1046         "t      c #8E9200",
1047         "y      c #EFF700",
1048         "u      c #969A00",
1049         "i      c #414500",
1050         "p      c #595D00",
1051         "a      c #E7E700",
1052         "s      c #C7C700",
1053         "d      c #797D00",
1054         "f      c #BEC300",
1055         "g      c #DFE300",
1056         "h      c #868600",
1057         "j      c #EFEF00",
1058         "k      c #9E9E00",
1059         "l      c #616500",
1060         "z      c #DFDF00",
1061         "x      c #868A00",
1062         "c      c #969200",
1063         "v      c #B6BA00",
1064         "b      c #A6A600",
1065         "n      c #8E8A00",
1066         "m      c #717100",
1067         "M      c #AEAE00",
1068         "N      c #AEAA00",
1069         "B      c #868200",
1070         "               ...............               ",
1071         "             ....XoO+@##+O$%....             ",
1072         "           ...%X&*========-;;:o...           ",
1073         "         ...>.>,<122222222222134@...         ",
1074         "        ..>5678912222222222222220q%..        ",
1075         "       ..$.&-w2222222222222222222er>..       ",
1076         "      ..O.t31222222222222222222222y4>..      ",
1077         "    ...O5u3222222222222222222222222yri...    ",
1078         "    ..>p&a22222222222222222222222222wso..    ",
1079         "   ..ids91222222222222222222222222222wfi..   ",
1080         "  ..X.7w222222wgs-w2222222213=g0222222<hi..  ",
1081         "  ..Xuj2222222<@X5=222222229k@l:022222y4i..  ",
1082         "  .Xdz22222222*X%.s22222222axo%$-222222<c>.. ",
1083         " ..o7y22222222v...r222222223hX.i82222221si.. ",
1084         "..io*222222222&...u22222222yt..%*22222220:%. ",
1085         "..>k02222222227...f222222222v..X=222222229t. ",
1086         "..dz12222222220ui:y2222222223d%qw222222221g. ",
1087         ".%vw222222222221y2222222222219*y2222222222wd.",
1088         ".X;2222222222222222222222222222222222222222b.",
1089         ".i*2222222222222222222222222222222222222222v.",
1090         ".i*2222222222222222222222222222222222222222;.",
1091         ".i*22222222222222222222222222222222222222228.",
1092         ".>*2222222222222222222222222222222222222222=.",
1093         ".i*22222222222222222222222222222222222222228.",
1094         ".i*2222222222222222222222222222222222222222;.",
1095         ".X*222222222222222222222222222222we12222222r.",
1096         ".Xs12222222w3aw22222222222222222y8s0222222wk.",
1097         ".Xq02222222a,na22222222222222222zm6zwy2222gi.",
1098         "..>*22222y<:Xcj22222222222222222-o$k;;02228..",
1099         "..i7y2220rhX.:y22222222222222222jtiXd,a220,..",
1100         " .X@z222a,do%kj2222222222222222wMX5q;gw228%..",
1101         " ..58222wagsh6ry222222222222221;>Of0w222y:...",
1102         " ...:e2222218mdz22222222222222a&$vw222220@...",
1103         " ...O-122222y:.u02222222222229q$uj222221r... ",
1104         "  ..%&a1222223&573w2222222219NOxz122221z>... ",
1105         "   ...t3222221-l$nr8ay1222yzbo,=12222w-5...  ",
1106         "    ..X:022222w-k+>o,7s**s7xOn=12221<f5...   ",
1107         "     ..o:9222221j8:&Bl>>>>ihv<12221=dX...    ",
1108         "      ..Xb9122222109g-****;<y22221zn%...     ",
1109         "       ..X&801222222222222222222w-h....      ",
1110         "        ...o:=022222222222222221=lX...       ",
1111         "          ..X@:;3w2222222222210fO...         ",
1112         "           ...XX&v8<30000003-N@...           ",
1113         "             .....XmnbN:q&Bo....             ",
1114         "                 ............                "
1115     };
1116     static char *msgs[] = {
1117         "Have a nice day!",
1118         "Focus follow mouse users will burn in hell!!!",
1119         "Mooo Canada!!!!",
1120         "Hi! My name is bobby...",
1121         "AHH! The neurotic monkeys are after me!",
1122         "WE GET SIGNAL",
1123         "HOW ARE YOU GENTLEMEN?",
1124         "WHAT YOU SAY??",
1125         "SOMEBODY SET UP US THE BOMB",
1126         "ALL YOUR BASE ARE BELONG TO US!",
1127         "Oh My God!!! Larry is back!"
1128     };
1129
1130
1131     clicks++;
1132
1133     if (!panel->timer && !broken && clicks > 0) {
1134         WMFont *font;
1135
1136         panel->x = 0;
1137         clicks = 0;
1138         if (!panel->icon) {
1139             panel->icon = WMGetApplicationIconImage(panel->scr->wmscreen);
1140             if (!panel->icon) {
1141                 broken = 1;
1142                 return;
1143             } else {
1144                 RColor color;
1145
1146                 color.red = 0xae;  color.green = 0xaa;
1147                 color.blue = 0xae; color.alpha = 0;
1148
1149                 panel->icon = RCloneImage(panel->icon);
1150                 RCombineImageWithColor(panel->icon, &color);
1151             }
1152         }
1153         if (!panel->pic) {
1154             panel->pic = RGetImageFromXPMData(panel->scr->rcontext, pic_data);
1155             if (!panel->pic) {
1156                 broken = 1;
1157                 RReleaseImage(panel->icon);
1158                 panel->icon = NULL;
1159                 return;
1160             }
1161         }
1162
1163         panel->str = msgs[rand()%(sizeof(msgs)/sizeof(char*))];
1164
1165         panel->timer = WMAddTimerHandler(50, logoPushCallback, panel);
1166         panel->cycle = 0;
1167         panel->oldPix = WMRetainPixmap(WMGetLabelImage(panel->logoL));
1168         /* If we don't use a fixed font, scrolling will be jumpy */
1169         /* Alternatively we can draw text in a pixmap and scroll it smoothly */
1170         if ((panel->oldFont = WMGetLabelFont(panel->versionL))!=NULL)
1171             WMRetainFont(panel->oldFont);
1172         font = WMCreateFont(WMWidgetScreen(panel->versionL),
1173                             "Lucida Console,Courier New,monospace:pixelsize=12");
1174         if (font) {
1175             WMSetLabelFont(panel->versionL, font);
1176             WMReleaseFont(font);
1177         }
1178         WMSetLabelText(panel->versionL, "");
1179     } else if (panel->timer) {
1180         char version[20];
1181
1182         panel->x = 0;
1183         clicks = 0;
1184         WMSetLabelImage(panel->logoL, panel->oldPix);
1185         WMReleasePixmap(panel->oldPix);
1186         panel->oldPix = NULL;
1187
1188         WMDeleteTimerHandler(panel->timer);
1189         panel->timer = NULL;
1190
1191         WMSetLabelFont(panel->versionL, panel->oldFont);
1192         if (panel->oldFont) {
1193             WMReleaseFont(panel->oldFont);
1194             panel->oldFont = NULL;
1195         }
1196         snprintf(version, sizeof(version), _("Version %s"), VERSION);
1197         WMSetLabelText(panel->versionL, version);
1198         XFlush(WMScreenDisplay(WMWidgetScreen(panel->versionL)));
1199     }
1200
1201     {
1202         XEvent ev;
1203         while (XCheckTypedWindowEvent(dpy, WMWidgetXID(panel->versionL),
1204                                       ButtonPress, &ev));
1205     }
1206 }
1207 #endif /* SILLYNESS */
1208
1209
1210 void
1211 wShowInfoPanel(WScreen *scr)
1212 {
1213     InfoPanel *panel;
1214     WMPixmap *logo;
1215     WMSize size;
1216     WMFont *font;
1217     char *strbuf = NULL;
1218     char buffer[256];
1219     char *name;
1220     Window parent;
1221     WWindow *wwin;
1222     char **strl;
1223     int i, width=50, sepWidth;
1224     char *visuals[] = {
1225         "StaticGray",
1226         "GrayScale",
1227         "StaticColor",
1228         "PseudoColor",
1229         "TrueColor",
1230         "DirectColor"
1231     };
1232
1233
1234     if (thePanel) {
1235         if (thePanel->scr == scr) {
1236             wRaiseFrame(thePanel->wwin->frame->core);
1237             wSetFocusTo(scr, thePanel->wwin);
1238         }
1239         return;
1240     }
1241
1242     panel = wmalloc(sizeof(InfoPanel));
1243     memset(panel, 0, sizeof(InfoPanel));
1244
1245     panel->scr = scr;
1246
1247     panel->win = WMCreateWindow(scr->wmscreen, "info");
1248     WMResizeWidget(panel->win, 390, 230);
1249
1250     logo = WMCreateApplicationIconBlendedPixmap(scr->wmscreen, (RColor*)NULL);
1251     if (!logo) {
1252         logo = WMRetainPixmap(WMGetApplicationIconPixmap(scr->wmscreen));
1253     }
1254     if (logo) {
1255         size = WMGetPixmapSize(logo);
1256         panel->logoL = WMCreateLabel(panel->win);
1257         WMResizeWidget(panel->logoL, 64, 64);
1258         WMMoveWidget(panel->logoL, 30, 20);
1259         WMSetLabelImagePosition(panel->logoL, WIPImageOnly);
1260         WMSetLabelImage(panel->logoL, logo);
1261 #ifdef SILLYNESS
1262         WMCreateEventHandler(WMWidgetView(panel->logoL), ButtonPressMask,
1263                              handleLogoPush, panel);
1264 #endif
1265         WMReleasePixmap(logo);
1266     }
1267
1268     sepWidth = 3;
1269     panel->name1L = WMCreateLabel(panel->win);
1270     WMResizeWidget(panel->name1L, 240, 30 - sepWidth);
1271     WMMoveWidget(panel->name1L, 100, 30);
1272
1273     name = "Lucida Sans,Comic Sans MS,URW Gothic L,Trebuchet MS"
1274         ":bold:pixelsize=26:antialias=true";
1275     font = WMCreateFont(scr->wmscreen, name);
1276     strbuf = "Window Maker";
1277     if (font) {
1278         width = WMWidthOfString(font, strbuf, strlen(strbuf));
1279         WMSetLabelFont(panel->name1L, font);
1280         WMReleaseFont(font);
1281     }
1282     WMSetLabelTextAlignment(panel->name1L, WACenter);
1283     WMSetLabelText(panel->name1L, strbuf);
1284
1285     panel->lineF = WMCreateFrame(panel->win);
1286     WMResizeWidget(panel->lineF, width, sepWidth);
1287     WMMoveWidget(panel->lineF, 100+(240-width)/2, 60 - sepWidth);
1288     WMSetFrameRelief(panel->lineF, WRSimple);
1289     WMSetWidgetBackgroundColor(panel->lineF, scr->black);
1290
1291     panel->name2L = WMCreateLabel(panel->win);
1292     WMResizeWidget(panel->name2L, 240, 24);
1293     WMMoveWidget(panel->name2L, 100, 60);
1294     name = "URW Gothic L,Nimbus Sans L:pixelsize=16:antialias=true";
1295     font = WMCreateFont(scr->wmscreen, name);
1296     if (font) {
1297         WMSetLabelFont(panel->name2L, font);
1298         WMReleaseFont(font);
1299         font = NULL;
1300     }
1301     WMSetLabelTextAlignment(panel->name2L, WACenter);
1302     WMSetLabelText(panel->name2L, _("Window Manager for X"));
1303
1304     snprintf(buffer, sizeof(buffer), _("Version %s"), VERSION);
1305     panel->versionL = WMCreateLabel(panel->win);
1306     WMResizeWidget(panel->versionL, 310, 16);
1307     WMMoveWidget(panel->versionL, 30, 95);
1308     WMSetLabelTextAlignment(panel->versionL, WARight);
1309     WMSetLabelText(panel->versionL, buffer);
1310     WMSetLabelWraps(panel->versionL, False);
1311
1312     panel->copyrL = WMCreateLabel(panel->win);
1313     WMResizeWidget(panel->copyrL, 360, 40);
1314     WMMoveWidget(panel->copyrL, 15, 185);
1315     WMSetLabelTextAlignment(panel->copyrL, WALeft);
1316     WMSetLabelText(panel->copyrL, COPYRIGHT_TEXT);
1317     font = WMSystemFontOfSize(scr->wmscreen, 11);
1318     if (font) {
1319         WMSetLabelFont(panel->copyrL, font);
1320         WMReleaseFont(font);
1321         font = NULL;
1322     }
1323
1324     strbuf = NULL;
1325     snprintf(buffer, sizeof(buffer), _("Using visual 0x%x: %s %ibpp "),
1326              (unsigned)scr->w_visual->visualid,
1327              visuals[scr->w_visual->class], scr->w_depth);
1328
1329     strbuf = wstrappend(strbuf, buffer);
1330
1331     switch (scr->w_depth) {
1332     case 15:
1333         strbuf = wstrappend(strbuf, _("(32 thousand colors)\n"));
1334         break;
1335     case 16:
1336         strbuf = wstrappend(strbuf, _("(64 thousand colors)\n"));
1337         break;
1338     case 24:
1339     case 32:
1340         strbuf = wstrappend(strbuf, _("(16 million colors)\n"));
1341         break;
1342     default:
1343         snprintf(buffer, sizeof(buffer), _("(%d colors)\n"), 1<<scr->w_depth);
1344         strbuf = wstrappend(strbuf, buffer);
1345         break;
1346     }
1347
1348
1349 #if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
1350     {
1351         struct mallinfo ma = mallinfo();
1352         snprintf(buffer, sizeof(buffer),
1353                  _("Total allocated memory: %i kB. Total memory in use: %i kB.\n"),
1354                  (ma.arena+ma.hblkhd)/1024, (ma.uordblks+ma.hblkhd)/1024);
1355
1356         strbuf = wstrappend(strbuf, buffer);
1357     }
1358 #endif
1359
1360     strbuf = wstrappend(strbuf, _("Supported image formats: "));
1361     strl = RSupportedFileFormats();
1362     for (i=0; strl[i]!=NULL; i++) {
1363         strbuf = wstrappend(strbuf, strl[i]);
1364         strbuf = wstrappend(strbuf, " ");
1365     }
1366
1367     strbuf = wstrappend(strbuf, _("\nAdditional support for: "));
1368     {
1369         char *list[9];
1370         char buf[80];
1371         int j = 0;
1372
1373 #ifdef NETWM_HINTS
1374         list[j++] = "WMSPEC";
1375 #endif
1376 #ifdef MWM_HINTS
1377         list[j++] = "MWM";
1378 #endif
1379
1380         buf[0] = 0;
1381         for (i = 0; i < j; i++) {
1382             if (i > 0) {
1383                 if (i == j - 1)
1384                     strcat(buf, _(" and "));
1385                 else
1386                     strcat(buf, ", ");
1387             }
1388             strcat(buf, list[i]);
1389         }
1390         strbuf = wstrappend(strbuf, buf);
1391     }
1392
1393     if (wPreferences.no_sound) {
1394         strbuf = wstrappend(strbuf, _("\nSound disabled"));
1395     } else {
1396         strbuf = wstrappend(strbuf, _("\nSound enabled"));
1397     }
1398
1399 #ifdef VIRTUAL_DESKTOP
1400     if (wPreferences.vedge_thickness == 0)
1401         strbuf = wstrappend(strbuf, _(", VirtualDesktop disabled"));
1402     else
1403         strbuf = wstrappend(strbuf, _(", VirtualDesktop enabled"));
1404 #endif
1405
1406 #ifdef XINERAMA
1407     strbuf = wstrappend(strbuf, _("\n"));
1408 #ifdef SOLARIS_XINERAMA
1409     strbuf = wstrappend(strbuf, _("Solaris "));
1410 #endif
1411     strbuf = wstrappend(strbuf, _("Xinerama: "));
1412     {
1413         char tmp[128];
1414         snprintf(tmp, sizeof(tmp)-1, "%d heads found.", scr->xine_info.count);
1415         strbuf = wstrappend(strbuf, tmp);
1416     }
1417 #endif
1418
1419
1420     panel->infoL = WMCreateLabel(panel->win);
1421     WMResizeWidget(panel->infoL, 350, 75);
1422     WMMoveWidget(panel->infoL, 15, 115);
1423     WMSetLabelText(panel->infoL, strbuf);
1424     font = WMSystemFontOfSize(scr->wmscreen, 11);
1425     if (font) {
1426         WMSetLabelFont(panel->infoL, font);
1427         WMReleaseFont(font);
1428         font = NULL;
1429     }
1430     wfree(strbuf);
1431
1432
1433     WMRealizeWidget(panel->win);
1434     WMMapSubwidgets(panel->win);
1435
1436     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 382, 230, 0, 0, 0);
1437
1438     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1439
1440     WMMapWidget(panel->win);
1441
1442     {
1443         WMPoint center = getCenter(scr, 382, 230);
1444
1445         wwin = wManageInternalWindow(scr, parent, None, _("Info"),
1446                                      center.x, center.y,
1447                                      382, 230);
1448     }
1449
1450     WSETUFLAG(wwin, no_closable, 0);
1451     WSETUFLAG(wwin, no_close_button, 0);
1452 #ifdef XKB_BUTTON_HINT
1453     wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1454 #endif
1455     wWindowUpdateButtonImages(wwin);
1456     wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1457     wwin->frame->on_click_right = destroyInfoPanel;
1458
1459     wWindowMap(wwin);
1460
1461     panel->wwin = wwin;
1462
1463     thePanel = panel;
1464 #ifdef SILLYNESS
1465     if (InitXThing(panel->scr)) {
1466         panel->timer = WMAddTimerHandler(100, logoPushCallback, panel);
1467         panel->cycle = 0;
1468         panel->x = 1;
1469         panel->str = _("Merry Christmas!");
1470         panel->oldPix = WMRetainPixmap(WMGetLabelImage(panel->logoL));
1471     }
1472 #endif
1473 }
1474
1475
1476 /*
1477  ***********************************************************************
1478  * Legal Panel
1479  ***********************************************************************
1480  */
1481
1482 typedef struct {
1483     WScreen *scr;
1484
1485     WWindow *wwin;
1486
1487     WMWindow *win;
1488
1489     WMLabel *licenseL;
1490 } LegalPanel;
1491
1492
1493 static LegalPanel *legalPanel = NULL;
1494
1495 static void
1496 destroyLegalPanel(WCoreWindow *foo, void *data, XEvent *event)
1497 {
1498     WMUnmapWidget(legalPanel->win);
1499
1500     WMDestroyWidget(legalPanel->win);
1501
1502     wUnmanageWindow(legalPanel->wwin, False, False);
1503
1504     wfree(legalPanel);
1505
1506     legalPanel = NULL;
1507 }
1508
1509
1510 void
1511 wShowLegalPanel(WScreen *scr)
1512 {
1513     LegalPanel *panel;
1514     Window parent;
1515     WWindow *wwin;
1516
1517     if (legalPanel) {
1518         if (legalPanel->scr == scr) {
1519             wRaiseFrame(legalPanel->wwin->frame->core);
1520             wSetFocusTo(scr, legalPanel->wwin);
1521         }
1522         return;
1523     }
1524
1525     panel = wmalloc(sizeof(LegalPanel));
1526
1527     panel->scr = scr;
1528
1529     panel->win = WMCreateWindow(scr->wmscreen, "legal");
1530     WMResizeWidget(panel->win, 420, 250);
1531
1532
1533     panel->licenseL = WMCreateLabel(panel->win);
1534     WMSetLabelWraps(panel->licenseL, True);
1535     WMResizeWidget(panel->licenseL, 400, 230);
1536     WMMoveWidget(panel->licenseL, 10, 10);
1537     WMSetLabelTextAlignment(panel->licenseL, WALeft);
1538     WMSetLabelText(panel->licenseL,
1539                    _("    Window Maker is free software; you can redistribute it and/or\n"
1540                      "modify it under the terms of the GNU General Public License as\n"
1541                      "published by the Free Software Foundation; either version 2 of the\n"
1542                      "License, or (at your option) any later version.\n\n"
1543                      "    Window Maker is distributed in the hope that it will be useful,\n"
1544                      "but WITHOUT ANY WARRANTY; without even the implied warranty\n"
1545                      "of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
1546                      "See the GNU General Public License for more details.\n\n"
1547                      "    You should have received a copy of the GNU General Public\n"
1548                      "License along with this program; if not, write to the Free Software\n"
1549                      "Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA\n"
1550                      "02111-1307, USA."));
1551     WMSetLabelRelief(panel->licenseL, WRGroove);
1552
1553     WMRealizeWidget(panel->win);
1554     WMMapSubwidgets(panel->win);
1555
1556     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 420, 250, 0, 0, 0);
1557
1558     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1559
1560     {
1561         WMPoint center = getCenter(scr, 420, 250);
1562
1563         wwin = wManageInternalWindow(scr, parent, None, _("Legal"),
1564                                      center.x, center.y,
1565                                      420, 250);
1566     }
1567
1568     WSETUFLAG(wwin, no_closable, 0);
1569     WSETUFLAG(wwin, no_close_button, 0);
1570     wWindowUpdateButtonImages(wwin);
1571     wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1572 #ifdef XKB_BUTTON_HINT
1573     wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1574 #endif
1575     wwin->frame->on_click_right = destroyLegalPanel;
1576
1577     panel->wwin = wwin;
1578
1579     WMMapWidget(panel->win);
1580
1581     wWindowMap(wwin);
1582
1583     legalPanel = panel;
1584 }
1585
1586
1587 /*
1588  ***********************************************************************
1589  * Crashing Dialog Panel
1590  ***********************************************************************
1591  */
1592
1593 extern WDDomain *WDWindowAttributes;
1594
1595
1596 typedef struct _CrashPanel {
1597     WMWindow *win;            /* main window */
1598
1599     WMLabel *iconL;           /* application icon */
1600     WMLabel *nameL;           /* title of panel */
1601
1602     WMFrame *sepF;            /* separator frame */
1603
1604     WMLabel *noteL;           /* Title of note */
1605     WMLabel *note2L;          /* body of note with what happened */
1606
1607     WMFrame *whatF;           /* "what to do next" frame */
1608     WMPopUpButton *whatP;     /* action selection popup button */
1609
1610     WMButton *okB;            /* ok button */
1611
1612     Bool done;                /* if finished with this dialog */
1613     int action;               /* what to do after */
1614
1615     KeyCode retKey;
1616
1617 } CrashPanel;
1618
1619
1620 static void
1621 handleKeyPress(XEvent *event, void *clientData)
1622 {
1623     CrashPanel *panel = (CrashPanel*)clientData;
1624
1625     if (event->xkey.keycode == panel->retKey) {
1626         WMPerformButtonClick(panel->okB);
1627     }
1628 }
1629
1630
1631 static void
1632 okButtonCallback(void *self, void *clientData)
1633 {
1634     CrashPanel *panel = (CrashPanel*)clientData;
1635
1636     panel->done = True;
1637 }
1638
1639
1640 static void
1641 setCrashAction(void *self, void *clientData)
1642 {
1643     WMPopUpButton *pop = (WMPopUpButton*)self;
1644     CrashPanel *panel = (CrashPanel*)clientData;
1645
1646     panel->action = WMGetPopUpButtonSelectedItem(pop);
1647 }
1648
1649
1650 static WMPixmap*
1651 getWindowMakerIconImage(WMScreen *scr)
1652 {
1653     WMPropList *dict, *key, *option, *value=NULL;
1654     WMPixmap *pix=NULL;
1655     char *path;
1656
1657     WMPLSetCaseSensitive(True);
1658
1659     key = WMCreatePLString("Logo.WMPanel");
1660     option = WMCreatePLString("Icon");
1661
1662     dict = WMGetFromPLDictionary(WDWindowAttributes->dictionary, key);
1663
1664     if (dict) {
1665         value = WMGetFromPLDictionary(dict, option);
1666     }
1667
1668     WMReleasePropList(key);
1669     WMReleasePropList(option);
1670
1671     WMPLSetCaseSensitive(False);
1672
1673     if (value && WMIsPLString(value)) {
1674         path = FindImage(wPreferences.icon_path, WMGetFromPLString(value));
1675
1676         if (path) {
1677             RColor gray;
1678
1679             gray.red = 0xae;  gray.green = 0xaa;
1680             gray.blue = 0xae; gray.alpha = 0;
1681
1682             pix = WMCreateBlendedPixmapFromFile(scr, path, &gray);
1683             wfree(path);
1684         }
1685     }
1686
1687     return pix;
1688 }
1689
1690
1691 #define PWIDTH  295
1692 #define PHEIGHT 345
1693
1694
1695 int
1696 wShowCrashingDialogPanel(int whatSig)
1697 {
1698     CrashPanel *panel;
1699     WMScreen *scr;
1700     WMFont *font;
1701     WMPixmap *logo;
1702     int screen_no, scr_width, scr_height;
1703     int action;
1704     char buf[256];
1705
1706     panel = wmalloc(sizeof(CrashPanel));
1707     memset(panel, 0, sizeof(CrashPanel));
1708
1709     screen_no = DefaultScreen(dpy);
1710     scr_width = WidthOfScreen(ScreenOfDisplay(dpy, screen_no));
1711     scr_height = HeightOfScreen(ScreenOfDisplay(dpy, screen_no));
1712
1713     scr = WMCreateScreen(dpy, screen_no);
1714     if (!scr) {
1715         wsyserror(_("cannot open connection for crashing dialog panel. Aborting."));
1716         return WMAbort;
1717     }
1718
1719     panel->retKey = XKeysymToKeycode(dpy, XK_Return);
1720
1721     panel->win = WMCreateWindow(scr, "crashingDialog");
1722     WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1723     WMMoveWidget(panel->win, (scr_width - PWIDTH)/2, (scr_height - PHEIGHT)/2);
1724
1725     logo = getWindowMakerIconImage(scr);
1726     if (logo) {
1727         panel->iconL = WMCreateLabel(panel->win);
1728         WMResizeWidget(panel->iconL, 64, 64);
1729         WMMoveWidget(panel->iconL, 10, 10);
1730         WMSetLabelImagePosition(panel->iconL, WIPImageOnly);
1731         WMSetLabelImage(panel->iconL, logo);
1732     }
1733
1734     panel->nameL = WMCreateLabel(panel->win);
1735     WMResizeWidget(panel->nameL, 190, 18);
1736     WMMoveWidget(panel->nameL, 80, 35);
1737     WMSetLabelTextAlignment(panel->nameL, WALeft);
1738     font = WMBoldSystemFontOfSize(scr, 18);
1739     WMSetLabelFont(panel->nameL, font);
1740     WMReleaseFont(font);
1741     WMSetLabelText(panel->nameL, _("Fatal error"));
1742
1743     panel->sepF = WMCreateFrame(panel->win);
1744     WMResizeWidget(panel->sepF, PWIDTH+4, 2);
1745     WMMoveWidget(panel->sepF, -2, 80);
1746
1747     panel->noteL = WMCreateLabel(panel->win);
1748     WMResizeWidget(panel->noteL, PWIDTH-20, 40);
1749     WMMoveWidget(panel->noteL, 10, 90);
1750     WMSetLabelTextAlignment(panel->noteL, WAJustified);
1751 #ifdef SYS_SIGLIST_DECLARED
1752     snprintf(buf, sizeof(buf), _("Window Maker received signal %i\n(%s)."),
1753              whatSig, sys_siglist[whatSig]);
1754 #else
1755     snprintf(buf, sizeof(buf), _("Window Maker received signal %i."), whatSig);
1756 #endif
1757     WMSetLabelText(panel->noteL, buf);
1758
1759     panel->note2L = WMCreateLabel(panel->win);
1760     WMResizeWidget(panel->note2L, PWIDTH-20, 100);
1761     WMMoveWidget(panel->note2L, 10, 130);
1762     WMSetLabelTextAlignment(panel->note2L, WALeft);
1763     WMSetLabelText(panel->note2L,
1764                    _(" This fatal error occured probably due to a bug."
1765                      " Please fill the included BUGFORM and "
1766                      "report it to bugs@windowmaker.org."));
1767     WMSetLabelWraps(panel->note2L, True);
1768
1769
1770     panel->whatF = WMCreateFrame(panel->win);
1771     WMResizeWidget(panel->whatF, PWIDTH-20, 50);
1772     WMMoveWidget(panel->whatF, 10, 240);
1773     WMSetFrameTitle(panel->whatF, _("What do you want to do now?"));
1774
1775     panel->whatP = WMCreatePopUpButton(panel->whatF);
1776     WMResizeWidget(panel->whatP, PWIDTH-20-70, 20);
1777     WMMoveWidget(panel->whatP, 35, 20);
1778     WMSetPopUpButtonPullsDown(panel->whatP, False);
1779     WMSetPopUpButtonText(panel->whatP, _("Select action"));
1780     WMAddPopUpButtonItem(panel->whatP, _("Abort and leave a core file"));
1781     WMAddPopUpButtonItem(panel->whatP, _("Restart Window Maker"));
1782     WMAddPopUpButtonItem(panel->whatP, _("Start alternate window manager"));
1783     WMSetPopUpButtonAction(panel->whatP, setCrashAction, panel);
1784     WMSetPopUpButtonSelectedItem(panel->whatP, WMRestart);
1785     panel->action = WMRestart;
1786
1787     WMMapSubwidgets(panel->whatF);
1788
1789     panel->okB = WMCreateCommandButton(panel->win);
1790     WMResizeWidget(panel->okB, 80, 26);
1791     WMMoveWidget(panel->okB, 205, 309);
1792     WMSetButtonText(panel->okB, _("OK"));
1793     WMSetButtonImage(panel->okB, WMGetSystemPixmap(scr, WSIReturnArrow));
1794     WMSetButtonAltImage(panel->okB, WMGetSystemPixmap(scr, WSIHighlightedReturnArrow));
1795     WMSetButtonImagePosition(panel->okB, WIPRight);
1796     WMSetButtonAction(panel->okB, okButtonCallback, panel);
1797
1798     panel->done = 0;
1799
1800     WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask,
1801                          handleKeyPress, panel);
1802
1803     WMRealizeWidget(panel->win);
1804     WMMapSubwidgets(panel->win);
1805
1806     WMMapWidget(panel->win);
1807
1808     XSetInputFocus(dpy, WMWidgetXID(panel->win), RevertToParent, CurrentTime);
1809
1810     while (!panel->done) {
1811         XEvent event;
1812
1813         WMNextEvent(dpy, &event);
1814         WMHandleEvent(&event);
1815     }
1816
1817     action = panel->action;
1818
1819     WMUnmapWidget(panel->win);
1820     WMDestroyWidget(panel->win);
1821     wfree(panel);
1822
1823     return action;
1824 }
1825
1826
1827
1828
1829 /*****************************************************************************
1830  *                      About GNUstep Panel
1831  *****************************************************************************/
1832
1833
1834 static void
1835 drawGNUstepLogo(Display *dpy, Drawable d, int width, int height,
1836                 unsigned long blackPixel, unsigned long whitePixel)
1837 {
1838     GC gc;
1839     XGCValues gcv;
1840     XRectangle rects[3];
1841
1842     gcv.foreground = blackPixel;
1843     gc = XCreateGC(dpy, d, GCForeground, &gcv);
1844
1845     XFillArc(dpy, d, gc, width/45, height/45,
1846              width - 2*width/45, height - 2*height/45, 0, 360*64);
1847
1848     rects[0].x = 0;
1849     rects[0].y = 37*height/45;
1850     rects[0].width = width/3;
1851     rects[0].height = height - rects[0].y;
1852
1853     rects[1].x = rects[0].width;
1854     rects[1].y = height/2;
1855     rects[1].width = width - 2*width/3;
1856     rects[1].height = height - rects[1].y;
1857
1858     rects[2].x = 2*width/3;
1859     rects[2].y = height - 37*height/45;
1860     rects[2].width = width/3;
1861     rects[2].height = height - rects[2].y;
1862
1863     XSetClipRectangles(dpy, gc, 0, 0, rects, 3, Unsorted);
1864     XFillRectangle(dpy, d, gc, 0, 0, width, height);
1865
1866     XSetForeground(dpy, gc, whitePixel);
1867     XFillArc(dpy, d, gc, width/45, height/45,
1868              width - 2*width/45, height - 2*height/45, 0, 360*64);
1869
1870     XFreeGC(dpy, gc);
1871 }
1872
1873
1874 typedef struct {
1875     WScreen *scr;
1876
1877     WWindow *wwin;
1878
1879     WMWindow *win;
1880
1881     WMLabel *gstepL;
1882     WMLabel *textL;
1883 } GNUstepPanel;
1884
1885
1886 static GNUstepPanel *gnustepPanel = NULL;
1887
1888 static void
1889 destroyGNUstepPanel(WCoreWindow *foo, void *data, XEvent *event)
1890 {
1891     WMUnmapWidget(gnustepPanel->win);
1892
1893     WMDestroyWidget(gnustepPanel->win);
1894
1895     wUnmanageWindow(gnustepPanel->wwin, False, False);
1896
1897     wfree(gnustepPanel);
1898
1899     gnustepPanel = NULL;
1900 }
1901
1902
1903 void
1904 wShowGNUstepPanel(WScreen *scr)
1905 {
1906     GNUstepPanel *panel;
1907     Window parent;
1908     WWindow *wwin;
1909     WMPixmap *pixmap;
1910     WMColor *color;
1911
1912     if (gnustepPanel) {
1913         if (gnustepPanel->scr == scr) {
1914             wRaiseFrame(gnustepPanel->wwin->frame->core);
1915             wSetFocusTo(scr, gnustepPanel->wwin);
1916         }
1917         return;
1918     }
1919
1920     panel = wmalloc(sizeof(GNUstepPanel));
1921
1922     panel->scr = scr;
1923
1924     panel->win = WMCreateWindow(scr->wmscreen, "About GNUstep");
1925     WMResizeWidget(panel->win, 325, 205);
1926
1927     pixmap = WMCreatePixmap(scr->wmscreen, 130, 130,
1928                             WMScreenDepth(scr->wmscreen), True);
1929
1930     color = WMCreateNamedColor(scr->wmscreen, "gray50", True);
1931
1932     drawGNUstepLogo(dpy, WMGetPixmapXID(pixmap), 130, 130,
1933                     WMColorPixel(color), scr->white_pixel);
1934
1935     WMReleaseColor(color);
1936
1937     XSetForeground(dpy, scr->mono_gc, 0);
1938     XFillRectangle(dpy, WMGetPixmapMaskXID(pixmap), scr->mono_gc, 0, 0,
1939                    130, 130);
1940     drawGNUstepLogo(dpy, WMGetPixmapMaskXID(pixmap), 130, 130, 1, 1);
1941
1942     panel->gstepL = WMCreateLabel(panel->win);
1943     WMResizeWidget(panel->gstepL, 285, 64);
1944     WMMoveWidget(panel->gstepL, 20, 0);
1945     WMSetLabelTextAlignment(panel->gstepL, WARight);
1946     WMSetLabelText(panel->gstepL, "GNUstep");
1947     {
1948         WMFont *font = WMBoldSystemFontOfSize(scr->wmscreen, 24);
1949
1950         WMSetLabelFont(panel->gstepL, font);
1951         WMReleaseFont(font);
1952     }
1953
1954     panel->textL = WMCreateLabel(panel->win);
1955     WMResizeWidget(panel->textL, 305, 140);
1956     WMMoveWidget(panel->textL, 10, 50);
1957     WMSetLabelTextAlignment(panel->textL, WARight);
1958     WMSetLabelImagePosition(panel->textL, WIPOverlaps);
1959     WMSetLabelText(panel->textL,
1960                    _("Window Maker is part of the GNUstep project.\n"\
1961                      "The GNUstep project aims to create a free\n"\
1962                      "implementation of the OpenStep(tm) specification\n"\
1963                      "which is a object-oriented framework for\n"\
1964                      "creating advanced graphical, multi-platform\n"\
1965                      "applications. Additionally, a development and\n"\
1966                      "user desktop enviroment will be created on top\n"\
1967                      "of the framework. For more information about\n"\
1968                      "GNUstep, please visit: www.gnustep.org"));
1969     WMSetLabelImage(panel->textL, pixmap);
1970
1971     WMReleasePixmap(pixmap);
1972
1973     WMRealizeWidget(panel->win);
1974     WMMapSubwidgets(panel->win);
1975
1976     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 325, 200, 0, 0, 0);
1977
1978     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1979
1980     {
1981         WMPoint center = getCenter(scr, 325, 200);
1982
1983         wwin = wManageInternalWindow(scr, parent, None, _("About GNUstep"),
1984                                      center.x, center.y,
1985                                      325, 200);
1986     }
1987
1988     WSETUFLAG(wwin, no_closable, 0);
1989     WSETUFLAG(wwin, no_close_button, 0);
1990     wWindowUpdateButtonImages(wwin);
1991     wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1992 #ifdef XKB_BUTTON_HINT
1993     wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1994 #endif
1995     wwin->frame->on_click_right = destroyGNUstepPanel;
1996
1997     panel->wwin = wwin;
1998
1999     WMMapWidget(panel->win);
2000
2001     wWindowMap(wwin);
2002
2003     gnustepPanel = panel;
2004 }
2005