Added the crash dialog panel
[wmaker-crm.git] / src / kwm.c
blob58433ecd5c0c74559c7d0637d1b86bb116f3e571
1 /* kwm.c-- stuff for support for kwm hints
3 * Window Maker window manager
4 *
5 * Copyright (c) 1998, 1999 Alfredo K. Kojima
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 * USA.
25 * Supported stuff:
26 * ================
28 * kfm icon selection from krootbgwm
30 * kwm.h function/method Notes
31 *----------------------------------------------------------------------------
32 * setUnsavedDataHint() currently, only gives visual clue that
33 * there is unsaved data (broken X close button)
34 * setSticky()
35 * setIcon() std X thing...
36 * setDecoration()
37 * logout()
38 * refreshScreen()
39 * setWmCommand() std X thing
40 * currentDesktop()
41 * setKWMModule()
43 * isKWMInitialized() not trustworthy
44 * activeWindow() dunno it's use, but since it's easy to
45 * implement it won't hurt to support
46 * switchToDesktop()
47 * (set/get)WindowRegion()
48 * (set)numberOfDesktops() KDE limits to 32, but wmaker is virtually
49 * unlimited. May raise some incompatibility
50 * in badly written KDE modules?
51 * (set/get)DesktopName()
52 * sendKWMCommand() also does the message relay thing
53 * desktop()
54 * geometryRestore()
55 * isIconified()
56 * isMaximized()
57 * isSticky()
58 * moveToDesktop() WARNING: evil mechanism
59 * setGeometryRestore() WARNING: evil mechanism
60 * setMaximize() woo hoo! wanna race?
61 * setIconify() BAH!: why reinvent the f'ing wheel!?
62 * its even broken!!!
63 * move() std X thing
64 * setGeometry() std X thing
65 * close() std X thing
66 * activate()
67 * activateInternal()
68 * raise() std X thing
69 * lower() std X thing
70 * prepareForSwallowing() std X thing
71 * doNotManage() klugy thing...
72 * getBlablablaString()
73 * setKWMDockModule() maybe we can make the Dock behave as the KDE
74 * dock, but must figure where to show the windows
75 * setDockWindow()
77 * Unsupported stuff (superfluous/not-essential/nonsense):
78 * =======================================================
80 * darkenScreen()
81 * setMiniIcon()
82 * configureWm()
83 * raiseSoundEvent()
84 * registerSoundEvent()
85 * unregisterSoundEvent()
86 * title()
87 * titleWithState()
88 * geometry() kde lib code makes it unnecessary
91 * Extensions to KDE:
92 * ==================
94 * These are clientmessage-type messages specific to Window Maker:
95 * wmaker:info - show info panel
96 * wmaker:legal - show legal panel
97 * wmaker:arrangeIcons - arrange icons
98 * wmaker:showAll - show all windows
99 * wmaker:hideOthers - hide others
100 * wmaker:restart - restart wmaker
101 * wmaker:exit - exit wmaker
105 * TODO
106 * different WORKAREA for each workspace
110 #include "wconfig.h"
112 #ifdef KWM_HINTS
114 #include <X11/Xlib.h>
115 #include <X11/Xutil.h>
116 #include <X11/Xatom.h>
118 #include <stdlib.h>
119 #include <stdio.h>
120 #include <string.h>
121 #include <unistd.h>
123 #include <sys/types.h>
124 #include <sys/socket.h>
125 #include <sys/un.h>
126 #include <signal.h>
129 #include "WindowMaker.h"
131 #include "screen.h"
132 #include "wcore.h"
133 #include "framewin.h"
134 #include "window.h"
135 #include "properties.h"
136 #include "icon.h"
137 #include "client.h"
138 #include "funcs.h"
139 #include "actions.h"
140 #include "workspace.h"
141 #include "dialog.h"
142 #include "stacking.h"
144 #include "kwm.h"
146 /*#define DEBUG1
148 /******* Global ******/
150 extern Time LastFocusChange;
151 extern Time LastTimestamp;
154 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW;
155 extern Atom _XA_WM_DELETE_WINDOW;
157 /** Local **/
159 static Atom _XA_KWM_COMMAND = 0;
160 static Atom _XA_KWM_ACTIVATE_WINDOW = 0;
161 static Atom _XA_KWM_ACTIVE_WINDOW = 0;
162 static Atom _XA_KWM_DO_NOT_MANAGE = 0;
163 static Atom _XA_KWM_DOCKWINDOW = 0;
164 static Atom _XA_KWM_RUNNING = 0;
166 static Atom _XA_KWM_MODULE = 0;
168 static Atom _XA_KWM_MODULE_INIT = 0;
169 static Atom _XA_KWM_MODULE_INITIALIZED = 0;
170 static Atom _XA_KWM_MODULE_DESKTOP_CHANGE = 0;
171 static Atom _XA_KWM_MODULE_DESKTOP_NAME_CHANGE = 0;
172 static Atom _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE = 0;
173 static Atom _XA_KWM_MODULE_WIN_ADD = 0;
174 static Atom _XA_KWM_MODULE_WIN_REMOVE = 0;
175 static Atom _XA_KWM_MODULE_WIN_CHANGE = 0;
176 static Atom _XA_KWM_MODULE_WIN_RAISE = 0;
177 static Atom _XA_KWM_MODULE_WIN_LOWER = 0;
178 static Atom _XA_KWM_MODULE_WIN_ACTIVATE = 0;
179 static Atom _XA_KWM_MODULE_WIN_ICON_CHANGE = 0;
180 static Atom _XA_KWM_MODULE_DOCKWIN_ADD = 0;
181 static Atom _XA_KWM_MODULE_DOCKWIN_REMOVE = 0;
183 static Atom _XA_KWM_WIN_UNSAVED_DATA = 0;
184 static Atom _XA_KWM_WIN_DECORATION = 0;
185 static Atom _XA_KWM_WIN_DESKTOP = 0;
186 static Atom _XA_KWM_WIN_GEOMETRY_RESTORE = 0;
187 static Atom _XA_KWM_WIN_ICONIFIED = 0;
188 static Atom _XA_KWM_WIN_MAXIMIZED = 0;
189 static Atom _XA_KWM_WIN_STICKY = 0;
191 static Atom _XA_KWM_WIN_ICON_GEOMETRY = 0;
193 static Atom _XA_KWM_CURRENT_DESKTOP = 0;
194 static Atom _XA_KWM_NUMBER_OF_DESKTOPS = 0;
195 static Atom _XA_KWM_DESKTOP_NAME_[MAX_WORKSPACES];
196 static Atom _XA_KWM_WINDOW_REGION_[MAX_WORKSPACES];
200 /* list of window titles that must not be managed */
201 typedef struct KWMDoNotManageList {
202 char title[20];
203 struct KWMDoNotManageList *next;
204 } KWMDoNotManageList;
206 static KWMDoNotManageList *KWMDoNotManageCrap = NULL;
209 /* list of KWM modules */
210 typedef struct KWMModuleList {
211 Window window;
212 struct KWMModuleList *next;
213 #ifdef DEBUG1
214 char *title;
215 #endif
216 } KWMModuleList;
218 static KWMModuleList *KWMModules = NULL;
220 static KWMModuleList *KWMDockWindows = NULL;
222 /* window decoration types */
223 enum {
224 KWMnoDecoration = 0,
225 KWMnormalDecoration = 1,
226 KWMtinyDecoration = 2,
227 KWMnoFocus = 256,
228 KWMstandaloneMenuBar = 512,
229 KWMdesktopIcon = 1024,
230 KWMstaysOnTop = 2048
235 static Bool
236 getSimpleHint(Window win, Atom atom, long *retval)
238 long *data = 0;
240 assert(atom!=0);
242 data = (long*)PropGetCheckProperty(win, atom, atom, 32, 1, NULL);
244 if (!data)
245 return False;
247 *retval = *data;
249 XFree(data);
251 return True;
256 static void
257 setSimpleHint(Window win, Atom atom, long value)
259 assert(atom!=0);
260 XChangeProperty(dpy, win, atom, atom,
261 32, PropModeReplace, (unsigned char*)&value, 1);
265 static void
266 sendClientMessage(WScreen *scr, Window window, Atom atom, long value)
268 XEvent event;
269 long mask = 0;
271 assert(atom!=0);
273 memset(&event, 0, sizeof(XEvent));
274 event.xclient.type = ClientMessage;
275 event.xclient.message_type = atom;
276 event.xclient.window = window;
277 event.xclient.format = 32;
278 event.xclient.data.l[0] = value;
279 event.xclient.data.l[1] = LastTimestamp;
281 if (scr && scr->root_win == window)
282 mask = SubstructureRedirectMask;
284 XSendEvent(dpy, window, False, mask, &event);
288 static void
289 sendTextMessage(WScreen *scr, Window window, Atom atom, char *text)
291 XEvent event;
292 long mask = 0;
293 int i;
295 assert(atom!=0);
297 memset(&event, 0, sizeof(XEvent));
298 event.xclient.type = ClientMessage;
299 event.xclient.message_type = atom;
300 event.xclient.window = window;
301 event.xclient.format = 8;
303 for (i=0; i<20 && text[i]; i++)
304 event.xclient.data.b[i] = text[i];
306 if (scr && scr->root_win == window)
307 mask = SubstructureRedirectMask;
309 XSendEvent(dpy, window, False, mask, &event);
313 static Bool
314 getAreaHint(Window win, Atom atom, WArea *area)
316 long *data = 0;
318 data = (long*)PropGetCheckProperty(win, atom, atom, 32, 4, NULL);
320 if (!data)
321 return False;
323 area->x1 = data[0];
324 area->y1 = data[1];
325 area->x2 = data[2] + area->x1;
326 area->y2 = data[3] + area->y1;
328 XFree(data);
330 return True;
334 static void
335 setAreaHint(Window win, Atom atom, WArea area)
337 long value[4];
339 assert(atom!=0);
340 value[0] = area.x1;
341 value[1] = area.y1;
342 value[2] = area.x2 - area.x1;
343 value[3] = area.y2 - area.y1;
344 XChangeProperty(dpy, win, atom, atom, 32, PropModeReplace,
345 (unsigned char*)&value, 4);
349 static void
350 addModule(WScreen *scr, Window window)
352 KWMModuleList *node;
353 long val;
354 WWindow *ptr;
356 node = malloc(sizeof(KWMModuleList));
357 if (!node) {
358 wwarning("out of memory while registering KDE module");
359 return;
362 node->next = KWMModules;
363 node->window = window;
364 KWMModules = node;
366 sendClientMessage(scr, window, _XA_KWM_MODULE_INIT, 0);
368 if (getSimpleHint(window, _XA_KWM_MODULE, &val) && val==2) {
369 if (scr->kwm_dock != None) {
370 setSimpleHint(window, _XA_KWM_MODULE, 1);
371 } else {
372 KWMModuleList *ptr;
374 scr->kwm_dock = window;
376 for (ptr = KWMDockWindows; ptr!=NULL; ptr = ptr->next) {
377 sendClientMessage(scr, scr->kwm_dock, _XA_KWM_MODULE_DOCKWIN_ADD,
378 ptr->window);
383 /* send list of windows */
384 for (ptr = scr->focused_window; ptr!=NULL; ptr = ptr->prev) {
385 if (!ptr->flags.kwm_hidden_for_modules
386 && !WFLAGP(ptr, skip_window_list)) {
387 sendClientMessage(scr, window, _XA_KWM_MODULE_WIN_ADD,
388 ptr->client_win);
392 /* send window stacking order */
393 wKWMSendStacking(scr, window);
395 /* send focused window */
396 if (scr->focused_window && scr->focused_window->flags.focused) {
397 sendClientMessage(scr, window, _XA_KWM_MODULE_WIN_ACTIVATE,
398 scr->focused_window->client_win);
401 /* tell who we are */
402 sendTextMessage(scr, window, _XA_KWM_COMMAND, "wm:wmaker");
405 sendClientMessage(scr, window, _XA_KWM_MODULE_INITIALIZED, 0);
406 #ifdef DEBUG1
407 KWMModules->title = NULL;
408 XFetchName(dpy, window, &KWMModules->title);
409 printf("NEW MODULE %s\n", KWMModules->title);
410 #endif
414 static void
415 removeModule(WScreen *scr, Window window)
417 KWMModuleList *next;
419 if (!KWMModules) {
420 return;
423 if (KWMModules->window == window) {
424 next = KWMModules->next;
425 #ifdef DEBUG1
426 printf("REMOVING MODULE %s\n", KWMModules->title);
427 if (KWMModules->title)
428 XFree(KWMModules->title);
429 #endif
430 free(KWMModules);
431 KWMModules = next;
432 } else {
433 KWMModuleList *ptr;
435 ptr = KWMModules;
436 while (ptr->next) {
437 if (ptr->next->window == window) {
438 next = ptr->next->next;
439 #ifdef DEBUG1
440 printf("REMOVING MODULE %s\n", ptr->next->title);
441 if (ptr->next->title)
442 XFree(ptr->next->title);
443 #endif
444 free(ptr->next);
445 ptr->next->next = next;
446 break;
448 ptr->next = ptr->next->next;
452 if (scr->kwm_dock == window)
453 scr->kwm_dock = None;
458 static void
459 addDockWindow(WScreen *scr, Window window)
461 KWMModuleList *ptr;
463 for (ptr = KWMDockWindows; ptr != NULL; ptr = ptr->next) {
464 if (ptr->window == window)
465 break;
467 if (!ptr) {
468 KWMModuleList *node;
470 node = malloc(sizeof(KWMModuleList));
471 if (!node) {
472 wwarning("out of memory while processing KDE dock window");
473 return;
475 node->next = KWMDockWindows;
476 KWMDockWindows = node;
477 node->window = window;
478 XSelectInput(dpy, window, StructureNotifyMask);
480 sendClientMessage(scr, scr->kwm_dock, _XA_KWM_MODULE_DOCKWIN_ADD,
481 window);
486 static void
487 removeDockWindow(WScreen *scr, Window window)
489 if (!KWMDockWindows)
490 return;
492 if (KWMDockWindows->window == window) {
493 KWMModuleList *next;
495 sendClientMessage(scr, scr->kwm_dock, _XA_KWM_MODULE_DOCKWIN_REMOVE,
496 window);
498 next = KWMDockWindows->next;
499 free(KWMDockWindows);
500 KWMDockWindows = next;
502 } else {
503 KWMModuleList *ptr, *next;
505 ptr = KWMDockWindows;
506 while (ptr->next) {
507 if (ptr->next->window == window) {
508 sendClientMessage(scr, scr->kwm_dock,
509 _XA_KWM_MODULE_DOCKWIN_REMOVE, window);
510 next = ptr->next->next;
511 free(ptr->next);
512 ptr->next = next;
513 return;
515 ptr = ptr->next;
521 static void
522 sendToModules(WScreen *scr, Atom atom, WWindow *wwin, long data)
524 KWMModuleList *ptr;
525 XEvent event;
526 long mask;
528 if (wwin) {
529 if (wwin->flags.kwm_hidden_for_modules
530 || WFLAGP(wwin, skip_window_list))
531 return;
532 data = wwin->client_win;
534 #ifdef DEBUG1
535 printf("notifying %s\n",XGetAtomName(dpy, atom));
536 #endif
537 memset(&event, 0, sizeof(XEvent));
538 event.xclient.type = ClientMessage;
539 event.xclient.message_type = atom;
540 event.xclient.format = 32;
541 event.xclient.data.l[1] = LastTimestamp;
543 mask = 0;
544 if (scr && scr->root_win == data)
545 mask = SubstructureRedirectMask;
547 for (ptr = KWMModules; ptr!=NULL; ptr = ptr->next) {
548 event.xclient.window = ptr->window;
549 event.xclient.data.l[0] = data;
550 XSendEvent(dpy, ptr->window, False, mask, &event);
555 void
556 wKWMInitStuff(WScreen *scr)
558 if (!_XA_KWM_WIN_STICKY) {
559 _XA_KWM_WIN_UNSAVED_DATA = XInternAtom(dpy, "KWM_WIN_UNSAVED_DATA",
560 False);
562 _XA_KWM_WIN_DECORATION = XInternAtom(dpy, "KWM_WIN_DECORATION", False);
564 _XA_KWM_WIN_DESKTOP = XInternAtom(dpy, "KWM_WIN_DESKTOP", False);
566 _XA_KWM_WIN_GEOMETRY_RESTORE = XInternAtom(dpy,
567 "KWM_WIN_GEOMETRY_RESTORE",
568 False);
570 _XA_KWM_WIN_STICKY = XInternAtom(dpy, "KWM_WIN_STICKY", False);
572 _XA_KWM_WIN_ICONIFIED = XInternAtom(dpy, "KWM_WIN_ICONIFIED", False);
574 _XA_KWM_WIN_MAXIMIZED = XInternAtom(dpy, "KWM_WIN_MAXIMIZED", False);
576 _XA_KWM_WIN_ICON_GEOMETRY = XInternAtom(dpy, "KWM_WIN_ICON_GEOMETRY",
577 False);
579 _XA_KWM_COMMAND = XInternAtom(dpy, "KWM_COMMAND", False);
581 _XA_KWM_ACTIVE_WINDOW = XInternAtom(dpy, "KWM_ACTIVE_WINDOW", False);
583 _XA_KWM_ACTIVATE_WINDOW = XInternAtom(dpy, "KWM_ACTIVATE_WINDOW",
584 False);
586 _XA_KWM_DO_NOT_MANAGE = XInternAtom(dpy, "KWM_DO_NOT_MANAGE", False);
588 _XA_KWM_CURRENT_DESKTOP = XInternAtom(dpy, "KWM_CURRENT_DESKTOP",
589 False);
591 _XA_KWM_NUMBER_OF_DESKTOPS = XInternAtom(dpy, "KWM_NUMBER_OF_DESKTOPS",
592 False);
594 _XA_KWM_DOCKWINDOW = XInternAtom(dpy, "KWM_DOCKWINDOW", False);
596 _XA_KWM_RUNNING = XInternAtom(dpy, "KWM_RUNNING", False);
598 _XA_KWM_MODULE = XInternAtom(dpy, "KWM_MODULE", False);
600 _XA_KWM_MODULE_INIT = XInternAtom(dpy, "KWM_MODULE_INIT", False);
601 _XA_KWM_MODULE_INITIALIZED = XInternAtom(dpy, "KWM_MODULE_INITIALIZED", False);
603 /* dunno what these do, but Matthias' patch contains it... */
604 _XA_KWM_MODULE_DESKTOP_CHANGE = XInternAtom(dpy, "KWM_MODULE_DESKTOP_CHANGE", False);
605 _XA_KWM_MODULE_DESKTOP_NAME_CHANGE = XInternAtom(dpy, "KWM_MODULE_DESKTOP_NAME_CHANGE", False);
606 _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE = XInternAtom(dpy, "KWM_MODULE_DESKTOP_NUMBER_CHANGE", False);
608 _XA_KWM_MODULE_WIN_ADD = XInternAtom(dpy, "KWM_MODULE_WIN_ADD", False);
609 _XA_KWM_MODULE_WIN_REMOVE = XInternAtom(dpy, "KWM_MODULE_WIN_REMOVE", False);
610 _XA_KWM_MODULE_WIN_CHANGE = XInternAtom(dpy, "KWM_MODULE_WIN_CHANGE", False);
611 _XA_KWM_MODULE_WIN_RAISE = XInternAtom(dpy, "KWM_MODULE_WIN_RAISE", False);
612 _XA_KWM_MODULE_WIN_LOWER = XInternAtom(dpy, "KWM_MODULE_WIN_LOWER", False);
613 _XA_KWM_MODULE_WIN_ACTIVATE = XInternAtom(dpy, "KWM_MODULE_WIN_ACTIVATE", False);
614 _XA_KWM_MODULE_WIN_ICON_CHANGE = XInternAtom(dpy, "KWM_MODULE_WIN_ICON_CHANGE", False);
615 _XA_KWM_MODULE_DOCKWIN_ADD = XInternAtom(dpy, "KWM_MODULE_DOCKWIN_ADD", False);
616 _XA_KWM_MODULE_DOCKWIN_REMOVE = XInternAtom(dpy, "KWM_MODULE_DOCKWIN_REMOVE", False);
618 memset(_XA_KWM_WINDOW_REGION_, 0, sizeof(_XA_KWM_WINDOW_REGION_));
620 memset(_XA_KWM_DESKTOP_NAME_, 0, sizeof(_XA_KWM_DESKTOP_NAME_));
623 #define SETSTR(hint, str) {\
624 static Atom a = 0; if (!a) a = XInternAtom(dpy, #hint, False);\
625 XChangeProperty(dpy, scr->root_win, a, XA_STRING, 8, PropModeReplace,\
626 (unsigned char*)str, strlen(str));}
628 SETSTR(KWM_STRING_MAXIMIZE, _("Maximize"));
629 SETSTR(KWM_STRING_UNMAXIMIZE, _("Unmaximize"));
630 SETSTR(KWM_STRING_ICONIFY, _("Miniaturize"));
631 SETSTR(KWM_STRING_UNICONIFY, _("Deminiaturize"));
632 SETSTR(KWM_STRING_STICKY, _("Omnipresent"));
633 SETSTR(KWM_STRING_UNSTICKY, _("Not Omnipresent"));
634 SETSTR(KWM_STRING_STRING_MOVE, _("Move"));
635 SETSTR(KWM_STRING_STRING_RESIZE, _("Resize"));
636 SETSTR(KWM_STRING_CLOSE, _("Close"));
637 SETSTR(KWM_STRING_TODESKTOP, _("Move To"));
638 SETSTR(KWM_STRING_ONTOCURRENTDESKTOP, _("Bring Here"));
639 #undef SETSTR
643 void
644 wKWMSendStacking(WScreen *scr, Window module)
646 int i;
647 WCoreWindow *core;
649 for (i = 0; i < MAX_WINDOW_LEVELS; i++) {
650 for (core = scr->stacking_list[i]; core != NULL;
651 core = core->stacking->under) {
652 WWindow *wwin;
654 wwin = wWindowFor(core->window);
655 if (wwin)
656 sendClientMessage(scr, module, _XA_KWM_MODULE_WIN_RAISE,
657 wwin->client_win);
663 void
664 wKWMBroadcastStacking(WScreen *scr)
666 KWMModuleList *ptr = KWMModules;
668 while (ptr) {
669 wKWMSendStacking(scr, ptr->window);
671 ptr = ptr->next;
676 char*
677 wKWMGetWorkspaceName(WScreen *scr, int workspace)
679 Atom type_ret;
680 int fmt_ret;
681 unsigned long nitems_ret;
682 unsigned long bytes_after_ret;
683 char *data = NULL, *tmp;
684 char buffer[64];
686 assert(workspace >= 0 && workspace < MAX_WORKSPACES);
688 if (_XA_KWM_DESKTOP_NAME_[workspace]==0) {
689 sprintf(buffer, "KWM_DESKTOP_NAME_%d", workspace + 1);
691 _XA_KWM_DESKTOP_NAME_[workspace] = XInternAtom(dpy, buffer, False);
694 /* What do these people have against correctly using property types? */
695 if (XGetWindowProperty(dpy, scr->root_win,
696 _XA_KWM_DESKTOP_NAME_[workspace], 0, 128, False,
697 XA_STRING,
698 &type_ret, &fmt_ret, &nitems_ret, &bytes_after_ret,
699 (unsigned char**)&data)!=Success || !data)
700 return NULL;
702 tmp = wstrdup(data);
703 XFree(data);
705 return tmp;
709 void
710 wKWMSetInitializedHint(WScreen *scr)
712 setSimpleHint(scr->root_win, _XA_KWM_RUNNING, 1);
716 void
717 wKWMShutdown(WScreen *scr, Bool closeModules)
719 KWMModuleList *ptr;
721 XDeleteProperty(dpy, scr->root_win, _XA_KWM_RUNNING);
723 if (closeModules) {
724 for (ptr = KWMModules; ptr != NULL; ptr = ptr->next) {
725 XKillClient(dpy, ptr->window);
731 void
732 wKWMCheckClientHints(WWindow *wwin, int *layer, int *workspace)
734 long val;
736 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_UNSAVED_DATA, &val)
737 && val) {
739 wwin->client_flags.broken_close = 1;
741 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DECORATION, &val)) {
742 if (val & KWMnoFocus) {
743 wwin->client_flags.no_focusable = 1;
745 switch (val & ~KWMnoFocus) {
746 case KWMnoDecoration:
747 wwin->client_flags.no_titlebar = 1;
748 wwin->client_flags.no_resizebar = 1;
749 break;
750 case KWMtinyDecoration:
751 wwin->client_flags.no_resizebar = 1;
752 break;
753 case KWMstandaloneMenuBar:
754 wwin->client_flags.no_titlebar = 1;
755 wwin->client_flags.no_resizebar = 1;
756 wwin->client_flags.no_resizable = 1;
757 wwin->client_flags.skip_window_list = 1;
758 wwin->client_flags.no_hide_others = 1;
759 wwin->flags.kwm_menubar = 1;
760 *layer = WMMainMenuLevel;
761 break;
762 case KWMdesktopIcon:
763 *layer = WMDesktopLevel;
764 break;
765 case KWMstaysOnTop:
766 *layer = WMFloatingLevel;
767 break;
768 case KWMnormalDecoration:
769 default:
770 break;
773 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP, &val)) {
774 *workspace = val - 1;
779 void
780 wKWMCheckClientInitialState(WWindow *wwin)
782 long val;
784 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY, &val) && val) {
786 wwin->client_flags.omnipresent = 1;
788 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED, &val) && val) {
790 wwin->flags.miniaturized = 1;
792 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED, &val) && val) {
794 wwin->flags.maximized = MAX_VERTICAL|MAX_HORIZONTAL;
799 Bool
800 wKWMCheckClientHintChange(WWindow *wwin, XPropertyEvent *event)
802 Bool processed = True;
803 Bool flag;
804 long value;
807 if (!wwin->frame) {
808 return False;
811 if (event->atom == _XA_KWM_WIN_UNSAVED_DATA) {
812 #ifdef DEBUG1
813 printf("got KDE unsaved data change\n");
814 #endif
816 flag = getSimpleHint(wwin->client_win, _XA_KWM_WIN_UNSAVED_DATA,
817 &value) && value;
819 if (flag != wwin->client_flags.broken_close) {
820 wwin->client_flags.broken_close = flag;
821 if (wwin->frame)
822 wWindowUpdateButtonImages(wwin);
824 } else if (event->atom == _XA_KWM_WIN_STICKY) {
826 #ifdef DEBUG1
827 printf("got KDE sticky change\n");
828 #endif
829 flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY,
830 &value) || value;
832 if (flag != wwin->client_flags.omnipresent) {
834 wwin->client_flags.omnipresent = flag;
836 UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_WORKSPACE);
839 } else if (event->atom == _XA_KWM_WIN_MAXIMIZED) {
841 #ifdef DEBUG1
842 printf("got KDE maximize change\n");
843 #endif
844 flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED,
845 &value) || value;
847 if (flag != (wwin->flags.maximized!=0)) {
849 if (flag)
850 wMaximizeWindow(wwin, flag*(MAX_VERTICAL|MAX_HORIZONTAL));
851 else
852 wUnmaximizeWindow(wwin);
854 } else if (event->atom == _XA_KWM_WIN_ICONIFIED) {
856 #ifdef DEBUG1
857 printf("got KDE iconify change\n");
858 #endif
859 flag = !getSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED,
860 &value) || value;
862 if (flag != wwin->flags.miniaturized) {
864 if (flag)
865 wIconifyWindow(wwin);
866 else
867 wDeiconifyWindow(wwin);
870 } else if (event->atom == _XA_KWM_WIN_DECORATION) {
871 Bool refresh = False;
872 int oldnofocus;
874 #ifdef DEBUG1
875 printf("got KDE decoration change\n");
876 #endif
878 oldnofocus = wwin->client_flags.no_focusable;
880 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DECORATION, &value)) {
881 wwin->client_flags.no_focusable = (value & KWMnoFocus)!=0;
883 switch (value & ~KWMnoFocus) {
884 case KWMnoDecoration:
885 if (!WFLAGP(wwin, no_titlebar) || !WFLAGP(wwin, no_resizebar))
886 refresh = True;
888 wwin->client_flags.no_titlebar = 1;
889 wwin->client_flags.no_resizebar = 1;
890 break;
892 case KWMtinyDecoration:
893 if (WFLAGP(wwin, no_titlebar) || !WFLAGP(wwin, no_resizebar))
894 refresh = True;
896 wwin->client_flags.no_titlebar = 0;
897 wwin->client_flags.no_resizebar = 1;
898 break;
900 case KWMnormalDecoration:
901 default:
902 if (WFLAGP(wwin, no_titlebar) || WFLAGP(wwin, no_resizebar))
903 refresh = True;
905 wwin->client_flags.no_titlebar = 0;
906 wwin->client_flags.no_resizebar = 0;
907 break;
909 } else {
910 if (WFLAGP(wwin, no_titlebar) || WFLAGP(wwin, no_resizebar))
911 refresh = True;
912 wwin->client_flags.no_focusable = (value & KWMnoFocus)!=0;
913 wwin->client_flags.no_titlebar = 0;
914 wwin->client_flags.no_resizebar = 0;
917 if (refresh)
918 wWindowConfigureBorders(wwin);
920 if (wwin->client_flags.no_focusable && !oldnofocus) {
922 sendToModules(wwin->screen_ptr, _XA_KWM_MODULE_WIN_REMOVE,
923 wwin, 0);
924 wwin->flags.kwm_hidden_for_modules = 1;
926 } else if (!wwin->client_flags.no_focusable && oldnofocus) {
928 if (wwin->flags.kwm_hidden_for_modules) {
929 sendToModules(wwin->screen_ptr, _XA_KWM_MODULE_WIN_ADD,
930 wwin, 0);
931 wwin->flags.kwm_hidden_for_modules = 0;
934 } else if (event->atom == _XA_KWM_WIN_DESKTOP && wwin->frame) {
935 #ifdef DEBUG1
936 printf("got KDE workspace change for %s\n", wwin->frame->title);
937 #endif
938 if (getSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP, &value)
939 && value-1 != wwin->frame->workspace) {
940 wWindowChangeWorkspace(wwin, value-1);
943 } else if (event->atom == _XA_KWM_WIN_GEOMETRY_RESTORE) {
944 WArea area;
946 #ifdef DEBUG1
947 printf("got KDE geometry restore change\n");
948 #endif
949 if (getAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, &area)
950 && (wwin->old_geometry.x != area.x1
951 || wwin->old_geometry.y != area.y1
952 || wwin->old_geometry.width != area.x2 - area.x1
953 || wwin->old_geometry.height != area.y2 - area.y1)) {
955 wwin->old_geometry.x = area.x1;
956 wwin->old_geometry.y = area.y1;
957 wwin->old_geometry.width = area.x2 - area.x1;
958 wwin->old_geometry.height = area.y2 - area.y1;
960 } else {
961 processed = False;
964 return processed;
968 static Bool
969 performWindowCommand(WScreen *scr, char *command)
971 WWindow *wwin = NULL;
974 wwin = scr->focused_window;
975 if (!wwin || !wwin->flags.focused || !wwin->flags.mapped) {
976 wwin = NULL;
979 CloseWindowMenu(scr);
982 if (strcmp(command, "winMove")==0 || strcmp(command, "winResize")==0) {
984 if (wwin)
985 wKeyboardMoveResizeWindow(wwin);
987 } else if (strcmp(command, "winMaximize")==0) {
989 if (wwin)
990 wMaximizeWindow(wwin, MAX_VERTICAL|MAX_HORIZONTAL);
992 } else if (strcmp(command, "winRestore")==0) {
994 if (wwin && wwin->flags.maximized)
995 wUnmaximizeWindow(wwin);
997 } else if (strcmp(command, "winIconify")==0) {
1000 if (wwin && !WFLAGP(wwin, no_miniaturizable)) {
1001 if (wwin->protocols.MINIATURIZE_WINDOW)
1002 wClientSendProtocol(wwin, _XA_GNUSTEP_WM_MINIATURIZE_WINDOW,
1003 LastTimestamp);
1004 else {
1005 wIconifyWindow(wwin);
1009 } else if (strcmp(command, "winClose")==0) {
1011 if (wwin && !WFLAGP(wwin, no_closable)) {
1012 if (wwin->protocols.DELETE_WINDOW)
1013 wClientSendProtocol(wwin, _XA_WM_DELETE_WINDOW, LastTimestamp);
1016 } else if (strcmp(command, "winSticky")==0) {
1018 if (wwin) {
1019 wwin->client_flags.omnipresent ^= 1;
1020 UpdateSwitchMenu(scr, wwin, ACTION_CHANGE_WORKSPACE);
1023 } else if (strcmp(command, "winShade")==0) {
1025 if (wwin && !WFLAGP(wwin, no_shadeable)) {
1026 if (wwin->flags.shaded)
1027 wUnshadeWindow(wwin);
1028 else
1029 wShadeWindow(wwin);
1032 } else if (strcmp(command, "winOperation")==0) {
1034 if (wwin)
1035 OpenWindowMenu(wwin, wwin->frame_x,
1036 wwin->frame_y+wwin->frame->top_width, True);
1038 } else {
1039 return False;
1042 return True;
1046 static void
1047 performCommand(WScreen *scr, char *command, XClientMessageEvent *event)
1049 assert(scr != NULL);
1051 if (strcmp(command, "commandLine")==0
1052 || strcmp(command, "execute")==0) {
1053 char *cmd;
1055 cmd = ExpandOptions(scr, _("%a(Run Command,Type the command to run:)"));
1056 if (cmd) {
1057 ExecuteShellCommand(scr, cmd);
1058 free(cmd);
1060 } else if (strcmp(command, "logout")==0) {
1062 Shutdown(WSLogoutMode);
1064 } else if (strcmp(command, "refreshScreen")==0) {
1066 wRefreshDesktop(scr);
1068 } else if (strncmp(command, "go:", 3)==0) {
1070 Shutdown(WSRestartPreparationMode);
1071 Restart(&command[3]);
1073 } else if (strcmp(command, "desktop+1")==0) {
1075 wWorkspaceRelativeChange(scr, 1);
1077 } else if (strcmp(command, "desktop-1")==0) {
1079 wWorkspaceRelativeChange(scr, -1);
1081 } else if (strcmp(command, "desktop+2")==0) {
1083 wWorkspaceRelativeChange(scr, 2);
1085 } else if (strcmp(command, "desktop-2")==0) {
1087 wWorkspaceRelativeChange(scr, -2);
1089 } else if (strcmp(command, "desktop%%2")==0) {
1091 if (scr->current_workspace % 2 == 1)
1092 wWorkspaceRelativeChange(scr, 1);
1093 else
1094 wWorkspaceRelativeChange(scr, -1);
1095 } else if (strncmp(command, "desktop", 7)==0) {
1096 int ws;
1098 ws = atoi(&command[7]);
1099 wWorkspaceChange(scr, ws);
1101 /* wmaker specific stuff */
1102 } else if (strcmp(command, "wmaker:info")==0) {
1104 wShowInfoPanel(scr);
1106 } else if (strcmp(command, "wmaker:legal")==0) {
1108 wShowLegalPanel(scr);
1110 } else if (strcmp(command, "wmaker:arrangeIcons")==0) {
1112 wArrangeIcons(scr, True);
1114 } else if (strcmp(command, "wmaker:showAll")==0) {
1116 wShowAllWindows(scr);
1118 } else if (strcmp(command, "wmaker:hideOthers")==0) {
1120 wHideOtherApplications(scr->focused_window);
1122 } else if (strcmp(command, "wmaker:restart")==0) {
1124 Shutdown(WSRestartPreparationMode);
1125 Restart(NULL);
1127 } else if (strcmp(command, "wmaker:exit")==0) {
1129 Shutdown(WSExitMode);
1131 #ifdef UNSUPPORTED_STUFF
1132 } else if (strcmp(command, "moduleRaised")==0) { /* useless */
1133 } else if (strcmp(command, "deskUnclutter")==0) {
1134 } else if (strcmp(command, "deskCascade")==0) {
1135 } else if (strcmp(command, "configure")==0) {
1136 } else if (strcmp(command, "taskManager")==0) {
1137 } else if (strcmp(command, "darkenScreen")==0) { /* breaks consistency */
1138 #endif
1139 } else if (!performWindowCommand(scr, command)) {
1140 KWMModuleList *module;
1141 long mask = 0;
1142 XEvent ev;
1143 /* do message relay thing */
1145 ev.xclient = *event;
1146 for (module = KWMModules; module != NULL; module = module->next) {
1148 ev.xclient.window = module->window;
1149 if (module->window == scr->root_win)
1150 mask = SubstructureRedirectMask;
1151 else
1152 mask = 0;
1154 XSendEvent(dpy, module->window, False, mask, &ev);
1160 Bool
1161 wKWMProcessClientMessage(XClientMessageEvent *event)
1163 Bool processed = True;
1164 WScreen *scr;
1165 #ifdef DEBUG1
1166 printf("CLIENT MESS %s\n", XGetAtomName(dpy, event->message_type));
1167 #endif
1168 if (event->message_type == _XA_KWM_COMMAND && event->format==8) {
1169 char buffer[24];
1170 int i;
1172 scr = wScreenForRootWindow(event->window);
1174 for (i=0; i<20; i++) {
1175 buffer[i] = event->data.b[i];
1177 buffer[i] = 0;
1179 #ifdef DEBUG1
1180 printf("got KDE command %s\n", buffer);
1181 #endif
1182 performCommand(scr, buffer, event);
1184 } else if (event->message_type == _XA_KWM_ACTIVATE_WINDOW) {
1185 WWindow *wwin;
1187 #ifdef DEBUG1
1188 printf("got KDE activate internal\n");
1189 #endif
1190 wwin = wWindowFor(event->data.l[0]);
1192 if (wwin)
1193 wSetFocusTo(wwin->screen_ptr, wwin);
1195 } else if (event->message_type == _XA_KWM_DO_NOT_MANAGE
1196 && event->format == 8) {
1197 KWMDoNotManageList *node;
1198 int i;
1200 #ifdef DEBUG1
1201 printf("got KDE dont manage\n");
1202 #endif
1204 node = malloc(sizeof(KWMDoNotManageList));
1205 if (!node) {
1206 wwarning("out of memory processing KWM_DO_NOT_MANAGE message");
1208 for (i=0; i<20 && event->data.b[i]; i++)
1209 node->title[i] = event->data.b[i];
1210 node->title[i] = 0;
1212 node->next = KWMDoNotManageCrap;
1213 KWMDoNotManageCrap = node;
1215 } else if (event->message_type == _XA_KWM_MODULE) {
1216 long val;
1217 Window modwin = event->data.l[0];
1219 scr = wScreenForRootWindow(event->window);
1221 if (getSimpleHint(modwin, _XA_KWM_MODULE, &val) && val) {
1222 #ifdef DEBUG1
1223 puts("got KDE module startup");
1224 #endif
1225 addModule(scr, modwin);
1226 } else {
1227 #ifdef DEBUG1
1228 puts("got KDE module finish");
1229 #endif
1230 removeModule(scr, modwin);
1232 } else {
1233 processed = False;
1236 return processed;
1240 void
1241 wKWMCheckModule(WScreen *scr, Window window)
1243 long val;
1245 if (getSimpleHint(window, _XA_KWM_MODULE, &val) && val) {
1246 #ifdef DEBUG1
1247 puts("got KDE module startup");
1248 #endif
1249 addModule(scr, window);
1254 Bool
1255 wKWMCheckRootHintChange(WScreen *scr, XPropertyEvent *event)
1257 Bool processed = True;
1258 long value;
1260 if (event->atom == _XA_KWM_CURRENT_DESKTOP) {
1261 if (getSimpleHint(scr->root_win, _XA_KWM_CURRENT_DESKTOP, &value)) {
1262 #ifdef DEBUG1
1263 printf("got KDE workspace switch to %li\n", value);
1264 #endif
1265 if (value-1 != scr->current_workspace) {
1266 wWorkspaceChange(scr, value-1);
1269 } else if (event->atom == _XA_KWM_NUMBER_OF_DESKTOPS) {
1270 #ifdef DEBUG1
1271 printf("got KDE workspace number change\n");
1272 #endif
1274 if (getSimpleHint(scr->root_win, _XA_KWM_NUMBER_OF_DESKTOPS, &value)) {
1276 /* increasing is easy... */
1277 if (value > scr->workspace_count) {
1278 scr->flags.kwm_syncing_count = 1;
1280 wWorkspaceMake(scr, value - scr->workspace_count);
1282 scr->flags.kwm_syncing_count = 0;
1284 } else if (value < scr->workspace_count) {
1285 int i;
1286 Bool rebuild = False;
1288 scr->flags.kwm_syncing_count = 1;
1290 /* decrease all we can do */
1291 for (i = scr->workspace_count; i >= value; i--) {
1292 if (!wWorkspaceDelete(scr, i)) {
1293 rebuild = True;
1294 break;
1298 scr->flags.kwm_syncing_count = 0;
1300 /* someone destroyed a workspace that can't be destroyed.
1301 * Reset the hints to reflect our internal state.
1303 if (rebuild) {
1304 wKWMUpdateWorkspaceCountHint(scr);
1308 } else {
1309 int i;
1311 processed = False;
1313 for (i = 0; i < MAX_WORKSPACES && i < scr->workspace_count; i++) {
1314 if (event->atom == _XA_KWM_DESKTOP_NAME_[i]) {
1315 char *name;
1317 name = wKWMGetWorkspaceName(scr, i);
1319 #ifdef DEBUG1
1320 printf("got KDE workspace name change to %s\n", name);
1321 #endif
1323 if (name && strncmp(name, scr->workspaces[i]->name,
1324 MAX_WORKSPACENAME_WIDTH)!=0) {
1325 scr->flags.kwm_syncing_name = 1;
1326 wWorkspaceRename(scr, i, name);
1327 scr->flags.kwm_syncing_name = 0;
1329 if (name)
1330 XFree(name);
1331 processed = True;
1332 break;
1333 } else if (event->atom == _XA_KWM_WINDOW_REGION_[i]) {
1334 WArea area;
1336 if (getAreaHint(scr->root_win, event->atom, &area)) {
1338 if (scr->totalUsableArea.x1 != area.x1
1339 || scr->totalUsableArea.y1 != area.y1
1340 || scr->totalUsableArea.x2 != area.x2
1341 || scr->totalUsableArea.y2 != area.y2) {
1342 wScreenUpdateUsableArea(scr);
1346 processed = True;
1347 break;
1352 return processed;
1356 Bool
1357 wKWMManageableClient(WScreen *scr, Window win, char *title)
1359 KWMDoNotManageList *ptr, *next;
1360 long val;
1362 if (getSimpleHint(win, _XA_KWM_DOCKWINDOW, &val) && val) {
1363 addDockWindow(scr, win);
1364 return False;
1367 ptr = KWMDoNotManageCrap;
1369 * TODO: support for glob patterns or regexes
1371 if (ptr && strncmp(ptr->title, title, strlen(ptr->title))==0) {
1372 next = ptr->next;
1373 free(ptr);
1374 KWMDoNotManageCrap = next;
1375 #ifdef DEBUG1
1376 printf("window %s not managed per KDE request\n", title);
1377 #endif
1379 sendToModules(scr, _XA_KWM_MODULE_WIN_ADD, NULL, win);
1380 sendToModules(scr, _XA_KWM_MODULE_WIN_REMOVE, NULL, win);
1382 return False;
1383 } else if (ptr) {
1384 while (ptr->next) {
1385 if (strncmp(ptr->next->title, title, strlen(ptr->next->title))==0) {
1386 #ifdef DEBUG1
1387 printf("window %s not managed per KDE request\n", title);
1388 #endif
1389 next = ptr->next->next;
1390 free(ptr->next);
1391 ptr->next = next;
1393 sendToModules(scr, _XA_KWM_MODULE_WIN_ADD, NULL, win);
1394 sendToModules(scr, _XA_KWM_MODULE_WIN_REMOVE, NULL, win);
1396 return False;
1399 ptr = ptr->next;
1403 return True;
1407 void
1408 wKWMUpdateCurrentWorkspaceHint(WScreen *scr)
1410 setSimpleHint(scr->root_win, _XA_KWM_CURRENT_DESKTOP,
1411 scr->current_workspace+1);
1413 sendToModules(scr, _XA_KWM_MODULE_DESKTOP_CHANGE, NULL,
1414 scr->current_workspace+1);
1418 void
1419 wKWMUpdateActiveWindowHint(WScreen *scr)
1421 long val;
1422 WWindow *wwin, *tmp;
1424 if (!scr->focused_window || !scr->focused_window->flags.focused)
1425 val = None;
1426 else {
1427 val = (long)(scr->focused_window->client_win);
1429 /* raise the menubar thing */
1430 wwin = scr->focused_window;
1431 tmp = wwin->prev;
1432 while (tmp) {
1433 if (tmp->flags.kwm_menubar
1434 && tmp->transient_for == wwin->client_win) {
1435 wRaiseFrame(tmp->frame->core);
1436 break;
1438 tmp = tmp->prev;
1442 XChangeProperty(dpy, scr->root_win, _XA_KWM_ACTIVE_WINDOW,
1443 _XA_KWM_ACTIVE_WINDOW, 32, PropModeReplace,
1444 (unsigned char*)&val, 1);
1445 XFlush(dpy);
1449 void
1450 wKWMUpdateWorkspaceCountHint(WScreen *scr)
1452 if (scr->flags.kwm_syncing_count)
1453 return;
1455 setSimpleHint(scr->root_win, _XA_KWM_NUMBER_OF_DESKTOPS,
1456 scr->workspace_count);
1458 sendToModules(scr, _XA_KWM_MODULE_DESKTOP_NUMBER_CHANGE, NULL,
1459 scr->workspace_count);
1463 void
1464 wKWMCheckDestroy(XDestroyWindowEvent *event)
1466 WScreen *scr;
1468 if (event->event == event->window) {
1469 return;
1472 scr = wScreenSearchForRootWindow(event->event);
1473 if (!scr) {
1474 return;
1477 removeModule(scr, event->window);
1478 removeDockWindow(scr, event->window);
1482 void
1483 wKWMUpdateWorkspaceNameHint(WScreen *scr, int workspace)
1485 char buffer[64];
1487 assert(workspace >= 0 && workspace < MAX_WORKSPACES);
1489 if (_XA_KWM_DESKTOP_NAME_[workspace]==0) {
1490 sprintf(buffer, "KWM_DESKTOP_NAME_%d", workspace + 1);
1492 _XA_KWM_DESKTOP_NAME_[workspace] = XInternAtom(dpy, buffer, False);
1495 XChangeProperty(dpy, scr->root_win, _XA_KWM_DESKTOP_NAME_[workspace],
1496 XA_STRING, 8, PropModeReplace,
1497 (unsigned char*)scr->workspaces[workspace]->name,
1498 strlen(scr->workspaces[workspace]->name)+1);
1500 sendToModules(scr, _XA_KWM_MODULE_DESKTOP_NAME_CHANGE, NULL, workspace+1);
1505 void
1506 wKWMUpdateClientWorkspace(WWindow *wwin)
1508 #ifdef DEBUG1
1509 printf("updating workspace of %s to %i\n",
1510 wwin->frame->title, wwin->frame->workspace+1);
1511 #endif
1512 setSimpleHint(wwin->client_win, _XA_KWM_WIN_DESKTOP,
1513 wwin->frame->workspace+1);
1517 void
1518 wKWMUpdateClientGeometryRestore(WWindow *wwin)
1520 WArea rect;
1522 rect.x1 = wwin->old_geometry.x;
1523 rect.y1 = wwin->old_geometry.y;
1524 rect.x2 = wwin->old_geometry.x + wwin->old_geometry.width;
1525 rect.y2 = wwin->old_geometry.y + wwin->old_geometry.height;
1527 setAreaHint(wwin->client_win, _XA_KWM_WIN_GEOMETRY_RESTORE, rect);
1531 void
1532 wKWMUpdateClientStateHint(WWindow *wwin, WKWMStateFlag flags)
1534 if (flags & KWMIconifiedFlag) {
1535 setSimpleHint(wwin->client_win, _XA_KWM_WIN_ICONIFIED,
1536 wwin->flags.miniaturized /*|| wwin->flags.shaded
1537 || wwin->flags.hidden*/);
1539 if (flags & KWMStickyFlag) {
1540 setSimpleHint(wwin->client_win, _XA_KWM_WIN_STICKY,
1541 IS_OMNIPRESENT(wwin));
1543 if (flags & KWMMaximizedFlag) {
1544 setSimpleHint(wwin->client_win, _XA_KWM_WIN_MAXIMIZED,
1545 wwin->flags.maximized!=0);
1550 Bool
1551 wKWMGetUsableArea(WScreen *scr, WArea *area)
1553 char buffer[64];
1555 if (_XA_KWM_WINDOW_REGION_[0]==0) {
1556 sprintf(buffer, "KWM_WINDOW_REGION_%d", 1);
1558 _XA_KWM_WINDOW_REGION_[0] = XInternAtom(dpy, buffer, False);
1561 return getAreaHint(scr->root_win, _XA_KWM_WINDOW_REGION_[0], area);
1566 Bool
1567 wKWMGetIconGeometry(WWindow *wwin, WArea *area)
1569 return getAreaHint(wwin->client_win, _XA_KWM_WIN_ICON_GEOMETRY, area);
1574 #ifdef not_used
1575 void
1576 wKWMSetUsableAreaHint(WScreen *scr, int workspace)
1578 /* if we set this after making changes of our own to the area,
1579 * the next time the area changes, we won't know what should
1580 * be the new final area. This protocol isn't worth a shit :/
1583 * According to Matthias Ettrich:
1584 * Indeed, there's no protocol to deal with the area yet in case several
1585 * clients want to influence it. It is sufficent, though, if it is clear
1586 * that one process is responsable for the area. For KDE this is kpanel, but
1587 * I see that there might be a conflict with the docking area of windowmaker
1588 * itself.
1592 #ifdef notdef
1593 char buffer[64];
1595 assert(workspace >= 0 && workspace < MAX_WORKSPACES);
1597 if (_XA_KWM_WINDOW_REGION_[workspace]==0) {
1598 sprintf(buffer, "KWM_WINDOW_REGION_%d", workspace+1);
1600 _XA_KWM_WINDOW_REGION_[workspace] = XInternAtom(dpy, buffer, False);
1603 setAreaHint(scr->root_win, _XA_KWM_WINDOW_REGION_[workspace],
1604 scr->totalUsableArea);
1605 #endif
1607 #endif /* not_used */
1609 void
1610 wKWMSendEventMessage(WWindow *wwin, WKWMEventMessage message)
1612 Atom msg;
1614 if (wwin && (wwin->flags.internal_window
1615 || wwin->flags.kwm_hidden_for_modules
1616 || !wwin->flags.kwm_managed
1617 || WFLAGP(wwin, skip_window_list)))
1618 return;
1620 switch (message) {
1621 case WKWMAddWindow:
1622 msg = _XA_KWM_MODULE_WIN_ADD;
1623 break;
1624 case WKWMRemoveWindow:
1625 msg = _XA_KWM_MODULE_WIN_REMOVE;
1626 break;
1627 case WKWMFocusWindow:
1628 msg = _XA_KWM_MODULE_WIN_ACTIVATE;
1629 break;
1630 case WKWMRaiseWindow:
1631 msg = _XA_KWM_MODULE_WIN_RAISE;
1632 break;
1633 case WKWMLowerWindow:
1634 msg = _XA_KWM_MODULE_WIN_LOWER;
1635 break;
1636 case WKWMChangedClient:
1637 msg = _XA_KWM_MODULE_WIN_CHANGE;
1638 break;
1639 case WKWMIconChange:
1640 msg = _XA_KWM_MODULE_WIN_ICON_CHANGE;
1641 break;
1642 default:
1643 return;
1646 sendToModules(wwin ? wwin->screen_ptr : NULL, msg, wwin, 0);
1650 static void
1651 writeSocket(int sock, char *data)
1653 char buffer[128];
1655 sprintf(buffer, "%i ", strlen(data));
1656 write(sock, buffer, strlen(buffer));
1657 write(sock, data, strlen(data));
1661 static int
1662 connectKFM(WScreen *scr)
1664 char *path;
1665 char buffer[128];
1666 char *ptr;
1667 FILE *f;
1668 int pid;
1669 int sock = 0;
1670 struct sockaddr_un addr;
1672 path = wstrappend(wgethomedir(), "/.kde/share/apps/kfm/pid");
1673 strcpy(buffer, getenv("DISPLAY"));
1675 ptr = strchr(buffer, ':');
1676 if (ptr)
1677 *ptr = '_';
1679 ptr = strrchr(buffer, '.');
1680 if (ptr)
1681 *ptr = 0;
1683 char b[32];
1685 sprintf(b, ".%i", scr->screen);
1686 strcat(buffer, b);
1688 ptr = path;
1689 path = wstrappend(ptr, buffer);
1690 free(ptr);
1692 /* pid file */
1693 f = fopen(path, "r");
1694 free(path);
1695 if (!f)
1696 return -1;
1698 buffer[0] = 0;
1699 fgets(buffer, 123, f);
1700 pid = atoi(buffer);
1701 if (pid <= 0)
1702 return -1;
1704 if (kill(pid, 0) != 0)
1705 return -1;
1707 buffer[0] = 0;
1708 fscanf(f, "%s", buffer);
1709 fclose(f);
1711 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1712 if (sock < 0)
1713 return -1;
1714 addr.sun_family = AF_UNIX;
1715 strcpy(addr.sun_path, buffer);
1717 if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
1718 close(sock);
1719 return -1;
1722 path = wstrappend(wgethomedir(), "/.kde/share/apps/kfm/magic");
1723 f = fopen(path, "r");
1724 if (!f) {
1725 return -1;
1727 ptr = fgets(buffer, 123, f);
1728 fclose(f);
1729 if (!ptr) {
1730 return -1;
1732 puts(buffer);
1734 ptr = wstrappend("auth", buffer);
1736 writeSocket(sock, ptr);
1737 free(ptr);
1739 return sock;
1743 void
1744 wKWMSelectRootRegion(WScreen *scr, int x, int y, int w, int h, Bool control)
1746 char buffer[128];
1747 int sock;
1748 #if 0
1749 puts("CONNECTING");
1750 sock = connectKFM(scr);
1751 if (sock < 0)
1752 return;
1753 puts("SENDING DATA");
1755 writeSocket(sock, "refreshDesktop");
1757 sprintf(buffer, "selectRootIcons %i %i %i %i %c", x, y, w, h, control);
1758 writeSocket(sock, buffer);
1760 close(sock);
1761 #endif
1765 #endif /* KWM_HINTS */