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 along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include "wconfig.h"
  24
  25 #include <X11/Xlib.h>
  26 #include <X11/Xutil.h>
  27 #include <X11/keysym.h>
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <unistd.h>
  32 #include <string.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <dirent.h>
  36 #include <limits.h>
  37
  38 #ifdef HAVE_MALLOC_H
  39 #include <malloc.h>
  40 #endif
  41
  42 #include <signal.h>
  43 #ifdef __FreeBSD__
  44 #include <sys/signal.h>
  45 #endif
  46
  47 #ifndef PATH_MAX
  48 #define PATH_MAX DEFAULT_PATH_MAX
  49 #endif
  50
  51 #include "WindowMaker.h"
  52 #include "GNUstep.h"
  53 #include "screen.h"
  54 #include "dialog.h"
  55 #include "funcs.h"
  56 #include "stacking.h"
  57 #include "framewin.h"
  58 #include "window.h"
  59 #include "actions.h"
  60 #include "xinerama.h"
  61
  62 extern WPreferences wPreferences;
  63
  64 static WMPoint getCenter(WScreen * scr, int width, int height)
  65 {
  66         return wGetPointToCenterRectInHead(scr, wGetHeadForPointerLocation(scr), width, height);
  67 }
  68
  69 int wMessageDialog(WScreen * scr, char *title, char *message, char *defBtn, char *altBtn, char *othBtn)
  70 {
  71         WMAlertPanel *panel;
  72         Window parent;
  73         WWindow *wwin;
  74         int result;
  75         WMPoint center;
  76
  77         panel = WMCreateAlertPanel(scr->wmscreen, NULL, title, message, defBtn, altBtn, othBtn);
  78
  79         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 400, 180, 0, 0, 0);
  80
  81         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
  82
  83         center = getCenter(scr, 400, 180);
  84         wwin = wManageInternalWindow(scr, parent, None, NULL, center.x, center.y, 400, 180);
  85         wwin->client_leader = WMWidgetXID(panel->win);
  86
  87         WMMapWidget(panel->win);
  88
  89         wWindowMap(wwin);
  90
  91         WMRunModalLoop(WMWidgetScreen(panel->win), WMWidgetView(panel->win));
  92
  93         result = panel->result;
  94
  95         WMUnmapWidget(panel->win);
  96
  97         wUnmanageWindow(wwin, False, False);
  98
  99         WMDestroyAlertPanel(panel);
 100
 101         XDestroyWindow(dpy, parent);
 102
 103         return result;
 104 }
 105
 106 static void toggleSaveSession(WMWidget *w, void *data)
 107 {
 108         wPreferences.save_session_on_exit = WMGetButtonSelected((WMButton *) w);
 109 }
 110
 111 int wExitDialog(WScreen * scr, char *title, char *message, char *defBtn, char *altBtn, char *othBtn)
 112 {
 113         WMAlertPanel *panel;
 114         WMButton *saveSessionBtn;
 115         Window parent;
 116         WWindow *wwin;
 117         WMPoint center;
 118         int result;
 119
 120         panel = WMCreateAlertPanel(scr->wmscreen, NULL, title, message, defBtn, altBtn, othBtn);
 121
 122         /* add save session button */
 123         saveSessionBtn = WMCreateSwitchButton(panel->hbox);
 124         WMSetButtonAction(saveSessionBtn, toggleSaveSession, NULL);
 125         WMAddBoxSubview(panel->hbox, WMWidgetView(saveSessionBtn), False, True, 200, 0, 0);
 126         WMSetButtonText(saveSessionBtn, _("Save workspace state"));
 127         WMSetButtonSelected(saveSessionBtn, wPreferences.save_session_on_exit);
 128         WMRealizeWidget(saveSessionBtn);
 129         WMMapWidget(saveSessionBtn);
 130
 131         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 400, 180, 0, 0, 0);
 132
 133         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 134
 135         center = getCenter(scr, 400, 180);
 136         wwin = wManageInternalWindow(scr, parent, None, NULL, center.x, center.y, 400, 180);
 137
 138         wwin->client_leader = WMWidgetXID(panel->win);
 139
 140         WMMapWidget(panel->win);
 141
 142         wWindowMap(wwin);
 143
 144         WMRunModalLoop(WMWidgetScreen(panel->win), WMWidgetView(panel->win));
 145
 146         result = panel->result;
 147
 148         WMUnmapWidget(panel->win);
 149
 150         wUnmanageWindow(wwin, False, False);
 151
 152         WMDestroyAlertPanel(panel);
 153
 154         XDestroyWindow(dpy, parent);
 155
 156         return result;
 157 }
 158
 159 typedef struct _WMInputPanelWithHistory {
 160         WMInputPanel *panel;
 161         WMArray *history;
 162         int histpos;
 163         char *prefix;
 164         char *suffix;
 165         char *rest;
 166         WMArray *variants;
 167         int varpos;
 168 } WMInputPanelWithHistory;
 169
 170 static char *HistoryFileName(char *name)
 171 {
 172         char *filename = NULL;
 173
 174         filename = wstrdup(wusergnusteppath());
 175         filename = wstrappend(filename, "/.AppInfo/WindowMaker/History");
 176         if (name && strlen(name)) {
 177                 filename = wstrappend(filename, ".");
 178                 filename = wstrappend(filename, name);
 179         }
 180         return filename;
 181 }
 182
 183 static int strmatch(const void *str1, const void *str2)
 184 {
 185         return !strcmp((const char *)str1, (const char *)str2);
 186 }
 187
 188 static WMArray *LoadHistory(char *filename, int max)
 189 {
 190         WMPropList *plhistory;
 191         WMPropList *plitem;
 192         WMArray *history;
 193         int i, num;
 194
 195         history = WMCreateArrayWithDestructor(1, wfree);
 196         WMAddToArray(history, wstrdup(""));
 197
 198         plhistory = WMReadPropListFromFile((char *)filename);
 199
 200         if (plhistory && WMIsPLArray(plhistory)) {
 201                 num = WMGetPropListItemCount(plhistory);
 202                 if (num > max)
 203                         num = max;
 204
 205                 for (i = 0; i < num; ++i) {
 206                         plitem = WMGetFromPLArray(plhistory, i);
 207                         if (WMIsPLString(plitem) && WMFindInArray(history, strmatch,
 208                                                                   WMGetFromPLString(plitem)) == WANotFound)
 209                                 WMAddToArray(history, WMGetFromPLString(plitem));
 210                 }
 211         }
 212
 213         return history;
 214 }
 215
 216 static void SaveHistory(WMArray * history, char *filename)
 217 {
 218         int i;
 219         WMPropList *plhistory;
 220
 221         plhistory = WMCreatePLArray(NULL);
 222
 223         for (i = 0; i < WMGetArrayItemCount(history); ++i)
 224                 WMAddToPLArray(plhistory, WMCreatePLString(WMGetFromArray(history, i)));
 225
 226         WMWritePropListToFile(plhistory, (char *)filename);
 227         WMReleasePropList(plhistory);
 228 }
 229
 230 static int pstrcmp(const char **str1, const char **str2)
 231 {
 232         return strcmp(*str1, *str2);
 233 }
 234
 235 static void
 236 ScanFiles(const char *dir, const char *prefix, unsigned acceptmask, unsigned declinemask, WMArray * result)
 237 {
 238         int prefixlen;
 239         DIR *d;
 240         struct dirent *de;
 241         struct stat sb;
 242         char *fullfilename, *suffix;
 243
 244         prefixlen = strlen(prefix);
 245         if ((d = opendir(dir)) != NULL) {
 246                 while ((de = readdir(d)) != NULL) {
 247                         if (strlen(de->d_name) > prefixlen &&
 248                             !strncmp(prefix, de->d_name, prefixlen) &&
 249                             strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..")) {
 250                                 fullfilename = wstrconcat((char *)dir, "/");
 251                                 fullfilename = wstrappend(fullfilename, de->d_name);
 252
 253                                 if (stat(fullfilename, &sb) == 0 &&
 254                                     (sb.st_mode & acceptmask) &&
 255                                     !(sb.st_mode & declinemask) &&
 256                                     WMFindInArray(result, (WMMatchDataProc *) strmatch,
 257                                                   de->d_name + prefixlen) == WANotFound) {
 258                                         suffix = wstrdup(de->d_name + prefixlen);
 259                                         if (sb.st_mode & S_IFDIR)
 260                                                 wstrappend(suffix,"/");
 261                                         WMAddToArray(result, suffix);
 262                                 }
 263                                 wfree(fullfilename);
 264                         }
 265                 }
 266                 closedir(d);
 267         }
 268 }
 269
 270 static WMArray *GenerateVariants(const char *complete)
 271 {
 272         Bool firstWord = True;
 273         WMArray *variants = NULL;
 274         char *pos = NULL, *path = NULL, *tmp = NULL, *dir = NULL, *prefix = NULL;
 275
 276         variants = WMCreateArrayWithDestructor(0, wfree);
 277
 278         while (*complete == ' ')
 279                 ++complete;
 280
 281         if ((pos = strrchr(complete, ' ')) != NULL) {
 282                 complete = pos + 1;
 283                 firstWord = False;
 284         }
 285
 286         if ((pos = strrchr(complete, '/')) != NULL) {
 287                 tmp = wstrndup((char *)complete, pos - complete + 1);
 288                 if (*tmp == '~' && *(tmp + 1) == '/' && getenv("HOME")) {
 289                         dir = wstrdup(getenv("HOME"));
 290                         dir = wstrappend(dir, tmp + 1);
 291                         wfree(tmp);
 292                 } else {
 293                         dir = tmp;
 294                 }
 295                 prefix = wstrdup(pos + 1);
 296                 ScanFiles(dir, prefix, (unsigned)-1, 0, variants);
 297                 wfree(dir);
 298                 wfree(prefix);
 299         } else if (*complete == '~') {
 300                 WMAddToArray(variants, wstrdup("/"));
 301         } else if (firstWord) {
 302                 path = getenv("PATH");
 303                 while (path) {
 304                         pos = strchr(path, ':');
 305                         if (pos) {
 306                                 tmp = wstrndup(path, pos - path);
 307                                 path = pos + 1;
 308                         } else if (*path != '\0') {
 309                                 tmp = wstrdup(path);
 310                                 path = NULL;
 311                         } else
 312                                 break;
 313                         ScanFiles(tmp, complete, S_IXOTH | S_IXGRP | S_IXUSR, S_IFDIR, variants);
 314                         wfree(tmp);
 315                 }
 316         }
 317
 318         WMSortArray(variants, (WMCompareDataProc *) pstrcmp);
 319         return variants;
 320 }
 321
 322 static void handleHistoryKeyPress(XEvent * event, void *clientData)
 323 {
 324         char *text;
 325         unsigned pos;
 326         WMInputPanelWithHistory *p = (WMInputPanelWithHistory *) clientData;
 327         KeySym ksym;
 328
 329         ksym = XLookupKeysym(&event->xkey, 0);
 330
 331         switch (ksym) {
 332         case XK_Up:
 333                 if (p->histpos < WMGetArrayItemCount(p->history) - 1) {
 334                         if (p->histpos == 0)
 335                                 wfree(WMReplaceInArray(p->history, 0, WMGetTextFieldText(p->panel->text)));
 336                         p->histpos++;
 337                         WMSetTextFieldText(p->panel->text, WMGetFromArray(p->history, p->histpos));
 338                 }
 339                 break;
 340         case XK_Down:
 341                 if (p->histpos > 0) {
 342                         p->histpos--;
 343                         WMSetTextFieldText(p->panel->text, WMGetFromArray(p->history, p->histpos));
 344                 }
 345                 break;
 346         case XK_Tab:
 347                 if (!p->variants) {
 348                         text = WMGetTextFieldText(p->panel->text);
 349                         pos = WMGetTextFieldCursorPosition(p->panel->text);
 350                         p->prefix = wstrndup(text, pos);
 351                         p->suffix = wstrdup(text + pos);
 352                         wfree(text);
 353                         p->variants = GenerateVariants(p->prefix);
 354                         p->varpos = 0;
 355                         if (!p->variants) {
 356                                 wfree(p->prefix);
 357                                 wfree(p->suffix);
 358                                 p->prefix = NULL;
 359                                 p->suffix = NULL;
 360                         }
 361                 }
 362                 if (p->variants && p->prefix && p->suffix) {
 363                         p->varpos++;
 364                         if (p->varpos > WMGetArrayItemCount(p->variants))
 365                                 p->varpos = 0;
 366                         if (p->varpos > 0)
 367                                 text = wstrconcat(p->prefix, WMGetFromArray(p->variants, p->varpos - 1));
 368                         else
 369                                 text = wstrdup(p->prefix);
 370                         pos = strlen(text);
 371                         text = wstrappend(text, p->suffix);
 372                         WMSetTextFieldText(p->panel->text, text);
 373                         WMSetTextFieldCursorPosition(p->panel->text, pos);
 374                         wfree(text);
 375                 }
 376                 break;
 377         }
 378         if (ksym != XK_Tab) {
 379                 if (p->prefix) {
 380                         wfree(p->prefix);
 381                         p->prefix = NULL;
 382                 }
 383                 if (p->suffix) {
 384                         wfree(p->suffix);
 385                         p->suffix = NULL;
 386                 }
 387                 if (p->variants) {
 388                         WMFreeArray(p->variants);
 389                         p->variants = NULL;
 390                 }
 391         }
 392 }
 393
 394 int wAdvancedInputDialog(WScreen * scr, char *title, char *message, char *name, char **text)
 395 {
 396         WWindow *wwin;
 397         Window parent;
 398         char *result;
 399         WMPoint center;
 400         WMInputPanelWithHistory *p;
 401         char *filename;
 402
 403         filename = HistoryFileName(name);
 404         p = wmalloc(sizeof(WMInputPanelWithHistory));
 405         p->panel = WMCreateInputPanel(scr->wmscreen, NULL, title, message, *text, _("OK"), _("Cancel"));
 406         p->history = LoadHistory(filename, wPreferences.history_lines);
 407         p->histpos = 0;
 408         p->prefix = NULL;
 409         p->suffix = NULL;
 410         p->rest = NULL;
 411         p->variants = NULL;
 412         p->varpos = 0;
 413         WMCreateEventHandler(WMWidgetView(p->panel->text), KeyPressMask, handleHistoryKeyPress, p);
 414
 415         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 320, 160, 0, 0, 0);
 416         XSelectInput(dpy, parent, KeyPressMask | KeyReleaseMask);
 417
 418         XReparentWindow(dpy, WMWidgetXID(p->panel->win), parent, 0, 0);
 419
 420         center = getCenter(scr, 320, 160);
 421         wwin = wManageInternalWindow(scr, parent, None, NULL, center.x, center.y, 320, 160);
 422
 423         wwin->client_leader = WMWidgetXID(p->panel->win);
 424
 425         WMMapWidget(p->panel->win);
 426
 427         wWindowMap(wwin);
 428
 429         WMRunModalLoop(WMWidgetScreen(p->panel->win), WMWidgetView(p->panel->win));
 430
 431         if (p->panel->result == WAPRDefault) {
 432                 result = WMGetTextFieldText(p->panel->text);
 433                 wfree(WMReplaceInArray(p->history, 0, wstrdup(result)));
 434                 SaveHistory(p->history, filename);
 435         } else
 436                 result = NULL;
 437
 438         wUnmanageWindow(wwin, False, False);
 439
 440         WMDestroyInputPanel(p->panel);
 441         WMFreeArray(p->history);
 442         wfree(p);
 443         wfree(filename);
 444
 445         XDestroyWindow(dpy, parent);
 446
 447         if (result == NULL)
 448                 return False;
 449         else {
 450                 if (*text)
 451                         wfree(*text);
 452                 *text = result;
 453
 454                 return True;
 455         }
 456 }
 457
 458 int wInputDialog(WScreen * scr, char *title, char *message, char **text)
 459 {
 460         WWindow *wwin;
 461         Window parent;
 462         WMInputPanel *panel;
 463         char *result;
 464         WMPoint center;
 465
 466         panel = WMCreateInputPanel(scr->wmscreen, NULL, title, message, *text, _("OK"), _("Cancel"));
 467
 468         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 320, 160, 0, 0, 0);
 469         XSelectInput(dpy, parent, KeyPressMask | KeyReleaseMask);
 470
 471         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 472
 473         center = getCenter(scr, 320, 160);
 474         wwin = wManageInternalWindow(scr, parent, None, NULL, center.x, center.y, 320, 160);
 475
 476         wwin->client_leader = WMWidgetXID(panel->win);
 477
 478         WMMapWidget(panel->win);
 479
 480         wWindowMap(wwin);
 481
 482         WMRunModalLoop(WMWidgetScreen(panel->win), WMWidgetView(panel->win));
 483
 484         if (panel->result == WAPRDefault)
 485                 result = WMGetTextFieldText(panel->text);
 486         else
 487                 result = NULL;
 488
 489         wUnmanageWindow(wwin, False, False);
 490
 491         WMDestroyInputPanel(panel);
 492
 493         XDestroyWindow(dpy, parent);
 494
 495         if (result == NULL)
 496                 return False;
 497         else {
 498                 if (*text)
 499                         wfree(*text);
 500                 *text = result;
 501
 502                 return True;
 503         }
 504 }
 505
 506 /*
 507  *****************************************************************
 508  * Icon Selection Panel
 509  *****************************************************************
 510  */
 511
 512 typedef struct IconPanel {
 513
 514         WScreen *scr;
 515
 516         WMWindow *win;
 517
 518         WMLabel *dirLabel;
 519         WMLabel *iconLabel;
 520
 521         WMList *dirList;
 522         WMList *iconList;
 523         WMFont *normalfont;
 524
 525         WMButton *previewButton;
 526
 527         WMLabel *iconView;
 528
 529         WMLabel *fileLabel;
 530         WMTextField *fileField;
 531
 532         WMButton *okButton;
 533         WMButton *cancelButton;
 534 #if 0
 535         WMButton *chooseButton;
 536 #endif
 537         short done;
 538         short result;
 539         short preview;
 540 } IconPanel;
 541
 542 static void listPixmaps(WScreen * scr, WMList * lPtr, char *path)
 543 {
 544         struct dirent *dentry;
 545         DIR *dir;
 546         char pbuf[PATH_MAX + 16];
 547         char *apath;
 548         IconPanel *panel = WMGetHangedData(lPtr);
 549
 550         panel->preview = False;
 551
 552         apath = wexpandpath(path);
 553         dir = opendir(apath);
 554
 555         if (!dir) {
 556                 char *msg;
 557                 char *tmp;
 558                 tmp = _("Could not open directory ");
 559                 msg = wmalloc(strlen(tmp) + strlen(path) + 6);
 560                 strcpy(msg, tmp);
 561                 strcat(msg, path);
 562
 563                 wMessageDialog(scr, _("Error"), msg, _("OK"), NULL, NULL);
 564                 wfree(msg);
 565                 wfree(apath);
 566                 return;
 567         }
 568
 569         /* list contents in the column */
 570         while ((dentry = readdir(dir))) {
 571                 struct stat statb;
 572
 573                 if (strcmp(dentry->d_name, ".") == 0 || strcmp(dentry->d_name, "..") == 0)
 574                         continue;
 575
 576                 strcpy(pbuf, apath);
 577                 strcat(pbuf, "/");
 578                 strcat(pbuf, dentry->d_name);
 579
 580                 if (stat(pbuf, &statb) < 0)
 581                         continue;
 582
 583                 if (statb.st_mode & (S_IRUSR | S_IRGRP | S_IROTH)
 584                     && statb.st_mode & (S_IFREG | S_IFLNK)) {
 585                         WMAddListItem(lPtr, dentry->d_name);
 586                 }
 587         }
 588         WMSortListItems(lPtr);
 589
 590         closedir(dir);
 591         wfree(apath);
 592         panel->preview = True;
 593 }
 594
 595 static void setViewedImage(IconPanel * panel, char *file)
 596 {
 597         WMPixmap *pixmap;
 598         RColor color;
 599
 600         color.red = 0xae;
 601         color.green = 0xaa;
 602         color.blue = 0xae;
 603         color.alpha = 0;
 604         pixmap = WMCreateBlendedPixmapFromFile(WMWidgetScreen(panel->win), file, &color);
 605         if (!pixmap) {
 606                 WMSetButtonEnabled(panel->okButton, False);
 607
 608                 WMSetLabelText(panel->iconView, _("Could not load image file "));
 609
 610                 WMSetLabelImage(panel->iconView, NULL);
 611         } else {
 612                 WMSetButtonEnabled(panel->okButton, True);
 613
 614                 WMSetLabelText(panel->iconView, NULL);
 615                 WMSetLabelImage(panel->iconView, pixmap);
 616                 WMReleasePixmap(pixmap);
 617         }
 618 }
 619
 620 static void listCallback(void *self, void *data)
 621 {
 622         WMList *lPtr = (WMList *) self;
 623         IconPanel *panel = (IconPanel *) data;
 624         char *path;
 625
 626         if (lPtr == panel->dirList) {
 627                 WMListItem *item = WMGetListSelectedItem(lPtr);
 628
 629                 if (item == NULL)
 630                         return;
 631                 path = item->text;
 632
 633                 WMSetTextFieldText(panel->fileField, path);
 634
 635                 WMSetLabelImage(panel->iconView, NULL);
 636
 637                 WMSetButtonEnabled(panel->okButton, False);
 638
 639                 WMClearList(panel->iconList);
 640                 listPixmaps(panel->scr, panel->iconList, path);
 641         } else {
 642                 char *tmp, *iconFile;
 643                 WMListItem *item = WMGetListSelectedItem(panel->dirList);
 644
 645                 if (item == NULL)
 646                         return;
 647                 path = item->text;
 648                 tmp = wexpandpath(path);
 649
 650                 item = WMGetListSelectedItem(panel->iconList);
 651                 if (item == NULL)
 652                         return;
 653                 iconFile = item->text;
 654
 655                 path = wmalloc(strlen(tmp) + strlen(iconFile) + 4);
 656                 strcpy(path, tmp);
 657                 strcat(path, "/");
 658                 strcat(path, iconFile);
 659                 wfree(tmp);
 660                 WMSetTextFieldText(panel->fileField, path);
 661                 setViewedImage(panel, path);
 662                 wfree(path);
 663         }
 664 }
 665
 666 static void listIconPaths(WMList * lPtr)
 667 {
 668         char *paths;
 669         char *path;
 670
 671         paths = wstrdup(wPreferences.icon_path);
 672
 673         path = strtok(paths, ":");
 674
 675         do {
 676                 char *tmp;
 677
 678                 tmp = wexpandpath(path);
 679                 /* do not sort, because the order implies the order of
 680                  * directories searched */
 681                 if (access(tmp, X_OK) == 0)
 682                         WMAddListItem(lPtr, path);
 683                 wfree(tmp);
 684         } while ((path = strtok(NULL, ":")) != NULL);
 685
 686         wfree(paths);
 687 }
 688
 689 static void drawIconProc(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
 690 {
 691         IconPanel *panel = WMGetHangedData(lPtr);
 692         WScreen *scr = panel->scr;
 693         GC gc = scr->draw_gc;
 694         GC copygc = scr->copy_gc;
 695         char *file, *dirfile;
 696         WMPixmap *pixmap;
 697         WMColor *back;
 698         WMSize size;
 699         WMScreen *wmscr = WMWidgetScreen(panel->win);
 700         RColor color;
 701         int x, y, width, height, len;
 702
 703         if (!panel->preview)
 704                 return;
 705
 706         x = rect->pos.x;
 707         y = rect->pos.y;
 708         width = rect->size.width;
 709         height = rect->size.height;
 710
 711         back = (state & WLDSSelected) ? scr->white : scr->gray;
 712
 713         dirfile = wexpandpath(WMGetListSelectedItem(panel->dirList)->text);
 714         len = strlen(dirfile) + strlen(text) + 4;
 715         file = wmalloc(len);
 716         snprintf(file, len, "%s/%s", dirfile, text);
 717         wfree(dirfile);
 718
 719         color.red = WMRedComponentOfColor(back) >> 8;
 720         color.green = WMGreenComponentOfColor(back) >> 8;
 721         color.blue = WMBlueComponentOfColor(back) >> 8;
 722         color.alpha = WMGetColorAlpha(back) >> 8;
 723
 724         pixmap = WMCreateBlendedPixmapFromFile(wmscr, file, &color);
 725         wfree(file);
 726
 727         if (!pixmap) {
 728                 /*WMRemoveListItem(lPtr, index); */
 729                 return;
 730         }
 731
 732         XFillRectangle(dpy, d, WMColorGC(back), x, y, width, height);
 733
 734         XSetClipMask(dpy, gc, None);
 735         /*XDrawRectangle(dpy, d, WMColorGC(white), x+5, y+5, width-10, 54); */
 736         XDrawLine(dpy, d, WMColorGC(scr->white), x, y + height - 1, x + width, y + height - 1);
 737
 738         size = WMGetPixmapSize(pixmap);
 739
 740         XSetClipMask(dpy, copygc, WMGetPixmapMaskXID(pixmap));
 741         XSetClipOrigin(dpy, copygc, x + (width - size.width) / 2, y + 2);
 742         XCopyArea(dpy, WMGetPixmapXID(pixmap), d, copygc, 0, 0,
 743                   size.width > 100 ? 100 : size.width, size.height > 64 ? 64 : size.height,
 744                   x + (width - size.width) / 2, y + 2);
 745
 746         {
 747                 int i, j;
 748                 int fheight = WMFontHeight(panel->normalfont);
 749                 int tlen = strlen(text);
 750                 int twidth = WMWidthOfString(panel->normalfont, text, tlen);
 751                 int ofx, ofy;
 752
 753                 ofx = x + (width - twidth) / 2;
 754                 ofy = y + 64 - fheight;
 755
 756                 for (i = -1; i < 2; i++)
 757                         for (j = -1; j < 2; j++)
 758                                 WMDrawString(wmscr, d, scr->white, panel->normalfont,
 759                                              ofx + i, ofy + j, text, tlen);
 760
 761                 WMDrawString(wmscr, d, scr->black, panel->normalfont, ofx, ofy, text, tlen);
 762         }
 763
 764         WMReleasePixmap(pixmap);
 765         /* I hope it is better to do not use cache / on my box it is fast nuff */
 766         XFlush(dpy);
 767 }
 768
 769 static void buttonCallback(void *self, void *clientData)
 770 {
 771         WMButton *bPtr = (WMButton *) self;
 772         IconPanel *panel = (IconPanel *) clientData;
 773
 774         if (bPtr == panel->okButton) {
 775                 panel->done = True;
 776                 panel->result = True;
 777         } else if (bPtr == panel->cancelButton) {
 778                 panel->done = True;
 779                 panel->result = False;
 780         } else if (bPtr == panel->previewButton) {
 781         /**** Previewer ****/
 782                 WMSetButtonEnabled(bPtr, False);
 783                 WMSetListUserDrawItemHeight(panel->iconList, 68);
 784                 WMSetListUserDrawProc(panel->iconList, drawIconProc);
 785                 WMRedisplayWidget(panel->iconList);
 786                 /* for draw proc to access screen/gc */
 787         /*** end preview ***/
 788         }
 789 #if 0
 790         else if (bPtr == panel->chooseButton) {
 791                 WMOpenPanel *op;
 792
 793                 op = WMCreateOpenPanel(WMWidgetScreen(bPtr));
 794
 795                 if (WMRunModalFilePanelForDirectory(op, NULL, "/usr/local", NULL, NULL)) {
 796                         char *path;
 797                         path = WMGetFilePanelFile(op);
 798                         WMSetTextFieldText(panel->fileField, path);
 799                         setViewedImage(panel, path);
 800                         wfree(path);
 801                 }
 802                 WMDestroyFilePanel(op);
 803         }
 804 #endif
 805 }
 806
 807 static void keyPressHandler(XEvent * event, void *data)
 808 {
 809         IconPanel *panel = (IconPanel *) data;
 810         char buffer[32];
 811         KeySym ksym;
 812         int iidx;
 813         int didx;
 814         int item = 0;
 815         WMList *list = NULL;
 816
 817         if (event->type == KeyRelease)
 818                 return;
 819
 820         buffer[0] = 0;
 821         XLookupString(&event->xkey, buffer, sizeof(buffer), &ksym, NULL);
 822
 823         iidx = WMGetListSelectedItemRow(panel->iconList);
 824         didx = WMGetListSelectedItemRow(panel->dirList);
 825
 826         switch (ksym) {
 827         case XK_Up:
 828                 if (iidx > 0)
 829                         item = iidx - 1;
 830                 else
 831                         item = iidx;
 832                 list = panel->iconList;
 833                 break;
 834         case XK_Down:
 835                 if (iidx < WMGetListNumberOfRows(panel->iconList) - 1)
 836                         item = iidx + 1;
 837                 else
 838                         item = iidx;
 839                 list = panel->iconList;
 840                 break;
 841         case XK_Home:
 842                 item = 0;
 843                 list = panel->iconList;
 844                 break;
 845         case XK_End:
 846                 item = WMGetListNumberOfRows(panel->iconList) - 1;
 847                 list = panel->iconList;
 848                 break;
 849         case XK_Next:
 850                 if (didx < WMGetListNumberOfRows(panel->dirList) - 1)
 851                         item = didx + 1;
 852                 else
 853                         item = didx;
 854                 list = panel->dirList;
 855                 break;
 856         case XK_Prior:
 857                 if (didx > 0)
 858                         item = didx - 1;
 859                 else
 860                         item = 0;
 861                 list = panel->dirList;
 862                 break;
 863         case XK_Return:
 864                 WMPerformButtonClick(panel->okButton);
 865                 break;
 866         case XK_Escape:
 867                 WMPerformButtonClick(panel->cancelButton);
 868                 break;
 869         }
 870
 871         if (list) {
 872                 WMSelectListItem(list, item);
 873                 WMSetListPosition(list, item - 5);
 874                 listCallback(list, panel);
 875         }
 876 }
 877
 878 Bool wIconChooserDialog(WScreen * scr, char **file, char *instance, char *class)
 879 {
 880         WWindow *wwin;
 881         Window parent;
 882         IconPanel *panel;
 883         WMColor *color;
 884         WMFont *boldFont;
 885         Bool result;
 886
 887         panel = wmalloc(sizeof(IconPanel));
 888
 889         panel->scr = scr;
 890
 891         panel->win = WMCreateWindow(scr->wmscreen, "iconChooser");
 892         WMResizeWidget(panel->win, 450, 280);
 893
 894         WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask | KeyReleaseMask, keyPressHandler, panel);
 895
 896         boldFont = WMBoldSystemFontOfSize(scr->wmscreen, 12);
 897         panel->normalfont = WMSystemFontOfSize(WMWidgetScreen(panel->win), 12);
 898
 899         panel->dirLabel = WMCreateLabel(panel->win);
 900         WMResizeWidget(panel->dirLabel, 200, 20);
 901         WMMoveWidget(panel->dirLabel, 10, 7);
 902         WMSetLabelText(panel->dirLabel, _("Directories"));
 903         WMSetLabelFont(panel->dirLabel, boldFont);
 904         WMSetLabelTextAlignment(panel->dirLabel, WACenter);
 905
 906         WMSetLabelRelief(panel->dirLabel, WRSunken);
 907
 908         panel->iconLabel = WMCreateLabel(panel->win);
 909         WMResizeWidget(panel->iconLabel, 140, 20);
 910         WMMoveWidget(panel->iconLabel, 215, 7);
 911         WMSetLabelText(panel->iconLabel, _("Icons"));
 912         WMSetLabelFont(panel->iconLabel, boldFont);
 913         WMSetLabelTextAlignment(panel->iconLabel, WACenter);
 914
 915         WMReleaseFont(boldFont);
 916
 917         color = WMWhiteColor(scr->wmscreen);
 918         WMSetLabelTextColor(panel->dirLabel, color);
 919         WMSetLabelTextColor(panel->iconLabel, color);
 920         WMReleaseColor(color);
 921
 922         color = WMDarkGrayColor(scr->wmscreen);
 923         WMSetWidgetBackgroundColor(panel->iconLabel, color);
 924         WMSetWidgetBackgroundColor(panel->dirLabel, color);
 925         WMReleaseColor(color);
 926
 927         WMSetLabelRelief(panel->iconLabel, WRSunken);
 928
 929         panel->dirList = WMCreateList(panel->win);
 930         WMResizeWidget(panel->dirList, 200, 170);
 931         WMMoveWidget(panel->dirList, 10, 30);
 932         WMSetListAction(panel->dirList, listCallback, panel);
 933
 934         panel->iconList = WMCreateList(panel->win);
 935         WMResizeWidget(panel->iconList, 140, 170);
 936         WMMoveWidget(panel->iconList, 215, 30);
 937         WMSetListAction(panel->iconList, listCallback, panel);
 938
 939         WMHangData(panel->iconList, panel);
 940
 941         panel->previewButton = WMCreateCommandButton(panel->win);
 942         WMResizeWidget(panel->previewButton, 75, 26);
 943         WMMoveWidget(panel->previewButton, 365, 130);
 944         WMSetButtonText(panel->previewButton, _("Preview"));
 945         WMSetButtonAction(panel->previewButton, buttonCallback, panel);
 946
 947         panel->iconView = WMCreateLabel(panel->win);
 948         WMResizeWidget(panel->iconView, 75, 75);
 949         WMMoveWidget(panel->iconView, 365, 40);
 950         WMSetLabelImagePosition(panel->iconView, WIPOverlaps);
 951         WMSetLabelRelief(panel->iconView, WRSunken);
 952         WMSetLabelTextAlignment(panel->iconView, WACenter);
 953
 954         panel->fileLabel = WMCreateLabel(panel->win);
 955         WMResizeWidget(panel->fileLabel, 80, 20);
 956         WMMoveWidget(panel->fileLabel, 10, 210);
 957         WMSetLabelText(panel->fileLabel, _("File Name:"));
 958
 959         panel->fileField = WMCreateTextField(panel->win);
 960         WMSetViewNextResponder(WMWidgetView(panel->fileField), WMWidgetView(panel->win));
 961         WMResizeWidget(panel->fileField, 345, 20);
 962         WMMoveWidget(panel->fileField, 95, 210);
 963         WMSetTextFieldEditable(panel->fileField, False);
 964
 965         panel->okButton = WMCreateCommandButton(panel->win);
 966         WMResizeWidget(panel->okButton, 80, 26);
 967         WMMoveWidget(panel->okButton, 360, 240);
 968         WMSetButtonText(panel->okButton, _("OK"));
 969         WMSetButtonEnabled(panel->okButton, False);
 970         WMSetButtonAction(panel->okButton, buttonCallback, panel);
 971
 972         panel->cancelButton = WMCreateCommandButton(panel->win);
 973         WMResizeWidget(panel->cancelButton, 80, 26);
 974         WMMoveWidget(panel->cancelButton, 270, 240);
 975         WMSetButtonText(panel->cancelButton, _("Cancel"));
 976         WMSetButtonAction(panel->cancelButton, buttonCallback, panel);
 977 #if 0
 978         panel->chooseButton = WMCreateCommandButton(panel->win);
 979         WMResizeWidget(panel->chooseButton, 110, 26);
 980         WMMoveWidget(panel->chooseButton, 150, 240);
 981         WMSetButtonText(panel->chooseButton, _("Choose File"));
 982         WMSetButtonAction(panel->chooseButton, buttonCallback, panel);
 983 #endif
 984         WMRealizeWidget(panel->win);
 985         WMMapSubwidgets(panel->win);
 986
 987         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 450, 280, 0, 0, 0);
 988
 989         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 990
 991         {
 992                 char *tmp;
 993                 int len = (instance ? strlen(instance) : 0)
 994                     + (class ? strlen(class) : 0) + 32;
 995                 WMPoint center;
 996
 997                 tmp = wmalloc(len);
 998
 999                 if (tmp && (instance || class))
1000                         snprintf(tmp, len, "%s [%s.%s]", _("Icon Chooser"), instance, class);
1001                 else
1002                         strcpy(tmp, _("Icon Chooser"));
1003
1004                 center = getCenter(scr, 450, 280);
1005
1006                 wwin = wManageInternalWindow(scr, parent, None, tmp, center.x, center.y, 450, 280);
1007                 wfree(tmp);
1008         }
1009
1010         /* put icon paths in the list */
1011         listIconPaths(panel->dirList);
1012
1013         WMMapWidget(panel->win);
1014
1015         wWindowMap(wwin);
1016
1017         while (!panel->done) {
1018                 XEvent event;
1019
1020                 WMNextEvent(dpy, &event);
1021                 WMHandleEvent(&event);
1022         }
1023
1024         if (panel->result) {
1025                 char *defaultPath, *wantedPath;
1026
1027                 /* check if the file the user selected is not the one that
1028                  * would be loaded by default with the current search path */
1029                 *file = WMGetListSelectedItem(panel->iconList)->text;
1030                 if (**file == 0) {
1031                         wfree(*file);
1032                         *file = NULL;
1033                 } else {
1034                         defaultPath = FindImage(wPreferences.icon_path, *file);
1035                         wantedPath = WMGetTextFieldText(panel->fileField);
1036                         /* if the file is not the default, use full path */
1037                         if (strcmp(wantedPath, defaultPath) != 0) {
1038                                 *file = wantedPath;
1039                         } else {
1040                                 *file = wstrdup(*file);
1041                                 wfree(wantedPath);
1042                         }
1043                         wfree(defaultPath);
1044                 }
1045         } else {
1046                 *file = NULL;
1047         }
1048
1049         result = panel->result;
1050
1051         WMReleaseFont(panel->normalfont);
1052
1053         WMUnmapWidget(panel->win);
1054
1055         WMDestroyWidget(panel->win);
1056
1057         wUnmanageWindow(wwin, False, False);
1058
1059         wfree(panel);
1060
1061         XDestroyWindow(dpy, parent);
1062
1063         return result;
1064 }
1065
1066 /*
1067  ***********************************************************************
1068  * Info Panel
1069  ***********************************************************************
1070  */
1071
1072 typedef struct {
1073         WScreen *scr;
1074         WWindow *wwin;
1075         WMWindow *win;
1076         WMLabel *logoL;
1077         WMLabel *name1L;
1078         WMFrame *lineF;
1079         WMLabel *name2L;
1080         WMLabel *versionL;
1081         WMLabel *infoL;
1082         WMLabel *copyrL;
1083 } InfoPanel;
1084
1085 #define COPYRIGHT_TEXT  \
1086     "Copyright \xc2\xa9 1997-2006 Alfredo K. Kojima\n"\
1087     "Copyright \xc2\xa9 1998-2006 Dan Pascu"
1088
1089 static InfoPanel *thePanel = NULL;
1090
1091 static void destroyInfoPanel(WCoreWindow *foo, void *data, XEvent *event)
1092 {
1093         WMUnmapWidget(thePanel);
1094         wUnmanageWindow(thePanel->wwin, False, False);
1095         WMDestroyWidget(thePanel->win);
1096         wfree(thePanel);
1097         thePanel = NULL;
1098 }
1099
1100 void wShowInfoPanel(WScreen * scr)
1101 {
1102         InfoPanel *panel;
1103         WMPixmap *logo;
1104         WMFont *font;
1105         char *strbuf = NULL;
1106         char buffer[256];
1107         char *name;
1108         Window parent;
1109         WWindow *wwin;
1110         char **strl;
1111         int i, width = 50, sepHeight;
1112         char *visuals[] = {
1113                 "StaticGray",
1114                 "GrayScale",
1115                 "StaticColor",
1116                 "PseudoColor",
1117                 "TrueColor",
1118                 "DirectColor"
1119         };
1120
1121         if (thePanel) {
1122                 if (thePanel->scr == scr) {
1123                         wRaiseFrame(thePanel->wwin->frame->core);
1124                         wSetFocusTo(scr, thePanel->wwin);
1125                 }
1126                 return;
1127         }
1128
1129         panel = wmalloc(sizeof(InfoPanel));
1130
1131         panel->scr = scr;
1132
1133         panel->win = WMCreateWindow(scr->wmscreen, "info");
1134         WMResizeWidget(panel->win, 390, 230);
1135
1136         logo = WMCreateApplicationIconBlendedPixmap(scr->wmscreen, (RColor *) NULL);
1137         if (!logo) {
1138                 logo = WMRetainPixmap(WMGetApplicationIconPixmap(scr->wmscreen));
1139         }
1140         if (logo) {
1141                 panel->logoL = WMCreateLabel(panel->win);
1142                 WMResizeWidget(panel->logoL, 64, 64);
1143                 WMMoveWidget(panel->logoL, 30, 20);
1144                 WMSetLabelImagePosition(panel->logoL, WIPImageOnly);
1145                 WMSetLabelImage(panel->logoL, logo);
1146                 WMReleasePixmap(logo);
1147         }
1148
1149         sepHeight = 3;
1150         panel->name1L = WMCreateLabel(panel->win);
1151         WMResizeWidget(panel->name1L, 240, 30 + 2);
1152         WMMoveWidget(panel->name1L, 100, 30 - 2 - sepHeight);
1153
1154         name = "Lucida Sans,Comic Sans MS,URW Gothic L,Trebuchet MS" ":italic:pixelsize=28:antialias=true";
1155         font = WMCreateFont(scr->wmscreen, name);
1156         strbuf = "Window Maker";
1157         if (font) {
1158                 width = WMWidthOfString(font, strbuf, strlen(strbuf));
1159                 WMSetLabelFont(panel->name1L, font);
1160                 WMReleaseFont(font);
1161         }
1162         WMSetLabelTextAlignment(panel->name1L, WACenter);
1163         WMSetLabelText(panel->name1L, strbuf);
1164
1165         panel->lineF = WMCreateFrame(panel->win);
1166         WMResizeWidget(panel->lineF, width, sepHeight);
1167         WMMoveWidget(panel->lineF, 100 + (240 - width) / 2, 60 - sepHeight);
1168         WMSetFrameRelief(panel->lineF, WRSimple);
1169         WMSetWidgetBackgroundColor(panel->lineF, scr->black);
1170
1171         panel->name2L = WMCreateLabel(panel->win);
1172         WMResizeWidget(panel->name2L, 240, 24);
1173         WMMoveWidget(panel->name2L, 100, 60);
1174         name = "URW Gothic L,Nimbus Sans L:pixelsize=16:antialias=true";
1175         font = WMCreateFont(scr->wmscreen, name);
1176         if (font) {
1177                 WMSetLabelFont(panel->name2L, font);
1178                 WMReleaseFont(font);
1179                 font = NULL;
1180         }
1181         WMSetLabelTextAlignment(panel->name2L, WACenter);
1182         WMSetLabelText(panel->name2L, _("Window Manager for X"));
1183
1184         snprintf(buffer, sizeof(buffer), _("Version %s"), VERSION);
1185         panel->versionL = WMCreateLabel(panel->win);
1186         WMResizeWidget(panel->versionL, 310, 16);
1187         WMMoveWidget(panel->versionL, 30, 95);
1188         WMSetLabelTextAlignment(panel->versionL, WARight);
1189         WMSetLabelText(panel->versionL, buffer);
1190         WMSetLabelWraps(panel->versionL, False);
1191
1192         panel->copyrL = WMCreateLabel(panel->win);
1193         WMResizeWidget(panel->copyrL, 360, 40);
1194         WMMoveWidget(panel->copyrL, 15, 185);
1195         WMSetLabelTextAlignment(panel->copyrL, WALeft);
1196         WMSetLabelText(panel->copyrL, COPYRIGHT_TEXT);
1197         font = WMSystemFontOfSize(scr->wmscreen, 11);
1198         if (font) {
1199                 WMSetLabelFont(panel->copyrL, font);
1200                 WMReleaseFont(font);
1201                 font = NULL;
1202         }
1203
1204         strbuf = NULL;
1205         snprintf(buffer, sizeof(buffer), _("Using visual 0x%x: %s %ibpp "),
1206                  (unsigned)scr->w_visual->visualid, visuals[scr->w_visual->class], scr->w_depth);
1207
1208         strbuf = wstrappend(strbuf, buffer);
1209
1210         switch (scr->w_depth) {
1211         case 15:
1212                 strbuf = wstrappend(strbuf, _("(32 thousand colors)\n"));
1213                 break;
1214         case 16:
1215                 strbuf = wstrappend(strbuf, _("(64 thousand colors)\n"));
1216                 break;
1217         case 24:
1218         case 32:
1219                 strbuf = wstrappend(strbuf, _("(16 million colors)\n"));
1220                 break;
1221         default:
1222                 snprintf(buffer, sizeof(buffer), _("(%d colors)\n"), 1 << scr->w_depth);
1223                 strbuf = wstrappend(strbuf, buffer);
1224                 break;
1225         }
1226
1227 #if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
1228         {
1229                 struct mallinfo ma = mallinfo();
1230                 snprintf(buffer, sizeof(buffer),
1231                          _("Total memory allocated: %i kB (in use: %i kB).\n"),
1232                          (ma.arena + ma.hblkhd) / 1024, (ma.uordblks + ma.hblkhd) / 1024);
1233
1234                 strbuf = wstrappend(strbuf, buffer);
1235         }
1236 #endif
1237
1238         strbuf = wstrappend(strbuf, _("Supported image formats: "));
1239         strl = RSupportedFileFormats();
1240         for (i = 0; strl[i] != NULL; i++) {
1241                 strbuf = wstrappend(strbuf, strl[i]);
1242                 strbuf = wstrappend(strbuf, " ");
1243         }
1244
1245         strbuf = wstrappend(strbuf, _("\nAdditional support for: WMSPEC"));
1246 #ifdef MWM_HINTS
1247         strbuf = wstrappend(strbuf, " and MWM");
1248 #endif
1249
1250 #ifdef XINERAMA
1251         strbuf = wstrappend(strbuf, _("\n"));
1252 #ifdef SOLARIS_XINERAMA
1253         strbuf = wstrappend(strbuf, _("Solaris "));
1254 #endif
1255         strbuf = wstrappend(strbuf, _("Xinerama: "));
1256         {
1257                 char tmp[128];
1258                 snprintf(tmp, sizeof(tmp) - 1, "%d heads found.", scr->xine_info.count);
1259                 strbuf = wstrappend(strbuf, tmp);
1260         }
1261 #endif
1262
1263         panel->infoL = WMCreateLabel(panel->win);
1264         WMResizeWidget(panel->infoL, 350, 75);
1265         WMMoveWidget(panel->infoL, 15, 115);
1266         WMSetLabelText(panel->infoL, strbuf);
1267         font = WMSystemFontOfSize(scr->wmscreen, 11);
1268         if (font) {
1269                 WMSetLabelFont(panel->infoL, font);
1270                 WMReleaseFont(font);
1271                 font = NULL;
1272         }
1273         wfree(strbuf);
1274
1275         WMRealizeWidget(panel->win);
1276         WMMapSubwidgets(panel->win);
1277
1278         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 382, 230, 0, 0, 0);
1279
1280         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1281
1282         WMMapWidget(panel->win);
1283
1284         {
1285                 WMPoint center = getCenter(scr, 382, 230);
1286
1287                 wwin = wManageInternalWindow(scr, parent, None, _("Info"), center.x, center.y, 382, 230);
1288         }
1289
1290         WSETUFLAG(wwin, no_closable, 0);
1291         WSETUFLAG(wwin, no_close_button, 0);
1292 #ifdef XKB_BUTTON_HINT
1293         wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1294 #endif
1295         wWindowUpdateButtonImages(wwin);
1296         wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1297         wwin->frame->on_click_right = destroyInfoPanel;
1298
1299         wWindowMap(wwin);
1300
1301         panel->wwin = wwin;
1302         thePanel = panel;
1303 }
1304
1305 /*
1306  ***********************************************************************
1307  * Legal Panel
1308  ***********************************************************************
1309  */
1310
1311 typedef struct {
1312         WScreen *scr;
1313
1314         WWindow *wwin;
1315
1316         WMWindow *win;
1317
1318         WMLabel *licenseL;
1319 } LegalPanel;
1320
1321 static LegalPanel *legalPanel = NULL;
1322
1323 static void destroyLegalPanel(WCoreWindow * foo, void *data, XEvent * event)
1324 {
1325         WMUnmapWidget(legalPanel->win);
1326
1327         WMDestroyWidget(legalPanel->win);
1328
1329         wUnmanageWindow(legalPanel->wwin, False, False);
1330
1331         wfree(legalPanel);
1332
1333         legalPanel = NULL;
1334 }
1335
1336 void wShowLegalPanel(WScreen * scr)
1337 {
1338         LegalPanel *panel;
1339         Window parent;
1340         WWindow *wwin;
1341
1342         if (legalPanel) {
1343                 if (legalPanel->scr == scr) {
1344                         wRaiseFrame(legalPanel->wwin->frame->core);
1345                         wSetFocusTo(scr, legalPanel->wwin);
1346                 }
1347                 return;
1348         }
1349
1350         panel = wmalloc(sizeof(LegalPanel));
1351
1352         panel->scr = scr;
1353
1354         panel->win = WMCreateWindow(scr->wmscreen, "legal");
1355         WMResizeWidget(panel->win, 420, 250);
1356
1357         panel->licenseL = WMCreateLabel(panel->win);
1358         WMSetLabelWraps(panel->licenseL, True);
1359         WMResizeWidget(panel->licenseL, 400, 230);
1360         WMMoveWidget(panel->licenseL, 10, 10);
1361         WMSetLabelTextAlignment(panel->licenseL, WALeft);
1362         WMSetLabelText(panel->licenseL,
1363                        _("    Window Maker is free software; you can redistribute it and/or\n"
1364                          "modify it under the terms of the GNU General Public License as\n"
1365                          "published by the Free Software Foundation; either version 2 of the\n"
1366                          "License, or (at your option) any later version.\n\n"
1367                          "    Window Maker is distributed in the hope that it will be useful,\n"
1368                          "but WITHOUT ANY WARRANTY; without even the implied warranty\n"
1369                          "of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
1370                          "See the GNU General Public License for more details.\n\n"
1371                          "    You should have received a copy of the GNU General Public\n"
1372                          "License along with this program; if not, write to the Free Software\n"
1373                          "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n"
1374                          "02110-1301 USA."));
1375         WMSetLabelRelief(panel->licenseL, WRGroove);
1376
1377         WMRealizeWidget(panel->win);
1378         WMMapSubwidgets(panel->win);
1379
1380         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 420, 250, 0, 0, 0);
1381
1382         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1383
1384         {
1385                 WMPoint center = getCenter(scr, 420, 250);
1386
1387                 wwin = wManageInternalWindow(scr, parent, None, _("Legal"), center.x, center.y, 420, 250);
1388         }
1389
1390         WSETUFLAG(wwin, no_closable, 0);
1391         WSETUFLAG(wwin, no_close_button, 0);
1392         wWindowUpdateButtonImages(wwin);
1393         wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1394 #ifdef XKB_BUTTON_HINT
1395         wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1396 #endif
1397         wwin->frame->on_click_right = destroyLegalPanel;
1398
1399         panel->wwin = wwin;
1400
1401         WMMapWidget(panel->win);
1402
1403         wWindowMap(wwin);
1404
1405         legalPanel = panel;
1406 }
1407
1408 /*
1409  ***********************************************************************
1410  * Crashing Dialog Panel
1411  ***********************************************************************
1412  */
1413
1414 extern WDDomain *WDWindowAttributes;
1415
1416 typedef struct _CrashPanel {
1417         WMWindow *win;          /* main window */
1418
1419         WMLabel *iconL;         /* application icon */
1420         WMLabel *nameL;         /* title of panel */
1421
1422         WMFrame *sepF;          /* separator frame */
1423
1424         WMLabel *noteL;         /* Title of note */
1425         WMLabel *note2L;        /* body of note with what happened */
1426
1427         WMFrame *whatF;         /* "what to do next" frame */
1428         WMPopUpButton *whatP;   /* action selection popup button */
1429
1430         WMButton *okB;          /* ok button */
1431
1432         Bool done;              /* if finished with this dialog */
1433         int action;             /* what to do after */
1434
1435         KeyCode retKey;
1436
1437 } CrashPanel;
1438
1439 static void handleKeyPress(XEvent * event, void *clientData)
1440 {
1441         CrashPanel *panel = (CrashPanel *) clientData;
1442
1443         if (event->xkey.keycode == panel->retKey) {
1444                 WMPerformButtonClick(panel->okB);
1445         }
1446 }
1447
1448 static void okButtonCallback(void *self, void *clientData)
1449 {
1450         CrashPanel *panel = (CrashPanel *) clientData;
1451
1452         panel->done = True;
1453 }
1454
1455 static void setCrashAction(void *self, void *clientData)
1456 {
1457         WMPopUpButton *pop = (WMPopUpButton *) self;
1458         CrashPanel *panel = (CrashPanel *) clientData;
1459
1460         panel->action = WMGetPopUpButtonSelectedItem(pop);
1461 }
1462
1463 /* Make this read the logo from a compiled in pixmap -Dan */
1464 static WMPixmap *getWindowMakerIconImage(WMScreen *scr)
1465 {
1466         WMPixmap *pix = NULL;
1467         char *path = NULL;
1468
1469         /* Get the Logo icon, without the default icon */
1470         path = get_icon_filename(NULL, "Logo", "WMPanel", NULL, False);
1471
1472         if (path) {
1473                 RColor gray;
1474
1475                 gray.red = 0xae;
1476                 gray.green = 0xaa;
1477                 gray.blue = 0xae;
1478                 gray.alpha = 0;
1479
1480                 pix = WMCreateBlendedPixmapFromFile(scr, path, &gray);
1481                 wfree(path);
1482         }
1483
1484         return pix;
1485 }
1486
1487 #define PWIDTH  295
1488 #define PHEIGHT 345
1489
1490 int wShowCrashingDialogPanel(int whatSig)
1491 {
1492         CrashPanel *panel;
1493         WMScreen *scr;
1494         WMFont *font;
1495         WMPixmap *logo;
1496         int screen_no, scr_width, scr_height;
1497         int action;
1498         char buf[256];
1499
1500         panel = wmalloc(sizeof(CrashPanel));
1501
1502         screen_no = DefaultScreen(dpy);
1503         scr_width = WidthOfScreen(ScreenOfDisplay(dpy, screen_no));
1504         scr_height = HeightOfScreen(ScreenOfDisplay(dpy, screen_no));
1505
1506         scr = WMCreateScreen(dpy, screen_no);
1507         if (!scr) {
1508                 werror(_("cannot open connection for crashing dialog panel. Aborting."));
1509                 return WMAbort;
1510         }
1511
1512         panel->retKey = XKeysymToKeycode(dpy, XK_Return);
1513
1514         panel->win = WMCreateWindow(scr, "crashingDialog");
1515         WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1516         WMMoveWidget(panel->win, (scr_width - PWIDTH) / 2, (scr_height - PHEIGHT) / 2);
1517
1518         logo = getWindowMakerIconImage(scr);
1519         if (logo) {
1520                 panel->iconL = WMCreateLabel(panel->win);
1521                 WMResizeWidget(panel->iconL, 64, 64);
1522                 WMMoveWidget(panel->iconL, 10, 10);
1523                 WMSetLabelImagePosition(panel->iconL, WIPImageOnly);
1524                 WMSetLabelImage(panel->iconL, logo);
1525         }
1526
1527         panel->nameL = WMCreateLabel(panel->win);
1528         WMResizeWidget(panel->nameL, 200, 30);
1529         WMMoveWidget(panel->nameL, 80, 25);
1530         WMSetLabelTextAlignment(panel->nameL, WALeft);
1531         font = WMBoldSystemFontOfSize(scr, 24);
1532         WMSetLabelFont(panel->nameL, font);
1533         WMReleaseFont(font);
1534         WMSetLabelText(panel->nameL, _("Fatal error"));
1535
1536         panel->sepF = WMCreateFrame(panel->win);
1537         WMResizeWidget(panel->sepF, PWIDTH + 4, 2);
1538         WMMoveWidget(panel->sepF, -2, 80);
1539
1540         panel->noteL = WMCreateLabel(panel->win);
1541         WMResizeWidget(panel->noteL, PWIDTH - 20, 40);
1542         WMMoveWidget(panel->noteL, 10, 90);
1543         WMSetLabelTextAlignment(panel->noteL, WAJustified);
1544         snprintf(buf, sizeof(buf), _("Window Maker received signal %i."), whatSig);
1545         WMSetLabelText(panel->noteL, buf);
1546
1547         panel->note2L = WMCreateLabel(panel->win);
1548         WMResizeWidget(panel->note2L, PWIDTH - 20, 100);
1549         WMMoveWidget(panel->note2L, 10, 130);
1550         WMSetLabelTextAlignment(panel->note2L, WALeft);
1551         WMSetLabelText(panel->note2L,
1552                        _(" This fatal error occured probably due to a bug."
1553                          " Please fill the included BUGFORM and " "report it to bugs@windowmaker.info."));
1554         WMSetLabelWraps(panel->note2L, True);
1555
1556         panel->whatF = WMCreateFrame(panel->win);
1557         WMResizeWidget(panel->whatF, PWIDTH - 20, 50);
1558         WMMoveWidget(panel->whatF, 10, 240);
1559         WMSetFrameTitle(panel->whatF, _("What do you want to do now?"));
1560
1561         panel->whatP = WMCreatePopUpButton(panel->whatF);
1562         WMResizeWidget(panel->whatP, PWIDTH - 20 - 70, 20);
1563         WMMoveWidget(panel->whatP, 35, 20);
1564         WMSetPopUpButtonPullsDown(panel->whatP, False);
1565         WMSetPopUpButtonText(panel->whatP, _("Select action"));
1566         WMAddPopUpButtonItem(panel->whatP, _("Abort and leave a core file"));
1567         WMAddPopUpButtonItem(panel->whatP, _("Restart Window Maker"));
1568         WMAddPopUpButtonItem(panel->whatP, _("Start alternate window manager"));
1569         WMSetPopUpButtonAction(panel->whatP, setCrashAction, panel);
1570         WMSetPopUpButtonSelectedItem(panel->whatP, WMRestart);
1571         panel->action = WMRestart;
1572
1573         WMMapSubwidgets(panel->whatF);
1574
1575         panel->okB = WMCreateCommandButton(panel->win);
1576         WMResizeWidget(panel->okB, 80, 26);
1577         WMMoveWidget(panel->okB, 205, 309);
1578         WMSetButtonText(panel->okB, _("OK"));
1579         WMSetButtonImage(panel->okB, WMGetSystemPixmap(scr, WSIReturnArrow));
1580         WMSetButtonAltImage(panel->okB, WMGetSystemPixmap(scr, WSIHighlightedReturnArrow));
1581         WMSetButtonImagePosition(panel->okB, WIPRight);
1582         WMSetButtonAction(panel->okB, okButtonCallback, panel);
1583
1584         panel->done = 0;
1585
1586         WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask, handleKeyPress, panel);
1587
1588         WMRealizeWidget(panel->win);
1589         WMMapSubwidgets(panel->win);
1590
1591         WMMapWidget(panel->win);
1592
1593         XSetInputFocus(dpy, WMWidgetXID(panel->win), RevertToParent, CurrentTime);
1594
1595         while (!panel->done) {
1596                 XEvent event;
1597
1598                 WMNextEvent(dpy, &event);
1599                 WMHandleEvent(&event);
1600         }
1601
1602         action = panel->action;
1603
1604         WMUnmapWidget(panel->win);
1605         WMDestroyWidget(panel->win);
1606         wfree(panel);
1607
1608         return action;
1609 }