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     Display *dpy = event->xany.display;
 507     char buffer[32];
 508     int count;
 509     KeySym ksym;
 510     int iidx;
 511     int didx;
 512     int item;
 513     WMList *list = NULL;
 514
 515     if (event->type == KeyRelease)
 516         return;
 517
 518     buffer[0] = 0;
 519     count = XLookupString(&event->xkey, buffer, sizeof(buffer), &ksym, NULL);
 520
 521
 522     iidx = WMGetListSelectedItemRow(panel->iconList);
 523     didx = WMGetListSelectedItemRow(panel->dirList);
 524
 525     switch (ksym) {
 526      case XK_Up:
 527         if (iidx > 0)
 528             item = iidx-1;
 529         else
 530             item = iidx;
 531         list = panel->iconList;
 532         break;
 533      case XK_Down:
 534         if (iidx < WMGetListNumberOfRows(panel->iconList) - 1)
 535             item = iidx+1;
 536         else
 537             item = iidx;
 538         list = panel->iconList;
 539         break;
 540      case XK_Home:
 541         item = 0;
 542         list = panel->iconList;
 543         break;
 544      case XK_End:
 545         item = WMGetListNumberOfRows(panel->iconList) - 1;
 546         list = panel->iconList;
 547         break;
 548      case XK_Next:
 549         if (didx < WMGetListNumberOfRows(panel->dirList) - 1)
 550             item = didx + 1;
 551         else
 552             item = didx;
 553         list = panel->dirList;
 554         break;
 555      case XK_Prior:
 556         if (didx > 0)
 557             item = didx - 1;
 558         else
 559             item = 0;
 560         list = panel->dirList;
 561         break;
 562      case XK_Return:
 563         WMPerformButtonClick(panel->okButton);
 564         break;
 565      case XK_Escape:
 566         WMPerformButtonClick(panel->cancelButton);
 567         break;
 568     }
 569
 570     if (list) {
 571         WMSelectListItem(list, item);
 572         WMSetListPosition(list, item - 5);
 573         listCallback(list, panel);
 574     }
 575 }
 576
 577
 578
 579 Bool
 580 wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
 581 {
 582     WWindow *wwin;
 583     Window parent;
 584     IconPanel *panel;
 585     WMColor *color;
 586     WMFont *boldFont;
 587
 588     panel = wmalloc(sizeof(IconPanel));
 589     memset(panel, 0, sizeof(IconPanel));
 590
 591     panel->scr = scr;
 592
 593     panel->win = WMCreateWindow(scr->wmscreen, "iconChooser");
 594     WMResizeWidget(panel->win, 450, 280);
 595
 596     WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask|KeyReleaseMask,
 597                          keyPressHandler, panel);
 598
 599
 600     boldFont = WMBoldSystemFontOfSize(scr->wmscreen, 12);
 601     panel->normalfont = WMSystemFontOfSize(WMWidgetScreen(panel->win), 12);
 602
 603     panel->dirLabel = WMCreateLabel(panel->win);
 604     WMResizeWidget(panel->dirLabel, 200, 20);
 605     WMMoveWidget(panel->dirLabel, 10, 7);
 606     WMSetLabelText(panel->dirLabel, _("Directories"));
 607     WMSetLabelFont(panel->dirLabel, boldFont);
 608     WMSetLabelTextAlignment(panel->dirLabel, WACenter);
 609
 610     WMSetLabelRelief(panel->dirLabel, WRSunken);
 611
 612     panel->iconLabel = WMCreateLabel(panel->win);
 613     WMResizeWidget(panel->iconLabel, 140, 20);
 614     WMMoveWidget(panel->iconLabel, 215, 7);
 615     WMSetLabelText(panel->iconLabel, _("Icons"));
 616     WMSetLabelFont(panel->iconLabel, boldFont);
 617     WMSetLabelTextAlignment(panel->iconLabel, WACenter);
 618
 619     WMReleaseFont(boldFont);
 620
 621     color = WMWhiteColor(scr->wmscreen);
 622     WMSetLabelTextColor(panel->dirLabel, color);
 623     WMSetLabelTextColor(panel->iconLabel, color);
 624     WMReleaseColor(color);
 625
 626     color = WMDarkGrayColor(scr->wmscreen);
 627     WMSetWidgetBackgroundColor(panel->iconLabel, color);
 628     WMSetWidgetBackgroundColor(panel->dirLabel, color);
 629     WMReleaseColor(color);
 630
 631     WMSetLabelRelief(panel->iconLabel, WRSunken);
 632
 633     panel->dirList = WMCreateList(panel->win);
 634     WMResizeWidget(panel->dirList, 200, 170);
 635     WMMoveWidget(panel->dirList, 10, 30);
 636     WMSetListAction(panel->dirList, listCallback, panel);
 637
 638     panel->iconList = WMCreateList(panel->win);
 639     WMResizeWidget(panel->iconList, 140, 170);
 640     WMMoveWidget(panel->iconList, 215, 30);
 641     WMSetListAction(panel->iconList, listCallback, panel);
 642
 643     WMHangData(panel->iconList,panel);
 644
 645     panel->previewButton = WMCreateCommandButton(panel->win);
 646     WMResizeWidget(panel->previewButton, 75, 26);
 647     WMMoveWidget(panel->previewButton, 365, 130);
 648     WMSetButtonText(panel->previewButton, _("Preview"));
 649     WMSetButtonAction(panel->previewButton, buttonCallback, panel);
 650
 651     panel->iconView = WMCreateLabel(panel->win);
 652     WMResizeWidget(panel->iconView, 75, 75);
 653     WMMoveWidget(panel->iconView, 365, 40);
 654     WMSetLabelImagePosition(panel->iconView, WIPOverlaps);
 655     WMSetLabelRelief(panel->iconView, WRSunken);
 656     WMSetLabelTextAlignment(panel->iconView, WACenter);
 657
 658     panel->fileLabel = WMCreateLabel(panel->win);
 659     WMResizeWidget(panel->fileLabel, 80, 20);
 660     WMMoveWidget(panel->fileLabel, 10, 210);
 661     WMSetLabelText(panel->fileLabel, _("File Name:"));
 662
 663     panel->fileField = WMCreateTextField(panel->win);
 664     WMSetViewNextResponder(WMWidgetView(panel->fileField), WMWidgetView(panel->win));
 665     WMResizeWidget(panel->fileField, 345, 20);
 666     WMMoveWidget(panel->fileField, 95, 210);
 667     WMSetTextFieldEditable(panel->fileField, False);
 668
 669     panel->okButton = WMCreateCommandButton(panel->win);
 670     WMResizeWidget(panel->okButton, 80, 26);
 671     WMMoveWidget(panel->okButton, 360, 240);
 672     WMSetButtonText(panel->okButton, _("OK"));
 673     WMSetButtonEnabled(panel->okButton, False);
 674     WMSetButtonAction(panel->okButton, buttonCallback, panel);
 675
 676     panel->cancelButton = WMCreateCommandButton(panel->win);
 677     WMResizeWidget(panel->cancelButton, 80, 26);
 678     WMMoveWidget(panel->cancelButton, 270, 240);
 679     WMSetButtonText(panel->cancelButton, _("Cancel"));
 680     WMSetButtonAction(panel->cancelButton, buttonCallback, panel);
 681 #if 0
 682     panel->chooseButton = WMCreateCommandButton(panel->win);
 683     WMResizeWidget(panel->chooseButton, 110, 26);
 684     WMMoveWidget(panel->chooseButton, 150, 240);
 685     WMSetButtonText(panel->chooseButton, _("Choose File"));
 686     WMSetButtonAction(panel->chooseButton, buttonCallback, panel);
 687 #endif
 688     WMRealizeWidget(panel->win);
 689     WMMapSubwidgets(panel->win);
 690
 691     parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 450, 280, 0, 0, 0);
 692
 693     XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 694
 695     {
 696         char *tmp;
 697         int len = (instance ? strlen(instance) : 0)
 698             + (class ? strlen(class) : 0) + 32;
 699
 700         tmp = wmalloc(len);
 701
 702         if (tmp && (instance || class))
 703             snprintf(tmp, len, "%s [%s.%s]", _("Icon Chooser"), instance, class);
 704         else
 705             strcpy(tmp, _("Icon Chooser"));
 706
 707         wwin = wManageInternalWindow(scr, parent, None, tmp,
 708                                      (scr->scr_width - 450)/2,
 709                                      (scr->scr_height - 280)/2, 450, 280);
 710         wfree(tmp);
 711     }
 712
 713     /* put icon paths in the list */
 714     listIconPaths(panel->dirList);
 715
 716     WMMapWidget(panel->win);
 717
 718     wWindowMap(wwin);
 719
 720     while (!panel->done) {
 721         XEvent event;
 722
 723         WMNextEvent(dpy, &event);
 724         WMHandleEvent(&event);
 725     }
 726
 727     if (panel->result) {
 728         char *defaultPath, *wantedPath;
 729
 730         /* check if the file the user selected is not the one that
 731          * would be loaded by default with the current search path */
 732         *file = WMGetListSelectedItem(panel->iconList)->text;
 733         if ((*file)[0]==0) {
 734             wfree(*file);
 735             *file = NULL;
 736         } else {
 737             defaultPath = FindImage(wPreferences.icon_path, *file);
 738             wantedPath = WMGetTextFieldText(panel->fileField);
 739             /* if the file is not the default, use full path */
 740             if (strcmp(wantedPath, defaultPath)!=0) {
 741                 *file = wantedPath;
 742             } else {
 743                 *file = wstrdup(*file);
 744                 wfree(wantedPath);
 745             }
 746             wfree(defaultPath);
 747         }
 748     } else {
 749         *file = NULL;
 750     }
 751
 752     WMReleaseFont(panel->normalfont);
 753
 754     WMUnmapWidget(panel->win);
 755
 756     WMDestroyWidget(panel->win);
 757
 758     wUnmanageWindow(wwin, False, False);
 759
 760     wfree(panel);
 761
 762     XDestroyWindow(dpy, parent);
 763
 764     return panel->result;
 765 }
 766
 767
 768 /*
 769  ***********************************************************************
 770  * Info Panel
 771  ***********************************************************************
 772  */
 773
 774
 775 typedef struct {
 776     WScreen *scr;
 777
 778     WWindow *wwin;
 779
 780     WMWindow *win;
 781
 782     WMLabel *logoL;
 783     WMLabel *name1L;
 784     WMLabel *name2L;
 785
 786     WMLabel *versionL;
 787
 788     WMLabel *infoL;
 789
 790     WMLabel *copyrL;
 791
 792 #ifdef SILLYNESS
 793     WMHandlerID timer;
 794     int cycle;
 795     RImage *icon;
 796     RImage *pic;
 797     WMPixmap *oldPix;
 798     WMFont *oldFont;
 799     char *str;
 800     int x;
 801 #endif
 802 } InfoPanel;
 803
 804
 805
 806 #define COPYRIGHT_TEXT  \
 807      "Copyright \xa9 1997~2001 Alfredo K. Kojima <kojima@windowmaker.org>\n"\
 808      "Copyright \xa9 1998~2001 Dan Pascu <dan@windowmaker.org>"
 809
 810
 811
 812 static InfoPanel *thePanel = NULL;
 813
 814 static void
 815 destroyInfoPanel(WCoreWindow *foo, void *data, XEvent *event)
 816 {
 817 #ifdef SILLYNESS
 818     if (thePanel->timer) {
 819         WMDeleteTimerHandler(thePanel->timer);
 820     }
 821     if (thePanel->oldPix) {
 822         WMReleasePixmap(thePanel->oldPix);
 823     }
 824     if (thePanel->oldFont) {
 825         WMReleaseFont(thePanel->oldFont);
 826     }
 827     if (thePanel->icon) {
 828         RReleaseImage(thePanel->icon);
 829     }
 830     if (thePanel->pic) {
 831         RReleaseImage(thePanel->pic);
 832     }
 833 #endif /* SILLYNESS */
 834     WMUnmapWidget(thePanel);
 835
 836     wUnmanageWindow(thePanel->wwin, False, False);
 837
 838     WMDestroyWidget(thePanel->win);
 839
 840     wfree(thePanel);
 841
 842     thePanel = NULL;
 843 }
 844
 845
 846 WMPixmap*
 847 renderText(WMScreen *scr, char *text, char *font, RColor *from, RColor *to)
 848 {
 849     WMPixmap *wpix = NULL;
 850     Pixmap grad = None;
 851     Pixmap mask = None;
 852     RContext *rc = WMScreenRContext(scr);
 853     XFontStruct *f = NULL;
 854     int w, h;
 855     GC gc = None;
 856
 857     f = XLoadQueryFont(dpy, font);
 858     if (!f)
 859         return NULL;
 860
 861     w = XTextWidth(f, text, strlen(text));
 862     h = f->ascent+f->descent;
 863
 864     mask = XCreatePixmap(dpy, rc->drawable, w, h, 1);
 865     gc = XCreateGC(dpy, mask, 0, NULL);
 866     XSetForeground(dpy, gc, 0);
 867     XSetFont(dpy, gc, f->fid);
 868     XFillRectangle(dpy, mask, gc, 0, 0, w, h);
 869
 870     XSetForeground(dpy, gc, 1);
 871     XDrawString(dpy, mask, gc, 0, f->ascent, text, strlen(text));
 872     XSetLineAttributes(dpy, gc, 3, LineSolid, CapRound, JoinMiter);
 873     XDrawLine(dpy, mask, gc, 0, h-2, w, h-2);
 874
 875     grad = XCreatePixmap(dpy, rc->drawable, w, h, rc->depth);
 876     {
 877         WMColor *color;
 878
 879         color = WMBlackColor(scr);
 880         XFillRectangle(dpy, grad, WMColorGC(color), 0, 0, w, h);
 881         WMReleaseColor(color);
 882     }
 883
 884     wpix = WMCreatePixmapFromXPixmaps(scr, grad, mask, w, h, rc->depth);
 885
 886     if (gc)
 887         XFreeGC(dpy, gc);
 888     XFreeFont(dpy, f);
 889
 890     return wpix;
 891 }
 892
 893 #ifdef SILLYNESS
 894
 895 extern WMPixmap *DoXThing();
 896 extern Bool InitXThing();
 897
 898 static void
 899 logoPushCallback(void *data)
 900 {
 901     InfoPanel *panel = (InfoPanel*)data;
 902     char buffer[512];
 903     int i;
 904     static int oldi = 0;
 905     int len;
 906     static int jingobeu[] = {
 907         329, 150, -1, 100, 329, 150, -1, 100, 329, 300, -1, 250,
 908             329, 150, -1, 100, 329, 150, -1, 100,  329, 300, -1, 250,
 909             329, 150, 392, 150, 261, 150, 293, 150, 329, 400, -1, 400, 0
 910     };
 911     static int c = 0;
 912
 913     if (panel->x) {
 914         XKeyboardControl kc;
 915
 916         if (panel->x > 0) {
 917             if(jingobeu[panel->x-1]==0){panel->x=-1;}else if(jingobeu[panel->x
 918 -1]<0){panel->x++;c=jingobeu[panel->x-1]/50;panel->x++;}else if(c==0){
 919     kc.bell_pitch=jingobeu[panel->x-1];panel->x++;kc.bell_percent=50;c=
 920         jingobeu[panel->x-1]/50;kc.bell_duration=jingobeu[panel->x-1];panel->x++;
 921 XChangeKeyboardControl(dpy,KBBellPitch|KBBellDuration|KBBellPercent,&kc);
 922     XBell(dpy,50);XFlush(dpy);}else{c--;}}
 923         if (!(panel->cycle % 4)) {
 924             WMPixmap *p;
 925
 926             p = DoXThing(panel->wwin);
 927             WMSetLabelImage(panel->logoL, p);
 928         }
 929     } else if (panel->cycle < 30) {
 930         RImage *image;
 931         WMPixmap *pix;
 932         RColor gray;
 933
 934         gray.red = 0xae;  gray.green = 0xaa;
 935         gray.blue = 0xae; gray.alpha = 0;
 936
 937         image = RScaleImage(panel->icon, panel->pic->width, panel->pic->height);
 938         RCombineImagesWithOpaqueness(image, panel->pic, panel->cycle*255/30);
 939         pix = WMCreateBlendedPixmapFromRImage(panel->scr->wmscreen, image, &gray);
 940         RReleaseImage(image);
 941         WMSetLabelImage(panel->logoL, pix);
 942         WMReleasePixmap(pix);
 943     }
 944
 945     /* slow down text a little */
 946     i = (int)(panel->cycle * 50.0/85.0)%200;
 947
 948     if (i != oldi) {
 949         len = strlen(panel->str);
 950
 951         strncpy(buffer, panel->str, i<len ? i : len);
 952         if (i >= len)
 953             memset(&buffer[len], ' ', i-len);
 954
 955         strncpy(buffer, panel->str, i<len ? i : len);
 956         if (i >= len)
 957             memset(&buffer[len], ' ', i-len);
 958         buffer[i]=0;
 959
 960         WMSetLabelText(panel->versionL, buffer);
 961
 962         XFlush(WMScreenDisplay(WMWidgetScreen(panel->versionL)));
 963
 964         oldi = i;
 965     }
 966
 967     panel->timer = WMAddTimerHandler(50, logoPushCallback, panel);
 968     panel->cycle++;
 969 }
 970
 971
 972 static void
 973 handleLogoPush(XEvent *event, void *data)
 974 {
 975     InfoPanel *panel = (InfoPanel*)data;
 976     static int broken = 0;
 977     static int clicks = 0;
 978     static char *pic_data[] = {
 979         "45 45 57 1",
 980         "       c None",
 981         ".      c #000000",
 982         "X      c #383C00",
 983         "o      c #515500",
 984         "O      c #616100",
 985         "+      c #616900",
 986         "@      c #696D00",
 987         "#      c #697100",
 988         "$      c #495100",
 989         "%      c #202800",
 990         "&      c #969600",
 991         "*      c #CFCF00",
 992         "=      c #D7DB00",
 993         "-      c #D7D700",
 994         ";      c #C7CB00",
 995         ":      c #A6AA00",
 996         ">      c #494900",
 997         ",      c #8E8E00",
 998         "<      c #DFE700",
 999         "1      c #F7FF00",
1000         "2      c #FFFF00",
1001         "3      c #E7EB00",
1002         "4      c #B6B600",
1003         "5      c #595900",
1004         "6      c #717500",
1005         "7      c #AEB200",
1006         "8      c #CFD300",
1007         "9      c #E7EF00",
1008         "0      c #EFF300",
1009         "q      c #9EA200",
1010         "w      c #F7FB00",
1011         "e      c #F7F700",
1012         "r      c #BEBE00",
1013         "t      c #8E9200",
1014         "y      c #EFF700",
1015         "u      c #969A00",
1016         "i      c #414500",
1017         "p      c #595D00",
1018         "a      c #E7E700",
1019         "s      c #C7C700",
1020         "d      c #797D00",
1021         "f      c #BEC300",
1022         "g      c #DFE300",
1023         "h      c #868600",
1024         "j      c #EFEF00",
1025         "k      c #9E9E00",
1026         "l      c #616500",
1027         "z      c #DFDF00",
1028         "x      c #868A00",
1029         "c      c #969200",
1030         "v      c #B6BA00",
1031         "b      c #A6A600",
1032         "n      c #8E8A00",
1033         "m      c #717100",
1034         "M      c #AEAE00",
1035         "N      c #AEAA00",
1036         "B      c #868200",
1037         "               ...............               ",
1038         "             ....XoO+@##+O$%....             ",
1039         "           ...%X&*========-;;:o...           ",
1040         "         ...>.>,<122222222222134@...         ",
1041         "        ..>5678912222222222222220q%..        ",
1042         "       ..$.&-w2222222222222222222er>..       ",
1043         "      ..O.t31222222222222222222222y4>..      ",
1044         "    ...O5u3222222222222222222222222yri...    ",
1045         "    ..>p&a22222222222222222222222222wso..    ",
1046         "   ..ids91222222222222222222222222222wfi..   ",
1047         "  ..X.7w222222wgs-w2222222213=g0222222<hi..  ",
1048         "  ..Xuj2222222<@X5=222222229k@l:022222y4i..  ",
1049         "  .Xdz22222222*X%.s22222222axo%$-222222<c>.. ",
1050         " ..o7y22222222v...r222222223hX.i82222221si.. ",
1051         "..io*222222222&...u22222222yt..%*22222220:%. ",
1052         "..>k02222222227...f222222222v..X=222222229t. ",
1053         "..dz12222222220ui:y2222222223d%qw222222221g. ",
1054         ".%vw222222222221y2222222222219*y2222222222wd.",
1055         ".X;2222222222222222222222222222222222222222b.",
1056         ".i*2222222222222222222222222222222222222222v.",
1057         ".i*2222222222222222222222222222222222222222;.",
1058         ".i*22222222222222222222222222222222222222228.",
1059         ".>*2222222222222222222222222222222222222222=.",
1060         ".i*22222222222222222222222222222222222222228.",
1061         ".i*2222222222222222222222222222222222222222;.",
1062         ".X*222222222222222222222222222222we12222222r.",
1063         ".Xs12222222w3aw22222222222222222y8s0222222wk.",
1064         ".Xq02222222a,na22222222222222222zm6zwy2222gi.",
1065         "..>*22222y<:Xcj22222222222222222-o$k;;02228..",
1066         "..i7y2220rhX.:y22222222222222222jtiXd,a220,..",
1067         " .X@z222a,do%kj2222222222222222wMX5q;gw228%..",
1068         " ..58222wagsh6ry222222222222221;>Of0w222y:...",
1069         " ...:e2222218mdz22222222222222a&$vw222220@...",
1070         " ...O-122222y:.u02222222222229q$uj222221r... ",
1071         "  ..%&a1222223&573w2222222219NOxz122221z>... ",
1072         "   ...t3222221-l$nr8ay1222yzbo,=12222w-5...  ",
1073         "    ..X:022222w-k+>o,7s**s7xOn=12221<f5...   ",
1074         "     ..o:9222221j8:&Bl>>>>ihv<12221=dX...    ",
1075         "      ..Xb9122222109g-****;<y22221zn%...     ",
1076         "       ..X&801222222222222222222w-h....      ",
1077         "        ...o:=022222222222222221=lX...       ",
1078         "          ..X@:;3w2222222222210fO...         ",
1079         "           ...XX&v8<30000003-N@...           ",
1080         "             .....XmnbN:q&Bo....             ",
1081         "                 ............                "
1082     };
1083     static char *msgs[] = {
1084         "Have a nice day!",
1085         "Focus follow mouse users will burn in hell!!!",
1086         "Mooo Canada!!!!",
1087         "Hi! My name is bobby...",
1088         "AHH! The neurotic monkeys are after me!",
1089         "WHAT YOU SAY??",
1090         "WE GET SIGNAL",
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     proplist_t dict, key, option, value=NULL;
1596     WMPixmap *pix=NULL;
1597     char *path;
1598
1599     PLSetStringCmpHook(NULL);
1600
1601     key = PLMakeString("Logo.WMPanel");
1602     option = PLMakeString("Icon");
1603
1604     dict = PLGetDictionaryEntry(WDWindowAttributes->dictionary, key);
1605
1606     if (dict) {
1607         value = PLGetDictionaryEntry(dict, option);
1608     }
1609
1610     PLRelease(key);
1611     PLRelease(option);
1612
1613     PLSetStringCmpHook(StringCompareHook);
1614
1615     if (value && PLIsString(value)) {
1616         path = FindImage(wPreferences.icon_path, PLGetString(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 }