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