1 // BaseDisplay.cc for Openbox
2 // Copyright (c) 2001 Sean 'Shaleh' Perry <shaleh@debian.org>
3 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
5 // Permission is hereby granted, free of charge, to any person obtaining a
6 // copy of this software and associated documentation files (the "Software"),
7 // to deal in the Software without restriction, including without limitation
8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 // and/or sell copies of the Software, and to permit persons to whom the
10 // Software is furnished to do so, subject to the following conditions:
12 // The above copyright notice and this permission notice shall be included in
13 // all copies or substantial portions of the Software.
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 // DEALINGS IN THE SOFTWARE.
23 // stupid macros needed to access some functions in version 2 of the GNU C
30 # include "../config.h"
31 #endif // HAVE_CONFIG_H
34 #include <X11/Xatom.h>
35 #include <X11/Xutil.h>
36 #include <X11/cursorfont.h>
37 #include <X11/keysym.h>
40 # include <X11/extensions/shape.h>
45 #endif // HAVE_FCNTL_H
49 #endif // HAVE_STDIO_H
53 #endif // HAVE_STDLIB_H
57 #endif // HAVE_STRING_H
60 # include <sys/types.h>
62 #endif // HAVE_UNISTD_H
64 #ifdef HAVE_SYS_SELECT_H
65 # include <sys/select.h>
66 #endif // HAVE_SYS_SELECT_H
70 #endif // HAVE_SIGNAL_H
74 # define SA_NODEFER SA_INTERRUPT
75 # else // !SA_INTERRUPT
76 # define SA_NODEFER (0)
77 # endif // SA_INTERRUPT
80 #ifdef HAVE_SYS_WAIT_H
81 # include <sys/types.h>
82 # include <sys/wait.h>
83 #endif // HAVE_SYS_WAIT_H
85 #if defined(HAVE_PROCESS_H) && defined(__EMX__)
87 #endif // HAVE_PROCESS_H __EMX__
90 #include "BaseDisplay.h"
91 #include "LinkedList.h"
94 // X error handler to handle any and all X errors while the application is
96 static Bool internal_error
= False
;
97 static Window last_bad_window
= None
;
99 BaseDisplay
*base_display
;
101 static int handleXErrors(Display
*d
, XErrorEvent
*e
) {
105 XGetErrorText(d
, e
->error_code
, errtxt
, 128);
106 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayXError
,
107 "%s: X error: %s(%d) opcodes %d/%d\n resource 0x%lx\n"),
108 base_display
->getApplicationName(), errtxt
, e
->error_code
,
109 e
->request_code
, e
->minor_code
, e
->resourceid
);
112 if (e
->error_code
== BadWindow
) last_bad_window
= e
->resourceid
;
113 if (internal_error
) abort();
119 // signal handler to allow for proper and gentle shutdown
121 #ifndef HAVE_SIGACTION
122 static RETSIGTYPE
signalhandler(int sig
) {
123 #else // HAVE_SIGACTION
124 static void signalhandler(int sig
) {
125 #endif // HAVE_SIGACTION
127 static int re_enter
= 0;
132 waitpid(-1, &status
, WNOHANG
| WUNTRACED
);
134 #ifndef HAVE_SIGACTION
135 // assume broken, braindead sysv signal semantics
136 signal(SIGCHLD
, (RETSIGTYPE (*)(int)) signalhandler
);
137 #endif // HAVE_SIGACTION
142 if (base_display
->handleSignal(sig
)) {
144 #ifndef HAVE_SIGACTION
145 // assume broken, braindead sysv signal semantics
146 signal(sig
, (RETSIGTYPE (*)(int)) signalhandler
);
147 #endif // HAVE_SIGACTION
152 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplaySignalCaught
,
153 "%s: signal %d caught\n"),
154 base_display
->getApplicationName(), sig
);
156 if (! base_display
->isStartup() && ! re_enter
) {
157 internal_error
= True
;
160 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayShuttingDown
,
162 base_display
->shutdown();
165 if (sig
!= SIGTERM
&& sig
!= SIGINT
) {
166 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayAborting
,
167 "aborting... dumping core\n"));
178 // convenience functions
180 void bexec(const char *command
, char* displaystring
) {
183 putenv(displaystring
);
184 execl("/bin/sh", "/bin/sh", "-c", command
, NULL
);
190 char *bstrdup(const char *s
) {
191 const int l
= strlen(s
) + 1;
192 char *n
= new char[l
];
197 BaseDisplay::BaseDisplay(const char *app_name
, char *dpy_name
) {
198 application_name
= bstrdup(app_name
);
203 last_bad_window
= None
;
205 ::base_display
= this;
207 #ifdef HAVE_SIGACTION
208 struct sigaction action
;
210 action
.sa_handler
= signalhandler
;
211 action
.sa_mask
= sigset_t();
212 action
.sa_flags
= SA_NOCLDSTOP
| SA_NODEFER
;
214 sigaction(SIGPIPE
, &action
, NULL
);
215 sigaction(SIGSEGV
, &action
, NULL
);
216 sigaction(SIGFPE
, &action
, NULL
);
217 sigaction(SIGTERM
, &action
, NULL
);
218 sigaction(SIGINT
, &action
, NULL
);
219 sigaction(SIGCHLD
, &action
, NULL
);
220 sigaction(SIGHUP
, &action
, NULL
);
221 sigaction(SIGUSR1
, &action
, NULL
);
222 sigaction(SIGUSR2
, &action
, NULL
);
223 #else // !HAVE_SIGACTION
224 signal(SIGPIPE
, (RETSIGTYPE (*)(int)) signalhandler
);
225 signal(SIGSEGV
, (RETSIGTYPE (*)(int)) signalhandler
);
226 signal(SIGFPE
, (RETSIGTYPE (*)(int)) signalhandler
);
227 signal(SIGTERM
, (RETSIGTYPE (*)(int)) signalhandler
);
228 signal(SIGINT
, (RETSIGTYPE (*)(int)) signalhandler
);
229 signal(SIGUSR1
, (RETSIGTYPE (*)(int)) signalhandler
);
230 signal(SIGUSR2
, (RETSIGTYPE (*)(int)) signalhandler
);
231 signal(SIGHUP
, (RETSIGTYPE (*)(int)) signalhandler
);
232 signal(SIGCHLD
, (RETSIGTYPE (*)(int)) signalhandler
);
233 #endif // HAVE_SIGACTION
235 if (! (display
= XOpenDisplay(dpy_name
))) {
236 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayXConnectFail
,
237 "BaseDisplay::BaseDisplay: connection to X server failed.\n"));
239 } else if (fcntl(ConnectionNumber(display
), F_SETFD
, 1) == -1) {
241 i18n
->getMessage(BaseDisplaySet
, BaseDisplayCloseOnExecFail
,
242 "BaseDisplay::BaseDisplay: couldn't mark display connection "
243 "as close-on-exec\n"));
247 number_of_screens
= ScreenCount(display
);
248 display_name
= XDisplayName(dpy_name
);
251 shape
.extensions
= XShapeQueryExtension(display
, &shape
.event_basep
,
254 shape
.extensions
= False
;
257 xa_wm_colormap_windows
=
258 XInternAtom(display
, "WM_COLORMAP_WINDOWS", False
);
259 xa_wm_protocols
= XInternAtom(display
, "WM_PROTOCOLS", False
);
260 xa_wm_state
= XInternAtom(display
, "WM_STATE", False
);
261 xa_wm_change_state
= XInternAtom(display
, "WM_CHANGE_STATE", False
);
262 xa_wm_delete_window
= XInternAtom(display
, "WM_DELETE_WINDOW", False
);
263 xa_wm_take_focus
= XInternAtom(display
, "WM_TAKE_FOCUS", False
);
264 motif_wm_hints
= XInternAtom(display
, "_MOTIF_WM_HINTS", False
);
266 openbox_hints
= XInternAtom(display
, "_BLACKBOX_HINTS", False
);
267 openbox_attributes
= XInternAtom(display
, "_BLACKBOX_ATTRIBUTES", False
);
268 openbox_change_attributes
=
269 XInternAtom(display
, "_BLACKBOX_CHANGE_ATTRIBUTES", False
);
271 openbox_structure_messages
=
272 XInternAtom(display
, "_BLACKBOX_STRUCTURE_MESSAGES", False
);
273 openbox_notify_startup
=
274 XInternAtom(display
, "_BLACKBOX_NOTIFY_STARTUP", False
);
275 openbox_notify_window_add
=
276 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_ADD", False
);
277 openbox_notify_window_del
=
278 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_DEL", False
);
279 openbox_notify_current_workspace
=
280 XInternAtom(display
, "_BLACKBOX_NOTIFY_CURRENT_WORKSPACE", False
);
281 openbox_notify_workspace_count
=
282 XInternAtom(display
, "_BLACKBOX_NOTIFY_WORKSPACE_COUNT", False
);
283 openbox_notify_window_focus
=
284 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_FOCUS", False
);
285 openbox_notify_window_raise
=
286 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_RAISE", False
);
287 openbox_notify_window_lower
=
288 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_LOWER", False
);
290 openbox_change_workspace
=
291 XInternAtom(display
, "_BLACKBOX_CHANGE_WORKSPACE", False
);
292 openbox_change_window_focus
=
293 XInternAtom(display
, "_BLACKBOX_CHANGE_WINDOW_FOCUS", False
);
294 openbox_cycle_window_focus
=
295 XInternAtom(display
, "_BLACKBOX_CYCLE_WINDOW_FOCUS", False
);
299 net_supported
= XInternAtom(display
, "_NET_SUPPORTED", False
);
300 net_client_list
= XInternAtom(display
, "_NET_CLIENT_LIST", False
);
301 net_client_list_stacking
= XInternAtom(display
, "_NET_CLIENT_LIST_STACKING", False
);
302 net_number_of_desktops
= XInternAtom(display
, "_NET_NUMBER_OF_DESKTOPS", False
);
303 net_desktop_geometry
= XInternAtom(display
, "_NET_DESKTOP_GEOMETRY", False
);
304 net_desktop_viewport
= XInternAtom(display
, "_NET_DESKTOP_VIEWPORT", False
);
305 net_current_desktop
= XInternAtom(display
, "_NET_CURRENT_DESKTOP", False
);
306 net_desktop_names
= XInternAtom(display
, "_NET_DESKTOP_NAMES", False
);
307 net_active_window
= XInternAtom(display
, "_NET_ACTIVE_WINDOW", False
);
308 net_workarea
= XInternAtom(display
, "_NET_WORKAREA", False
);
309 net_supporting_wm_check
= XInternAtom(display
, "_NET_SUPPORTING_WM_CHECK", False
);
310 net_virtual_roots
= XInternAtom(display
, "_NET_VIRTUAL_ROOTS", False
);
312 net_close_window
= XInternAtom(display
, "_NET_CLOSE_WINDOW", False
);
313 net_wm_moveresize
= XInternAtom(display
, "_NET_WM_MOVERESIZE", False
);
315 net_properties
= XInternAtom(display
, "_NET_PROPERTIES", False
);
316 net_wm_name
= XInternAtom(display
, "_NET_WM_NAME", False
);
317 net_wm_desktop
= XInternAtom(display
, "_NET_WM_DESKTOP", False
);
318 net_wm_window_type
= XInternAtom(display
, "_NET_WM_WINDOW_TYPE", False
);
319 net_wm_state
= XInternAtom(display
, "_NET_WM_STATE", False
);
320 net_wm_strut
= XInternAtom(display
, "_NET_WM_STRUT", False
);
321 net_wm_icon_geometry
= XInternAtom(display
, "_NET_WM_ICON_GEOMETRY", False
);
322 net_wm_icon
= XInternAtom(display
, "_NET_WM_ICON", False
);
323 net_wm_pid
= XInternAtom(display
, "_NET_WM_PID", False
);
324 net_wm_handled_icons
= XInternAtom(display
, "_NET_WM_HANDLED_ICONS", False
);
326 net_wm_ping
= XInternAtom(display
, "_NET_WM_PING", False
);
330 cursor
.session
= XCreateFontCursor(display
, XC_left_ptr
);
331 cursor
.move
= XCreateFontCursor(display
, XC_fleur
);
332 cursor
.ll_angle
= XCreateFontCursor(display
, XC_ll_angle
);
333 cursor
.lr_angle
= XCreateFontCursor(display
, XC_lr_angle
);
334 cursor
.ul_angle
= XCreateFontCursor(display
, XC_ul_angle
);
335 cursor
.ur_angle
= XCreateFontCursor(display
, XC_ur_angle
);
337 XSetErrorHandler((XErrorHandler
) handleXErrors
);
339 timerList
= new LinkedList
<BTimer
>;
341 screenInfoList
= new LinkedList
<ScreenInfo
>;
342 for (int i
= 0; i
< number_of_screens
; i
++) {
343 ScreenInfo
*screeninfo
= new ScreenInfo(*this, i
);
344 screenInfoList
->insert(screeninfo
);
348 NumLockMask
= ScrollLockMask
= 0;
350 const XModifierKeymap
* const modmap
= XGetModifierMapping(display
);
351 if (modmap
&& modmap
->max_keypermod
> 0) {
352 const int mask_table
[] = {
353 ShiftMask
, LockMask
, ControlMask
, Mod1Mask
,
354 Mod2Mask
, Mod3Mask
, Mod4Mask
, Mod5Mask
356 const size_t size
= (sizeof(mask_table
) / sizeof(mask_table
[0])) *
357 modmap
->max_keypermod
;
358 // get the values of the keyboard lock modifiers
359 // Note: Caps lock is not retrieved the same way as Scroll and Num lock
360 // since it doesn't need to be.
361 const KeyCode num_lock_code
= XKeysymToKeycode(display
, XK_Num_Lock
);
362 const KeyCode scroll_lock_code
= XKeysymToKeycode(display
, XK_Scroll_Lock
);
364 for (size_t cnt
= 0; cnt
< size
; ++cnt
) {
365 if (! modmap
->modifiermap
[cnt
]) continue;
367 if (num_lock_code
== modmap
->modifiermap
[cnt
])
368 NumLockMask
= mask_table
[cnt
/ modmap
->max_keypermod
];
369 if (scroll_lock_code
== modmap
->modifiermap
[cnt
])
370 ScrollLockMask
= mask_table
[cnt
/ modmap
->max_keypermod
];
375 MaskList
[1] = LockMask
;
376 MaskList
[2] = NumLockMask
;
377 MaskList
[3] = ScrollLockMask
;
378 MaskList
[4] = LockMask
| NumLockMask
;
379 MaskList
[5] = NumLockMask
| ScrollLockMask
;
380 MaskList
[6] = LockMask
| ScrollLockMask
;
381 MaskList
[7] = LockMask
| NumLockMask
| ScrollLockMask
;
382 MaskListLength
= sizeof(MaskList
) / sizeof(MaskList
[0]);
384 if (modmap
) XFreeModifiermap(const_cast<XModifierKeymap
*>(modmap
));
386 NumLockMask
= Mod2Mask
;
387 ScrollLockMask
= Mod5Mask
;
392 BaseDisplay::~BaseDisplay(void) {
393 while (screenInfoList
->count()) {
394 ScreenInfo
*si
= screenInfoList
->first();
396 screenInfoList
->remove(si
);
400 delete screenInfoList
;
402 // we don't create the BTimers, we don't delete them
403 while (timerList
->count())
404 timerList
->remove(0);
408 XCloseDisplay(display
);
412 void BaseDisplay::eventLoop(void) {
415 int xfd
= ConnectionNumber(display
);
417 while ((! _shutdown
) && (! internal_error
)) {
418 if (XPending(display
)) {
420 XNextEvent(display
, &e
);
422 if (last_bad_window
!= None
&& e
.xany
.window
== last_bad_window
) {
424 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
,
425 BaseDisplayBadWindowRemove
,
426 "BaseDisplay::eventLoop(): removing bad window "
427 "from event queue\n"));
430 last_bad_window
= None
;
435 timeval now
, tm
, *timeout
= (timeval
*) 0;
440 if (timerList
->count()) {
441 gettimeofday(&now
, 0);
443 tm
.tv_sec
= tm
.tv_usec
= 0l;
445 BTimer
*timer
= timerList
->first();
447 tm
.tv_sec
= timer
->getStartTime().tv_sec
+
448 timer
->getTimeout().tv_sec
- now
.tv_sec
;
449 tm
.tv_usec
= timer
->getStartTime().tv_usec
+
450 timer
->getTimeout().tv_usec
- now
.tv_usec
;
452 while (tm
.tv_usec
>= 1000000) {
454 tm
.tv_usec
-= 1000000;
457 while (tm
.tv_usec
< 0) {
460 tm
.tv_usec
+= 1000000;
470 select(xfd
+ 1, &rfds
, 0, 0, timeout
);
472 // check for timer timeout
473 gettimeofday(&now
, 0);
475 LinkedListIterator
<BTimer
> it(timerList
);
476 for(BTimer
*timer
= it
.current(); timer
; it
++, timer
= it
.current()) {
477 tm
.tv_sec
= timer
->getStartTime().tv_sec
+
478 timer
->getTimeout().tv_sec
;
479 tm
.tv_usec
= timer
->getStartTime().tv_usec
+
480 timer
->getTimeout().tv_usec
;
482 if ((now
.tv_sec
< tm
.tv_sec
) ||
483 (now
.tv_sec
== tm
.tv_sec
&& now
.tv_usec
< tm
.tv_usec
))
486 timer
->fireTimeout();
488 // restart the current timer so that the start time is updated
489 if (! timer
->doOnce()) timer
->start();
497 const Bool
BaseDisplay::validateWindow(Window window
) {
499 if (XCheckTypedWindowEvent(display
, window
, DestroyNotify
, &event
)) {
500 XPutBackEvent(display
, &event
);
509 void BaseDisplay::grab(void) {
510 if (! server_grabs
++)
511 XGrabServer(display
);
515 void BaseDisplay::ungrab(void) {
516 if (! --server_grabs
)
517 XUngrabServer(display
);
519 if (server_grabs
< 0) server_grabs
= 0;
523 void BaseDisplay::addTimer(BTimer
*timer
) {
526 LinkedListIterator
<BTimer
> it(timerList
);
528 for (BTimer
*tmp
= it
.current(); tmp
; it
++, index
++, tmp
= it
.current())
529 if ((tmp
->getTimeout().tv_sec
> timer
->getTimeout().tv_sec
) ||
530 ((tmp
->getTimeout().tv_sec
== timer
->getTimeout().tv_sec
) &&
531 (tmp
->getTimeout().tv_usec
>= timer
->getTimeout().tv_usec
)))
534 timerList
->insert(timer
, index
);
538 void BaseDisplay::removeTimer(BTimer
*timer
) {
539 timerList
->remove(timer
);
544 * Grabs a button, but also grabs the button in every possible combination with
545 * the keyboard lock keys, so that they do not cancel out the event.
547 void BaseDisplay::grabButton(unsigned int button
, unsigned int modifiers
,
548 Window grab_window
, Bool owner_events
,
549 unsigned int event_mask
, int pointer_mode
,
550 int keybaord_mode
, Window confine_to
,
554 for (size_t cnt
= 0; cnt
< MaskListLength
; ++cnt
)
555 XGrabButton(display
, button
, modifiers
| MaskList
[cnt
], grab_window
,
556 owner_events
, event_mask
, pointer_mode
, keybaord_mode
,
559 XGrabButton(display
, button
, modifiers
, grab_window
,
560 owner_events
, event_mask
, pointer_mode
, keybaord_mode
,
566 * Releases the grab on a button, and ungrabs all possible combinations of the
567 * keyboard lock keys.
569 void BaseDisplay::ungrabButton(unsigned int button
, unsigned int modifiers
,
570 Window grab_window
) const {
572 for (size_t cnt
= 0; cnt
< MaskListLength
; ++cnt
)
573 XUngrabButton(display
, button
, modifiers
| MaskList
[cnt
], grab_window
);
575 XUngrabButton(display
, button
, modifiers
, grab_window
);
580 ScreenInfo::ScreenInfo(BaseDisplay
&d
, int num
) : basedisplay(d
),
584 root_window
= RootWindow(basedisplay
.getXDisplay(), screen_number
);
585 depth
= DefaultDepth(basedisplay
.getXDisplay(), screen_number
);
587 m_size
= Size(WidthOfScreen(ScreenOfDisplay(basedisplay
.getXDisplay(),
589 HeightOfScreen(ScreenOfDisplay(basedisplay
.getXDisplay(),
592 // search for a TrueColor Visual... if we can't find one... we will use the
593 // default visual for the screen
594 XVisualInfo vinfo_template
, *vinfo_return
;
597 vinfo_template
.screen
= screen_number
;
598 vinfo_template
.c_class
= TrueColor
;
600 visual
= (Visual
*) 0;
602 if ((vinfo_return
= XGetVisualInfo(basedisplay
.getXDisplay(),
603 VisualScreenMask
| VisualClassMask
,
604 &vinfo_template
, &vinfo_nitems
)) &&
606 for (int i
= 0; i
< vinfo_nitems
; i
++) {
607 if (depth
< (vinfo_return
+ i
)->depth
) {
608 depth
= (vinfo_return
+ i
)->depth
;
609 visual
= (vinfo_return
+ i
)->visual
;
617 colormap
= XCreateColormap(basedisplay
.getXDisplay(), root_window
,
620 visual
= DefaultVisual(basedisplay
.getXDisplay(), screen_number
);
621 colormap
= DefaultColormap(basedisplay
.getXDisplay(), screen_number
);