src/dialog.c

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