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