2 * Window Maker window manager
4 * Copyright (c) 1997, 1998 Alfredo K. Kojima
5 * Copyright (c) 1999 Dan Pascu
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,
31 #include <sys/signal.h>
35 #include <X11/Xutil.h>
36 #include <X11/Intrinsic.h>
37 #include <X11/cursorfont.h>
38 #include <X11/Xproto.h>
39 #include <X11/keysym.h>
41 #include <X11/extensions/shape.h>
44 #include "WindowMaker.h"
53 #include "workspace.h"
58 #include "properties.h"
67 #ifdef SYS_SIGLIST_DECLARED
68 extern const char * const sys_siglist
[];
78 /****** Global Variables ******/
80 extern char **Arguments
;
82 extern WPreferences wPreferences
;
84 extern WDDomain
*WDWindowMaker
;
85 extern WDDomain
*WDRootMenu
;
86 extern WDDomain
*WDWindowAttributes
;
88 extern WShortKey wKeyBindings
[WKBD_LAST
];
90 extern int wScreenCount
;
94 extern Bool wShapeSupported
;
95 extern int wShapeEventBase
;
99 extern XContext wWinContext
;
100 extern XContext wAppWinContext
;
101 extern XContext wStackContext
;
104 extern Atom _XA_WM_STATE
;
105 extern Atom _XA_WM_CHANGE_STATE
;
106 extern Atom _XA_WM_PROTOCOLS
;
107 extern Atom _XA_WM_TAKE_FOCUS
;
108 extern Atom _XA_WM_DELETE_WINDOW
;
109 extern Atom _XA_WM_SAVE_YOURSELF
;
110 extern Atom _XA_WM_CLIENT_LEADER
;
111 extern Atom _XA_WM_COLORMAP_WINDOWS
;
112 extern Atom _XA_WM_COLORMAP_NOTIFY
;
114 extern Atom _XA_GNUSTEP_WM_ATTR
;
116 extern Atom _XA_WINDOWMAKER_MENU
;
117 extern Atom _XA_WINDOWMAKER_WM_PROTOCOLS
;
118 extern Atom _XA_WINDOWMAKER_STATE
;
119 extern Atom _XA_WINDOWMAKER_WM_FUNCTION
;
120 extern Atom _XA_WINDOWMAKER_NOTICEBOARD
;
121 extern Atom _XA_WINDOWMAKER_COMMAND
;
123 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW
;
126 extern Atom _XA_DND_PROTOCOL
;
127 extern Atom _XA_DND_SELECTION
;
130 extern Atom _XA_XDE_REQUEST
;
131 extern Atom _XA_XDE_ENTER
;
132 extern Atom _XA_XDE_LEAVE
;
133 extern Atom _XA_XDE_DATA_AVAILABLE
;
134 extern Atom _XDE_FILETYPE
;
135 extern Atom _XDE_URLTYPE
;
140 extern Cursor wCursor
[WCUR_LAST
];
143 extern char WDelayedActionSet
;
147 static WScreen
**wScreen
= NULL
;
150 static unsigned int _NumLockMask
= 0;
151 static unsigned int _ScrollLockMask
= 0;
155 static void manageAllWindows();
157 extern void NotifyDeadProcess(pid_t pid
, unsigned char status
);
160 typedef struct _CrashPanel
{
161 WMWindow
*win
; /* main window */
163 WMLabel
*iconL
; /* application icon */
164 WMLabel
*nameL
; /* title of panel */
166 WMFrame
*sepF
; /* separator frame */
168 WMLabel
*noteL
; /* Title of note */
169 WMLabel
*note2L
; /* body of note with what happened */
171 WMFrame
*whatF
; /* "what to do next" frame */
172 WMPopUpButton
*whatP
; /* action selection popup button */
174 WMButton
*okB
; /* ok button */
176 Bool done
; /* if finished with this dialog */
177 int action
; /* what to do after */
192 handleKeyPress(XEvent
*event
, void *clientData
)
194 CrashPanel
*panel
= (CrashPanel
*)clientData
;
196 if (event
->xkey
.keycode
== panel
->retKey
) {
197 WMPerformButtonClick(panel
->okB
);
203 buttonCallback(void *self
, void *clientData
)
205 CrashPanel
*panel
= (CrashPanel
*)clientData
;
212 setAction(void *self
, void *clientData
)
214 WMPopUpButton
*pop
= (WMPopUpButton
*)self
;
215 CrashPanel
*panel
= (CrashPanel
*)clientData
;
217 panel
->action
= WMGetPopUpButtonSelectedItem(pop
);
222 getWindowMakerIconImage(WMScreen
*scr
)
224 proplist_t dict
, key
, option
, value
=NULL
;
228 PLSetStringCmpHook(NULL
);
230 key
= PLMakeString("Logo.WMPanel");
231 option
= PLMakeString("Icon");
233 dict
= PLGetDictionaryEntry(WDWindowAttributes
->dictionary
, key
);
236 value
= PLGetDictionaryEntry(dict
, option
);
242 PLSetStringCmpHook(StringCompareHook
);
244 if (value
&& PLIsString(value
)) {
245 path
= FindImage(wPreferences
.icon_path
, PLGetString(value
));
250 image
= RLoadImage(WMScreenRContext(scr
), path
, 0);
252 pix
= WMCreatePixmapFromRImage(scr
, image
, 0);
253 RDestroyImage(image
);
268 showCrashPanel(int whatSig
)
275 int screen_no
, scr_width
, scr_height
;
279 panel
= wmalloc(sizeof(CrashPanel
));
280 memset(panel
, 0, sizeof(CrashPanel
));
282 /* Close the X connection and open a new one. This is to avoid messing
283 * Xlib because we call to Xlib functions in a signal handler.
286 newdpy
= XOpenDisplay("");
288 wfatal(_("cannot open connection for crashing dialog panel. Aborting."));
292 screen_no
= DefaultScreen(newdpy
);
293 scr_width
= WidthOfScreen(ScreenOfDisplay(newdpy
, screen_no
));
294 scr_height
= HeightOfScreen(ScreenOfDisplay(newdpy
, screen_no
));
296 scr
= WMCreateScreen(newdpy
, screen_no
);
298 wfatal(_("cannot open connection for crashing dialog panel. Aborting."));
302 panel
->retKey
= XKeysymToKeycode(newdpy
, XK_Return
);
304 panel
->win
= WMCreateWindow(scr
, "crashingDialog");
305 WMResizeWidget(panel
->win
, PWIDTH
, PHEIGHT
);
306 WMMoveWidget(panel
->win
, (scr_width
- PWIDTH
)/2, (scr_height
- PHEIGHT
)/2);
308 logo
= getWindowMakerIconImage(scr
);
310 panel
->iconL
= WMCreateLabel(panel
->win
);
311 WMResizeWidget(panel
->iconL
, 64, 64);
312 WMMoveWidget(panel
->iconL
, 10, 10);
313 WMSetLabelImagePosition(panel
->iconL
, WIPImageOnly
);
314 WMSetLabelImage(panel
->iconL
, logo
);
317 panel
->nameL
= WMCreateLabel(panel
->win
);
318 WMResizeWidget(panel
->nameL
, 190, 18);
319 WMMoveWidget(panel
->nameL
, 80, 35);
320 WMSetLabelTextAlignment(panel
->nameL
, WALeft
);
321 font
= WMBoldSystemFontOfSize(scr
, 18);
322 WMSetLabelFont(panel
->nameL
, font
);
324 WMSetLabelText(panel
->nameL
, _("Fatal error"));
326 panel
->sepF
= WMCreateFrame(panel
->win
);
327 WMResizeWidget(panel
->sepF
, PWIDTH
+4, 2);
328 WMMoveWidget(panel
->sepF
, -2, 80);
330 panel
->noteL
= WMCreateLabel(panel
->win
);
331 WMResizeWidget(panel
->noteL
, PWIDTH
-20, 40);
332 WMMoveWidget(panel
->noteL
, 10, 90);
333 WMSetLabelTextAlignment(panel
->noteL
, WAJustified
);
334 #ifdef SYS_SIGLIST_DECLARED
335 sprintf(buf
, _("Window Maker received signal %i\n(%s)."),
336 whatSig
, sys_siglist
[whatSig
]);
338 sprintf(buf
, _("Window Maker received signal %i."), whatSig
);
340 WMSetLabelText(panel
->noteL
, buf
);
342 panel
->note2L
= WMCreateLabel(panel
->win
);
343 WMResizeWidget(panel
->note2L
, PWIDTH
-20, 100);
344 WMMoveWidget(panel
->note2L
, 10, 130);
345 WMSetLabelTextAlignment(panel
->note2L
, WALeft
);
346 WMSetLabelText(panel
->note2L
,
347 _(" This fatal error occured probably due to a bug."
348 " Please fill the included BUGFORM and "
349 "report it to bugs@windowmaker.org."));
352 panel
->whatF
= WMCreateFrame(panel
->win
);
353 WMResizeWidget(panel
->whatF
, PWIDTH
-20, 50);
354 WMMoveWidget(panel
->whatF
, 10, 240);
355 WMSetFrameTitle(panel
->whatF
, _("What do you want to do now?"));
357 panel
->whatP
= WMCreatePopUpButton(panel
->whatF
);
358 WMResizeWidget(panel
->whatP
, PWIDTH
-20-70, 20);
359 WMMoveWidget(panel
->whatP
, 35, 20);
360 WMSetPopUpButtonPullsDown(panel
->whatP
, False
);
361 WMSetPopUpButtonText(panel
->whatP
, _("Select action"));
362 WMAddPopUpButtonItem(panel
->whatP
, _("Abort and leave a core file"));
363 WMAddPopUpButtonItem(panel
->whatP
, _("Restart Window Maker"));
364 WMAddPopUpButtonItem(panel
->whatP
, _("Start alternate window manager"));
365 WMSetPopUpButtonAction(panel
->whatP
, setAction
, panel
);
366 WMSetPopUpButtonSelectedItem(panel
->whatP
, WMRestart
);
367 panel
->action
= WMRestart
;
369 WMMapSubwidgets(panel
->whatF
);
371 panel
->okB
= WMCreateCommandButton(panel
->win
);
372 WMResizeWidget(panel
->okB
, 80, 26);
373 WMMoveWidget(panel
->okB
, 205, 309);
374 WMSetButtonText(panel
->okB
, _("OK"));
375 WMSetButtonImage(panel
->okB
, WMGetSystemPixmap(scr
, WSIReturnArrow
));
376 WMSetButtonAltImage(panel
->okB
, WMGetSystemPixmap(scr
, WSIHighlightedReturnArrow
));
377 WMSetButtonImagePosition(panel
->okB
, WIPRight
);
378 WMSetButtonAction(panel
->okB
, buttonCallback
, panel
);
382 WMCreateEventHandler(WMWidgetView(panel
->win
), KeyPressMask
,
383 handleKeyPress
, panel
);
385 WMRealizeWidget(panel
->win
);
386 WMMapSubwidgets(panel
->win
);
388 WMMapWidget(panel
->win
);
390 XSetInputFocus(newdpy
, WMWidgetXID(panel
->win
), RevertToParent
, CurrentTime
);
392 while (!panel
->done
) {
395 WMNextEvent(newdpy
, &event
);
396 WMHandleEvent(&event
);
399 action
= panel
->action
;
401 WMUnmapWidget(panel
->win
);
402 WMDestroyWidget(panel
->win
);
404 XCloseDisplay(newdpy
);
411 catchXError(Display
*dpy
, XErrorEvent
*error
)
413 char buffer
[MAXLINE
];
415 /* ignore some errors */
416 if (error
->resourceid
!= None
417 && ((error
->error_code
== BadDrawable
418 && error
->request_code
== X_GetGeometry
)
419 || (error
->error_code
== BadMatch
420 && (error
->request_code
== X_SetInputFocus
))
421 || (error
->error_code
== BadWindow
)
423 && (error->request_code == X_GetWindowAttributes
424 || error->request_code == X_SetInputFocus
425 || error->request_code == X_ChangeWindowAttributes
426 || error->request_code == X_GetProperty
427 || error->request_code == X_ChangeProperty
428 || error->request_code == X_QueryTree
429 || error->request_code == X_GrabButton
430 || error->request_code == X_UngrabButton
431 || error->request_code == X_SendEvent
432 || error->request_code == X_ConfigureWindow))
434 || (error
->request_code
== X_InstallColormap
))) {
439 printf("got X error %x %x %x\n", error
->request_code
,
440 error
->error_code
, (unsigned)error
->resourceid
);
444 FormatXError(dpy
, error
, buffer
, MAXLINE
);
445 wwarning(_("internal X error: %s\n"), buffer
);
451 *----------------------------------------------------------------------
453 * Handle X shutdowns and other stuff.
454 *----------------------------------------------------------------------
457 handleXIO(Display
*dpy
)
466 *----------------------------------------------------------------------
468 * Action to be executed after the signal() handler is exited.
469 *----------------------------------------------------------------------
472 delayedAction(void *cdata
)
474 WDelayedActionSet
= 0;
476 * Make the event dispatcher do whatever it needs to do,
477 * including handling zombie processes, restart and exit
486 *----------------------------------------------------------------------
488 * general signal handler. Exits the program gently.
489 *----------------------------------------------------------------------
494 static int already_crashed
= 0;
496 #ifndef NO_EMERGENCY_AUTORESTART
504 * No functions that potentially do Xlib calls should be called from
505 * here. Xlib calls are not reentrant so the integrity of Xlib is
506 * not guaranteed if a Xlib call is made from a signal handler.
508 if (sig
== SIGUSR1
) {
509 #ifdef SYS_SIGLIST_DECLARED
510 wwarning(_("got signal %i (%s) - restarting\n"), sig
, sys_siglist
[sig
]);
512 wwarning(_("got signal %i - restarting\n"), sig
);
515 WCHANGE_STATE(WSTATE_NEED_RESTART
);
516 /* setup idle handler, so that this will be handled when
517 * the select() is returned becaused of the signal, even if
518 * there are no X events in the queue */
519 if (!WDelayedActionSet
) {
520 WDelayedActionSet
= 1;
521 WMAddIdleHandler(delayedAction
, NULL
);
524 } else if (sig
== SIGTERM
|| sig
== SIGHUP
) {
525 #ifdef SYS_SIGLIST_DECLARED
526 wwarning(_("got signal %i (%s) - exiting...\n"), sig
, sys_siglist
[sig
]);
528 wwarning(_("got signal %i - exiting...\n"), sig
);
531 WCHANGE_STATE(WSTATE_NEED_EXIT
);
533 if (!WDelayedActionSet
) {
534 WDelayedActionSet
= 1;
535 WMAddIdleHandler(delayedAction
, NULL
);
540 #ifdef SYS_SIGLIST_DECLARED
541 wfatal(_("got signal %i (%s)\n"), sig
, sys_siglist
[sig
]);
543 wfatal(_("got signal %i\n"), sig
);
546 /* Setting the signal behaviour back to default and then reraising the
547 * signal is a cleaner way to make program exit and core dump than calling
548 * abort(), since it correctly returns from the signal handler and sets
549 * the flags accordingly. -Dan
551 if (sig
==SIGSEGV
|| sig
==SIGFPE
|| sig
==SIGBUS
|| sig
==SIGILL
553 if (already_crashed
) {
554 wfatal(_("crashed while trying to do some post-crash cleanup. Aborting immediatelly."));
555 signal(sig
, SIG_DFL
);
563 #ifndef NO_EMERGENCY_AUTORESTART
564 crashAction
= showCrashPanel(sig
);
566 if (crashAction
== WMAbort
) {
567 signal(sig
, SIG_DFL
);
572 if (crashAction
== WMRestart
) {
573 /* we try to restart Window Maker */
574 wwarning(_("trying to restart Window Maker..."));
575 execvp(Arguments
[0], Arguments
);
576 wwarning(_("we failed to restart Window Maker."));
577 /* fallback to alternate window manager then */
580 wwarning(_("trying to start alternate window manager..."));
582 argv
[0] = FALLBACK_WINDOWMANAGER
;
583 execvp(FALLBACK_WINDOWMANAGER
, argv
);
586 execvp("fvwm", argv
);
591 wfatal(_("failed to start alternate window manager. Aborting."));
593 wfatal(_("a fatal error has occured, probably due to a bug. "
594 "Please fill the included BUGFORM and report it."));
595 #endif /* !NO_EMERGENCY_AUTORESTART */
597 signal(sig
, SIG_DFL
);
608 ignoreSig(int signal
)
621 pid
= waitpid(-1, &status
, WNOHANG
);
623 NotifyDeadProcess(pid
, WEXITSTATUS(status
));
625 * Make sure that the kid will be buried even if there are
626 * no events in the X event queue
628 if (!WDelayedActionSet
) {
629 WDelayedActionSet
= 1;
630 WMAddIdleHandler(delayedAction
, NULL
);
637 getWorkspaceState(Window root
, WWorkspaceState
**state
)
641 unsigned long nitems_ret
;
642 unsigned long bytes_after_ret
;
645 if (XGetWindowProperty(dpy
, root
, _XA_WINDOWMAKER_STATE
, 0, 2,
646 True
, _XA_WINDOWMAKER_STATE
,
647 &type_ret
, &fmt_ret
, &nitems_ret
, &bytes_after_ret
,
648 (unsigned char **)&data
)!=Success
|| !data
)
651 *state
= malloc(sizeof(WWorkspaceState
));
653 (*state
)->flags
= data
[0];
654 (*state
)->workspace
= data
[1];
658 if (*state
&& type_ret
==_XA_WINDOWMAKER_STATE
)
666 getOffendingModifiers()
669 XModifierKeymap
*modmap
;
670 KeyCode nlock
, slock
;
671 static int mask_table
[8] = {
672 ShiftMask
,LockMask
,ControlMask
,Mod1Mask
,
673 Mod2Mask
, Mod3Mask
, Mod4Mask
, Mod5Mask
676 nlock
= XKeysymToKeycode(dpy
, XK_Num_Lock
);
677 slock
= XKeysymToKeycode(dpy
, XK_Scroll_Lock
);
680 * Find out the masks for the NumLock and ScrollLock modifiers,
681 * so that we can bind the grabs for when they are enabled too.
683 modmap
= XGetModifierMapping(dpy
);
685 if (modmap
!=NULL
&& modmap
->max_keypermod
>0) {
686 for (i
=0; i
<8*modmap
->max_keypermod
; i
++) {
687 if (modmap
->modifiermap
[i
]==nlock
&& nlock
!=0)
688 _NumLockMask
= mask_table
[i
/modmap
->max_keypermod
];
689 else if (modmap
->modifiermap
[i
]==slock
&& slock
!=0)
690 _ScrollLockMask
= mask_table
[i
/modmap
->max_keypermod
];
695 XFreeModifiermap(modmap
);
702 wHackedGrabKey(int keycode
, unsigned int modifiers
,
703 Window grab_window
, Bool owner_events
, int pointer_mode
,
706 if (modifiers
== AnyModifier
)
709 /* grab all combinations of the modifier with CapsLock, NumLock and
710 * ScrollLock. How much memory/CPU does such a monstrosity consume
714 XGrabKey(dpy
, keycode
, modifiers
|_NumLockMask
,
715 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
717 XGrabKey(dpy
, keycode
, modifiers
|_ScrollLockMask
,
718 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
719 if (_NumLockMask
&& _ScrollLockMask
)
720 XGrabKey(dpy
, keycode
, modifiers
|_NumLockMask
|_ScrollLockMask
,
721 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
723 XGrabKey(dpy
, keycode
, modifiers
|_NumLockMask
|LockMask
,
724 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
726 XGrabKey(dpy
, keycode
, modifiers
|_ScrollLockMask
|LockMask
,
727 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
728 if (_NumLockMask
&& _ScrollLockMask
)
729 XGrabKey(dpy
, keycode
, modifiers
|_NumLockMask
|_ScrollLockMask
|LockMask
,
730 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
731 /* phew, I guess that's all, right? */
736 wHackedGrabButton(unsigned int button
, unsigned int modifiers
,
737 Window grab_window
, Bool owner_events
,
738 unsigned int event_mask
, int pointer_mode
,
739 int keyboard_mode
, Window confine_to
, Cursor cursor
)
741 XGrabButton(dpy
, button
, modifiers
, grab_window
, owner_events
,
742 event_mask
, pointer_mode
, keyboard_mode
, confine_to
, cursor
);
744 if (modifiers
==AnyModifier
)
747 XGrabButton(dpy
, button
, modifiers
|LockMask
, grab_window
, owner_events
,
748 event_mask
, pointer_mode
, keyboard_mode
, confine_to
, cursor
);
751 /* same as above, but for mouse buttons */
753 XGrabButton(dpy
, button
, modifiers
|_NumLockMask
,
754 grab_window
, owner_events
, event_mask
, pointer_mode
,
755 keyboard_mode
, confine_to
, cursor
);
757 XGrabButton(dpy
, button
, modifiers
|_ScrollLockMask
,
758 grab_window
, owner_events
, event_mask
, pointer_mode
,
759 keyboard_mode
, confine_to
, cursor
);
760 if (_NumLockMask
&& _ScrollLockMask
)
761 XGrabButton(dpy
, button
, modifiers
|_ScrollLockMask
|_NumLockMask
,
762 grab_window
, owner_events
, event_mask
, pointer_mode
,
763 keyboard_mode
, confine_to
, cursor
);
765 XGrabButton(dpy
, button
, modifiers
|_NumLockMask
|LockMask
,
766 grab_window
, owner_events
, event_mask
, pointer_mode
,
767 keyboard_mode
, confine_to
, cursor
);
769 XGrabButton(dpy
, button
, modifiers
|_ScrollLockMask
|LockMask
,
770 grab_window
, owner_events
, event_mask
, pointer_mode
,
771 keyboard_mode
, confine_to
, cursor
);
772 if (_NumLockMask
&& _ScrollLockMask
)
773 XGrabButton(dpy
, button
, modifiers
|_ScrollLockMask
|_NumLockMask
|LockMask
,
774 grab_window
, owner_events
, event_mask
, pointer_mode
,
775 keyboard_mode
, confine_to
, cursor
);
776 #endif /* NUMLOCK_HACK */
781 wHackedUngrabButton(unsigned int button
, unsigned int modifiers
,
784 XUngrabButton(dpy
, button
, modifiers
|_NumLockMask
,
786 XUngrabButton(dpy
, button
, modifiers
|_ScrollLockMask
,
788 XUngrabButton(dpy
, button
, modifiers
|_NumLockMask
|_ScrollLockMask
,
790 XUngrabButton(dpy
, button
, modifiers
|_NumLockMask
|LockMask
,
792 XUngrabButton(dpy
, button
, modifiers
|_ScrollLockMask
|LockMask
,
794 XUngrabButton(dpy
, button
, modifiers
|_NumLockMask
|_ScrollLockMask
|LockMask
,
802 wScreenWithNumber(int i
)
804 assert(i
< wScreenCount
);
811 wScreenForRootWindow(Window window
)
819 * Since the number of heads will probably be small (normally 2),
820 * it should be faster to use this than a hash table, because
823 for (i
=0; i
<wScreenCount
; i
++) {
824 if (wScreen
[i
]->root_win
== window
) {
829 assert("bad_root_window" && 0);
836 wScreenSearchForRootWindow(Window window
)
844 * Since the number of heads will probably be small (normally 2),
845 * it should be faster to use this than a hash table, because
848 for (i
=0; i
<wScreenCount
; i
++) {
849 if (wScreen
[i
]->root_win
== window
) {
859 wScreenForWindow(Window window
)
861 XWindowAttributes attr
;
866 if (XGetWindowAttributes(dpy
, window
, &attr
)) {
867 return wScreenForRootWindow(attr
.root
);
875 *----------------------------------------------------------
877 * starts the window manager and setup global data.
878 * Called from main() at startup.
881 * global data declared in main.c is initialized
882 *----------------------------------------------------------
885 StartUp(Bool defaultScreenOnly
)
887 WWorkspaceState
*ws_state
;
888 struct sigaction sig_action
;
892 * Ignore CapsLock in modifiers
894 ValidModMask
= 0xff & ~LockMask
;
896 getOffendingModifiers();
898 * Ignore NumLock and ScrollLock too
900 ValidModMask
&= ~(_NumLockMask
|_ScrollLockMask
);
903 memset(&wKeyBindings
, 0, sizeof(wKeyBindings
));
905 wWinContext
= XUniqueContext();
906 wAppWinContext
= XUniqueContext();
907 wStackContext
= XUniqueContext();
909 /* _XA_VERSION = XInternAtom(dpy, "VERSION", False);*/
911 _XA_WM_STATE
= XInternAtom(dpy
, "WM_STATE", False
);
912 _XA_WM_CHANGE_STATE
= XInternAtom(dpy
, "WM_CHANGE_STATE", False
);
913 _XA_WM_PROTOCOLS
= XInternAtom(dpy
, "WM_PROTOCOLS", False
);
914 _XA_WM_TAKE_FOCUS
= XInternAtom(dpy
, "WM_TAKE_FOCUS", False
);
915 _XA_WM_DELETE_WINDOW
= XInternAtom(dpy
, "WM_DELETE_WINDOW", False
);
916 _XA_WM_SAVE_YOURSELF
= XInternAtom(dpy
, "WM_SAVE_YOURSELF", False
);
917 _XA_WM_CLIENT_LEADER
= XInternAtom(dpy
, "WM_CLIENT_LEADER", False
);
918 _XA_WM_COLORMAP_WINDOWS
= XInternAtom(dpy
, "WM_COLORMAP_WINDOWS", False
);
919 _XA_WM_COLORMAP_NOTIFY
= XInternAtom(dpy
, "WM_COLORMAP_NOTIFY", False
);
921 _XA_GNUSTEP_WM_ATTR
= XInternAtom(dpy
, GNUSTEP_WM_ATTR_NAME
, False
);
923 _XA_WINDOWMAKER_MENU
= XInternAtom(dpy
, "_WINDOWMAKER_MENU", False
);
924 _XA_WINDOWMAKER_STATE
= XInternAtom(dpy
, "_WINDOWMAKER_STATE", False
);
926 _XA_WINDOWMAKER_WM_PROTOCOLS
=
927 XInternAtom(dpy
, "_WINDOWMAKER_WM_PROTOCOLS", False
);
929 _XA_GNUSTEP_WM_MINIATURIZE_WINDOW
=
930 XInternAtom(dpy
, GNUSTEP_WM_MINIATURIZE_WINDOW
, False
);
932 _XA_WINDOWMAKER_WM_FUNCTION
= XInternAtom(dpy
, "_WINDOWMAKER_WM_FUNCTION",
935 _XA_WINDOWMAKER_NOTICEBOARD
= XInternAtom(dpy
, "_WINDOWMAKER_NOTICEBOARD",
938 _XA_WINDOWMAKER_COMMAND
= XInternAtom(dpy
, "_WINDOWMAKER_COMMAND", False
);
941 _XA_DND_SELECTION
= XInternAtom(dpy
, "DndSelection", False
);
942 _XA_DND_PROTOCOL
= XInternAtom(dpy
, "DndProtocol", False
);
945 _XA_XDE_ENTER
= XInternAtom(dpy
, "_XDE_ENTER", False
);
946 _XA_XDE_REQUEST
= XInternAtom(dpy
, "_XDE_REQUEST", False
);
947 _XA_XDE_LEAVE
= XInternAtom(dpy
, "_XDE_LEAVE", False
);
948 _XA_XDE_DATA_AVAILABLE
= XInternAtom(dpy
, "_XDE_DATA_AVAILABLE", False
);
949 _XDE_FILETYPE
= XInternAtom(dpy
, "file:ALL", False
);
950 _XDE_URLTYPE
= XInternAtom(dpy
, "url:ALL", False
);
955 wCursor
[WCUR_NORMAL
] = XCreateFontCursor(dpy
, XC_left_ptr
);
956 wCursor
[WCUR_ARROW
] = XCreateFontCursor(dpy
, XC_top_left_arrow
);
957 wCursor
[WCUR_MOVE
] = XCreateFontCursor(dpy
, XC_fleur
);
958 wCursor
[WCUR_RESIZE
] = XCreateFontCursor(dpy
, XC_sizing
);
959 wCursor
[WCUR_WAIT
] = XCreateFontCursor(dpy
, XC_watch
);
960 wCursor
[WCUR_QUESTION
] = XCreateFontCursor(dpy
, XC_question_arrow
);
961 wCursor
[WCUR_TEXT
] = XCreateFontCursor(dpy
, XC_xterm
); /* odd name???*/
963 /* emergency exit... */
964 sig_action
.sa_handler
= handleSig
;
965 sigemptyset(&sig_action
.sa_mask
);
967 /* Here we don't care about SA_RESTART since these signals will close
970 sig_action
.sa_flags
= 0;
971 sigaction(SIGINT
, &sig_action
, NULL
);
972 sigaction(SIGTERM
, &sig_action
, NULL
);
973 sigaction(SIGHUP
, &sig_action
, NULL
);
974 sigaction(SIGQUIT
, &sig_action
, NULL
);
975 sigaction(SIGSEGV
, &sig_action
, NULL
);
976 sigaction(SIGBUS
, &sig_action
, NULL
);
977 sigaction(SIGFPE
, &sig_action
, NULL
);
978 sigaction(SIGABRT
, &sig_action
, NULL
);
980 /* Here we set SA_RESTART for safety, because SIGUSR1 may not be handled
983 sig_action
.sa_flags
= SA_RESTART
;
984 sigaction(SIGUSR1
, &sig_action
, NULL
);
986 /* ignore dead pipe */
987 sig_action
.sa_handler
= ignoreSig
;
988 sig_action
.sa_flags
= SA_RESTART
;
989 sigaction(SIGPIPE
, &sig_action
, NULL
);
991 /* handle dead children */
992 sig_action
.sa_handler
= buryChild
;
993 sig_action
.sa_flags
= SA_NOCLDSTOP
|SA_RESTART
;
994 sigaction(SIGCHLD
, &sig_action
, NULL
);
996 /* Now we unblock all signals, that may have been blocked by the parent
997 * who exec()-ed us. This can happen for example if Window Maker crashes
998 * and restarts itself or another window manager from the signal handler.
999 * In this case, the new proccess inherits the blocked signal mask and
1000 * will no longer react to that signal, until unblocked.
1001 * This is because the signal handler of the proccess who crashed (parent)
1002 * didn't return, and the signal remained blocked. -Dan
1004 sigfillset(&sig_action
.sa_mask
);
1005 sigprocmask(SIG_UNBLOCK
, &sig_action
.sa_mask
, NULL
);
1007 /* handle X shutdowns a such */
1008 XSetIOErrorHandler(handleXIO
);
1010 /* set hook for out event dispatcher in WINGs event dispatcher */
1011 WMHookEventHandler(DispatchEvent
);
1013 /* initialize defaults stuff */
1014 WDWindowMaker
= wDefaultsInitDomain("WindowMaker", True
);
1015 if (!WDWindowMaker
->dictionary
) {
1016 wwarning(_("could not read domain \"%s\" from defaults database"),
1020 /* read defaults that don't change until a restart and are
1021 * screen independent */
1022 wReadStaticDefaults(WDWindowMaker
? WDWindowMaker
->dictionary
: NULL
);
1024 /* check sanity of some values */
1025 if (wPreferences
.icon_size
< 16) {
1026 wwarning(_("icon size is configured to %i, but it's too small. Using 16, instead\n"),
1027 wPreferences
.icon_size
);
1028 wPreferences
.icon_size
= 16;
1031 /* init other domains */
1032 WDRootMenu
= wDefaultsInitDomain("WMRootMenu", False
);
1033 if (!WDRootMenu
->dictionary
) {
1034 wwarning(_("could not read domain \"%s\" from defaults database"),
1038 WDWindowAttributes
= wDefaultsInitDomain("WMWindowAttributes", True
);
1039 if (!WDWindowAttributes
->dictionary
) {
1040 wwarning(_("could not read domain \"%s\" from defaults database"),
1041 "WMWindowAttributes");
1044 XSetErrorHandler((XErrorHandler
)catchXError
);
1048 wShapeSupported
= XShapeQueryExtension(dpy
, &wShapeEventBase
, &j
);
1051 if (defaultScreenOnly
) {
1054 max
= ScreenCount(dpy
);
1056 wScreen
= wmalloc(sizeof(WScreen
*)*max
);
1060 /* manage the screens */
1061 for (j
= 0; j
< max
; j
++) {
1062 if (defaultScreenOnly
|| max
==1) {
1063 wScreen
[wScreenCount
] = wScreenInit(DefaultScreen(dpy
));
1064 if (!wScreen
[wScreenCount
]) {
1065 wfatal(_("it seems that there is already a window manager running"));
1069 wScreen
[wScreenCount
] = wScreenInit(j
);
1070 if (!wScreen
[wScreenCount
]) {
1071 wwarning(_("could not manage screen %i"), j
);
1078 /* initialize/restore state for the screens */
1079 for (j
= 0; j
< wScreenCount
; j
++) {
1080 /* restore workspace state */
1081 if (!getWorkspaceState(wScreen
[j
]->root_win
, &ws_state
)) {
1085 wScreenRestoreState(wScreen
[j
]);
1087 /* manage all windows that were already here before us */
1088 if (!wPreferences
.flags
.nodock
&& wScreen
[j
]->dock
)
1089 wScreen
[j
]->last_dock
= wScreen
[j
]->dock
;
1091 manageAllWindows(wScreen
[j
]);
1093 /* restore saved menus */
1094 wMenuRestoreState(wScreen
[j
]);
1096 /* If we're not restarting restore session */
1097 if (ws_state
== NULL
)
1098 wSessionRestoreState(wScreen
[j
]);
1101 /* auto-launch apps */
1102 if (!wPreferences
.flags
.nodock
&& wScreen
[j
]->dock
) {
1103 wScreen
[j
]->last_dock
= wScreen
[j
]->dock
;
1104 wDockDoAutoLaunch(wScreen
[j
]->dock
, 0);
1106 /* auto-launch apps in clip */
1107 if (!wPreferences
.flags
.noclip
) {
1109 for(i
=0; i
<wScreen
[j
]->workspace_count
; i
++) {
1110 if (wScreen
[j
]->workspaces
[i
]->clip
) {
1111 wScreen
[j
]->last_dock
= wScreen
[j
]->workspaces
[i
]->clip
;
1112 wDockDoAutoLaunch(wScreen
[j
]->workspaces
[i
]->clip
, i
);
1117 /* go to workspace where we were before restart */
1119 wWorkspaceForceChange(wScreen
[j
], ws_state
->workspace
);
1122 wSessionRestoreLastWorkspace(wScreen
[j
]);
1126 wKWMSetInitializedHint(wScreen
[j
]);
1130 if (wScreenCount
== 0) {
1131 wfatal(_("could not manage any screen"));
1135 if (!wPreferences
.flags
.noupdates
) {
1136 /* setup defaults file polling */
1137 WMAddTimerHandler(3000, wDefaultsCheckDomains
, NULL
);
1145 windowInList(Window window
, Window
*list
, int count
)
1147 for (; count
>=0; count
--) {
1148 if (window
== list
[count
])
1155 *-----------------------------------------------------------------------
1156 * manageAllWindows--
1157 * Manages all windows in the screen.
1160 * Called when the wm is being started.
1161 * No events can be processed while the windows are being
1162 * reparented/managed.
1163 *-----------------------------------------------------------------------
1166 manageAllWindows(WScreen
*scr
)
1168 Window root
, parent
;
1170 unsigned int nchildren
;
1175 XQueryTree(dpy
, scr
->root_win
, &root
, &parent
, &children
, &nchildren
);
1177 scr
->flags
.startup
= 1;
1179 /* first remove all icon windows */
1180 for (i
= 0; i
< nchildren
; i
++) {
1183 if (children
[i
]==None
)
1186 wmhints
= XGetWMHints(dpy
, children
[i
]);
1187 if (wmhints
&& (wmhints
->flags
& IconWindowHint
)) {
1188 for (j
= 0; j
< nchildren
; j
++) {
1189 if (children
[j
] == wmhints
->icon_window
) {
1203 for (i
= 0; i
< nchildren
; i
++) {
1204 if (children
[i
] == None
)
1208 wKWMCheckModule(scr
, children
[i
]);
1210 wwin
= wManageWindow(scr
, children
[i
]);
1212 /* apply states got from WSavedState */
1213 /* shaded + minimized is not restored correctly */
1214 if (wwin
->flags
.shaded
) {
1215 wwin
->flags
.shaded
= 0;
1218 if (wwin
->flags
.miniaturized
1219 && (wwin
->transient_for
== None
1220 || wwin
->transient_for
== scr
->root_win
1221 || !windowInList(wwin
->transient_for
, children
,
1224 wwin
->flags
.skip_next_animation
= 1;
1225 wwin
->flags
.miniaturized
= 0;
1226 wIconifyWindow(wwin
);
1228 wClientSetState(wwin
, NormalState
, None
);
1235 wwin
= scr
->focused_window
;
1237 if (wwin
->flags
.hidden
) {
1238 WApplication
*wapp
= wApplicationOf(wwin
->main_window
);
1241 wwin
->flags
.hidden
= 0;
1242 wHideApplication(wapp
);
1244 wwin
->flags
.hidden
= 0;
1251 scr
->flags
.startup
= 0;
1252 scr
->flags
.startup2
= 1;
1254 while (XPending(dpy
)) {
1256 WMNextEvent(dpy
, &ev
);
1259 wWorkspaceForceChange(scr
, 0);
1260 if (!wPreferences
.flags
.noclip
)
1261 wDockShowIcons(scr
->workspaces
[scr
->current_workspace
]->clip
);
1262 scr
->flags
.startup2
= 0;