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