src/dialog.c

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