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