1 /* kwm.c-- stuff for support for kwm hints
3 * Window Maker window manager
5 * Copyright (c) 1998, 1999 Alfredo K. Kojima
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,
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)
35 * setIcon() std X thing...
39 * setWmCommand() std X thing
43 * isKWMInitialized() not trustworthy
44 * activeWindow() dunno it's use, but since it's easy to
45 * implement it won't hurt to support
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
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!?
64 * setGeometry() 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
77 * Unsupported stuff (superfluous/not-essential/nonsense):
78 * =======================================================
84 * registerSoundEvent()
85 * unregisterSoundEvent()
88 * geometry() kde lib code makes it unnecessary
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
106 * different WORKAREA for each workspace
114 #include <X11/Xlib.h>
115 #include <X11/Xutil.h>
116 #include <X11/Xatom.h>
123 #include <sys/types.h>
124 #include <sys/socket.h>
129 #include "WindowMaker.h"
133 #include "framewin.h"
135 #include "properties.h"
140 #include "workspace.h"
142 #include "stacking.h"
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
;
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
{
203 struct KWMDoNotManageList
*next
;
204 } KWMDoNotManageList
;
206 static KWMDoNotManageList
*KWMDoNotManageCrap
= NULL
;
209 /* list of KWM modules */
210 typedef struct KWMModuleList
{
212 struct KWMModuleList
*next
;
218 static KWMModuleList
*KWMModules
= NULL
;
220 static KWMModuleList
*KWMDockWindows
= NULL
;
222 /* window decoration types */
225 KWMnormalDecoration
= 1,
226 KWMtinyDecoration
= 2,
228 KWMstandaloneMenuBar
= 512,
229 KWMdesktopIcon
= 1024,
236 getSimpleHint(Window win
, Atom atom
, long *retval
)
242 data
= (long*)PropGetCheckProperty(win
, atom
, atom
, 32, 1, NULL
);
257 setSimpleHint(Window win
, Atom atom
, long value
)
260 XChangeProperty(dpy
, win
, atom
, atom
,
261 32, PropModeReplace
, (unsigned char*)&value
, 1);
266 sendClientMessage(WScreen
*scr
, Window window
, Atom atom
, long value
)
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
);
289 sendTextMessage(WScreen
*scr
, Window window
, Atom atom
, char *text
)
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
);
314 getAreaHint(Window win
, Atom atom
, WArea
*area
)
318 data
= (long*)PropGetCheckProperty(win
, atom
, atom
, 32, 4, NULL
);
325 area
->x2
= data
[2] + area
->x1
;
326 area
->y2
= data
[3] + area
->y1
;
335 setAreaHint(Window win
, Atom atom
, WArea area
)
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);
350 addModule(WScreen
*scr
, Window window
)
356 node
= malloc(sizeof(KWMModuleList
));
358 wwarning("out of memory while registering KDE module");
362 node
->next
= KWMModules
;
363 node
->window
= window
;
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);
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
,
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
,
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);
407 KWMModules
->title
= NULL
;
408 XFetchName(dpy
, window
, &KWMModules
->title
);
409 printf("NEW MODULE %s\n", KWMModules
->title
);
415 removeModule(WScreen
*scr
, Window window
)
423 if (KWMModules
->window
== window
) {
424 next
= KWMModules
->next
;
426 printf("REMOVING MODULE %s\n", KWMModules
->title
);
427 if (KWMModules
->title
)
428 XFree(KWMModules
->title
);
437 if (ptr
->next
->window
== window
) {
438 next
= ptr
->next
->next
;
440 printf("REMOVING MODULE %s\n", ptr
->next
->title
);
441 if (ptr
->next
->title
)
442 XFree(ptr
->next
->title
);
445 ptr
->next
->next
= next
;
448 ptr
->next
= ptr
->next
->next
;
452 if (scr
->kwm_dock
== window
)
453 scr
->kwm_dock
= None
;
459 addDockWindow(WScreen
*scr
, Window window
)
463 for (ptr
= KWMDockWindows
; ptr
!= NULL
; ptr
= ptr
->next
) {
464 if (ptr
->window
== window
)
470 node
= malloc(sizeof(KWMModuleList
));
472 wwarning("out of memory while processing KDE dock window");
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
,
487 removeDockWindow(WScreen
*scr
, Window window
)
492 if (KWMDockWindows
->window
== window
) {
495 sendClientMessage(scr
, scr
->kwm_dock
, _XA_KWM_MODULE_DOCKWIN_REMOVE
,
498 next
= KWMDockWindows
->next
;
499 free(KWMDockWindows
);
500 KWMDockWindows
= next
;
503 KWMModuleList
*ptr
, *next
;
505 ptr
= KWMDockWindows
;
507 if (ptr
->next
->window
== window
) {
508 sendClientMessage(scr
, scr
->kwm_dock
,
509 _XA_KWM_MODULE_DOCKWIN_REMOVE
, window
);
510 next
= ptr
->next
->next
;
522 sendToModules(WScreen
*scr
, Atom atom
, WWindow
*wwin
, long data
)
529 if (wwin
->flags
.kwm_hidden_for_modules
530 || WFLAGP(wwin
, skip_window_list
))
532 data
= wwin
->client_win
;
535 printf("notifying %s\n",XGetAtomName(dpy
, atom
));
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
;
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
);
556 wKWMInitStuff(WScreen
*scr
)
558 if (!_XA_KWM_WIN_STICKY
) {
559 _XA_KWM_WIN_UNSAVED_DATA
= XInternAtom(dpy
, "KWM_WIN_UNSAVED_DATA",
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",
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",
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",
586 _XA_KWM_DO_NOT_MANAGE
= XInternAtom(dpy
, "KWM_DO_NOT_MANAGE", False
);
588 _XA_KWM_CURRENT_DESKTOP
= XInternAtom(dpy
, "KWM_CURRENT_DESKTOP",
591 _XA_KWM_NUMBER_OF_DESKTOPS
= XInternAtom(dpy
, "KWM_NUMBER_OF_DESKTOPS",
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"));
644 wKWMSendStacking(WScreen
*scr
, Window module
)
649 for (i
= 0; i
< MAX_WINDOW_LEVELS
; i
++) {
650 for (core
= scr
->stacking_list
[i
]; core
!= NULL
;
651 core
= core
->stacking
->under
) {
654 wwin
= wWindowFor(core
->window
);
656 sendClientMessage(scr
, module
, _XA_KWM_MODULE_WIN_RAISE
,
664 wKWMBroadcastStacking(WScreen
*scr
)
666 KWMModuleList
*ptr
= KWMModules
;
669 wKWMSendStacking(scr
, ptr
->window
);
677 wKWMGetWorkspaceName(WScreen
*scr
, int workspace
)
681 unsigned long nitems_ret
;
682 unsigned long bytes_after_ret
;
683 char *data
= NULL
, *tmp
;
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
,
698 &type_ret
, &fmt_ret
, &nitems_ret
, &bytes_after_ret
,
699 (unsigned char**)&data
)!=Success
|| !data
)
710 wKWMSetInitializedHint(WScreen
*scr
)
712 setSimpleHint(scr
->root_win
, _XA_KWM_RUNNING
, 1);
717 wKWMShutdown(WScreen
*scr
, Bool closeModules
)
721 XDeleteProperty(dpy
, scr
->root_win
, _XA_KWM_RUNNING
);
724 for (ptr
= KWMModules
; ptr
!= NULL
; ptr
= ptr
->next
) {
725 XKillClient(dpy
, ptr
->window
);
732 wKWMCheckClientHints(WWindow
*wwin
, int *layer
, int *workspace
)
736 if (getSimpleHint(wwin
->client_win
, _XA_KWM_WIN_UNSAVED_DATA
, &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;
750 case KWMtinyDecoration
:
751 wwin
->client_flags
.no_resizebar
= 1;
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
;
763 *layer
= WMDesktopLevel
;
766 *layer
= WMFloatingLevel
;
768 case KWMnormalDecoration
:
773 if (getSimpleHint(wwin
->client_win
, _XA_KWM_WIN_DESKTOP
, &val
)) {
774 *workspace
= val
- 1;
780 wKWMCheckClientInitialState(WWindow
*wwin
)
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
;
800 wKWMCheckClientHintChange(WWindow
*wwin
, XPropertyEvent
*event
)
802 Bool processed
= True
;
811 if (event
->atom
== _XA_KWM_WIN_UNSAVED_DATA
) {
813 printf("got KDE unsaved data change\n");
816 flag
= getSimpleHint(wwin
->client_win
, _XA_KWM_WIN_UNSAVED_DATA
,
819 if (flag
!= wwin
->client_flags
.broken_close
) {
820 wwin
->client_flags
.broken_close
= flag
;
822 wWindowUpdateButtonImages(wwin
);
824 } else if (event
->atom
== _XA_KWM_WIN_STICKY
) {
827 printf("got KDE sticky change\n");
829 flag
= !getSimpleHint(wwin
->client_win
, _XA_KWM_WIN_STICKY
,
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
) {
842 printf("got KDE maximize change\n");
844 flag
= !getSimpleHint(wwin
->client_win
, _XA_KWM_WIN_MAXIMIZED
,
847 if (flag
!= (wwin
->flags
.maximized
!=0)) {
850 wMaximizeWindow(wwin
, flag
*(MAX_VERTICAL
|MAX_HORIZONTAL
));
852 wUnmaximizeWindow(wwin
);
854 } else if (event
->atom
== _XA_KWM_WIN_ICONIFIED
) {
857 printf("got KDE iconify change\n");
859 flag
= !getSimpleHint(wwin
->client_win
, _XA_KWM_WIN_ICONIFIED
,
862 if (flag
!= wwin
->flags
.miniaturized
) {
865 wIconifyWindow(wwin
);
867 wDeiconifyWindow(wwin
);
870 } else if (event
->atom
== _XA_KWM_WIN_DECORATION
) {
871 Bool refresh
= False
;
875 printf("got KDE decoration change\n");
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
))
888 wwin
->client_flags
.no_titlebar
= 1;
889 wwin
->client_flags
.no_resizebar
= 1;
892 case KWMtinyDecoration
:
893 if (WFLAGP(wwin
, no_titlebar
) || !WFLAGP(wwin
, no_resizebar
))
896 wwin
->client_flags
.no_titlebar
= 0;
897 wwin
->client_flags
.no_resizebar
= 1;
900 case KWMnormalDecoration
:
902 if (WFLAGP(wwin
, no_titlebar
) || WFLAGP(wwin
, no_resizebar
))
905 wwin
->client_flags
.no_titlebar
= 0;
906 wwin
->client_flags
.no_resizebar
= 0;
910 if (WFLAGP(wwin
, no_titlebar
) || WFLAGP(wwin
, no_resizebar
))
912 wwin
->client_flags
.no_focusable
= (value
& KWMnoFocus
)!=0;
913 wwin
->client_flags
.no_titlebar
= 0;
914 wwin
->client_flags
.no_resizebar
= 0;
918 wWindowConfigureBorders(wwin
);
920 if (wwin
->client_flags
.no_focusable
&& !oldnofocus
) {
922 sendToModules(wwin
->screen_ptr
, _XA_KWM_MODULE_WIN_REMOVE
,
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
,
931 wwin
->flags
.kwm_hidden_for_modules
= 0;
934 } else if (event
->atom
== _XA_KWM_WIN_DESKTOP
&& wwin
->frame
) {
936 printf("got KDE workspace change for %s\n", wwin
->frame
->title
);
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
) {
947 printf("got KDE geometry restore change\n");
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
;
969 performWindowCommand(WScreen
*scr
, char *command
)
971 WWindow
*wwin
= NULL
;
974 wwin
= scr
->focused_window
;
975 if (!wwin
|| !wwin
->flags
.focused
|| !wwin
->flags
.mapped
) {
979 CloseWindowMenu(scr
);
982 if (strcmp(command
, "winMove")==0 || strcmp(command
, "winResize")==0) {
985 wKeyboardMoveResizeWindow(wwin
);
987 } else if (strcmp(command
, "winMaximize")==0) {
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
,
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) {
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
);
1032 } else if (strcmp(command
, "winOperation")==0) {
1035 OpenWindowMenu(wwin
, wwin
->frame_x
,
1036 wwin
->frame_y
+wwin
->frame
->top_width
, True
);
1047 performCommand(WScreen
*scr
, char *command
, XClientMessageEvent
*event
)
1049 assert(scr
!= NULL
);
1051 if (strcmp(command
, "commandLine")==0
1052 || strcmp(command
, "execute")==0) {
1055 cmd
= ExpandOptions(scr
, _("%a(Run Command,Type the command to run:)"));
1057 ExecuteShellCommand(scr
, 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);
1094 wWorkspaceRelativeChange(scr
, -1);
1095 } else if (strncmp(command
, "desktop", 7)==0) {
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
);
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 */
1139 } else if (!performWindowCommand(scr
, command
)) {
1140 KWMModuleList
*module
;
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
;
1154 XSendEvent(dpy
, module
->window
, False
, mask
, &ev
);
1161 wKWMProcessClientMessage(XClientMessageEvent
*event
)
1163 Bool processed
= True
;
1166 printf("CLIENT MESS %s\n", XGetAtomName(dpy
, event
->message_type
));
1168 if (event
->message_type
== _XA_KWM_COMMAND
&& event
->format
==8) {
1172 scr
= wScreenForRootWindow(event
->window
);
1174 for (i
=0; i
<20; i
++) {
1175 buffer
[i
] = event
->data
.b
[i
];
1180 printf("got KDE command %s\n", buffer
);
1182 performCommand(scr
, buffer
, event
);
1184 } else if (event
->message_type
== _XA_KWM_ACTIVATE_WINDOW
) {
1188 printf("got KDE activate internal\n");
1190 wwin
= wWindowFor(event
->data
.l
[0]);
1193 wSetFocusTo(wwin
->screen_ptr
, wwin
);
1195 } else if (event
->message_type
== _XA_KWM_DO_NOT_MANAGE
1196 && event
->format
== 8) {
1197 KWMDoNotManageList
*node
;
1201 printf("got KDE dont manage\n");
1204 node
= malloc(sizeof(KWMDoNotManageList
));
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
];
1212 node
->next
= KWMDoNotManageCrap
;
1213 KWMDoNotManageCrap
= node
;
1215 } else if (event
->message_type
== _XA_KWM_MODULE
) {
1217 Window modwin
= event
->data
.l
[0];
1219 scr
= wScreenForRootWindow(event
->window
);
1221 if (getSimpleHint(modwin
, _XA_KWM_MODULE
, &val
) && val
) {
1223 puts("got KDE module startup");
1225 addModule(scr
, modwin
);
1228 puts("got KDE module finish");
1230 removeModule(scr
, modwin
);
1241 wKWMCheckModule(WScreen
*scr
, Window window
)
1245 if (getSimpleHint(window
, _XA_KWM_MODULE
, &val
) && val
) {
1247 puts("got KDE module startup");
1249 addModule(scr
, window
);
1255 wKWMCheckRootHintChange(WScreen
*scr
, XPropertyEvent
*event
)
1257 Bool processed
= True
;
1260 if (event
->atom
== _XA_KWM_CURRENT_DESKTOP
) {
1261 if (getSimpleHint(scr
->root_win
, _XA_KWM_CURRENT_DESKTOP
, &value
)) {
1263 printf("got KDE workspace switch to %li\n", value
);
1265 if (value
-1 != scr
->current_workspace
) {
1266 wWorkspaceChange(scr
, value
-1);
1269 } else if (event
->atom
== _XA_KWM_NUMBER_OF_DESKTOPS
) {
1271 printf("got KDE workspace number change\n");
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
) {
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
)) {
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.
1304 wKWMUpdateWorkspaceCountHint(scr
);
1313 for (i
= 0; i
< MAX_WORKSPACES
&& i
< scr
->workspace_count
; i
++) {
1314 if (event
->atom
== _XA_KWM_DESKTOP_NAME_
[i
]) {
1317 name
= wKWMGetWorkspaceName(scr
, i
);
1320 printf("got KDE workspace name change to %s\n", name
);
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;
1333 } else if (event
->atom
== _XA_KWM_WINDOW_REGION_
[i
]) {
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
);
1357 wKWMManageableClient(WScreen
*scr
, Window win
, char *title
)
1359 KWMDoNotManageList
*ptr
, *next
;
1362 if (getSimpleHint(win
, _XA_KWM_DOCKWINDOW
, &val
) && val
) {
1363 addDockWindow(scr
, win
);
1367 ptr
= KWMDoNotManageCrap
;
1369 * TODO: support for glob patterns or regexes
1371 if (ptr
&& strncmp(ptr
->title
, title
, strlen(ptr
->title
))==0) {
1374 KWMDoNotManageCrap
= next
;
1376 printf("window %s not managed per KDE request\n", title
);
1379 sendToModules(scr
, _XA_KWM_MODULE_WIN_ADD
, NULL
, win
);
1380 sendToModules(scr
, _XA_KWM_MODULE_WIN_REMOVE
, NULL
, win
);
1385 if (strncmp(ptr
->next
->title
, title
, strlen(ptr
->next
->title
))==0) {
1387 printf("window %s not managed per KDE request\n", title
);
1389 next
= ptr
->next
->next
;
1393 sendToModules(scr
, _XA_KWM_MODULE_WIN_ADD
, NULL
, win
);
1394 sendToModules(scr
, _XA_KWM_MODULE_WIN_REMOVE
, NULL
, win
);
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);
1419 wKWMUpdateActiveWindowHint(WScreen
*scr
)
1422 WWindow
*wwin
, *tmp
;
1424 if (!scr
->focused_window
|| !scr
->focused_window
->flags
.focused
)
1427 val
= (long)(scr
->focused_window
->client_win
);
1429 /* raise the menubar thing */
1430 wwin
= scr
->focused_window
;
1433 if (tmp
->flags
.kwm_menubar
1434 && tmp
->transient_for
== wwin
->client_win
) {
1435 wRaiseFrame(tmp
->frame
->core
);
1442 XChangeProperty(dpy
, scr
->root_win
, _XA_KWM_ACTIVE_WINDOW
,
1443 _XA_KWM_ACTIVE_WINDOW
, 32, PropModeReplace
,
1444 (unsigned char*)&val
, 1);
1450 wKWMUpdateWorkspaceCountHint(WScreen
*scr
)
1452 if (scr
->flags
.kwm_syncing_count
)
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
);
1464 wKWMCheckDestroy(XDestroyWindowEvent
*event
)
1468 if (event
->event
== event
->window
) {
1472 scr
= wScreenSearchForRootWindow(event
->event
);
1477 removeModule(scr
, event
->window
);
1478 removeDockWindow(scr
, event
->window
);
1483 wKWMUpdateWorkspaceNameHint(WScreen
*scr
, int workspace
)
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);
1506 wKWMUpdateClientWorkspace(WWindow
*wwin
)
1509 printf("updating workspace of %s to %i\n",
1510 wwin
->frame
->title
, wwin
->frame
->workspace
+1);
1512 setSimpleHint(wwin
->client_win
, _XA_KWM_WIN_DESKTOP
,
1513 wwin
->frame
->workspace
+1);
1518 wKWMUpdateClientGeometryRestore(WWindow
*wwin
)
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
);
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);
1551 wKWMGetUsableArea(WScreen
*scr
, WArea
*area
)
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
);
1567 wKWMGetIconGeometry(WWindow
*wwin
, WArea
*area
)
1569 return getAreaHint(wwin
->client_win
, _XA_KWM_WIN_ICON_GEOMETRY
, area
);
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
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
);
1607 #endif /* not_used */
1610 wKWMSendEventMessage(WWindow
*wwin
, WKWMEventMessage message
)
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
)))
1622 msg
= _XA_KWM_MODULE_WIN_ADD
;
1624 case WKWMRemoveWindow
:
1625 msg
= _XA_KWM_MODULE_WIN_REMOVE
;
1627 case WKWMFocusWindow
:
1628 msg
= _XA_KWM_MODULE_WIN_ACTIVATE
;
1630 case WKWMRaiseWindow
:
1631 msg
= _XA_KWM_MODULE_WIN_RAISE
;
1633 case WKWMLowerWindow
:
1634 msg
= _XA_KWM_MODULE_WIN_LOWER
;
1636 case WKWMChangedClient
:
1637 msg
= _XA_KWM_MODULE_WIN_CHANGE
;
1639 case WKWMIconChange
:
1640 msg
= _XA_KWM_MODULE_WIN_ICON_CHANGE
;
1646 sendToModules(wwin
? wwin
->screen_ptr
: NULL
, msg
, wwin
, 0);
1651 writeSocket(int sock
, char *data
)
1655 sprintf(buffer
, "%i ", strlen(data
));
1656 write(sock
, buffer
, strlen(buffer
));
1657 write(sock
, data
, strlen(data
));
1662 connectKFM(WScreen
*scr
)
1670 struct sockaddr_un addr
;
1672 path
= wstrappend(wgethomedir(), "/.kde/share/apps/kfm/pid");
1673 strcpy(buffer
, getenv("DISPLAY"));
1675 ptr
= strchr(buffer
, ':');
1679 ptr
= strrchr(buffer
, '.');
1685 sprintf(b
, ".%i", scr
->screen
);
1689 path
= wstrappend(ptr
, buffer
);
1693 f
= fopen(path
, "r");
1699 fgets(buffer
, 123, f
);
1704 if (kill(pid
, 0) != 0)
1708 fscanf(f
, "%s", buffer
);
1711 sock
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1714 addr
.sun_family
= AF_UNIX
;
1715 strcpy(addr
.sun_path
, buffer
);
1717 if (connect(sock
, (struct sockaddr
*)&addr
, sizeof(addr
)) < 0) {
1722 path
= wstrappend(wgethomedir(), "/.kde/share/apps/kfm/magic");
1723 f
= fopen(path
, "r");
1727 ptr
= fgets(buffer
, 123, f
);
1734 ptr
= wstrappend("auth", buffer
);
1736 writeSocket(sock
, ptr
);
1744 wKWMSelectRootRegion(WScreen
*scr
, int x
, int y
, int w
, int h
, Bool control
)
1750 sock
= connectKFM(scr
);
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
);
1765 #endif /* KWM_HINTS */