?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

b671087cac8d8ba2892e3c44035be0920a1eb535
[wmaker-crm.git] / src / winspector.c
blobb671087cac8d8ba2892e3c44035be0920a1eb535
1 /* winspector.c - window attribute inspector
2 *
3 * Window Maker window manager
4 *
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
6 * Copyright (c) 1998-2003 Dan Pascu
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 #include "wconfig.h"
24
25 #include <X11/Xlib.h>
26 #include <X11/Xutil.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <strings.h>
31
32 #include "WindowMaker.h"
33 #include "screen.h"
34 #include "wcore.h"
35 #include "framewin.h"
36 #include "window.h"
37 #include "workspace.h"
38 #include "funcs.h"
39 #include "defaults.h"
40 #include "dialog.h"
41 #include "icon.h"
42 #include "stacking.h"
43 #include "application.h"
44 #include "appicon.h"
45 #include "actions.h"
46 #include "winspector.h"
47 #include "dock.h"
48 #include "client.h"
49 #include "wmspec.h"
50
51 #include <WINGs/WUtil.h>
52
53 typedef struct InspectorPanel {
54 struct InspectorPanel *nextPtr;
55
56 WWindow *frame;
57
58 WWindow *inspected; /* the window that's being inspected */
59
60 WMWindow *win;
61
62 Window parent;
63
64 /* common stuff */
65 WMButton *revertBtn;
66 WMButton *applyBtn;
67 WMButton *saveBtn;
68
69 WMPopUpButton *pagePopUp;
70
71 /* first page. general stuff */
72
73 WMFrame *specFrm;
74 WMButton *instRb;
75 WMButton *clsRb;
76 WMButton *bothRb;
77 WMButton *defaultRb;
78
79 WMButton *selWinB;
80
81 WMLabel *specLbl;
82
83 /* second page. attributes */
84
85 WMFrame *attrFrm;
86 WMButton *attrChk[11];
87
88 /* 3rd page. more attributes */
89 WMFrame *moreFrm;
90 #ifdef XKB_BUTTON_HINT
91 WMButton *moreChk[12];
92 #else
93 WMButton *moreChk[11];
94 #endif
95
96 /* 4th page. icon and workspace */
97 WMFrame *iconFrm;
98 WMLabel *iconLbl;
99 WMLabel *fileLbl;
100 WMTextField *fileText;
101 WMButton *alwChk;
102 /*
103 WMButton *updateIconBtn;
104 */
105 WMButton *browseIconBtn;
106
107 WMFrame *wsFrm;
108 WMPopUpButton *wsP;
109
110 /* 5th page. application wide attributes */
111 WMFrame *appFrm;
112 WMButton *appChk[3];
113
114 unsigned int done:1;
115 unsigned int destroyed:1;
116 unsigned int choosingIcon:1;
117 } InspectorPanel;
118
119 extern Cursor wCursor[WCUR_LAST];
120 extern WDDomain *WDWindowAttributes;
121 extern WPreferences wPreferences;
122
123 static InspectorPanel *panelList = NULL;
124 static WMPropList *ANoTitlebar = NULL;
125 static WMPropList *ANoResizebar;
126 static WMPropList *ANoMiniaturizeButton;
127 static WMPropList *ANoCloseButton;
128 static WMPropList *ANoBorder;
129 static WMPropList *ANoHideOthers;
130 static WMPropList *ANoMouseBindings;
131 static WMPropList *ANoKeyBindings;
132 static WMPropList *ANoAppIcon;
133 static WMPropList *AKeepOnTop;
134 static WMPropList *AKeepOnBottom;
135 static WMPropList *AOmnipresent;
136 static WMPropList *ASkipWindowList;
137 static WMPropList *ASkipSwitchPanel;
138 static WMPropList *AKeepInsideScreen;
139 static WMPropList *AUnfocusable;
140 static WMPropList *AFocusAcrossWorkspace;
141 static WMPropList *AAlwaysUserIcon;
142 static WMPropList *AStartMiniaturized;
143 static WMPropList *AStartMaximized;
144 static WMPropList *ADontSaveSession;
145 static WMPropList *AEmulateAppIcon;
146 static WMPropList *AFullMaximize;
147 static WMPropList *ASharedAppIcon;
148 static WMPropList *ANoMiniaturizable;
149 #ifdef XKB_BUTTON_HINT
150 static WMPropList *ANoLanguageButton;
151 #endif
152 static WMPropList *AStartWorkspace;
153 static WMPropList *AIcon;
154
155 /* application wide options */
156 static WMPropList *AStartHidden;
157 static WMPropList *AnyWindow;
158 static WMPropList *EmptyString;
159 static WMPropList *Yes, *No;
160
161 #define PWIDTH 290
162 #define PHEIGHT 360
163
164 static char *spec_text;
165 static void applySettings(WMButton *button, InspectorPanel *panel);
166
167 #define UNDEFINED_POS 0xffffff
168
169 static InspectorPanel *createInspectorForWindow(WWindow *wwin, int xpos, int ypos, Bool showSelectPanel);
170
171 static void make_keys(void)
172 {
173 if (ANoTitlebar != NULL)
174 return;
175
176 AIcon = WMCreatePLString("Icon");
177 ANoTitlebar = WMCreatePLString("NoTitlebar");
178 ANoResizebar = WMCreatePLString("NoResizebar");
179 ANoMiniaturizeButton = WMCreatePLString("NoMiniaturizeButton");
180 ANoCloseButton = WMCreatePLString("NoCloseButton");
181 ANoBorder = WMCreatePLString("NoBorder");
182 ANoHideOthers = WMCreatePLString("NoHideOthers");
183 ANoMouseBindings = WMCreatePLString("NoMouseBindings");
184 ANoKeyBindings = WMCreatePLString("NoKeyBindings");
185 ANoAppIcon = WMCreatePLString("NoAppIcon");
186 AKeepOnTop = WMCreatePLString("KeepOnTop");
187 AKeepOnBottom = WMCreatePLString("KeepOnBottom");
188 AOmnipresent = WMCreatePLString("Omnipresent");
189 ASkipWindowList = WMCreatePLString("SkipWindowList");
190 ASkipSwitchPanel = WMCreatePLString("SkipSwitchPanel");
191 AKeepInsideScreen = WMCreatePLString("KeepInsideScreen");
192 AUnfocusable = WMCreatePLString("Unfocusable");
193 AFocusAcrossWorkspace = WMCreatePLString("FocusAcrossWorkspace");
194 AAlwaysUserIcon = WMCreatePLString("AlwaysUserIcon");
195 AStartMiniaturized = WMCreatePLString("StartMiniaturized");
196 AStartMaximized = WMCreatePLString("StartMaximized");
197 AStartHidden = WMCreatePLString("StartHidden");
198 ADontSaveSession = WMCreatePLString("DontSaveSession");
199 AEmulateAppIcon = WMCreatePLString("EmulateAppIcon");
200 AFullMaximize = WMCreatePLString("FullMaximize");
201 ASharedAppIcon = WMCreatePLString("SharedAppIcon");
202 ANoMiniaturizable = WMCreatePLString("NoMiniaturizable");
203 #ifdef XKB_BUTTON_HINT
204 ANoLanguageButton = WMCreatePLString("NoLanguageButton");
205 #endif
206
207 AStartWorkspace = WMCreatePLString("StartWorkspace");
208
209 AnyWindow = WMCreatePLString("*");
210 EmptyString = WMCreatePLString("");
211 Yes = WMCreatePLString("Yes");
212 No = WMCreatePLString("No");
213 }
214
215 static void freeInspector(InspectorPanel *panel)
216 {
217 panel->destroyed = 1;
218
219 if (panel->choosingIcon)
220 return;
221
222 WMDestroyWidget(panel->win);
223 XDestroyWindow(dpy, panel->parent);
224 wfree(panel);
225 }
226
227 static void destroyInspector(WCoreWindow *foo, void *data, XEvent *event)
228 {
229 InspectorPanel *panel;
230 InspectorPanel *tmp;
231
232 panel = panelList;
233 while (panel->frame != data)
234 panel = panel->nextPtr;
235
236 if (panelList == panel)
237 panelList = panel->nextPtr;
238 else {
239 tmp = panelList;
240 while (tmp->nextPtr != panel) {
241 tmp = tmp->nextPtr;
242 }
243 tmp->nextPtr = panel->nextPtr;
244 }
245 panel->inspected->flags.inspector_open = 0;
246 panel->inspected->inspector = NULL;
247
248 WMRemoveNotificationObserver(panel);
249
250 wWindowUnmap(panel->frame);
251 wUnmanageWindow(panel->frame, True, False);
252
253 freeInspector(panel);
254 }
255
256 void wDestroyInspectorPanels(void)
257 {
258 InspectorPanel *panel;
259
260 while (panelList != NULL) {
261 panel = panelList;
262 panelList = panelList->nextPtr;
263 wUnmanageWindow(panel->frame, False, False);
264 WMDestroyWidget(panel->win);
265
266 panel->inspected->flags.inspector_open = 0;
267 panel->inspected->inspector = NULL;
268
269 wfree(panel);
270 }
271 }
272
273 static void changePage(WMPopUpButton *bPtr, InspectorPanel *panel)
274 {
275 int page;
276
277 page = WMGetPopUpButtonSelectedItem(bPtr);
278
279 if (page == 0) {
280 WMMapWidget(panel->specFrm);
281 WMMapWidget(panel->specLbl);
282 } else if (page == 1) {
283 WMMapWidget(panel->attrFrm);
284 } else if (page == 2) {
285 WMMapWidget(panel->moreFrm);
286 } else if (page == 3) {
287 WMMapWidget(panel->iconFrm);
288 WMMapWidget(panel->wsFrm);
289 } else {
290 WMMapWidget(panel->appFrm);
291 }
292
293 if (page != 0) {
294 WMUnmapWidget(panel->specFrm);
295 WMUnmapWidget(panel->specLbl);
296 }
297 if (page != 1)
298 WMUnmapWidget(panel->attrFrm);
299 if (page != 2)
300 WMUnmapWidget(panel->moreFrm);
301 if (page != 3) {
302 WMUnmapWidget(panel->iconFrm);
303 WMUnmapWidget(panel->wsFrm);
304 }
305 if (page != 4 && panel->appFrm)
306 WMUnmapWidget(panel->appFrm);
307 }
308
309 #define USE_TEXT_FIELD 1
310 #define UPDATE_TEXT_FIELD 2
311 #define REVERT_TO_DEFAULT 4
312
313 static int showIconFor(WMScreen *scrPtr, InspectorPanel *panel, char *wm_instance, char *wm_class, int flags)
314 {
315 WMPixmap *pixmap = (WMPixmap *) NULL;
316 char *file = NULL, *path = NULL;
317 char *db_icon = NULL;
318
319 if ((flags & USE_TEXT_FIELD) != 0) {
320 file = WMGetTextFieldText(panel->fileText);
321 if (file && file[0] == 0) {
322 wfree(file);
323 file = NULL;
324 }
325 } else {
326 db_icon = wDefaultGetIconFile(wm_instance, wm_class, False);
327 if (db_icon != NULL)
328 file = wstrdup(db_icon);
329 }
330 if (db_icon != NULL && (flags & REVERT_TO_DEFAULT) != 0) {
331 if (file)
332 file = wstrdup(db_icon);
333 flags |= UPDATE_TEXT_FIELD;
334 }
335
336 if ((flags & UPDATE_TEXT_FIELD) != 0) {
337 WMSetTextFieldText(panel->fileText, file);
338 }
339
340 if (file) {
341 path = FindImage(wPreferences.icon_path, file);
342
343 if (!path) {
344 char *buf;
345 int len = strlen(file) + 80;
346
347 buf = wmalloc(len);
348 snprintf(buf, len, _("Could not find icon \"%s\" specified for this window"), file);
349 wMessageDialog(panel->frame->screen_ptr, _("Error"), buf, _("OK"), NULL, NULL);
350 wfree(buf);
351 wfree(file);
352 return -1;
353 }
354
355 pixmap = WMCreatePixmapFromFile(scrPtr, path);
356 wfree(path);
357
358 if (!pixmap) {
359 char *buf;
360 int len = strlen(file) + 80;
361
362 buf = wmalloc(len);
363 snprintf(buf, len, _("Could not open specified icon \"%s\":%s"),
364 file, RMessageForError(RErrorCode));
365 wMessageDialog(panel->frame->screen_ptr, _("Error"), buf, _("OK"), NULL, NULL);
366 wfree(buf);
367 wfree(file);
368 return -1;
369 }
370 wfree(file);
371 }
372
373 WMSetLabelImage(panel->iconLbl, pixmap);
374 if (pixmap)
375 WMReleasePixmap(pixmap);
376
377 return 0;
378 }
379
380 #if 0
381 static void updateIcon(WMButton * button, InspectorPanel * panel)
382 {
383 showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD);
384 }
385 #endif
386
387 static int getBool(WMPropList *value)
388 {
389 char *val;
390
391 if (!WMIsPLString(value)) {
392 return 0;
393 }
394 if (!(val = WMGetFromPLString(value))) {
395 return 0;
396 }
397
398 if ((val[1] == '\0' && (val[0] == 'y' || val[0] == 'Y' || val[0] == 'T' || val[0] == 't' || val[0] == '1'))
399 || (strcasecmp(val, "YES") == 0 || strcasecmp(val, "TRUE") == 0)) {
400
401 return 1;
402 } else if ((val[1] == '\0'
403 && (val[0] == 'n' || val[0] == 'N' || val[0] == 'F' || val[0] == 'f' || val[0] == '0'))
404 || (strcasecmp(val, "NO") == 0 || strcasecmp(val, "FALSE") == 0)) {
405
406 return 0;
407 } else {
408 wwarning(_("can't convert \"%s\" to boolean"), val);
409 return 0;
410 }
411 }
412
413 #define UPDATE_DEFAULTS 1
414 #define IS_BOOLEAN 2
415
416 /*
417 * Will insert the attribute = value; pair in window's list,
418 * if it's different from the defaults.
419 * Defaults means either defaults database, or attributes saved
420 * for the default window "*". This is to let one revert options that are
421 * global because they were saved for all windows ("*").
422 *
423 */
424
425 static int
426 insertAttribute(WMPropList *dict, WMPropList *window, WMPropList *attr, WMPropList *value, int flags)
427 {
428 WMPropList *def_win, *def_value = NULL;
429 int update = 0;
430 int modified = 0;
431
432 if (!(flags & UPDATE_DEFAULTS) && dict) {
433 if ((def_win = WMGetFromPLDictionary(dict, AnyWindow)) != NULL) {
434 def_value = WMGetFromPLDictionary(def_win, attr);
435 }
436 }
437
438 /* If we could not find defaults in database, fall to hardcoded values.
439 * Also this is true if we save defaults for all windows
440 */
441 if (!def_value)
442 def_value = ((flags & IS_BOOLEAN) != 0) ? No : EmptyString;
443
444 if ((flags & IS_BOOLEAN))
445 update = (getBool(value) != getBool(def_value));
446 else {
447 update = !WMIsPropListEqualTo(value, def_value);
448 }
449
450 if (update) {
451 WMPutInPLDictionary(window, attr, value);
452 modified = 1;
453 }
454
455 return modified;
456 }
457
458 static void saveSettings(WMButton *button, InspectorPanel *panel)
459 {
460 WWindow *wwin = panel->inspected;
461 WDDomain *db = WDWindowAttributes;
462 WMPropList *dict = db->dictionary;
463 WMPropList *winDic, *appDic, *value, *key, *key2;
464 char *icon_file;
465 int flags = 0;
466 int different = 0, different2 = 0;
467
468 /* Save will apply the changes and save them */
469 applySettings(panel->applyBtn, panel);
470
471 if (WMGetButtonSelected(panel->instRb) != 0)
472 key = WMCreatePLString(wwin->wm_instance);
473 else if (WMGetButtonSelected(panel->clsRb) != 0)
474 key = WMCreatePLString(wwin->wm_class);
475 else if (WMGetButtonSelected(panel->bothRb) != 0) {
476 char *buffer;
477
478 buffer = StrConcatDot(wwin->wm_instance, wwin->wm_class);
479 key = WMCreatePLString(buffer);
480 wfree(buffer);
481 } else if (WMGetButtonSelected(panel->defaultRb) != 0) {
482 key = WMRetainPropList(AnyWindow);
483 flags = UPDATE_DEFAULTS;
484 } else
485 key = NULL;
486
487 if (!key)
488 return;
489
490 if (!dict) {
491 dict = WMCreatePLDictionary(NULL, NULL);
492 if (dict) {
493 db->dictionary = dict;
494 } else {
495 WMReleasePropList(key);
496 return;
497 }
498 }
499
500 if (showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD) < 0)
501 return;
502
503 WMPLSetCaseSensitive(True);
504
505 winDic = WMCreatePLDictionary(NULL, NULL);
506 appDic = WMCreatePLDictionary(NULL, NULL);
507
508 /* Update icon for window */
509 icon_file = WMGetTextFieldText(panel->fileText);
510 if (icon_file) {
511 if (icon_file[0] != 0) {
512 value = WMCreatePLString(icon_file);
513 different |= insertAttribute(dict, winDic, AIcon, value, flags);
514 different2 |= insertAttribute(dict, appDic, AIcon, value, flags);
515 WMReleasePropList(value);
516 }
517 wfree(icon_file);
518 }
519
520 {
521 int i = WMGetPopUpButtonSelectedItem(panel->wsP);
522
523 i--;
524
525 if (i >= 0 && i < panel->frame->screen_ptr->workspace_count) {
526 value = WMCreatePLString(panel->frame->screen_ptr->workspaces[i]->name);
527 different |= insertAttribute(dict, winDic, AStartWorkspace, value, flags);
528 WMReleasePropList(value);
529 }
530 }
531
532 flags |= IS_BOOLEAN;
533
534 value = (WMGetButtonSelected(panel->alwChk) != 0) ? Yes : No;
535 different |= insertAttribute(dict, winDic, AAlwaysUserIcon, value, flags);
536
537 value = (WMGetButtonSelected(panel->attrChk[0]) != 0) ? Yes : No;
538 different |= insertAttribute(dict, winDic, ANoTitlebar, value, flags);
539
540 value = (WMGetButtonSelected(panel->attrChk[1]) != 0) ? Yes : No;
541 different |= insertAttribute(dict, winDic, ANoResizebar, value, flags);
542
543 value = (WMGetButtonSelected(panel->attrChk[2]) != 0) ? Yes : No;
544 different |= insertAttribute(dict, winDic, ANoCloseButton, value, flags);
545
546 value = (WMGetButtonSelected(panel->attrChk[3]) != 0) ? Yes : No;
547 different |= insertAttribute(dict, winDic, ANoMiniaturizeButton, value, flags);
548
549 value = (WMGetButtonSelected(panel->attrChk[4]) != 0) ? Yes : No;
550 different |= insertAttribute(dict, winDic, ANoBorder, value, flags);
551
552 value = (WMGetButtonSelected(panel->attrChk[5]) != 0) ? Yes : No;
553 different |= insertAttribute(dict, winDic, AKeepOnTop, value, flags);
554
555 value = (WMGetButtonSelected(panel->attrChk[6]) != 0) ? Yes : No;
556 different |= insertAttribute(dict, winDic, AKeepOnBottom, value, flags);
557
558 value = (WMGetButtonSelected(panel->attrChk[7]) != 0) ? Yes : No;
559 different |= insertAttribute(dict, winDic, AOmnipresent, value, flags);
560
561 value = (WMGetButtonSelected(panel->attrChk[8]) != 0) ? Yes : No;
562 different |= insertAttribute(dict, winDic, AStartMiniaturized, value, flags);
563
564 value = (WMGetButtonSelected(panel->attrChk[9]) != 0) ? Yes : No;
565 different |= insertAttribute(dict, winDic, AStartMaximized, value, flags);
566
567 value = (WMGetButtonSelected(panel->attrChk[10]) != 0) ? Yes : No;
568 different |= insertAttribute(dict, winDic, AFullMaximize, value, flags);
569
570 value = (WMGetButtonSelected(panel->moreChk[0]) != 0) ? Yes : No;
571 different |= insertAttribute(dict, winDic, ANoKeyBindings, value, flags);
572
573 value = (WMGetButtonSelected(panel->moreChk[1]) != 0) ? Yes : No;
574 different |= insertAttribute(dict, winDic, ANoMouseBindings, value, flags);
575
576 value = (WMGetButtonSelected(panel->moreChk[2]) != 0) ? Yes : No;
577 different |= insertAttribute(dict, winDic, ASkipWindowList, value, flags);
578
579 value = (WMGetButtonSelected(panel->moreChk[3]) != 0) ? Yes : No;
580 different |= insertAttribute(dict, winDic, ASkipSwitchPanel, value, flags);
581
582 value = (WMGetButtonSelected(panel->moreChk[4]) != 0) ? Yes : No;
583 different |= insertAttribute(dict, winDic, AUnfocusable, value, flags);
584
585 value = (WMGetButtonSelected(panel->moreChk[5]) != 0) ? Yes : No;
586 different |= insertAttribute(dict, winDic, AKeepInsideScreen, value, flags);
587
588 value = (WMGetButtonSelected(panel->moreChk[6]) != 0) ? Yes : No;
589 different |= insertAttribute(dict, winDic, ANoHideOthers, value, flags);
590
591 value = (WMGetButtonSelected(panel->moreChk[7]) != 0) ? Yes : No;
592 different |= insertAttribute(dict, winDic, ADontSaveSession, value, flags);
593
594 value = (WMGetButtonSelected(panel->moreChk[8]) != 0) ? Yes : No;
595 different |= insertAttribute(dict, winDic, AEmulateAppIcon, value, flags);
596
597 value = (WMGetButtonSelected(panel->moreChk[9]) != 0) ? Yes : No;
598 different |= insertAttribute(dict, winDic, AFocusAcrossWorkspace, value, flags);
599
600 value = (WMGetButtonSelected(panel->moreChk[10]) != 0) ? Yes : No;
601 different |= insertAttribute(dict, winDic, ANoMiniaturizable, value, flags);
602
603 #ifdef XKB_BUTTON_HINT
604 value = (WMGetButtonSelected(panel->moreChk[11]) != 0) ? Yes : No;
605 different |= insertAttribute(dict, winDic, ANoLanguageButton, value, flags);
606 #endif
607
608 if (wwin->main_window != None && wApplicationOf(wwin->main_window) != NULL) {
609 value = (WMGetButtonSelected(panel->appChk[0]) != 0) ? Yes : No;
610 different2 |= insertAttribute(dict, appDic, AStartHidden, value, flags);
611
612 value = (WMGetButtonSelected(panel->appChk[1]) != 0) ? Yes : No;
613 different2 |= insertAttribute(dict, appDic, ANoAppIcon, value, flags);
614
615 value = (WMGetButtonSelected(panel->appChk[2]) != 0) ? Yes : No;
616 different2 |= insertAttribute(dict, appDic, ASharedAppIcon, value, flags);
617 }
618
619 if (wwin->fake_group) {
620 key2 = WMCreatePLString(wwin->fake_group->identifier);
621 if (WMIsPropListEqualTo(key, key2)) {
622 WMMergePLDictionaries(winDic, appDic, True);
623 different |= different2;
624 } else {
625 WMRemoveFromPLDictionary(dict, key2);
626 if (different2) {
627 WMPutInPLDictionary(dict, key2, appDic);
628 }
629 }
630 WMReleasePropList(key2);
631 WMReleasePropList(appDic);
632 } else if (wwin->main_window != wwin->client_win) {
633 WApplication *wapp = wApplicationOf(wwin->main_window);
634
635 if (wapp) {
636 char *instance = wapp->main_window_desc->wm_instance;
637 char *class = wapp->main_window_desc->wm_class;
638 char *buffer;
639
640 buffer = StrConcatDot(instance, class);
641 key2 = WMCreatePLString(buffer);
642 wfree(buffer);
643
644 if (WMIsPropListEqualTo(key, key2)) {
645 WMMergePLDictionaries(winDic, appDic, True);
646 different |= different2;
647 } else {
648 WMRemoveFromPLDictionary(dict, key2);
649 if (different2)
650 WMPutInPLDictionary(dict, key2, appDic);
651 }
652 WMReleasePropList(key2);
653 WMReleasePropList(appDic);
654 }
655 } else {
656 WMMergePLDictionaries(winDic, appDic, True);
657 different |= different2;
658 WMReleasePropList(appDic);
659 }
660
661 WMRemoveFromPLDictionary(dict, key);
662 if (different) {
663 WMPutInPLDictionary(dict, key, winDic);
664 }
665
666 WMReleasePropList(key);
667 WMReleasePropList(winDic);
668
669 UpdateDomainFile(db);
670
671 /* clean up */
672 WMPLSetCaseSensitive(False);
673 }
674
675 static void applySettings(WMButton *button, InspectorPanel *panel)
676 {
677 WWindow *wwin = panel->inspected;
678 WApplication *wapp = wApplicationOf(wwin->main_window);
679 int floating, sunken, skip_window_list;
680 int old_omnipresent;
681 int old_no_bind_keys;
682 int old_no_bind_mouse;
683
684 old_omnipresent = WFLAGP(wwin, omnipresent);
685 old_no_bind_keys = WFLAGP(wwin, no_bind_keys);
686 old_no_bind_mouse = WFLAGP(wwin, no_bind_mouse);
687
688 showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD);
689
690 /* Attributes... --> Window Attributes */
691 WSETUFLAG(wwin, no_titlebar, WMGetButtonSelected(panel->attrChk[0]));
692 WSETUFLAG(wwin, no_resizebar, WMGetButtonSelected(panel->attrChk[1]));
693 WSETUFLAG(wwin, no_close_button, WMGetButtonSelected(panel->attrChk[2]));
694 WSETUFLAG(wwin, no_miniaturize_button, WMGetButtonSelected(panel->attrChk[3]));
695 WSETUFLAG(wwin, no_border, WMGetButtonSelected(panel->attrChk[4]));
696 floating = WMGetButtonSelected(panel->attrChk[5]);
697 sunken = WMGetButtonSelected(panel->attrChk[6]);
698 WSETUFLAG(wwin, omnipresent, WMGetButtonSelected(panel->attrChk[7]));
699 WSETUFLAG(wwin, start_miniaturized, WMGetButtonSelected(panel->attrChk[8]));
700 WSETUFLAG(wwin, start_maximized, WMGetButtonSelected(panel->attrChk[9]));
701 WSETUFLAG(wwin, full_maximize, WMGetButtonSelected(panel->attrChk[10]));
702
703 /* Attributes... --> Advanced Options */
704 WSETUFLAG(wwin, no_bind_keys, WMGetButtonSelected(panel->moreChk[0]));
705 WSETUFLAG(wwin, no_bind_mouse, WMGetButtonSelected(panel->moreChk[1]));
706 skip_window_list = WMGetButtonSelected(panel->moreChk[2]);
707 WSETUFLAG(wwin, skip_switchpanel, WMGetButtonSelected(panel->moreChk[3]));
708 WSETUFLAG(wwin, no_focusable, WMGetButtonSelected(panel->moreChk[4]));
709 WSETUFLAG(wwin, dont_move_off, WMGetButtonSelected(panel->moreChk[5]));
710 WSETUFLAG(wwin, no_hide_others, WMGetButtonSelected(panel->moreChk[6]));
711 WSETUFLAG(wwin, dont_save_session, WMGetButtonSelected(panel->moreChk[7]));
712 WSETUFLAG(wwin, emulate_appicon, WMGetButtonSelected(panel->moreChk[8]));
713 WSETUFLAG(wwin, focus_across_wksp, WMGetButtonSelected(panel->moreChk[9]));
714 WSETUFLAG(wwin, no_miniaturizable, WMGetButtonSelected(panel->moreChk[10]));
715 #ifdef XKB_BUTTON_HINT
716 WSETUFLAG(wwin, no_language_button, WMGetButtonSelected(panel->moreChk[11]));
717 #endif
718 WSETUFLAG(wwin, always_user_icon, WMGetButtonSelected(panel->alwChk));
719
720 if (WFLAGP(wwin, no_titlebar) && wwin->flags.shaded)
721 wUnshadeWindow(wwin);
722
723 WSETUFLAG(wwin, no_shadeable, WFLAGP(wwin, no_titlebar));
724
725 if (floating) {
726 if (!WFLAGP(wwin, floating))
727 ChangeStackingLevel(wwin->frame->core, WMFloatingLevel);
728 } else if (sunken) {
729 if (!WFLAGP(wwin, sunken))
730 ChangeStackingLevel(wwin->frame->core, WMSunkenLevel);
731 } else {
732 if (WFLAGP(wwin, floating) || WFLAGP(wwin, sunken))
733 ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
734 }
735
736 WSETUFLAG(wwin, sunken, sunken);
737 WSETUFLAG(wwin, floating, floating);
738 wwin->flags.omnipresent = 0;
739
740 if (WFLAGP(wwin, skip_window_list) != skip_window_list) {
741 WSETUFLAG(wwin, skip_window_list, skip_window_list);
742 UpdateSwitchMenu(wwin->screen_ptr, wwin, skip_window_list ? ACTION_REMOVE : ACTION_ADD);
743 } else {
744 if (WFLAGP(wwin, omnipresent) != old_omnipresent) {
745 WMPostNotificationName(WMNChangedState, wwin, "omnipresent");
746 }
747 }
748
749 if (WFLAGP(wwin, no_bind_keys) != old_no_bind_keys) {
750 if (WFLAGP(wwin, no_bind_keys)) {
751 XUngrabKey(dpy, AnyKey, AnyModifier, wwin->frame->core->window);
752 } else {
753 wWindowSetKeyGrabs(wwin);
754 }
755 }
756
757 if (WFLAGP(wwin, no_bind_mouse) != old_no_bind_mouse) {
758 wWindowResetMouseGrabs(wwin);
759 }
760
761 wwin->frame->flags.need_texture_change = 1;
762 wWindowConfigureBorders(wwin);
763 wFrameWindowPaint(wwin->frame);
764 wNETWMUpdateActions(wwin, False);
765
766 /*
767 * Can't apply emulate_appicon because it will probably cause problems.
768 */
769 if (wapp) {
770 /* do application wide stuff */
771 WSETUFLAG(wapp->main_window_desc, start_hidden, WMGetButtonSelected(panel->appChk[0]));
772
773 WSETUFLAG(wapp->main_window_desc, no_appicon, WMGetButtonSelected(panel->appChk[1]));
774
775 WSETUFLAG(wapp->main_window_desc, shared_appicon, WMGetButtonSelected(panel->appChk[2]));
776
777 if (WFLAGP(wapp->main_window_desc, no_appicon))
778 removeAppIconFor(wapp);
779 else
780 makeAppIconFor(wapp);
781
782 if (wapp->app_icon && wapp->main_window == wwin->client_win) {
783 char *file = WMGetTextFieldText(panel->fileText);
784
785 if (file[0] == 0) {
786 wfree(file);
787 file = NULL;
788 }
789 wIconChangeImageFile(wapp->app_icon->icon, file);
790 if (file)
791 wfree(file);
792 wAppIconPaint(wapp->app_icon);
793 }
794 }
795 }
796
797 static void revertSettings(WMButton *button, InspectorPanel *panel)
798 {
799 WWindow *wwin = panel->inspected;
800 WApplication *wapp = wApplicationOf(wwin->main_window);
801 int i, n;
802 char *wm_instance = NULL;
803 char *wm_class = NULL;
804 int workspace, level;
805
806 if (panel->instRb && WMGetButtonSelected(panel->instRb) != 0)
807 wm_instance = wwin->wm_instance;
808 else if (panel->clsRb && WMGetButtonSelected(panel->clsRb) != 0)
809 wm_class = wwin->wm_class;
810 else if (panel->bothRb && WMGetButtonSelected(panel->bothRb) != 0) {
811 wm_instance = wwin->wm_instance;
812 wm_class = wwin->wm_class;
813 }
814 memset(&wwin->defined_user_flags, 0, sizeof(WWindowAttributes));
815 memset(&wwin->user_flags, 0, sizeof(WWindowAttributes));
816 memset(&wwin->client_flags, 0, sizeof(WWindowAttributes));
817
818 wWindowSetupInitialAttributes(wwin, &level, &workspace);
819
820 for (i = 0; i < (sizeof(panel->attrChk) / sizeof(panel->attrChk[0])); i++) {
821 int flag = 0;
822
823 switch (i) {
824 case 0:
825 flag = WFLAGP(wwin, no_titlebar);
826 break;
827 case 1:
828 flag = WFLAGP(wwin, no_resizebar);
829 break;
830 case 2:
831 flag = WFLAGP(wwin, no_close_button);
832 break;
833 case 3:
834 flag = WFLAGP(wwin, no_miniaturize_button);
835 break;
836 case 4:
837 flag = WFLAGP(wwin, no_border);
838 break;
839 case 5:
840 flag = WFLAGP(wwin, floating);
841 break;
842 case 6:
843 flag = WFLAGP(wwin, sunken);
844 break;
845 case 7:
846 flag = WFLAGP(wwin, omnipresent);
847 break;
848 case 8:
849 flag = WFLAGP(wwin, start_miniaturized);
850 break;
851 case 9:
852 flag = WFLAGP(wwin, start_maximized != 0);
853 break;
854 case 10:
855 flag = WFLAGP(wwin, full_maximize);
856 break;
857 }
858 WMSetButtonSelected(panel->attrChk[i], flag);
859 }
860 for (i = 0; i < (sizeof(panel->moreChk) / sizeof(panel->moreChk[0])); i++) {
861 int flag = 0;
862
863 switch (i) {
864 case 0:
865 flag = WFLAGP(wwin, no_bind_keys);
866 break;
867 case 1:
868 flag = WFLAGP(wwin, no_bind_mouse);
869 break;
870 case 2:
871 flag = WFLAGP(wwin, skip_window_list);
872 break;
873 case 3:
874 flag = WFLAGP(wwin, skip_switchpanel);
875 break;
876 case 4:
877 flag = WFLAGP(wwin, no_focusable);
878 break;
879 case 5:
880 flag = WFLAGP(wwin, dont_move_off);
881 break;
882 case 6:
883 flag = WFLAGP(wwin, no_hide_others);
884 break;
885 case 7:
886 flag = WFLAGP(wwin, dont_save_session);
887 break;
888 case 8:
889 flag = WFLAGP(wwin, emulate_appicon);
890 break;
891 case 9:
892 flag = WFLAGP(wwin, focus_across_wksp);
893 break;
894 case 10:
895 flag = WFLAGP(wwin, no_miniaturizable);
896 break;
897 #ifdef XKB_BUTTON_HINT
898 case 11:
899 flag = WFLAGP(wwin, no_language_button);
900 break;
901 #endif
902 }
903 WMSetButtonSelected(panel->moreChk[i], flag);
904 }
905 if (panel->appFrm && wapp) {
906 for (i = 0; i < (sizeof(panel->appChk) / sizeof(panel->appChk[0])); i++) {
907 int flag = 0;
908
909 switch (i) {
910 case 0:
911 flag = WFLAGP(wapp->main_window_desc, start_hidden);
912 break;
913 case 1:
914 flag = WFLAGP(wapp->main_window_desc, no_appicon);
915 break;
916 case 2:
917 flag = WFLAGP(wapp->main_window_desc, shared_appicon);
918 break;
919 }
920 WMSetButtonSelected(panel->appChk[i], flag);
921 }
922 }
923 WMSetButtonSelected(panel->alwChk, WFLAGP(wwin, always_user_icon));
924
925 showIconFor(WMWidgetScreen(panel->alwChk), panel, wm_instance, wm_class, REVERT_TO_DEFAULT);
926
927 n = wDefaultGetStartWorkspace(wwin->screen_ptr, wm_instance, wm_class);
928
929 if (n >= 0 && n < wwin->screen_ptr->workspace_count) {
930 WMSetPopUpButtonSelectedItem(panel->wsP, n + 1);
931 } else {
932 WMSetPopUpButtonSelectedItem(panel->wsP, 0);
933 }
934
935 /* must auto apply, so that there wno't be internal
936 * inconsistencies between the state in the flags and
937 * the actual state of the window */
938 applySettings(panel->applyBtn, panel);
939 }
940
941 static void chooseIconCallback(WMWidget *self, void *clientData)
942 {
943 char *file;
944 InspectorPanel *panel = (InspectorPanel *) clientData;
945 int result;
946
947 panel->choosingIcon = 1;
948
949 WMSetButtonEnabled(panel->browseIconBtn, False);
950
951 result = wIconChooserDialog(panel->frame->screen_ptr, &file,
952 panel->inspected->wm_instance, panel->inspected->wm_class);
953
954 panel->choosingIcon = 0;
955
956 if (!panel->destroyed) { /* kluge */
957 if (result) {
958 WMSetTextFieldText(panel->fileText, file);
959 showIconFor(WMWidgetScreen(self), panel, NULL, NULL, USE_TEXT_FIELD);
960 wfree(file);
961 }
962 WMSetButtonEnabled(panel->browseIconBtn, True);
963 } else {
964 freeInspector(panel);
965 }
966 }
967
968 static void textEditedObserver(void *observerData, WMNotification *notification)
969 {
970 InspectorPanel *panel = (InspectorPanel *) observerData;
971
972 if ((long)WMGetNotificationClientData(notification) != WMReturnTextMovement)
973 return;
974
975 showIconFor(WMWidgetScreen(panel->win), panel, NULL, NULL, USE_TEXT_FIELD);
976 /*
977 WMPerformButtonClick(panel->updateIconBtn);
978 */
979 }
980
981 static void selectSpecification(WMWidget *bPtr, void *data)
982 {
983 InspectorPanel *panel = (InspectorPanel *) data;
984 char *str;
985 WWindow *wwin = panel->inspected;
986 int len;
987
988 if (bPtr == panel->defaultRb && (wwin->wm_instance || wwin->wm_class))
989 WMSetButtonEnabled(panel->applyBtn, False);
990 else
991 WMSetButtonEnabled(panel->applyBtn, True);
992
993 len = 16 + strlen(wwin->wm_instance ? wwin->wm_instance : "?")
994 + strlen(wwin->wm_class ? wwin->wm_class : "?");
995
996 str = wmalloc(len);
997
998 snprintf(str, len, _("Inspecting %s.%s"),
999 wwin->wm_instance ? wwin->wm_instance : "?", wwin->wm_class ? wwin->wm_class : "?");
1000
1001 wFrameWindowChangeTitle(panel->frame->frame, str);
1002
1003 wfree(str);
1004 }
1005
1006 static void selectWindow(WMWidget *bPtr, void *data)
1007 {
1008 InspectorPanel *panel = (InspectorPanel *) data;
1009 WWindow *wwin = panel->inspected;
1010 WScreen *scr = wwin->screen_ptr;
1011 XEvent event;
1012 WWindow *iwin;
1013
1014 if (XGrabPointer(dpy, scr->root_win, True,
1015 ButtonPressMask, GrabModeAsync, GrabModeAsync, None,
1016 wCursor[WCUR_SELECT], CurrentTime) != GrabSuccess) {
1017 wwarning("could not grab mouse pointer");
1018 return;
1019 }
1020
1021 WMSetLabelText(panel->specLbl, _("Click in the window you wish to inspect."));
1022
1023 WMMaskEvent(dpy, ButtonPressMask, &event);
1024
1025 XUngrabPointer(dpy, CurrentTime);
1026
1027 iwin = wWindowFor(event.xbutton.subwindow);
1028
1029 if (iwin && !iwin->flags.internal_window && iwin != wwin && !iwin->flags.inspector_open) {
1030
1031 iwin->flags.inspector_open = 1;
1032 iwin->inspector = createInspectorForWindow(iwin,
1033 panel->frame->frame_x, panel->frame->frame_y, True);
1034 wCloseInspectorForWindow(wwin);
1035 } else {
1036 WMSetLabelText(panel->specLbl, spec_text);
1037 }
1038 }
1039
1040 static InspectorPanel *createInspectorForWindow(WWindow *wwin, int xpos, int ypos, Bool showSelectPanel)
1041 {
1042 WScreen *scr = wwin->screen_ptr;
1043 InspectorPanel *panel;
1044 Window parent;
1045 int i;
1046 int x, y;
1047 int btn_width, frame_width;
1048 WMButton *selectedBtn = NULL;
1049 #ifdef wrong_behaviour
1050 WMPixmap *pixmap;
1051 #endif
1052
1053 spec_text = _("The configuration will apply to all\n"
1054 "windows that have their WM_CLASS\n"
1055 "property set to the above selected\n" "name, when saved.");
1056
1057 panel = wmalloc(sizeof(InspectorPanel));
1058 memset(panel, 0, sizeof(InspectorPanel));
1059
1060 panel->destroyed = 0;
1061
1062 panel->inspected = wwin;
1063
1064 panel->nextPtr = panelList;
1065 panelList = panel;
1066
1067 panel->win = WMCreateWindow(scr->wmscreen, "windowInspector");
1068 WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
1069
1070 /**** create common stuff ****/
1071
1072 /* command buttons */
1073 /* (PWIDTH - (left and right margin) - (btn interval)) / 3 */
1074 btn_width = (PWIDTH - (2 * 15) - (2 * 10)) / 3;
1075 panel->saveBtn = WMCreateCommandButton(panel->win);
1076 WMSetButtonAction(panel->saveBtn, (WMAction *) saveSettings, panel);
1077 WMMoveWidget(panel->saveBtn, (2 * (btn_width + 10)) + 15, PHEIGHT - 40);
1078 WMSetButtonText(panel->saveBtn, _("Save"));
1079 WMResizeWidget(panel->saveBtn, btn_width, 28);
1080 if (wPreferences.flags.noupdates || !(wwin->wm_class || wwin->wm_instance))
1081 WMSetButtonEnabled(panel->saveBtn, False);
1082
1083 panel->applyBtn = WMCreateCommandButton(panel->win);
1084 WMSetButtonAction(panel->applyBtn, (WMAction *) applySettings, panel);
1085 WMMoveWidget(panel->applyBtn, btn_width + 10 + 15, PHEIGHT - 40);
1086 WMSetButtonText(panel->applyBtn, _("Apply"));
1087 WMResizeWidget(panel->applyBtn, btn_width, 28);
1088
1089 panel->revertBtn = WMCreateCommandButton(panel->win);
1090 WMSetButtonAction(panel->revertBtn, (WMAction *) revertSettings, panel);
1091 WMMoveWidget(panel->revertBtn, 15, PHEIGHT - 40);
1092 WMSetButtonText(panel->revertBtn, _("Reload"));
1093 WMResizeWidget(panel->revertBtn, btn_width, 28);
1094
1095 /* page selection popup button */
1096 panel->pagePopUp = WMCreatePopUpButton(panel->win);
1097 WMSetPopUpButtonAction(panel->pagePopUp, (WMAction *) changePage, panel);
1098 WMMoveWidget(panel->pagePopUp, 25, 15);
1099 WMResizeWidget(panel->pagePopUp, PWIDTH - 50, 20);
1100
1101 WMAddPopUpButtonItem(panel->pagePopUp, _("Window Specification"));
1102 WMAddPopUpButtonItem(panel->pagePopUp, _("Window Attributes"));
1103 WMAddPopUpButtonItem(panel->pagePopUp, _("Advanced Options"));
1104 WMAddPopUpButtonItem(panel->pagePopUp, _("Icon and Initial Workspace"));
1105 WMAddPopUpButtonItem(panel->pagePopUp, _("Application Specific"));
1106
1107 /**** window spec ****/
1108 frame_width = PWIDTH - (2 * 15);
1109
1110 panel->specFrm = WMCreateFrame(panel->win);
1111 WMSetFrameTitle(panel->specFrm, _("Window Specification"));
1112 WMMoveWidget(panel->specFrm, 15, 65);
1113 WMResizeWidget(panel->specFrm, frame_width, 145);
1114
1115 panel->defaultRb = WMCreateRadioButton(panel->specFrm);
1116 WMMoveWidget(panel->defaultRb, 10, 78);
1117 WMResizeWidget(panel->defaultRb, frame_width - (2 * 10), 20);
1118 WMSetButtonText(panel->defaultRb, _("Defaults for all windows"));
1119 WMSetButtonSelected(panel->defaultRb, False);
1120 WMSetButtonAction(panel->defaultRb, selectSpecification, panel);
1121
1122 if (wwin->wm_class && wwin->wm_instance) {
1123 char *str, *tmp;
1124
1125 tmp = wstrconcat(wwin->wm_instance, ".");
1126 str = wstrconcat(tmp, wwin->wm_class);
1127
1128 panel->bothRb = WMCreateRadioButton(panel->specFrm);
1129 WMMoveWidget(panel->bothRb, 10, 18);
1130 WMResizeWidget(panel->bothRb, frame_width - (2 * 10), 20);
1131 WMSetButtonText(panel->bothRb, str);
1132 wfree(tmp);
1133 wfree(str);
1134 WMGroupButtons(panel->defaultRb, panel->bothRb);
1135
1136 if (!selectedBtn)
1137 selectedBtn = panel->bothRb;
1138
1139 WMSetButtonAction(panel->bothRb, selectSpecification, panel);
1140 }
1141
1142 if (wwin->wm_instance) {
1143 panel->instRb = WMCreateRadioButton(panel->specFrm);
1144 WMMoveWidget(panel->instRb, 10, 38);
1145 WMResizeWidget(panel->instRb, frame_width - (2 * 10), 20);
1146 WMSetButtonText(panel->instRb, wwin->wm_instance);
1147 WMGroupButtons(panel->defaultRb, panel->instRb);
1148
1149 if (!selectedBtn)
1150 selectedBtn = panel->instRb;
1151
1152 WMSetButtonAction(panel->instRb, selectSpecification, panel);
1153 }
1154
1155 if (wwin->wm_class) {
1156 panel->clsRb = WMCreateRadioButton(panel->specFrm);
1157 WMMoveWidget(panel->clsRb, 10, 58);
1158 WMResizeWidget(panel->clsRb, frame_width - (2 * 10), 20);
1159 WMSetButtonText(panel->clsRb, wwin->wm_class);
1160 WMGroupButtons(panel->defaultRb, panel->clsRb);
1161
1162 if (!selectedBtn)
1163 selectedBtn = panel->clsRb;
1164
1165 WMSetButtonAction(panel->clsRb, selectSpecification, panel);
1166 }
1167
1168 panel->selWinB = WMCreateCommandButton(panel->specFrm);
1169 WMMoveWidget(panel->selWinB, 20, 145 - 24 - 10);
1170 WMResizeWidget(panel->selWinB, frame_width - 2 * 10 - 20, 24);
1171 WMSetButtonText(panel->selWinB, _("Select window"));
1172 WMSetButtonAction(panel->selWinB, selectWindow, panel);
1173
1174 panel->specLbl = WMCreateLabel(panel->win);
1175 WMMoveWidget(panel->specLbl, 15, 210);
1176 WMResizeWidget(panel->specLbl, frame_width, 100);
1177 WMSetLabelText(panel->specLbl, spec_text);
1178 WMSetLabelWraps(panel->specLbl, True);
1179
1180 WMSetLabelTextAlignment(panel->specLbl, WALeft);
1181
1182 /**** attributes ****/
1183 panel->attrFrm = WMCreateFrame(panel->win);
1184 WMSetFrameTitle(panel->attrFrm, _("Attributes"));
1185 WMMoveWidget(panel->attrFrm, 15, 45);
1186 WMResizeWidget(panel->attrFrm, frame_width, 250);
1187
1188 for (i = 0; i < (sizeof(panel->attrChk) / sizeof(panel->attrChk[0])); i++) {
1189 char *caption = NULL;
1190 int flag = 0;
1191 char *descr = NULL;
1192
1193 switch (i) {
1194 case 0:
1195 caption = _("Disable titlebar");
1196 flag = WFLAGP(wwin, no_titlebar);
1197 descr = _("Remove the titlebar of this window.\n"
1198 "To access the window commands menu of a window\n"
1199 "without it's titlebar, press Control+Esc (or the\n"
1200 "equivalent shortcut, if you changed the default\n" "settings).");
1201 break;
1202 case 1:
1203 caption = _("Disable resizebar");
1204 flag = WFLAGP(wwin, no_resizebar);
1205 descr = _("Remove the resizebar of this window.");
1206 break;
1207 case 2:
1208 caption = _("Disable close button");
1209 flag = WFLAGP(wwin, no_close_button);
1210 descr = _("Remove the `close window' button of this window.");
1211 break;
1212 case 3:
1213 caption = _("Disable miniaturize button");
1214 flag = WFLAGP(wwin, no_miniaturize_button);
1215 descr = _("Remove the `miniaturize window' button of the window.");
1216 break;
1217 case 4:
1218 caption = _("Disable border");
1219 flag = WFLAGP(wwin, no_border);
1220 descr = _("Remove the 1 pixel black border around the window.");
1221 break;
1222 case 5:
1223 caption = _("Keep on top (floating)");
1224 flag = WFLAGP(wwin, floating);
1225 descr = _("Keep the window over other windows, not allowing\n" "them to cover it.");
1226 break;
1227 case 6:
1228 caption = _("Keep at bottom (sunken)");
1229 flag = WFLAGP(wwin, sunken);
1230 descr = _("Keep the window under all other windows.");
1231 break;
1232 case 7:
1233 caption = _("Omnipresent");
1234 flag = WFLAGP(wwin, omnipresent);
1235 descr = _("Make window present in all workspaces.");
1236 break;
1237 case 8:
1238 caption = _("Start miniaturized");
1239 flag = WFLAGP(wwin, start_miniaturized);
1240 descr = _("Make the window be automatically miniaturized when it's\n" "first shown.");
1241 break;
1242 case 9:
1243 caption = _("Start maximized");
1244 flag = WFLAGP(wwin, start_maximized != 0);
1245 descr = _("Make the window be automatically maximized when it's\n" "first shown.");
1246 break;
1247 case 10:
1248 caption = _("Full screen maximization");
1249 flag = WFLAGP(wwin, full_maximize);
1250 descr = _("Make the window use the whole screen space when it's\n"
1251 "maximized. The titlebar and resizebar will be moved\n"
1252 "to outside the screen.");
1253 break;
1254 }
1255 panel->attrChk[i] = WMCreateSwitchButton(panel->attrFrm);
1256 WMMoveWidget(panel->attrChk[i], 10, 20 * (i + 1));
1257 WMResizeWidget(panel->attrChk[i], frame_width - 15, 20);
1258 WMSetButtonSelected(panel->attrChk[i], flag);
1259 WMSetButtonText(panel->attrChk[i], caption);
1260
1261 WMSetBalloonTextForView(descr, WMWidgetView(panel->attrChk[i]));
1262 }
1263
1264 /**** more attributes ****/
1265 panel->moreFrm = WMCreateFrame(panel->win);
1266 WMSetFrameTitle(panel->moreFrm, _("Advanced"));
1267 WMMoveWidget(panel->moreFrm, 15, 45);
1268 WMResizeWidget(panel->moreFrm, frame_width, 265);
1269
1270 for (i = 0; i < (sizeof(panel->moreChk) / sizeof(panel->moreChk[0])); i++) {
1271 char *caption = NULL;
1272 int flag = 0;
1273 char *descr = NULL;
1274
1275 switch (i) {
1276 case 0:
1277 caption = _("Do not bind keyboard shortcuts");
1278 flag = WFLAGP(wwin, no_bind_keys);
1279 descr = _("Do not bind keyboard shortcuts from Window Maker\n"
1280 "when this window is focused. This will allow the\n"
1281 "window to receive all key combinations regardless\n"
1282 "of your shortcut configuration.");
1283 break;
1284 case 1:
1285 caption = _("Do not bind mouse clicks");
1286 flag = WFLAGP(wwin, no_bind_mouse);
1287 descr = _("Do not bind mouse actions, such as `Alt'+drag\n"
1288 "in the window (when alt is the modifier you have\n" "configured).");
1289 break;
1290 case 2:
1291 caption = _("Do not show in the window list");
1292 flag = WFLAGP(wwin, skip_window_list);
1293 descr = _("Do not list the window in the window list menu.");
1294 break;
1295 case 3:
1296 caption = _("Do not show in the switch panel");
1297 flag = WFLAGP(wwin, skip_switchpanel);
1298 descr = _("Do not include in switchpanel while alternating windows.");
1299 break;
1300 case 4:
1301 caption = _("Do not let it take focus");
1302 flag = WFLAGP(wwin, no_focusable);
1303 descr = _("Do not let the window take keyboard focus when you\n" "click on it.");
1304 break;
1305 case 5:
1306 caption = _("Keep inside screen");
1307 flag = WFLAGP(wwin, dont_move_off);
1308 descr = _("Do not allow the window to move itself completely\n"
1309 "outside the screen. For bug compatibility.\n");
1310 break;
1311 case 6:
1312 caption = _("Ignore 'Hide Others'");
1313 flag = WFLAGP(wwin, no_hide_others);
1314 descr = _("Do not hide the window when issuing the\n" "`HideOthers' command.");
1315 break;
1316 case 7:
1317 caption = _("Ignore 'Save Session'");
1318 flag = WFLAGP(wwin, dont_save_session);
1319 descr = _("Do not save the associated application in the\n"
1320 "session's state, so that it won't be restarted\n"
1321 "together with other applications when Window Maker\n" "starts.");
1322 break;
1323 case 8:
1324 caption = _("Emulate application icon");
1325 flag = WFLAGP(wwin, emulate_appicon);
1326 descr = _("Make this window act as an application that provides\n"
1327 "enough information to Window Maker for a dockable\n"
1328 "application icon to be created.");
1329 break;
1330 case 9:
1331 caption = _("Focus across workspaces");
1332 flag = WFLAGP(wwin, focus_across_wksp);
1333 descr = _("Allow Window Maker to switch workspace to satisfy\n"
1334 "a focus request (annoying).");
1335 break;
1336 case 10:
1337 caption = _("Do not let it be minimized");
1338 flag = WFLAGP(wwin, no_miniaturizable);
1339 descr = _("Do not let the window of this application be\n"
1340 "minimized.\n");
1341 break;
1342 #ifdef XKB_BUTTON_HINT
1343 case 11:
1344 caption = _("Disable language button");
1345 flag = WFLAGP(wwin, no_language_button);
1346 descr = _("Remove the `toggle language' button of the window.");
1347 break;
1348 #endif
1349 }
1350 panel->moreChk[i] = WMCreateSwitchButton(panel->moreFrm);
1351 WMMoveWidget(panel->moreChk[i], 10, 20 * (i + 1));
1352 WMResizeWidget(panel->moreChk[i], frame_width - 15, 20);
1353 WMSetButtonSelected(panel->moreChk[i], flag);
1354 WMSetButtonText(panel->moreChk[i], caption);
1355
1356 WMSetBalloonTextForView(descr, WMWidgetView(panel->moreChk[i]));
1357 }
1358
1359 /* miniwindow/workspace */
1360 panel->iconFrm = WMCreateFrame(panel->win);
1361 WMMoveWidget(panel->iconFrm, 15, 50);
1362 WMResizeWidget(panel->iconFrm, PWIDTH - (2 * 15), 170);
1363 WMSetFrameTitle(panel->iconFrm, _("Miniwindow Image"));
1364
1365 panel->iconLbl = WMCreateLabel(panel->iconFrm);
1366 WMMoveWidget(panel->iconLbl, PWIDTH - (2 * 15) - 22 - 64, 20);
1367 WMResizeWidget(panel->iconLbl, 64, 64);
1368 WMSetLabelRelief(panel->iconLbl, WRGroove);
1369 WMSetLabelImagePosition(panel->iconLbl, WIPImageOnly);
1370
1371 panel->browseIconBtn = WMCreateCommandButton(panel->iconFrm);
1372 WMSetButtonAction(panel->browseIconBtn, chooseIconCallback, panel);
1373 WMMoveWidget(panel->browseIconBtn, 22, 32);
1374 WMResizeWidget(panel->browseIconBtn, 120, 26);
1375 WMSetButtonText(panel->browseIconBtn, _("Browse..."));
1376
1377 #ifdef wrong_behaviour
1378 WMSetButtonImagePosition(panel->updateIconBtn, WIPRight);
1379 pixmap = WMGetSystemPixmap(scr->wmscreen, WSIReturnArrow);
1380 WMSetButtonImage(panel->updateIconBtn, pixmap);
1381 WMReleasePixmap(pixmap);
1382 pixmap = WMGetSystemPixmap(scr->wmscreen, WSIHighlightedReturnArrow);
1383 WMSetButtonAltImage(panel->updateIconBtn, pixmap);
1384 WMReleasePixmap(pixmap);
1385 #endif
1386
1387 panel->fileLbl = WMCreateLabel(panel->iconFrm);
1388 WMMoveWidget(panel->fileLbl, 20, 85);
1389 WMResizeWidget(panel->fileLbl, PWIDTH - (2 * 15) - (2 * 20), 14);
1390 WMSetLabelText(panel->fileLbl, _("Icon filename:"));
1391
1392 panel->fileText = WMCreateTextField(panel->iconFrm);
1393 WMMoveWidget(panel->fileText, 20, 105);
1394 WMResizeWidget(panel->fileText, PWIDTH - (2 * 20) - (2 * 15), 20);
1395 WMSetTextFieldText(panel->fileText, NULL);
1396 WMAddNotificationObserver(textEditedObserver, panel, WMTextDidEndEditingNotification, panel->fileText);
1397
1398 panel->alwChk = WMCreateSwitchButton(panel->iconFrm);
1399 WMMoveWidget(panel->alwChk, 20, 130);
1400 WMResizeWidget(panel->alwChk, PWIDTH - (2 * 15) - (2 * 15), 30);
1401 WMSetButtonText(panel->alwChk, _("Ignore client supplied icon"));
1402 WMSetButtonSelected(panel->alwChk, WFLAGP(wwin, always_user_icon));
1403
1404 panel->wsFrm = WMCreateFrame(panel->win);
1405 WMMoveWidget(panel->wsFrm, 15, 225);
1406 WMResizeWidget(panel->wsFrm, PWIDTH - (2 * 15), 70);
1407 WMSetFrameTitle(panel->wsFrm, _("Initial Workspace"));
1408
1409 WMSetBalloonTextForView(_("The workspace to place the window when it's"
1410 "first shown."), WMWidgetView(panel->wsFrm));
1411
1412 panel->wsP = WMCreatePopUpButton(panel->wsFrm);
1413 WMMoveWidget(panel->wsP, 20, 30);
1414 WMResizeWidget(panel->wsP, PWIDTH - (2 * 15) - (2 * 20), 20);
1415 WMAddPopUpButtonItem(panel->wsP, _("Nowhere in particular"));
1416
1417 for (i = 0; i < wwin->screen_ptr->workspace_count; i++)
1418 WMAddPopUpButtonItem(panel->wsP, scr->workspaces[i]->name);
1419
1420 i = wDefaultGetStartWorkspace(wwin->screen_ptr, wwin->wm_instance, wwin->wm_class);
1421 if (i >= 0 && i <= wwin->screen_ptr->workspace_count)
1422 WMSetPopUpButtonSelectedItem(panel->wsP, i + 1);
1423 else
1424 WMSetPopUpButtonSelectedItem(panel->wsP, 0);
1425
1426 /* application wide attributes */
1427 if (wwin->main_window != None) {
1428 WApplication *wapp = wApplicationOf(wwin->main_window);
1429
1430 panel->appFrm = WMCreateFrame(panel->win);
1431 WMSetFrameTitle(panel->appFrm, _("Application Attributes"));
1432 WMMoveWidget(panel->appFrm, 15, 50);
1433 WMResizeWidget(panel->appFrm, frame_width, 240);
1434
1435 for (i = 0; i < (sizeof(panel->appChk) / sizeof(panel->appChk[0])); i++) {
1436 char *caption = NULL;
1437 int flag = 0;
1438 char *descr = NULL;
1439
1440 switch (i) {
1441 case 0:
1442 caption = _("Start hidden");
1443 flag = WFLAGP(wapp->main_window_desc, start_hidden);
1444 descr = _("Automatically hide application when it's started.");
1445 break;
1446 case 1:
1447 caption = _("No application icon");
1448 flag = WFLAGP(wapp->main_window_desc, no_appicon);
1449 descr = _("Disable the application icon for the application.\n"
1450 "Note that you won't be able to dock it anymore,\n"
1451 "and any icons that are already docked will stop\n"
1452 "working correctly.");
1453 break;
1454 case 2:
1455 caption = _("Shared application icon");
1456 flag = WFLAGP(wapp->main_window_desc, shared_appicon);
1457 descr = _("Use a single shared application icon for all of\n"
1458 "the instances of this application.\n");
1459 break;
1460 }
1461 panel->appChk[i] = WMCreateSwitchButton(panel->appFrm);
1462 WMMoveWidget(panel->appChk[i], 10, 20 * (i + 1));
1463 WMResizeWidget(panel->appChk[i], 205, 20);
1464 WMSetButtonSelected(panel->appChk[i], flag);
1465 WMSetButtonText(panel->appChk[i], caption);
1466 WMSetBalloonTextForView(descr, WMWidgetView(panel->appChk[i]));
1467 }
1468
1469 if (WFLAGP(wwin, emulate_appicon)) {
1470 WMSetButtonEnabled(panel->appChk[1], False);
1471 WMSetButtonEnabled(panel->moreChk[7], True);
1472 } else {
1473 WMSetButtonEnabled(panel->appChk[1], True);
1474 WMSetButtonEnabled(panel->moreChk[7], False);
1475 }
1476 } else {
1477 int tmp;
1478
1479 if ((wwin->transient_for != None && wwin->transient_for != scr->root_win)
1480 || !wwin->wm_class || !wwin->wm_instance)
1481 tmp = False;
1482 else
1483 tmp = True;
1484 WMSetButtonEnabled(panel->moreChk[7], tmp);
1485
1486 WMSetPopUpButtonItemEnabled(panel->pagePopUp, 4, False);
1487 panel->appFrm = NULL;
1488 }
1489
1490 /* if the window is a transient, don't let it have a miniaturize
1491 * button */
1492 if (wwin->transient_for != None && wwin->transient_for != scr->root_win)
1493 WMSetButtonEnabled(panel->attrChk[3], False);
1494 else
1495 WMSetButtonEnabled(panel->attrChk[3], True);
1496
1497 if (!wwin->wm_class && !wwin->wm_instance) {
1498 WMSetPopUpButtonItemEnabled(panel->pagePopUp, 0, False);
1499 }
1500
1501 WMRealizeWidget(panel->win);
1502
1503 WMMapSubwidgets(panel->win);
1504 WMMapSubwidgets(panel->specFrm);
1505 WMMapSubwidgets(panel->attrFrm);
1506 WMMapSubwidgets(panel->moreFrm);
1507 WMMapSubwidgets(panel->iconFrm);
1508 WMMapSubwidgets(panel->wsFrm);
1509 if (panel->appFrm)
1510 WMMapSubwidgets(panel->appFrm);
1511
1512 if (showSelectPanel) {
1513 WMSetPopUpButtonSelectedItem(panel->pagePopUp, 0);
1514 changePage(panel->pagePopUp, panel);
1515 } else {
1516 WMSetPopUpButtonSelectedItem(panel->pagePopUp, 1);
1517 changePage(panel->pagePopUp, panel);
1518 }
1519
1520 parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, PWIDTH, PHEIGHT, 0, 0, 0);
1521 XSelectInput(dpy, parent, KeyPressMask | KeyReleaseMask);
1522 panel->parent = parent;
1523 XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
1524
1525 WMMapWidget(panel->win);
1526
1527 XSetTransientForHint(dpy, parent, wwin->client_win);
1528
1529 if (xpos == UNDEFINED_POS) {
1530 x = wwin->frame_x + wwin->frame->core->width / 2;
1531 y = wwin->frame_y + wwin->frame->top_width * 2;
1532 if (y + PHEIGHT > scr->scr_height)
1533 y = scr->scr_height - PHEIGHT - 30;
1534 if (x + PWIDTH > scr->scr_width)
1535 x = scr->scr_width - PWIDTH;
1536 } else {
1537 x = xpos;
1538 y = ypos;
1539 }
1540
1541 panel->frame = wManageInternalWindow(scr, parent, wwin->client_win, "Inspector", x, y, PWIDTH, PHEIGHT);
1542
1543 if (!selectedBtn)
1544 selectedBtn = panel->defaultRb;
1545
1546 WMSetButtonSelected(selectedBtn, True);
1547
1548 selectSpecification(selectedBtn, panel);
1549
1550 /* kluge to know who should get the key events */
1551 panel->frame->client_leader = WMWidgetXID(panel->win);
1552
1553 WSETUFLAG(panel->frame, no_closable, 0);
1554 WSETUFLAG(panel->frame, no_close_button, 0);
1555 wWindowUpdateButtonImages(panel->frame);
1556 wFrameWindowShowButton(panel->frame->frame, WFF_RIGHT_BUTTON);
1557 panel->frame->frame->on_click_right = destroyInspector;
1558
1559 wWindowMap(panel->frame);
1560
1561 showIconFor(WMWidgetScreen(panel->alwChk), panel, wwin->wm_instance, wwin->wm_class, UPDATE_TEXT_FIELD);
1562
1563 return panel;
1564 }
1565
1566 void wShowInspectorForWindow(WWindow *wwin)
1567 {
1568 if (wwin->flags.inspector_open)
1569 return;
1570
1571 WMSetBalloonEnabled(wwin->screen_ptr->wmscreen, wPreferences.help_balloon);
1572
1573 make_keys();
1574 wwin->flags.inspector_open = 1;
1575 wwin->inspector = createInspectorForWindow(wwin, UNDEFINED_POS, UNDEFINED_POS, False);
1576 }
1577
1578 void wHideInspectorForWindow(WWindow *wwin)
1579 {
1580 WWindow *pwin = wwin->inspector->frame;
1581
1582 wWindowUnmap(pwin);
1583 pwin->flags.hidden = 1;
1584
1585 wClientSetState(pwin, IconicState, None);
1586 }
1587
1588 void wUnhideInspectorForWindow(WWindow *wwin)
1589 {
1590 WWindow *pwin = wwin->inspector->frame;
1591
1592 pwin->flags.hidden = 0;
1593 pwin->flags.mapped = 1;
1594 XMapWindow(dpy, pwin->client_win);
1595 XMapWindow(dpy, pwin->frame->core->window);
1596 wClientSetState(pwin, NormalState, None);
1597 }
1598
1599 WWindow *wGetWindowOfInspectorForWindow(WWindow *wwin)
1600 {
1601 if (wwin->inspector) {
1602 assert(wwin->flags.inspector_open != 0);
1603
1604 return wwin->inspector->frame;
1605 } else
1606 return NULL;
1607 }
1608
1609 void wCloseInspectorForWindow(WWindow *wwin)
1610 {
1611 WWindow *pwin = wwin->inspector->frame; /* the inspector window */
1612
1613 (*pwin->frame->on_click_right) (NULL, pwin, NULL);
1614 }
The Window Maker window manager