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         memset(panel, 0, sizeof(IconPanel));
 889
 890         panel->scr = scr;
 891
 892         panel->win = WMCreateWindow(scr->wmscreen, "iconChooser");
 893         WMResizeWidget(panel->win, 450, 280);
 894
 895         WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask | KeyReleaseMask, keyPressHandler, panel);
 896
 897         boldFont = WMBoldSystemFontOfSize(scr->wmscreen, 12);
 898         panel->normalfont = WMSystemFontOfSize(WMWidgetScreen(panel->win), 12);
 899
 900         panel->dirLabel = WMCreateLabel(panel->win);
 901         WMResizeWidget(panel->dirLabel, 200, 20);
 902         WMMoveWidget(panel->dirLabel, 10, 7);
 903         WMSetLabelText(panel->dirLabel, _("Directories"));
 904         WMSetLabelFont(panel->dirLabel, boldFont);
 905         WMSetLabelTextAlignment(panel->dirLabel, WACenter);
 906
 907         WMSetLabelRelief(panel->dirLabel, WRSunken);
 908
 909         panel->iconLabel = WMCreateLabel(panel->win);
 910         WMResizeWidget(panel->iconLabel, 140, 20);
 911         WMMoveWidget(panel->iconLabel, 215, 7);
 912         WMSetLabelText(panel->iconLabel, _("Icons"));
 913         WMSetLabelFont(panel->iconLabel, boldFont);
 914         WMSetLabelTextAlignment(panel->iconLabel, WACenter);
 915
 916         WMReleaseFont(boldFont);
 917
 918         color = WMWhiteColor(scr->wmscreen);
 919         WMSetLabelTextColor(panel->dirLabel, color);
 920         WMSetLabelTextColor(panel->iconLabel, color);
 921         WMReleaseColor(color);
 922
 923         color = WMDarkGrayColor(scr->wmscreen);
 924         WMSetWidgetBackgroundColor(panel->iconLabel, color);
 925         WMSetWidgetBackgroundColor(panel->dirLabel, color);
 926         WMReleaseColor(color);
 927
 928         WMSetLabelRelief(panel->iconLabel, WRSunken);
 929
 930         panel->dirList = WMCreateList(panel->win);
 931         WMResizeWidget(panel->dirList, 200, 170);
 932         WMMoveWidget(panel->dirList, 10, 30);
 933         WMSetListAction(panel->dirList, listCallback, panel);
 934
 935         panel->iconList = WMCreateList(panel->win);
 936         WMResizeWidget(panel->iconList, 140, 170);
 937         WMMoveWidget(panel->iconList, 215, 30);
 938         WMSetListAction(panel->iconList, listCallback, panel);
 939
 940         WMHangData(panel->iconList, panel);
 941
 942         panel->previewButton = WMCreateCommandButton(panel->win);
 943         WMResizeWidget(panel->previewButton, 75, 26);
 944         WMMoveWidget(panel->previewButton, 365, 130);
 945         WMSetButtonText(panel->previewButton, _("Preview"));
 946         WMSetButtonAction(panel->previewButton, buttonCallback, panel);
 947
 948         panel->iconView = WMCreateLabel(panel->win);
 949         WMResizeWidget(panel->iconView, 75, 75);
 950         WMMoveWidget(panel->iconView, 365, 40);
 951         WMSetLabelImagePosition(panel->iconView, WIPOverlaps);
 952         WMSetLabelRelief(panel->iconView, WRSunken);
 953         WMSetLabelTextAlignment(panel->iconView, WACenter);
 954
 955         panel->fileLabel = WMCreateLabel(panel->win);
 956         WMResizeWidget(panel->fileLabel, 80, 20);
 957         WMMoveWidget(panel->fileLabel, 10, 210);
 958         WMSetLabelText(panel->fileLabel, _("File Name:"));
 959
 960         panel->fileField = WMCreateTextField(panel->win);
 961         WMSetViewNextResponder(WMWidgetView(panel->fileField), WMWidgetView(panel->win));
 962         WMResizeWidget(panel->fileField, 345, 20);
 963         WMMoveWidget(panel->fileField, 95, 210);
 964         WMSetTextFieldEditable(panel->fileField, False);
 965
 966         panel->okButton = WMCreateCommandButton(panel->win);
 967         WMResizeWidget(panel->okButton, 80, 26);
 968         WMMoveWidget(panel->okButton, 360, 240);
 969         WMSetButtonText(panel->okButton, _("OK"));
 970         WMSetButtonEnabled(panel->okButton, False);
 971         WMSetButtonAction(panel->okButton, buttonCallback, panel);
 972
 973         panel->cancelButton = WMCreateCommandButton(panel->win);
 974         WMResizeWidget(panel->cancelButton, 80, 26);
 975         WMMoveWidget(panel->cancelButton, 270, 240);
 976         WMSetButtonText(panel->cancelButton, _("Cancel"));
 977         WMSetButtonAction(panel->cancelButton, buttonCallback, panel);
 978 #if 0
 979         panel->chooseButton = WMCreateCommandButton(panel->win);
 980         WMResizeWidget(panel->chooseButton, 110, 26);
 981         WMMoveWidget(panel->chooseButton, 150, 240);
 982         WMSetButtonText(panel->chooseButton, _("Choose File"));
 983         WMSetButtonAction(panel->chooseButton, buttonCallback, panel);
 984 #endif
 985         WMRealizeWidget(panel->win);
 986         WMMapSubwidgets(panel->win);
 987
 988         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 450, 280, 0, 0, 0);
 989
 990         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 991
 992         {
 993                 char *tmp;
 994                 int len = (instance ? strlen(instance) : 0)
 995                     + (class ? strlen(class) : 0) + 32;
 996                 WMPoint center;
 997
 998                 tmp = wmalloc(len);
 999
1000                 if (tmp && (instance || class))
1001                         snprintf(tmp, len, "%s [%s.%s]", _("Icon Chooser"), instance, class);
1002                 else
1003                         strcpy(tmp, _("Icon Chooser"));
1004
1005                 center = getCenter(scr, 450, 280);
1006
1007                 wwin = wManageInternalWindow(scr, parent, None, tmp, center.x, center.y, 450, 280);
1008                 wfree(tmp);
1009         }
1010
1011         /* put icon paths in the list */
1012         listIconPaths(panel->dirList);
1013
1014         WMMapWidget(panel->win);
1015
1016         wWindowMap(wwin);
1017
1018         while (!panel->done) {
1019                 XEvent event;
1020
1021                 WMNextEvent(dpy, &event);
1022                 WMHandleEvent(&event);
1023         }
1024
1025         if (panel->result) {
1026                 char *defaultPath, *wantedPath;
1027
1028                 /* check if the file the user selected is not the one that
1029                  * would be loaded by default with the current search path */
1030                 *file = WMGetListSelectedItem(panel->iconList)->text;
1031                 if (**file == 0) {
1032                         wfree(*file);
1033                         *file = NULL;
1034                 } else {
1035                         defaultPath = FindImage(wPreferences.icon_path, *file);
1036                         wantedPath = WMGetTextFieldText(panel->fileField);
1037                         /* if the file is not the default, use full path */
1038                         if (strcmp(wantedPath, defaultPath) != 0) {
1039                                 *file = wantedPath;
1040                         } else {
1041                                 *file = wstrdup(*file);
1042                                 wfree(wantedPath);
1043                         }
1044                         wfree(defaultPath);
1045                 }
1046         } else {
1047                 *file = NULL;
1048         }
1049
1050         result = panel->result;
1051
1052         WMReleaseFont(panel->normalfont);
1053
1054         WMUnmapWidget(panel->win);
1055
1056         WMDestroyWidget(panel->win);
1057
1058         wUnmanageWindow(wwin, False, False);
1059
1060         wfree(panel);
1061
1062         XDestroyWindow(dpy, parent);
1063
1064         return result;
1065 }
1066
1067 /*
1068  ***********************************************************************
1069  * Info Panel
1070  ***********************************************************************
1071  */
1072
1073 typedef struct {
1074         WScreen *scr;
1075         WWindow *wwin;
1076         WMWindow *win;
1077         WMLabel *logoL;
1078         WMLabel *name1L;
1079         WMFrame *lineF;
1080         WMLabel *name2L;
1081         WMLabel *versionL;
1082         WMLabel *infoL;
1083         WMLabel *copyrL;
1084 } InfoPanel;
1085
1086 #define COPYRIGHT_TEXT  \
1087     "Copyright \xc2\xa9 1997-2006 Alfredo K. Kojima\n"\
1088     "Copyright \xc2\xa9 1998-2006 Dan Pascu"
1089
1090 static InfoPanel *thePanel = NULL;
1091
1092 static void destroyInfoPanel(WCoreWindow *foo, void *data, XEvent *event)
1093 {
1094         WMUnmapWidget(thePanel);
1095         wUnmanageWindow(thePanel->wwin, False, False);
1096         WMDestroyWidget(thePanel->win);
1097         wfree(thePanel);
1098         thePanel = NULL;
1099 }
1100
1101 void wShowInfoPanel(WScreen * scr)
1102 {
1103         InfoPanel *panel;
1104         WMPixmap *logo;
1105         WMFont *font;
1106         char *strbuf = NULL;
1107         char buffer[256];
1108         char *name;
1109         Window parent;
1110         WWindow *wwin;
1111         char **strl;
1112         int i, width = 50, sepHeight;
1113         char *visuals[] = {
1114                 "StaticGray",
1115                 "GrayScale",
1116                 "StaticColor",
1117                 "PseudoColor",
1118                 "TrueColor",
1119                 "DirectColor"
1120         };
1121
1122         if (thePanel) {
1123                 if (thePanel->scr == scr) {
1124                         wRaiseFrame(thePanel->wwin->frame->core);
1125                         wSetFocusTo(scr, thePanel->wwin);
1126                 }
1127                 return;
1128         }
1129
1130         panel = wmalloc(sizeof(InfoPanel));
1131         memset(panel, 0, sizeof(InfoPanel));
1132
1133         panel->scr = scr;
1134
1135         panel->win = WMCreateWindow(scr->wmscreen, "info");
1136         WMResizeWidget(panel->win, 390, 230);
1137
1138         logo = WMCreateApplicationIconBlendedPixmap(scr->wmscreen, (RColor *) NULL);
1139         if (!logo) {
1140                 logo = WMRetainPixmap(WMGetApplicationIconPixmap(scr->wmscreen));
1141         }
1142         if (logo) {
1143                 panel->logoL = WMCreateLabel(panel->win);
1144                 WMResizeWidget(panel->logoL, 64, 64);
1145                 WMMoveWidget(panel->logoL, 30, 20);
1146                 WMSetLabelImagePosition(panel->logoL, WIPImageOnly);
1147                 WMSetLabelImage(panel->logoL, logo);
1148                 WMReleasePixmap(logo);
1149         }
1150
1151         sepHeight = 3;
1152         panel->name1L = WMCreateLabel(panel->win);
1153         WMResizeWidget(panel->name1L, 240, 30 + 2);
1154         WMMoveWidget(panel->name1L, 100, 30 - 2 - sepHeight);
1155
1156         name = "Lucida Sans,Comic Sans MS,URW Gothic L,Trebuchet MS" ":italic:pixelsize=28:antialias=true";
1157         font = WMCreateFont(scr->wmscreen, name);
1158         strbuf = "Window Maker";
1159         if (font) {
1160                 width = WMWidthOfString(font, strbuf, strlen(strbuf));
1161                 WMSetLabelFont(panel->name1L, font);
1162                 WMReleaseFont(font);
1163         }
1164         WMSetLabelTextAlignment(panel->name1L, WACenter);
1165         WMSetLabelText(panel->name1L, strbuf);
1166
1167         panel->lineF = WMCreateFrame(panel->win);
1168         WMResizeWidget(panel->lineF, width, sepHeight);
1169         WMMoveWidget(panel->lineF, 100 + (240 - width) / 2, 60 - sepHeight);
1170         WMSetFrameRelief(panel->lineF, WRSimple);
1171         WMSetWidgetBackgroundColor(panel->lineF, scr->black);
1172
1173         panel->name2L = WMCreateLabel(panel->win);
1174         WMResizeWidget(panel->name2L, 240, 24);
1175         WMMoveWidget(panel->name2L, 100, 60);
1176         name = "URW Gothic L,Nimbus Sans L:pixelsize=16:antialias=true";
1177         font = WMCreateFont(scr->wmscreen, name);
1178         if (font) {
1179                 WMSetLabelFont(panel->name2L, font);
1180                 WMReleaseFont(font);
1181                 font = NULL;
1182         }
1183         WMSetLabelTextAlignment(panel->name2L, WACenter);
1184         WMSetLabelText(panel->name2L, _("Window Manager for X"));
1185
1186         snprintf(buffer, sizeof(buffer), _("Version %s"), VERSION);
1187         panel->versionL = WMCreateLabel(panel->win);
1188         WMResizeWidget(panel->versionL, 310, 16);
1189         WMMoveWidget(panel->versionL, 30, 95);
1190         WMSetLabelTextAlignment(panel->versionL, WARight);
1191         WMSetLabelText(panel->versionL, buffer);
1192         WMSetLabelWraps(panel->versionL, False);
1193
1194         panel->copyrL = WMCreateLabel(panel->win);
1195         WMResizeWidget(panel->copyrL, 360, 40);
1196         WMMoveWidget(panel->copyrL, 15, 185);
1197         WMSetLabelTextAlignment(panel->copyrL, WALeft);
1198         WMSetLabelText(panel->copyrL, COPYRIGHT_TEXT);
1199         font = WMSystemFontOfSize(scr->wmscreen, 11);
1200         if (font) {
1201                 WMSetLabelFont(panel->copyrL, font);
1202                 WMReleaseFont(font);
1203                 font = NULL;
1204         }
1205
1206         strbuf = NULL;
1207         snprintf(buffer, sizeof(buffer), _("Using visual 0x%x: %s %ibpp "),
1208                  (unsigned)scr->w_visual->visualid, visuals[scr->w_visual->class], scr->w_depth);
1209
1210         strbuf = wstrappend(strbuf, buffer);
1211
1212         switch (scr->w_depth) {
1213         case 15:
1214                 strbuf = wstrappend(strbuf, _("(32 thousand colors)\n"));
1215                 break;
1216         case 16:
1217                 strbuf = wstrappend(strbuf, _("(64 thousand colors)\n"));
1218                 break;
1219         case 24:
1220         case 32:
1221                 strbuf = wstrappend(strbuf, _("(16 million colors)\n"));
1222                 break;
1223         default:
1224                 snprintf(buffer, sizeof(buffer), _("(%d colors)\n"), 1 << scr->w_depth);
1225                 strbuf = wstrappend(strbuf, buffer);
1226                 break;
1227         }
1228
1229 #if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO)
1230         {
1231                 struct mallinfo ma = mallinfo();
1232                 snprintf(buffer, sizeof(buffer),
1233                          _("Total memory allocated: %i kB (in use: %i kB).\n"),
1234                          (ma.arena + ma.hblkhd) / 1024, (ma.uordblks + ma.hblkhd) / 1024);
1235
1236                 strbuf = wstrappend(strbuf, buffer);
1237         }
1238 #endif
1239
1240         strbuf = wstrappend(strbuf, _("Supported image formats: "));
1241         strl = RSupportedFileFormats();
1242         for (i = 0; strl[i] != NULL; i++) {
1243                 strbuf = wstrappend(strbuf, strl[i]);
1244                 strbuf = wstrappend(strbuf, " ");
1245         }
1246
1247         strbuf = wstrappend(strbuf, _("\nAdditional support for: WMSPEC"));
1248 #ifdef MWM_HINTS
1249         strbuf = wstrappend(strbuf, " and MWM");
1250 #endif
1251
1252 #ifdef XINERAMA
1253         strbuf = wstrappend(strbuf, _("\n"));
1254 #ifdef SOLARIS_XINERAMA
1255         strbuf = wstrappend(strbuf, _("Solaris "));
1256 #endif
1257         strbuf = wstrappend(strbuf, _("Xinerama: "));
1258         {
1259                 char tmp[128];
1260                 snprintf(tmp, sizeof(tmp) - 1, "%d heads found.", scr->xine_info.count);
1261                 strbuf = wstrappend(strbuf, tmp);
1262         }
1263 #endif
1264
1265         panel->infoL = WMCreateLabel(panel->win);
1266         WMResizeWidget(panel->infoL, 350, 75);
1267         WMMoveWidget(panel->infoL, 15, 115);
1268         WMSetLabelText(panel->infoL, strbuf);
1269         font = WMSystemFontOfSize(scr->wmscreen, 11);
1270         if (font) {
1271                 WMSetLabelFont(panel->infoL, font);
1272                 WMReleaseFont(font);
1273                 font = NULL;
1274         }
1275         wfree(strbuf);
1276
1277         WMRealizeWidget(panel->win);
1278         WMMapSubwidgets(panel->win);
1279
1280         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 382, 230, 0, 0, 0);
1281
1282         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1283
1284         WMMapWidget(panel->win);
1285
1286         {
1287                 WMPoint center = getCenter(scr, 382, 230);
1288
1289                 wwin = wManageInternalWindow(scr, parent, None, _("Info"), center.x, center.y, 382, 230);
1290         }
1291
1292         WSETUFLAG(wwin, no_closable, 0);
1293         WSETUFLAG(wwin, no_close_button, 0);
1294 #ifdef XKB_BUTTON_HINT
1295         wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1296 #endif
1297         wWindowUpdateButtonImages(wwin);
1298         wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1299         wwin->frame->on_click_right = destroyInfoPanel;
1300
1301         wWindowMap(wwin);
1302
1303         panel->wwin = wwin;
1304         thePanel = panel;
1305 }
1306
1307 /*
1308  ***********************************************************************
1309  * Legal Panel
1310  ***********************************************************************
1311  */
1312
1313 typedef struct {
1314         WScreen *scr;
1315
1316         WWindow *wwin;
1317
1318         WMWindow *win;
1319
1320         WMLabel *licenseL;
1321 } LegalPanel;
1322
1323 static LegalPanel *legalPanel = NULL;
1324
1325 static void destroyLegalPanel(WCoreWindow * foo, void *data, XEvent * event)
1326 {
1327         WMUnmapWidget(legalPanel->win);
1328
1329         WMDestroyWidget(legalPanel->win);
1330
1331         wUnmanageWindow(legalPanel->wwin, False, False);
1332
1333         wfree(legalPanel);
1334
1335         legalPanel = NULL;
1336 }
1337
1338 void wShowLegalPanel(WScreen * scr)
1339 {
1340         LegalPanel *panel;
1341         Window parent;
1342         WWindow *wwin;
1343
1344         if (legalPanel) {
1345                 if (legalPanel->scr == scr) {
1346                         wRaiseFrame(legalPanel->wwin->frame->core);
1347                         wSetFocusTo(scr, legalPanel->wwin);
1348                 }
1349                 return;
1350         }
1351
1352         panel = wmalloc(sizeof(LegalPanel));
1353
1354         panel->scr = scr;
1355
1356         panel->win = WMCreateWindow(scr->wmscreen, "legal");
1357         WMResizeWidget(panel->win, 420, 250);
1358
1359         panel->licenseL = WMCreateLabel(panel->win);
1360         WMSetLabelWraps(panel->licenseL, True);
1361         WMResizeWidget(panel->licenseL, 400, 230);
1362         WMMoveWidget(panel->licenseL, 10, 10);
1363         WMSetLabelTextAlignment(panel->licenseL, WALeft);
1364         WMSetLabelText(panel->licenseL,
1365                        _("    Window Maker is free software; you can redistribute it and/or\n"
1366                          "modify it under the terms of the GNU General Public License as\n"
1367                          "published by the Free Software Foundation; either version 2 of the\n"
1368                          "License, or (at your option) any later version.\n\n"
1369                          "    Window Maker is distributed in the hope that it will be useful,\n"
1370                          "but WITHOUT ANY WARRANTY; without even the implied warranty\n"
1371                          "of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
1372                          "See the GNU General Public License for more details.\n\n"
1373                          "    You should have received a copy of the GNU General Public\n"
1374                          "License along with this program; if not, write to the Free Software\n"
1375                          "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n"
1376                          "02110-1301 USA."));
1377         WMSetLabelRelief(panel->licenseL, WRGroove);
1378
1379         WMRealizeWidget(panel->win);
1380         WMMapSubwidgets(panel->win);
1381
1382         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 420, 250, 0, 0, 0);
1383
1384         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1385
1386         {
1387                 WMPoint center = getCenter(scr, 420, 250);
1388
1389                 wwin = wManageInternalWindow(scr, parent, None, _("Legal"), center.x, center.y, 420, 250);
1390         }
1391
1392         WSETUFLAG(wwin, no_closable, 0);
1393         WSETUFLAG(wwin, no_close_button, 0);
1394         wWindowUpdateButtonImages(wwin);
1395         wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1396 #ifdef XKB_BUTTON_HINT
1397         wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1398 #endif
1399         wwin->frame->on_click_right = destroyLegalPanel;
1400
1401         panel->wwin = wwin;
1402
1403         WMMapWidget(panel->win);
1404
1405         wWindowMap(wwin);
1406
1407         legalPanel = panel;
1408 }
1409
1410 /*
1411  ***********************************************************************
1412  * Crashing Dialog Panel
1413  ***********************************************************************
1414  */
1415
1416 extern WDDomain *WDWindowAttributes;
1417
1418 typedef struct _CrashPanel {
1419         WMWindow *win;          /* main window */
1420
1421         WMLabel *iconL;         /* application icon */
1422         WMLabel *nameL;         /* title of panel */
1423
1424         WMFrame *sepF;          /* separator frame */
1425
1426         WMLabel *noteL;         /* Title of note */
1427         WMLabel *note2L;        /* body of note with what happened */
1428
1429         WMFrame *whatF;         /* "what to do next" frame */
1430         WMPopUpButton *whatP;   /* action selection popup button */
1431
1432         WMButton *okB;          /* ok button */
1433
1434         Bool done;              /* if finished with this dialog */
1435         int action;             /* what to do after */
1436
1437         KeyCode retKey;
1438
1439 } CrashPanel;
1440
1441 static void handleKeyPress(XEvent * event, void *clientData)
1442 {
1443         CrashPanel *panel = (CrashPanel *) clientData;
1444
1445         if (event->xkey.keycode == panel->retKey) {
1446                 WMPerformButtonClick(panel->okB);
1447         }
1448 }
1449
1450 static void okButtonCallback(void *self, void *clientData)
1451 {
1452         CrashPanel *panel = (CrashPanel *) clientData;
1453
1454         panel->done = True;
1455 }
1456
1457 static void setCrashAction(void *self, void *clientData)
1458 {
1459         WMPopUpButton *pop = (WMPopUpButton *) self;
1460         CrashPanel *panel = (CrashPanel *) clientData;
1461
1462         panel->action = WMGetPopUpButtonSelectedItem(pop);
1463 }
1464
1465 /* Make this read the logo from a compiled in pixmap -Dan */
1466 static WMPixmap *getWindowMakerIconImage(WMScreen * scr)
1467 {
1468         WMPropList *dict, *key, *option, *value = NULL;
1469         WMPixmap *pix = NULL;
1470         char *path;
1471
1472         if (!WDWindowAttributes || !WDWindowAttributes->dictionary)
1473                 return NULL;
1474
1475         WMPLSetCaseSensitive(True);
1476
1477         key = WMCreatePLString("Logo.WMPanel");
1478         option = WMCreatePLString("Icon");
1479
1480         dict = WMGetFromPLDictionary(WDWindowAttributes->dictionary, key);
1481
1482         if (dict) {
1483                 value = WMGetFromPLDictionary(dict, option);
1484         }
1485
1486         WMReleasePropList(key);
1487         WMReleasePropList(option);
1488
1489         WMPLSetCaseSensitive(False);
1490
1491         if (value && WMIsPLString(value)) {
1492                 path = FindImage(wPreferences.icon_path, WMGetFromPLString(value));
1493
1494                 if (path) {
1495                         RColor gray;
1496
1497                         gray.red = 0xae;
1498                         gray.green = 0xaa;
1499                         gray.blue = 0xae;
1500                         gray.alpha = 0;
1501
1502                         pix = WMCreateBlendedPixmapFromFile(scr, path, &gray);
1503                         wfree(path);
1504                 }
1505         }
1506
1507         return pix;
1508 }
1509
1510 #define PWIDTH  295
1511 #define PHEIGHT 345
1512
1513 int wShowCrashingDialogPanel(int whatSig)
1514 {
1515         CrashPanel *panel;
1516         WMScreen *scr;
1517         WMFont *font;
1518         WMPixmap *logo;
1519         int screen_no, scr_width, scr_height;
1520         int action;
1521         char buf[256];
1522
1523         panel = wmalloc(sizeof(CrashPanel));
1524         memset(panel, 0, sizeof(CrashPanel));
1525
1526         screen_no = DefaultScreen(dpy);
1527         scr_width = WidthOfScreen(ScreenOfDisplay(dpy, screen_no));
1528         scr_height = HeightOfScreen(ScreenOfDisplay(dpy, screen_no));
1529
1530         scr = WMCreateScreen(dpy, screen_no);
1531         if (!scr) {
1532                 werror(_("cannot open connection for crashing dialog panel. Aborting."));
1533                 return WMAbort;
1534         }
1535
1536         panel->retKey = XKeysymToKeycode(dpy, XK_Return);
1537
1538         panel->win = WMCreateWindow(scr, "crashingDialog");
1539         WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1540         WMMoveWidget(panel->win, (scr_width - PWIDTH) / 2, (scr_height - PHEIGHT) / 2);
1541
1542         logo = getWindowMakerIconImage(scr);
1543         if (logo) {
1544                 panel->iconL = WMCreateLabel(panel->win);
1545                 WMResizeWidget(panel->iconL, 64, 64);
1546                 WMMoveWidget(panel->iconL, 10, 10);
1547                 WMSetLabelImagePosition(panel->iconL, WIPImageOnly);
1548                 WMSetLabelImage(panel->iconL, logo);
1549         }
1550
1551         panel->nameL = WMCreateLabel(panel->win);
1552         WMResizeWidget(panel->nameL, 200, 30);
1553         WMMoveWidget(panel->nameL, 80, 25);
1554         WMSetLabelTextAlignment(panel->nameL, WALeft);
1555         font = WMBoldSystemFontOfSize(scr, 24);
1556         WMSetLabelFont(panel->nameL, font);
1557         WMReleaseFont(font);
1558         WMSetLabelText(panel->nameL, _("Fatal error"));
1559
1560         panel->sepF = WMCreateFrame(panel->win);
1561         WMResizeWidget(panel->sepF, PWIDTH + 4, 2);
1562         WMMoveWidget(panel->sepF, -2, 80);
1563
1564         panel->noteL = WMCreateLabel(panel->win);
1565         WMResizeWidget(panel->noteL, PWIDTH - 20, 40);
1566         WMMoveWidget(panel->noteL, 10, 90);
1567         WMSetLabelTextAlignment(panel->noteL, WAJustified);
1568         snprintf(buf, sizeof(buf), _("Window Maker received signal %i."), whatSig);
1569         WMSetLabelText(panel->noteL, buf);
1570
1571         panel->note2L = WMCreateLabel(panel->win);
1572         WMResizeWidget(panel->note2L, PWIDTH - 20, 100);
1573         WMMoveWidget(panel->note2L, 10, 130);
1574         WMSetLabelTextAlignment(panel->note2L, WALeft);
1575         WMSetLabelText(panel->note2L,
1576                        _(" This fatal error occured probably due to a bug."
1577                          " Please fill the included BUGFORM and " "report it to bugs@windowmaker.info."));
1578         WMSetLabelWraps(panel->note2L, True);
1579
1580         panel->whatF = WMCreateFrame(panel->win);
1581         WMResizeWidget(panel->whatF, PWIDTH - 20, 50);
1582         WMMoveWidget(panel->whatF, 10, 240);
1583         WMSetFrameTitle(panel->whatF, _("What do you want to do now?"));
1584
1585         panel->whatP = WMCreatePopUpButton(panel->whatF);
1586         WMResizeWidget(panel->whatP, PWIDTH - 20 - 70, 20);
1587         WMMoveWidget(panel->whatP, 35, 20);
1588         WMSetPopUpButtonPullsDown(panel->whatP, False);
1589         WMSetPopUpButtonText(panel->whatP, _("Select action"));
1590         WMAddPopUpButtonItem(panel->whatP, _("Abort and leave a core file"));
1591         WMAddPopUpButtonItem(panel->whatP, _("Restart Window Maker"));
1592         WMAddPopUpButtonItem(panel->whatP, _("Start alternate window manager"));
1593         WMSetPopUpButtonAction(panel->whatP, setCrashAction, panel);
1594         WMSetPopUpButtonSelectedItem(panel->whatP, WMRestart);
1595         panel->action = WMRestart;
1596
1597         WMMapSubwidgets(panel->whatF);
1598
1599         panel->okB = WMCreateCommandButton(panel->win);
1600         WMResizeWidget(panel->okB, 80, 26);
1601         WMMoveWidget(panel->okB, 205, 309);
1602         WMSetButtonText(panel->okB, _("OK"));
1603         WMSetButtonImage(panel->okB, WMGetSystemPixmap(scr, WSIReturnArrow));
1604         WMSetButtonAltImage(panel->okB, WMGetSystemPixmap(scr, WSIHighlightedReturnArrow));
1605         WMSetButtonImagePosition(panel->okB, WIPRight);
1606         WMSetButtonAction(panel->okB, okButtonCallback, panel);
1607
1608         panel->done = 0;
1609
1610         WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask, handleKeyPress, panel);
1611
1612         WMRealizeWidget(panel->win);
1613         WMMapSubwidgets(panel->win);
1614
1615         WMMapWidget(panel->win);
1616
1617         XSetInputFocus(dpy, WMWidgetXID(panel->win), RevertToParent, CurrentTime);
1618
1619         while (!panel->done) {
1620                 XEvent event;
1621
1622                 WMNextEvent(dpy, &event);
1623                 WMHandleEvent(&event);
1624         }
1625
1626         action = panel->action;
1627
1628         WMUnmapWidget(panel->win);
1629         WMDestroyWidget(panel->win);
1630         wfree(panel);
1631
1632         return action;
1633 }
1634
1635 /*****************************************************************************
1636  *                      About GNUstep Panel
1637  *****************************************************************************/
1638
1639 static void
1640 drawGNUstepLogo(Display * dpy, Drawable d, int width, int height,
1641                 unsigned long blackPixel, unsigned long whitePixel)
1642 {
1643         GC gc;
1644         XGCValues gcv;
1645         XRectangle rects[3];
1646
1647         gcv.foreground = blackPixel;
1648         gc = XCreateGC(dpy, d, GCForeground, &gcv);
1649
1650         XFillArc(dpy, d, gc, width / 45, height / 45,
1651                  width - 2 * width / 45, height - 2 * height / 45, 0, 360 * 64);
1652
1653         rects[0].x = 0;
1654         rects[0].y = 37 * height / 45;
1655         rects[0].width = width / 3;
1656         rects[0].height = height - rects[0].y;
1657
1658         rects[1].x = rects[0].width;
1659         rects[1].y = height / 2;
1660         rects[1].width = width - 2 * width / 3;
1661         rects[1].height = height - rects[1].y;
1662
1663         rects[2].x = 2 * width / 3;
1664         rects[2].y = height - 37 * height / 45;
1665         rects[2].width = width / 3;
1666         rects[2].height = height - rects[2].y;
1667
1668         XSetClipRectangles(dpy, gc, 0, 0, rects, 3, Unsorted);
1669         XFillRectangle(dpy, d, gc, 0, 0, width, height);
1670
1671         XSetForeground(dpy, gc, whitePixel);
1672         XFillArc(dpy, d, gc, width / 45, height / 45,
1673                  width - 2 * width / 45, height - 2 * height / 45, 0, 360 * 64);
1674
1675         XFreeGC(dpy, gc);
1676 }
1677
1678 typedef struct {
1679         WScreen *scr;
1680
1681         WWindow *wwin;
1682
1683         WMWindow *win;
1684
1685         WMLabel *gstepL;
1686         WMLabel *textL;
1687 } GNUstepPanel;
1688
1689 static GNUstepPanel *gnustepPanel = NULL;
1690
1691 static void destroyGNUstepPanel(WCoreWindow * foo, void *data, XEvent * event)
1692 {
1693         WMUnmapWidget(gnustepPanel->win);
1694
1695         WMDestroyWidget(gnustepPanel->win);
1696
1697         wUnmanageWindow(gnustepPanel->wwin, False, False);
1698
1699         wfree(gnustepPanel);
1700
1701         gnustepPanel = NULL;
1702 }
1703
1704 void wShowGNUstepPanel(WScreen * scr)
1705 {
1706         GNUstepPanel *panel;
1707         Window parent;
1708         WWindow *wwin;
1709         WMPixmap *pixmap;
1710         WMColor *color;
1711
1712         if (gnustepPanel) {
1713                 if (gnustepPanel->scr == scr) {
1714                         wRaiseFrame(gnustepPanel->wwin->frame->core);
1715                         wSetFocusTo(scr, gnustepPanel->wwin);
1716                 }
1717                 return;
1718         }
1719
1720         panel = wmalloc(sizeof(GNUstepPanel));
1721
1722         panel->scr = scr;
1723
1724         panel->win = WMCreateWindow(scr->wmscreen, "About GNUstep");
1725         WMResizeWidget(panel->win, 325, 205);
1726
1727         pixmap = WMCreatePixmap(scr->wmscreen, 130, 130, WMScreenDepth(scr->wmscreen), True);
1728
1729         color = WMCreateNamedColor(scr->wmscreen, "gray50", True);
1730
1731         drawGNUstepLogo(dpy, WMGetPixmapXID(pixmap), 130, 130, WMColorPixel(color), scr->white_pixel);
1732
1733         WMReleaseColor(color);
1734
1735         XSetForeground(dpy, scr->mono_gc, 0);
1736         XFillRectangle(dpy, WMGetPixmapMaskXID(pixmap), scr->mono_gc, 0, 0, 130, 130);
1737         drawGNUstepLogo(dpy, WMGetPixmapMaskXID(pixmap), 130, 130, 1, 1);
1738
1739         panel->gstepL = WMCreateLabel(panel->win);
1740         WMResizeWidget(panel->gstepL, 285, 64);
1741         WMMoveWidget(panel->gstepL, 20, 0);
1742         WMSetLabelTextAlignment(panel->gstepL, WARight);
1743         WMSetLabelText(panel->gstepL, "GNUstep");
1744         {
1745                 WMFont *font = WMBoldSystemFontOfSize(scr->wmscreen, 24);
1746
1747                 WMSetLabelFont(panel->gstepL, font);
1748                 WMReleaseFont(font);
1749         }
1750
1751         panel->textL = WMCreateLabel(panel->win);
1752         WMResizeWidget(panel->textL, 305, 140);
1753         WMMoveWidget(panel->textL, 10, 50);
1754         WMSetLabelTextAlignment(panel->textL, WARight);
1755         WMSetLabelImagePosition(panel->textL, WIPOverlaps);
1756         WMSetLabelText(panel->textL,
1757                        _("Window Maker is part of the GNUstep project.\n"
1758                          "The GNUstep project aims to create a free\n"
1759                          "implementation of the OpenStep(tm) specification\n"
1760                          "which is a object-oriented framework for\n"
1761                          "creating advanced graphical, multi-platform\n"
1762                          "applications. Additionally, a development and\n"
1763                          "user desktop environment will be created on top\n"
1764                          "of the framework. For more information about\n"
1765                          "GNUstep, please visit: www.gnustep.org"));
1766         WMSetLabelImage(panel->textL, pixmap);
1767
1768         WMReleasePixmap(pixmap);
1769
1770         WMRealizeWidget(panel->win);
1771         WMMapSubwidgets(panel->win);
1772
1773         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, 325, 200, 0, 0, 0);
1774
1775         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1776
1777         {
1778                 WMPoint center = getCenter(scr, 325, 200);
1779
1780                 wwin = wManageInternalWindow(scr, parent, None, _("About GNUstep"), center.x, center.y, 325, 200);
1781         }
1782
1783         WSETUFLAG(wwin, no_closable, 0);
1784         WSETUFLAG(wwin, no_close_button, 0);
1785         wWindowUpdateButtonImages(wwin);
1786         wFrameWindowShowButton(wwin->frame, WFF_RIGHT_BUTTON);
1787 #ifdef XKB_BUTTON_HINT
1788         wFrameWindowHideButton(wwin->frame, WFF_LANGUAGE_BUTTON);
1789 #endif
1790         wwin->frame->on_click_right = destroyGNUstepPanel;
1791
1792         panel->wwin = wwin;
1793
1794         WMMapWidget(panel->win);
1795
1796         wWindowMap(wwin);
1797
1798         gnustepPanel = panel;
1799 }