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