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     file = wmalloc(strlen(dirfile)+strlen(text)+4);
 385     sprintf(file, "%s/%s", dirfile, text);
 386     wfree(dirfile);
 387
 388     if ((state & WLDSSelected) != 0) {
 389         color.red = color.green = color.blue = 0xff;
 390         color.alpha = 0;
 391     } else {
 392         color.red = color.blue = 0xae;
 393         color.green = 0xaa; color.alpha = 0;
 394     }
 395     pixmap = WMCreateBlendedPixmapFromFile(wmscr, file, &color);
 396     wfree(file);
 397
 398     if (!pixmap) {
 399         WMRemoveListItem(lPtr, index);
 400         return;
 401     }
 402
 403     XClearArea(dpy, d, rect->pos.x, rect->pos.y, width, rect->size.height,
 404                False);
 405     XSetClipMask(dpy, gc, None);
 406     /*
 407     XDrawRectangle(dpy, d, WMColorGC(whitecolor), rect->pos.x + 5,
 408                    rect->pos.y +5, width - 10, 54);
 409      */
 410     XDrawLine(dpy, d, WMColorGC(whitecolor), rect->pos.x,
 411               rect->pos.y+rect->size.height-1, rect->pos.x+width,
 412               rect->pos.y+rect->size.height-1);
 413
 414
 415     if (state&WLDSSelected) {
 416         XFillRectangle(dpy, d, WMColorGC(whitecolor), rect->pos.x,
 417                        rect->pos.y, width, rect->size.height);
 418     }
 419
 420     size = WMGetPixmapSize(pixmap);
 421
 422     XSetClipMask(dpy, copygc, WMGetPixmapMaskXID(pixmap));
 423     XSetClipOrigin(dpy, copygc, rect->pos.x + (width-size.width)/2,
 424                    rect->pos.y+2);
 425     XCopyArea(dpy, WMGetPixmapXID(pixmap), d, copygc, 0, 0,
 426               size.width>100?100:size.width, size.height>64?64:size.height,
 427               rect->pos.x + (width-size.width)/2, rect->pos.y+2);
 428
 429     {
 430         int i,j;
 431         int fheight = WMFontHeight(panel->normalfont);
 432         int tlen = strlen(text);
 433         int twidth = WMWidthOfString(panel->normalfont, text, tlen);
 434         int ofx, ofy;
 435
 436         ofx = rect->pos.x + (width - twidth)/2;
 437         ofy = rect->pos.y + 64 - fheight;
 438
 439         for(i=-1;i<2;i++)
 440             for(j=-1;j<2;j++)
 441                 WMDrawString(wmscr, d, WMColorGC(whitecolor),
 442                              panel->normalfont, ofx+i, ofy+j,
 443                              text, tlen);
 444
 445         WMDrawString(wmscr, d, WMColorGC(blackcolor), panel->normalfont,
 446                      ofx, ofy, text, tlen);
 447     }
 448
 449     WMReleasePixmap(pixmap);
 450     /* I hope it is better to do not use cache / on my box it is fast nuff */
 451     XFlush(dpy);
 452
 453     WMReleaseColor(blackcolor);
 454     WMReleaseColor(whitecolor);
 455 }
 456
 457
 458 static void
 459 buttonCallback(void *self, void *clientData)
 460 {
 461     WMButton *bPtr = (WMButton*)self;
 462     IconPanel *panel = (IconPanel*)clientData;
 463
 464
 465     if (bPtr==panel->okButton) {
 466         panel->done = True;
 467         panel->result = True;
 468     } else if (bPtr==panel->cancelButton) {
 469         panel->done = True;
 470         panel->result = False;
 471     } else if (bPtr==panel->previewButton) {
 472         /**** Previewer ****/
 473         WMSetButtonEnabled(bPtr, False);
 474         WMSetListUserDrawItemHeight(panel->iconList, 68);
 475         WMSetListUserDrawProc(panel->iconList, drawIconProc);
 476         WMRedisplayWidget(panel->iconList);
 477         /* for draw proc to access screen/gc */
 478         /*** end preview ***/
 479     }
 480 #if 0
 481     else if (bPtr==panel->chooseButton) {
 482         WMOpenPanel *op;
 483
 484         op = WMCreateOpenPanel(WMWidgetScreen(bPtr));
 485
 486         if (WMRunModalFilePanelForDirectory(op, NULL, "/usr/local", NULL, NULL)) {
 487             char *path;
 488             path = WMGetFilePanelFile(op);
 489             WMSetTextFieldText(panel->fileField, path);
 490             setViewedImage(panel, path);
 491             wfree(path);
 492         }
 493         WMDestroyFilePanel(op);
 494     }
 495 #endif
 496 }
 497
 498
 499 static void
 500 keyPressHandler(XEvent *event, void *data)
 501 {
 502     IconPanel *panel = (IconPanel*)data;
 503     Display *dpy = event->xany.display;
 504     char buffer[32];
 505     int count;
 506     KeySym ksym;
 507     int iidx;
 508     int didx;
 509     int item;
 510     WMList *list = NULL;
 511
 512     if (event->type == KeyRelease)
 513         return;
 514
 515     buffer[0] = 0;
 516     count = XLookupString(&event->xkey, buffer, sizeof(buffer), &ksym, NULL);
 517
 518
 519     iidx = WMGetListSelectedItemRow(panel->iconList);
 520     didx = WMGetListSelectedItemRow(panel->dirList);
 521
 522     switch (ksym) {
 523      case XK_Up:
 524         if (iidx > 0)
 525             item = iidx-1;
 526         else
 527             item = iidx;
 528         list = panel->iconList;
 529         break;
 530      case XK_Down:
 531         if (iidx < WMGetListNumberOfRows(panel->iconList) - 1)
 532             item = iidx+1;
 533         else
 534             item = iidx;
 535         list = panel->iconList;
 536         break;
 537      case XK_Home:
 538         item = 0;
 539         list = panel->iconList;
 540         break;
 541      case XK_End:
 542         item = WMGetListNumberOfRows(panel->iconList) - 1;
 543         list = panel->iconList;
 544         break;
 545      case XK_Next:
 546         if (didx < WMGetListNumberOfRows(panel->dirList) - 1)
 547             item = didx + 1;
 548         else
 549             item = didx;
 550         list = panel->dirList;
 551         break;
 552      case XK_Prior:
 553         if (didx > 0)
 554             item = didx - 1;
 555         else
 556             item = 0;
 557         list = panel->dirList;
 558         break;
 559      case XK_Return:
 560         WMPerformButtonClick(panel->okButton);
 561         break;
 562      case XK_Escape:
 563         WMPerformButtonClick(panel->cancelButton);
 564         break;
 565     }
 566
 567     if (list) {
 568         WMSelectListItem(list, item);
 569         WMSetListPosition(list, item - 5);
 570         listCallback(list, panel);
 571     }
 572 }
 573
 574
 575
 576 Bool
 577 wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
 578 {
 579     WWindow *wwin;
 580     Window parent;
 581     IconPanel *panel;
 582     WMColor *color;
 583     WMFont *boldFont;
 584
 585     panel = wmalloc(sizeof(IconPanel));
 586     memset(panel, 0, sizeof(IconPanel));
 587
 588     panel->scr = scr;
 589
 590     panel->win = WMCreateWindow(scr->wmscreen, "iconChooser");
 591     WMResizeWidget(panel->win, 450, 280);
 592
 593     WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask|KeyReleaseMask,
 594                          keyPressHandler, panel);
 595
 596
 597     boldFont = WMBoldSystemFontOfSize(scr->wmscreen, 12);
 598     panel->normalfont = WMSystemFontOfSize(WMWidgetScreen(panel->win), 12);
 599
 600     panel->dirLabel = WMCreateLabel(panel->win);
 601     WMResizeWidget(panel->dirLabel, 200, 20);
 602     WMMoveWidget(panel->dirLabel, 10, 7);
 603     WMSetLabelText(panel->dirLabel, _("Directories"));
 604     WMSetLabelFont(panel->dirLabel, boldFont);
 605     WMSetLabelTextAlignment(panel->dirLabel, WACenter);
 606
 607     WMSetLabelRelief(panel->dirLabel, WRSunken);
 608
 609     panel->iconLabel = WMCreateLabel(panel->win);
 610     WMResizeWidget(panel->iconLabel, 140, 20);
 611     WMMoveWidget(panel->iconLabel, 215, 7);
 612     WMSetLabelText(panel->iconLabel, _("Icons"));
 613     WMSetLabelFont(panel->iconLabel, boldFont);
 614     WMSetLabelTextAlignment(panel->iconLabel, WACenter);
 615
 616     WMReleaseFont(boldFont);
 617
 618     color = WMWhiteColor(scr->wmscreen);
 619     WMSetLabelTextColor(panel->dirLabel, color);
 620     WMSetLabelTextColor(panel->iconLabel, color);
 621     WMReleaseColor(color);
 622
 623     color = WMDarkGrayColor(scr->wmscreen);
 624     WMSetWidgetBackgroundColor(panel->iconLabel, color);
 625     WMSetWidgetBackgroundColor(panel->dirLabel, color);
 626     WMReleaseColor(color);
 627
 628     WMSetLabelRelief(panel->iconLabel, WRSunken);
 629
 630     panel->dirList = WMCreateList(panel->win);
 631     WMResizeWidget(panel->dirList, 200, 170);
 632     WMMoveWidget(panel->dirList, 10, 30);
 633     WMSetListAction(panel->dirList, listCallback, panel);
 634
 635     panel->iconList = WMCreateList(panel->win);
 636     WMResizeWidget(panel->iconList, 140, 170);
 637     WMMoveWidget(panel->iconList, 215, 30);
 638     WMSetListAction(panel->iconList, listCallback, panel);
 639
 640     WMHangData(panel->iconList,panel);
 641
 642     panel->previewButton = WMCreateCommandButton(panel->win);
 643     WMResizeWidget(panel->previewButton, 75, 26);
 644     WMMoveWidget(panel->previewButton, 365, 130);
 645     WMSetButtonText(panel->previewButton, _("Preview"));
 646     WMSetButtonAction(panel->previewButton, buttonCallback, panel);
 647
 648     panel->iconView = WMCreateLabel(panel->win);
 649     WMResizeWidget(panel->iconView, 75, 75);
 650     WMMoveWidget(panel->iconView, 365, 40);
 651     WMSetLabelImagePosition(panel->iconView, WIPOverlaps);
 652     WMSetLabelRelief(panel->iconView, WRSunken);
 653     WMSetLabelTextAlignment(panel->iconView, WACenter);
 654
 655     panel->fileLabel = WMCreateLabel(panel->win);
 656     WMResizeWidget(panel->fileLabel, 80, 20);
 657     WMMoveWidget(panel->fileLabel, 10, 210);
 658     WMSetLabelText(panel->fileLabel, _("File Name:"));
 659
 660     panel->fileField = WMCreateTextField(panel->win);
 661     WMSetViewNextResponder(WMWidgetView(panel->fileField), WMWidgetView(panel->win));
 662     WMResizeWidget(panel->fileField, 345, 20);
 663     WMMoveWidget(panel->fileField, 95, 210);
 664     WMSetTextFieldEditable(panel->fileField, False);
 665
 666     panel->okButton = WMCreateCommandButton(panel->win);
 667     WMResizeWidget(panel->okButton, 80, 26);
 668     WMMoveWidget(panel->okButton, 360, 240);
 669     WMSetButtonText(panel->okButton, _("OK"));
 670     WMSetButtonEnabled(panel->okButton, False);
 671     WMSetButtonAction(panel->okButton, buttonCallback, panel);
 672
 673     panel->cancelButton = WMCreateCommandButton(panel->win);
 674     WMResizeWidget(panel->cancelButton, 80, 26);
 675     WMMoveWidget(panel->cancelButton, 270, 240);
 676     WMSetButtonText(panel->cancelButton, _("Cancel"));
 677     WMSetButtonAction(panel->cancelButton, buttonCallback, panel);
 678 #if 0
 679     panel->chooseButton = WMCreateCommandButton(panel->win);
 680     WMResizeWidget(panel->chooseButton, 110, 26);
 681     WMMoveWidget(panel->chooseButton, 150, 240);
 682     WMSetButtonText(panel->chooseButton, _("Choose File"));
 683     WMSetButtonAction(panel->chooseButton, buttonCallback, panel);
 684 #endif
 685     WMRealizeWidget(panel->win);
 686     WMMapSubwidgets(panel->win);
 687
 688     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 450, 280, 0, 0, 0);
 689
 690     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 691
 692     {
 693         char *tmp;
 694
 695         tmp = wmalloc((instance ? strlen(instance) : 0)
 696                      + (class ? strlen(class) : 0) + 32);
 697
 698         if (tmp && (instance || class))
 699             sprintf(tmp, "%s [%s.%s]", _("Icon Chooser"), instance, class);
 700         else
 701             strcpy(tmp, _("Icon Chooser"));
 702
 703         wwin = wManageInternalWindow(scr, parent, None, tmp,
 704                                      (scr->scr_width - 450)/2,
 705                                      (scr->scr_height - 280)/2, 450, 280);
 706         wfree(tmp);
 707     }
 708
 709     /* put icon paths in the list */
 710     listIconPaths(panel->dirList);
 711
 712     WMMapWidget(panel->win);
 713
 714     wWindowMap(wwin);
 715
 716     while (!panel->done) {
 717         XEvent event;
 718
 719         WMNextEvent(dpy, &event);
 720         WMHandleEvent(&event);
 721     }
 722
 723     if (panel->result) {
 724         char *defaultPath, *wantedPath;
 725
 726         /* check if the file the user selected is not the one that
 727          * would be loaded by default with the current search path */
 728         *file = WMGetListSelectedItem(panel->iconList)->text;
 729         if ((*file)[0]==0) {
 730             wfree(*file);
 731             *file = NULL;
 732         } else {
 733             defaultPath = FindImage(wPreferences.icon_path, *file);
 734             wantedPath = WMGetTextFieldText(panel->fileField);
 735             /* if the file is not the default, use full path */
 736             if (strcmp(wantedPath, defaultPath)!=0) {
 737                 *file = wantedPath;
 738             } else {
 739                 *file = wstrdup(*file);
 740                 wfree(wantedPath);
 741             }
 742             wfree(defaultPath);
 743         }
 744     } else {
 745         *file = NULL;
 746     }
 747
 748     WMReleaseFont(panel->normalfont);
 749
 750     WMUnmapWidget(panel->win);
 751
 752     WMDestroyWidget(panel->win);
 753
 754     wUnmanageWindow(wwin, False, False);
 755
 756     wfree(panel);
 757
 758     XDestroyWindow(dpy, parent);
 759
 760     return panel->result;
 761 }
 762
 763
 764 /*
 765  ***********************************************************************
 766  * Info Panel
 767  ***********************************************************************
 768  */
 769
 770
 771 typedef struct {
 772     WScreen *scr;
 773
 774     WWindow *wwin;
 775
 776     WMWindow *win;
 777
 778     WMLabel *logoL;
 779     WMLabel *name1L;
 780     WMLabel *name2L;
 781
 782     WMLabel *versionL;
 783
 784     WMLabel *infoL;
 785
 786     WMLabel *copyrL;
 787
 788 #ifdef SILLYNESS
 789     WMHandlerID timer;
 790     int cycle;
 791     RImage *icon;
 792     RImage *pic;
 793     WMPixmap *oldPix;
 794     WMFont *oldFont;
 795     char *str;
 796     int x;
 797 #endif
 798 } InfoPanel;
 799
 800
 801
 802 #define COPYRIGHT_TEXT  \
 803      "Copyright \xa9 1997~2001 Alfredo K. Kojima <kojima@windowmaker.org>\n"\
 804      "Copyright \xa9 1998~2001 Dan Pascu <dan@windowmaker.org>"
 805
 806
 807
 808 static InfoPanel *thePanel = NULL;
 809
 810 static void
 811 destroyInfoPanel(WCoreWindow *foo, void *data, XEvent *event)
 812 {
 813 #ifdef SILLYNESS
 814     if (thePanel->timer) {
 815         WMDeleteTimerHandler(thePanel->timer);
 816     }
 817     if (thePanel->oldPix) {
 818         WMReleasePixmap(thePanel->oldPix);
 819     }
 820     if (thePanel->oldFont) {
 821         WMReleaseFont(thePanel->oldFont);
 822     }
 823     if (thePanel->icon) {
 824         RReleaseImage(thePanel->icon);
 825     }
 826     if (thePanel->pic) {
 827         RReleaseImage(thePanel->pic);
 828     }
 829 #endif /* SILLYNESS */
 830     WMUnmapWidget(thePanel);
 831
 832     wUnmanageWindow(thePanel->wwin, False, False);
 833
 834     WMDestroyWidget(thePanel->win);
 835
 836     wfree(thePanel);
 837
 838     thePanel = NULL;
 839 }
 840
 841
 842 WMPixmap*
 843 renderText(WMScreen *scr, char *text, char *font, RColor *from, RColor *to)
 844 {
 845     WMPixmap *wpix = NULL;
 846     Pixmap grad = None;
 847     Pixmap mask = None;
 848     RContext *rc = WMScreenRContext(scr);
 849     XFontStruct *f = NULL;
 850     int w, h;
 851     GC gc = None;
 852
 853     f = XLoadQueryFont(dpy, font);
 854     if (!f)
 855         return NULL;
 856
 857     w = XTextWidth(f, text, strlen(text));
 858     h = f->ascent+f->descent;
 859
 860     mask = XCreatePixmap(dpy, rc->drawable, w, h, 1);
 861     gc = XCreateGC(dpy, mask, 0, NULL);
 862     XSetForeground(dpy, gc, 0);
 863     XSetFont(dpy, gc, f->fid);
 864     XFillRectangle(dpy, mask, gc, 0, 0, w, h);
 865
 866     XSetForeground(dpy, gc, 1);
 867     XDrawString(dpy, mask, gc, 0, f->ascent, text, strlen(text));
 868     XSetLineAttributes(dpy, gc, 3, LineSolid, CapRound, JoinMiter);
 869     XDrawLine(dpy, mask, gc, 0, h-2, w, h-2);
 870
 871     grad = XCreatePixmap(dpy, rc->drawable, w, h, rc->depth);
 872     {
 873         WMColor *color;
 874
 875         color = WMBlackColor(scr);
 876         XFillRectangle(dpy, grad, WMColorGC(color), 0, 0, w, h);
 877         WMReleaseColor(color);
 878     }
 879
 880     wpix = WMCreatePixmapFromXPixmaps(scr, grad, mask, w, h, rc->depth);
 881
 882     if (gc)
 883         XFreeGC(dpy, gc);
 884     XFreeFont(dpy, f);
 885
 886     return wpix;
 887 }
 888
 889 #ifdef SILLYNESS
 890
 891 extern WMPixmap *DoXThing();
 892 extern Bool InitXThing();
 893
 894 static void
 895 logoPushCallback(void *data)
 896 {
 897     InfoPanel *panel = (InfoPanel*)data;
 898     char buffer[512];
 899     int i;
 900     static int oldi = 0;
 901     int len;
 902     static int jingobeu[] = {
 903         329, 150, -1, 100, 329, 150, -1, 100, 329, 300, -1, 250,
 904             329, 150, -1, 100, 329, 150, -1, 100,  329, 300, -1, 250,
 905             329, 150, 392, 150, 261, 150, 293, 150, 329, 400, -1, 400, 0
 906     };
 907     static int c = 0;
 908
 909     if (panel->x) {
 910         XKeyboardControl kc;
 911
 912         if (panel->x > 0) {
 913             if(jingobeu[panel->x-1]==0){panel->x=-1;}else if(jingobeu[panel->x
 914 -1]<0){panel->x++;c=jingobeu[panel->x-1]/50;panel->x++;}else if(c==0){
 915     kc.bell_pitch=jingobeu[panel->x-1];panel->x++;kc.bell_percent=50;c=
 916         jingobeu[panel->x-1]/50;kc.bell_duration=jingobeu[panel->x-1];panel->x++;
 917 XChangeKeyboardControl(dpy,KBBellPitch|KBBellDuration|KBBellPercent,&kc);
 918     XBell(dpy,50);XFlush(dpy);}else{c--;}}
 919         if (!(panel->cycle % 4)) {
 920             WMPixmap *p;
 921
 922             p = DoXThing(panel->wwin);
 923             WMSetLabelImage(panel->logoL, p);
 924         }
 925     } else if (panel->cycle < 30) {
 926         RImage *image;
 927         WMPixmap *pix;
 928         RColor gray;
 929
 930         gray.red = 0xae;  gray.green = 0xaa;
 931         gray.blue = 0xae; gray.alpha = 0;
 932
 933         image = RScaleImage(panel->icon, panel->pic->width, panel->pic->height);
 934         RCombineImagesWithOpaqueness(image, panel->pic, panel->cycle*255/30);
 935         pix = WMCreateBlendedPixmapFromRImage(panel->scr->wmscreen, image, &gray);
 936         RReleaseImage(image);
 937         WMSetLabelImage(panel->logoL, pix);
 938         WMReleasePixmap(pix);
 939     }
 940
 941     /* slow down text a little */
 942     i = (int)(panel->cycle * 50.0/85.0)%200;
 943
 944     if (i != oldi) {
 945         len = strlen(panel->str);
 946
 947         strncpy(buffer, panel->str, i<len ? i : len);
 948         if (i >= len)
 949             memset(&buffer[len], ' ', i-len);
 950
 951         strncpy(buffer, panel->str, i<len ? i : len);
 952         if (i >= len)
 953             memset(&buffer[len], ' ', i-len);
 954         buffer[i]=0;
 955
 956         WMSetLabelText(panel->versionL, buffer);
 957
 958         XFlush(WMScreenDisplay(WMWidgetScreen(panel->versionL)));
 959
 960         oldi = i;
 961     }
 962
 963     panel->timer = WMAddTimerHandler(50, logoPushCallback, panel);
 964     panel->cycle++;
 965 }
 966
 967
 968 static void
 969 handleLogoPush(XEvent *event, void *data)
 970 {
 971     InfoPanel *panel = (InfoPanel*)data;
 972     static int broken = 0;
 973     static int clicks = 0;
 974     static char *pic_data[] = {
 975 "45 45 57 1",
 976 "       c None",
 977 ".      c #000000",
 978 "X      c #383C00",
 979 "o      c #515500",
 980 "O      c #616100",
 981 "+      c #616900",
 982 "@      c #696D00",
 983 "#      c #697100",
 984 "$      c #495100",
 985 "%      c #202800",
 986 "&      c #969600",
 987 "*      c #CFCF00",
 988 "=      c #D7DB00",
 989 "-      c #D7D700",
 990 ";      c #C7CB00",
 991 ":      c #A6AA00",
 992 ">      c #494900",
 993 ",      c #8E8E00",
 994 "<      c #DFE700",
 995 "1      c #F7FF00",
 996 "2      c #FFFF00",
 997 "3      c #E7EB00",
 998 "4      c #B6B600",
 999 "5      c #595900",
1000 "6      c #717500",
1001 "7      c #AEB200",
1002 "8      c #CFD300",
1003 "9      c #E7EF00",
1004 "0      c #EFF300",
1005 "q      c #9EA200",
1006 "w      c #F7FB00",
1007 "e      c #F7F700",
1008 "r      c #BEBE00",
1009 "t      c #8E9200",
1010 "y      c #EFF700",
1011 "u      c #969A00",
1012 "i      c #414500",
1013 "p      c #595D00",
1014 "a      c #E7E700",
1015 "s      c #C7C700",
1016 "d      c #797D00",
1017 "f      c #BEC300",
1018 "g      c #DFE300",
1019 "h      c #868600",
1020 "j      c #EFEF00",
1021 "k      c #9E9E00",
1022 "l      c #616500",
1023 "z      c #DFDF00",
1024 "x      c #868A00",
1025 "c      c #969200",
1026 "v      c #B6BA00",
1027 "b      c #A6A600",
1028 "n      c #8E8A00",
1029 "m      c #717100",
1030 "M      c #AEAE00",
1031 "N      c #AEAA00",
1032 "B      c #868200",
1033 "               ...............               ",
1034 "             ....XoO+@##+O$%....             ",
1035 "           ...%X&*========-;;:o...           ",
1036 "         ...>.>,<122222222222134@...         ",
1037 "        ..>5678912222222222222220q%..        ",
1038 "       ..$.&-w2222222222222222222er>..       ",
1039 "      ..O.t31222222222222222222222y4>..      ",
1040 "    ...O5u3222222222222222222222222yri...    ",
1041 "    ..>p&a22222222222222222222222222wso..    ",
1042 "   ..ids91222222222222222222222222222wfi..   ",
1043 "  ..X.7w222222wgs-w2222222213=g0222222<hi..  ",
1044 "  ..Xuj2222222<@X5=222222229k@l:022222y4i..  ",
1045 "  .Xdz22222222*X%.s22222222axo%$-222222<c>.. ",
1046 " ..o7y22222222v...r222222223hX.i82222221si.. ",
1047 "..io*222222222&...u22222222yt..%*22222220:%. ",
1048 "..>k02222222227...f222222222v..X=222222229t. ",
1049 "..dz12222222220ui:y2222222223d%qw222222221g. ",
1050 ".%vw222222222221y2222222222219*y2222222222wd.",
1051 ".X;2222222222222222222222222222222222222222b.",
1052 ".i*2222222222222222222222222222222222222222v.",
1053 ".i*2222222222222222222222222222222222222222;.",
1054 ".i*22222222222222222222222222222222222222228.",
1055 ".>*2222222222222222222222222222222222222222=.",
1056 ".i*22222222222222222222222222222222222222228.",
1057 ".i*2222222222222222222222222222222222222222;.",
1058 ".X*222222222222222222222222222222we12222222r.",
1059 ".Xs12222222w3aw22222222222222222y8s0222222wk.",
1060 ".Xq02222222a,na22222222222222222zm6zwy2222gi.",
1061 "..>*22222y<:Xcj22222222222222222-o$k;;02228..",
1062 "..i7y2220rhX.:y22222222222222222jtiXd,a220,..",
1063 " .X@z222a,do%kj2222222222222222wMX5q;gw228%..",
1064 " ..58222wagsh6ry222222222222221;>Of0w222y:...",
1065 " ...:e2222218mdz22222222222222a&$vw222220@...",
1066 " ...O-122222y:.u02222222222229q$uj222221r... ",
1067 "  ..%&a1222223&573w2222222219NOxz122221z>... ",
1068 "   ...t3222221-l$nr8ay1222yzbo,=12222w-5...  ",
1069 "    ..X:022222w-k+>o,7s**s7xOn=12221<f5...   ",
1070 "     ..o:9222221j8:&Bl>>>>ihv<12221=dX...    ",
1071 "      ..Xb9122222109g-****;<y22221zn%...     ",
1072 "       ..X&801222222222222222222w-h....      ",
1073 "        ...o:=022222222222222221=lX...       ",
1074 "          ..X@:;3w2222222222210fO...         ",
1075 "           ...XX&v8<30000003-N@...           ",
1076 "             .....XmnbN:q&Bo....             ",
1077 "                 ............                "};
1078     static char *msgs[] = {
1079             "Have a nice day!",
1080             "Focus follow mouse users will burn in hell!!!",
1081             "Mooo Canada!!!!",
1082             "Hi! My name is bobby...",
1083             "AHH! The neurotic monkeys are after me!",
1084             "WHAT YOU SAY??",
1085             "WE GET SIGNAL",
1086             "SOMEBODY SET UP US THE BOMB",
1087             "ALL YOUR BASE ARE BELONG TO US!",
1088             "Oh My God!!! Larry is back!"
1089     };
1090
1091
1092     clicks++;
1093
1094     if (!panel->timer && !broken && clicks > 0) {
1095         WMFont *font;
1096
1097         panel->x = 0;
1098         clicks = 0;
1099         if (!panel->icon) {
1100             panel->icon = WMGetApplicationIconImage(panel->scr->wmscreen);
1101             if (!panel->icon) {
1102                 broken = 1;
1103                 return;
1104             } else {
1105                 RColor color;
1106
1107                 color.red = 0xae;  color.green = 0xaa;
1108                 color.blue = 0xae; color.alpha = 0;
1109
1110                 panel->icon = RCloneImage(panel->icon);
1111                 RCombineImageWithColor(panel->icon, &color);
1112             }
1113         }
1114         if (!panel->pic) {
1115             panel->pic = RGetImageFromXPMData(panel->scr->rcontext, pic_data);
1116             if (!panel->pic) {
1117                 broken = 1;
1118                 RReleaseImage(panel->icon);
1119                 panel->icon = NULL;
1120                 return;
1121             }
1122         }
1123
1124         panel->str = msgs[rand()%(sizeof(msgs)/sizeof(char*))];
1125
1126         panel->timer = WMAddTimerHandler(50, logoPushCallback, panel);
1127         panel->cycle = 0;
1128         panel->oldPix = WMRetainPixmap(WMGetLabelImage(panel->logoL));
1129         /* If we don't use a fixed font, scrolling will be jumpy */
1130         /* Alternatively we can draw text in a pixmap and scroll it smoothly */
1131         if ((panel->oldFont = WMGetLabelFont(panel->versionL))!=NULL)
1132             WMRetainFont(panel->oldFont);
1133         font = WMCreateFont(WMWidgetScreen(panel->versionL), "-*-fixed-*-*-*-*-14-*-*-*-*-*-*-*");
1134         if (font) {
1135             WMSetLabelFont(panel->versionL, font);
1136             WMReleaseFont(font);
1137         }
1138         WMSetLabelText(panel->versionL, "");
1139     } else if (panel->timer) {
1140         char version[20];
1141
1142         panel->x = 0;
1143         clicks = 0;
1144         WMSetLabelImage(panel->logoL, panel->oldPix);
1145         WMReleasePixmap(panel->oldPix);
1146         panel->oldPix = NULL;
1147
1148         WMDeleteTimerHandler(panel->timer);
1149         panel->timer = NULL;
1150
1151         WMSetLabelFont(panel->versionL, panel->oldFont);
1152         if (panel->oldFont) {
1153             WMReleaseFont(panel->oldFont);
1154             panel->oldFont = NULL;
1155         }
1156         sprintf(version, _("Version %s"), VERSION);
1157         WMSetLabelText(panel->versionL, version);
1158         XFlush(WMScreenDisplay(WMWidgetScreen(panel->versionL)));
1159     }
1160
1161     {
1162         XEvent ev;
1163         while (XCheckTypedWindowEvent(dpy, WMWidgetXID(panel->versionL),
1164                                       ButtonPress, &ev));
1165     }
1166 }
1167 #endif /* SILLYNESS */
1168
1169
1170 void
1171 wShowInfoPanel(WScreen *scr)
1172 {
1173     InfoPanel *panel;
1174     WMPixmap *logo;
1175     WMSize size;
1176     WMFont *font;
1177     char version[32];
1178     char buffer[512];
1179     Window parent;
1180     WWindow *wwin;
1181     RColor color1, color2;
1182     char **strl;
1183     int i;
1184     char *visuals[] = {
1185         "StaticGray",
1186             "GrayScale",
1187             "StaticColor",
1188             "PseudoColor",
1189             "TrueColor",
1190             "DirectColor"
1191     };
1192
1193
1194     if (thePanel) {
1195         if (thePanel->scr == scr) {
1196             wRaiseFrame(thePanel->wwin->frame->core);
1197             wSetFocusTo(scr, thePanel->wwin);
1198         }
1199         return;
1200     }
1201
1202     panel = wmalloc(sizeof(InfoPanel));
1203     memset(panel, 0, sizeof(InfoPanel));
1204
1205     panel->scr = scr;
1206
1207     panel->win = WMCreateWindow(scr->wmscreen, "info");
1208     WMResizeWidget(panel->win, 382, 230);
1209
1210     logo = WMCreateApplicationIconBlendedPixmap(scr->wmscreen, (RColor*)NULL);
1211     if (!logo) {
1212         logo = WMRetainPixmap(WMGetApplicationIconPixmap(scr->wmscreen));
1213     }
1214     if (logo) {
1215         size = WMGetPixmapSize(logo);
1216         panel->logoL = WMCreateLabel(panel->win);
1217         WMResizeWidget(panel->logoL, 64, 64);
1218         WMMoveWidget(panel->logoL, 30, 20);
1219         WMSetLabelImagePosition(panel->logoL, WIPImageOnly);
1220         WMSetLabelImage(panel->logoL, logo);
1221 #ifdef SILLYNESS
1222         WMCreateEventHandler(WMWidgetView(panel->logoL), ButtonPressMask,
1223                              handleLogoPush, panel);
1224 #endif
1225         WMReleasePixmap(logo);
1226     }
1227
1228     panel->name1L = WMCreateLabel(panel->win);
1229     WMResizeWidget(panel->name1L, 240, 30);
1230     WMMoveWidget(panel->name1L, 100, 30);
1231     color1.red = 0;
1232     color1.green = 0;
1233     color1.blue = 0;
1234     color2.red = 0x50;
1235     color2.green = 0x50;
1236     color2.blue = 0x70;
1237     logo = renderText(scr->wmscreen, "GNU Window Maker",
1238                       "-*-utopia-*-r-*-*-25-*", &color1, &color2);
1239     if (logo) {
1240         WMSetLabelImagePosition(panel->name1L, WIPImageOnly);
1241         WMSetLabelImage(panel->name1L, logo);
1242         WMReleasePixmap(logo);
1243     } else {
1244         font = WMBoldSystemFontOfSize(scr->wmscreen, 20);
1245         if (font) {
1246             WMSetLabelFont(panel->name1L, font);
1247             WMReleaseFont(font);
1248         }
1249         WMSetLabelTextAlignment(panel->name1L, WACenter);
1250         WMSetLabelText(panel->name1L, "GNU Window Maker");
1251     }
1252
1253     panel->name2L = WMCreateLabel(panel->win);
1254     WMResizeWidget(panel->name2L, 240, 24);
1255     WMMoveWidget(panel->name2L, 100, 60);
1256     font = WMBoldSystemFontOfSize(scr->wmscreen, 18);
1257     if (font) {
1258         WMSetLabelFont(panel->name2L, font);
1259         WMReleaseFont(font);
1260         font = NULL;
1261     }
1262     WMSetLabelTextAlignment(panel->name2L, WACenter);
1263     WMSetLabelText(panel->name2L, _("Window Manager for X"));
1264
1265
1266     sprintf(version, _("Version %s"), VERSION);
1267     panel->versionL = WMCreateLabel(panel->win);
1268     WMResizeWidget(panel->versionL, 310, 16);
1269     WMMoveWidget(panel->versionL, 30, 95);
1270     WMSetLabelTextAlignment(panel->versionL, WARight);
1271     WMSetLabelText(panel->versionL, version);
1272     WMSetLabelWraps(panel->versionL, False);
1273
1274     panel->copyrL = WMCreateLabel(panel->win);
1275     WMResizeWidget(panel->copyrL, 340, 40);
1276     WMMoveWidget(panel->copyrL, 15, 185);
1277     WMSetLabelTextAlignment(panel->copyrL, WALeft);
1278     WMSetLabelText(panel->copyrL, COPYRIGHT_TEXT);
1279     /* we want the (c) character in the helvetica font */
1280     font = WMCreateNormalFont(scr->wmscreen, HELVETICA10_FONT);
1281     if (font) {
1282         WMSetLabelFont(panel->copyrL, font);
1283     }
1284
1285     switch (scr->w_depth) {
1286      case 15:
1287         strcpy(version, _("32 thousand"));
1288         break;
1289      case 16:
1290         strcpy(version, _("64 thousand"));
1291         break;
1292      case 24:
1293      case 32:
1294         strcpy(version, _("16 million"));
1295         break;
1296      default:
1297         sprintf(version, "%d", 1<<scr->w_depth);
1298         break;
1299     }
1300
1301     sprintf(buffer, _("Using visual 0x%x: %s %ibpp (%s colors)\n"),
1302             (unsigned)scr->w_visual->visualid,
1303             visuals[scr->w_visual->class], scr->w_depth, version);
1304
1305 #if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
1306     {
1307         struct mallinfo ma = mallinfo();
1308         sprintf(buffer+strlen(buffer),
1309                 _("Total allocated memory: %i kB. Total memory in use: %i kB.\n"),
1310                 (ma.arena+ma.hblkhd)/1024, (ma.uordblks+ma.hblkhd)/1024);
1311
1312     }
1313 #endif
1314
1315     strcat(buffer, _("Supported image formats: "));
1316     strl = RSupportedFileFormats();
1317     for (i=0; strl[i]!=NULL; i++) {
1318         strcat(buffer, strl[i]);
1319         strcat(buffer, " ");
1320     }
1321
1322     strcat(buffer, _("\nAdditional support for: "));
1323     {
1324         char *list[8];
1325         char buf[80];
1326         int j = 0;
1327
1328 #ifdef MWM_HINTS
1329         list[j++] = "MWM";
1330 #endif
1331 #ifdef KWM_HINTS
1332         list[j++] = "KDE";
1333 #endif
1334 #ifdef GNOME_STUFF
1335         list[j++] = "GNOME";
1336 #endif
1337 #ifdef OLWM_HINTS
1338         list[j++] = "OLWM";
1339 #endif
1340
1341         buf[0] = 0;
1342         for (i = 0; i < j; i++) {
1343             if (i > 0) {
1344                 if (i == j - 1)
1345                     strcat(buf, _(" and "));
1346                 else
1347                     strcat(buf, ", ");
1348             }
1349             strcat(buf, list[i]);
1350         }
1351         strcat(buffer, buf);
1352     }
1353
1354     if (wPreferences.no_sound) {
1355         strcat(buffer, _("\nSound support disabled"));
1356     } else {
1357         strcat(buffer, _("\nSound support enabled"));
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             RColor gray;
1608
1609             gray.red = 0xae;  gray.green = 0xaa;
1610             gray.blue = 0xae; gray.alpha = 0;
1611
1612             pix = WMCreateBlendedPixmapFromFile(scr, path, &gray);
1613             wfree(path);
1614         }
1615     }
1616
1617     return pix;
1618 }
1619
1620
1621 #define PWIDTH  295
1622 #define PHEIGHT 345
1623
1624
1625 int
1626 wShowCrashingDialogPanel(int whatSig)
1627 {
1628     CrashPanel *panel;
1629     WMScreen *scr;
1630     WMFont *font;
1631     WMPixmap *logo;
1632     int screen_no, scr_width, scr_height;
1633     int action;
1634     char buf[256];
1635
1636     panel = wmalloc(sizeof(CrashPanel));
1637     memset(panel, 0, sizeof(CrashPanel));
1638
1639     screen_no = DefaultScreen(dpy);
1640     scr_width = WidthOfScreen(ScreenOfDisplay(dpy, screen_no));
1641     scr_height = HeightOfScreen(ScreenOfDisplay(dpy, screen_no));
1642
1643     scr = WMCreateScreen(dpy, screen_no);
1644     if (!scr) {
1645         wsyserror(_("cannot open connection for crashing dialog panel. Aborting."));
1646         return WMAbort;
1647     }
1648
1649     panel->retKey = XKeysymToKeycode(dpy, XK_Return);
1650
1651     panel->win = WMCreateWindow(scr, "crashingDialog");
1652     WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1653     WMMoveWidget(panel->win, (scr_width - PWIDTH)/2, (scr_height - PHEIGHT)/2);
1654
1655     logo = getWindowMakerIconImage(scr);
1656     if (logo) {
1657         panel->iconL = WMCreateLabel(panel->win);
1658         WMResizeWidget(panel->iconL, 64, 64);
1659         WMMoveWidget(panel->iconL, 10, 10);
1660         WMSetLabelImagePosition(panel->iconL, WIPImageOnly);
1661         WMSetLabelImage(panel->iconL, logo);
1662     }
1663
1664     panel->nameL = WMCreateLabel(panel->win);
1665     WMResizeWidget(panel->nameL, 190, 18);
1666     WMMoveWidget(panel->nameL, 80, 35);
1667     WMSetLabelTextAlignment(panel->nameL, WALeft);
1668     font = WMBoldSystemFontOfSize(scr, 18);
1669     WMSetLabelFont(panel->nameL, font);
1670     WMReleaseFont(font);
1671     WMSetLabelText(panel->nameL, _("Fatal error"));
1672
1673     panel->sepF = WMCreateFrame(panel->win);
1674     WMResizeWidget(panel->sepF, PWIDTH+4, 2);
1675     WMMoveWidget(panel->sepF, -2, 80);
1676
1677     panel->noteL = WMCreateLabel(panel->win);
1678     WMResizeWidget(panel->noteL, PWIDTH-20, 40);
1679     WMMoveWidget(panel->noteL, 10, 90);
1680     WMSetLabelTextAlignment(panel->noteL, WAJustified);
1681 #ifdef SYS_SIGLIST_DECLARED
1682     sprintf(buf, _("Window Maker received signal %i\n(%s)."),
1683             whatSig, sys_siglist[whatSig]);
1684 #else
1685     sprintf(buf, _("Window Maker received signal %i."), whatSig);
1686 #endif
1687     WMSetLabelText(panel->noteL, buf);
1688
1689     panel->note2L = WMCreateLabel(panel->win);
1690     WMResizeWidget(panel->note2L, PWIDTH-20, 100);
1691     WMMoveWidget(panel->note2L, 10, 130);
1692     WMSetLabelTextAlignment(panel->note2L, WALeft);
1693     WMSetLabelText(panel->note2L,
1694                    _(" This fatal error occured probably due to a bug."
1695                    " Please fill the included BUGFORM and "
1696                    "report it to bugs@windowmaker.org."));
1697     WMSetLabelWraps(panel->note2L, True);
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 }