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
54 #endif // STDC_HEADERS
57 # include <sys/types.h>
59 #endif // HAVE_UNISTD_H
61 #ifdef HAVE_SYS_SELECT_H
62 # include <sys/select.h>
63 #endif // HAVE_SYS_SELECT_H
67 #endif // HAVE_SIGNAL_H
71 # define SA_NODEFER SA_INTERRUPT
72 # else // !SA_INTERRUPT
73 # define SA_NODEFER (0)
74 # endif // SA_INTERRUPT
77 #ifdef HAVE_SYS_WAIT_H
78 # include <sys/types.h>
79 # include <sys/wait.h>
80 #endif // HAVE_SYS_WAIT_H
82 #if defined(HAVE_PROCESS_H) && defined(__EMX__)
84 #endif // HAVE_PROCESS_H __EMX__
87 #include "BaseDisplay.h"
88 #include "LinkedList.h"
91 // X error handler to handle any and all X errors while the application is
93 static Bool internal_error
= False
;
94 static Window last_bad_window
= None
;
96 BaseDisplay
*base_display
;
98 static int handleXErrors(Display
*d
, XErrorEvent
*e
) {
102 XGetErrorText(d
, e
->error_code
, errtxt
, 128);
103 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayXError
,
104 "%s: X error: %s(%d) opcodes %d/%d\n resource 0x%lx\n"),
105 base_display
->getApplicationName(), errtxt
, e
->error_code
,
106 e
->request_code
, e
->minor_code
, e
->resourceid
);
109 if (e
->error_code
== BadWindow
) last_bad_window
= e
->resourceid
;
110 if (internal_error
) abort();
116 // signal handler to allow for proper and gentle shutdown
118 #ifndef HAVE_SIGACTION
119 static RETSIGTYPE
signalhandler(int sig
) {
120 #else // HAVE_SIGACTION
121 static void signalhandler(int sig
) {
122 #endif // HAVE_SIGACTION
124 static int re_enter
= 0;
129 waitpid(-1, &status
, WNOHANG
| WUNTRACED
);
131 #ifndef HAVE_SIGACTION
132 // assume broken, braindead sysv signal semantics
133 signal(SIGCHLD
, (RETSIGTYPE (*)(int)) signalhandler
);
134 #endif // HAVE_SIGACTION
139 if (base_display
->handleSignal(sig
)) {
141 #ifndef HAVE_SIGACTION
142 // assume broken, braindead sysv signal semantics
143 signal(sig
, (RETSIGTYPE (*)(int)) signalhandler
);
144 #endif // HAVE_SIGACTION
149 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplaySignalCaught
,
150 "%s: signal %d caught\n"),
151 base_display
->getApplicationName(), sig
);
153 if (! base_display
->isStartup() && ! re_enter
) {
154 internal_error
= True
;
157 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayShuttingDown
,
159 base_display
->shutdown();
162 if (sig
!= SIGTERM
&& sig
!= SIGINT
) {
163 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayAborting
,
164 "aborting... dumping core\n"));
175 // convenience functions
177 void bexec(const char *command
, char* displaystring
) {
180 putenv(displaystring
);
181 execl("/bin/sh", "/bin/sh", "-c", command
, NULL
);
187 char *bstrdup(const char *s
) {
188 const int l
= strlen(s
) + 1;
189 char *n
= new char[l
];
194 BaseDisplay::BaseDisplay(char *app_name
, char *dpy_name
) {
195 application_name
= app_name
;
200 last_bad_window
= None
;
202 ::base_display
= this;
204 #ifdef HAVE_SIGACTION
205 struct sigaction action
;
207 action
.sa_handler
= signalhandler
;
208 action
.sa_mask
= sigset_t();
209 action
.sa_flags
= SA_NOCLDSTOP
| SA_NODEFER
;
211 sigaction(SIGPIPE
, &action
, NULL
);
212 sigaction(SIGSEGV
, &action
, NULL
);
213 sigaction(SIGFPE
, &action
, NULL
);
214 sigaction(SIGTERM
, &action
, NULL
);
215 sigaction(SIGINT
, &action
, NULL
);
216 sigaction(SIGCHLD
, &action
, NULL
);
217 sigaction(SIGHUP
, &action
, NULL
);
218 sigaction(SIGUSR1
, &action
, NULL
);
219 sigaction(SIGUSR2
, &action
, NULL
);
220 #else // !HAVE_SIGACTION
221 signal(SIGPIPE
, (RETSIGTYPE (*)(int)) signalhandler
);
222 signal(SIGSEGV
, (RETSIGTYPE (*)(int)) signalhandler
);
223 signal(SIGFPE
, (RETSIGTYPE (*)(int)) signalhandler
);
224 signal(SIGTERM
, (RETSIGTYPE (*)(int)) signalhandler
);
225 signal(SIGINT
, (RETSIGTYPE (*)(int)) signalhandler
);
226 signal(SIGUSR1
, (RETSIGTYPE (*)(int)) signalhandler
);
227 signal(SIGUSR2
, (RETSIGTYPE (*)(int)) signalhandler
);
228 signal(SIGHUP
, (RETSIGTYPE (*)(int)) signalhandler
);
229 signal(SIGCHLD
, (RETSIGTYPE (*)(int)) signalhandler
);
230 #endif // HAVE_SIGACTION
232 if (! (display
= XOpenDisplay(dpy_name
))) {
233 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
, BaseDisplayXConnectFail
,
234 "BaseDisplay::BaseDisplay: connection to X server failed.\n"));
236 } else if (fcntl(ConnectionNumber(display
), F_SETFD
, 1) == -1) {
238 i18n
->getMessage(BaseDisplaySet
, BaseDisplayCloseOnExecFail
,
239 "BaseDisplay::BaseDisplay: couldn't mark display connection "
240 "as close-on-exec\n"));
244 number_of_screens
= ScreenCount(display
);
245 display_name
= XDisplayName(dpy_name
);
248 shape
.extensions
= XShapeQueryExtension(display
, &shape
.event_basep
,
251 shape
.extensions
= False
;
254 xa_wm_colormap_windows
=
255 XInternAtom(display
, "WM_COLORMAP_WINDOWS", False
);
256 xa_wm_protocols
= XInternAtom(display
, "WM_PROTOCOLS", False
);
257 xa_wm_state
= XInternAtom(display
, "WM_STATE", False
);
258 xa_wm_change_state
= XInternAtom(display
, "WM_CHANGE_STATE", False
);
259 xa_wm_delete_window
= XInternAtom(display
, "WM_DELETE_WINDOW", False
);
260 xa_wm_take_focus
= XInternAtom(display
, "WM_TAKE_FOCUS", False
);
261 motif_wm_hints
= XInternAtom(display
, "_MOTIF_WM_HINTS", False
);
263 openbox_hints
= XInternAtom(display
, "_BLACKBOX_HINTS", False
);
264 openbox_attributes
= XInternAtom(display
, "_BLACKBOX_ATTRIBUTES", False
);
265 openbox_change_attributes
=
266 XInternAtom(display
, "_BLACKBOX_CHANGE_ATTRIBUTES", False
);
268 openbox_structure_messages
=
269 XInternAtom(display
, "_BLACKBOX_STRUCTURE_MESSAGES", False
);
270 openbox_notify_startup
=
271 XInternAtom(display
, "_BLACKBOX_NOTIFY_STARTUP", False
);
272 openbox_notify_window_add
=
273 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_ADD", False
);
274 openbox_notify_window_del
=
275 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_DEL", False
);
276 openbox_notify_current_workspace
=
277 XInternAtom(display
, "_BLACKBOX_NOTIFY_CURRENT_WORKSPACE", False
);
278 openbox_notify_workspace_count
=
279 XInternAtom(display
, "_BLACKBOX_NOTIFY_WORKSPACE_COUNT", False
);
280 openbox_notify_window_focus
=
281 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_FOCUS", False
);
282 openbox_notify_window_raise
=
283 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_RAISE", False
);
284 openbox_notify_window_lower
=
285 XInternAtom(display
, "_BLACKBOX_NOTIFY_WINDOW_LOWER", False
);
287 openbox_change_workspace
=
288 XInternAtom(display
, "_BLACKBOX_CHANGE_WORKSPACE", False
);
289 openbox_change_window_focus
=
290 XInternAtom(display
, "_BLACKBOX_CHANGE_WINDOW_FOCUS", False
);
291 openbox_cycle_window_focus
=
292 XInternAtom(display
, "_BLACKBOX_CYCLE_WINDOW_FOCUS", False
);
296 net_supported
= XInternAtom(display
, "_NET_SUPPORTED", False
);
297 net_client_list
= XInternAtom(display
, "_NET_CLIENT_LIST", False
);
298 net_client_list_stacking
= XInternAtom(display
, "_NET_CLIENT_LIST_STACKING", False
);
299 net_number_of_desktops
= XInternAtom(display
, "_NET_NUMBER_OF_DESKTOPS", False
);
300 net_desktop_geometry
= XInternAtom(display
, "_NET_DESKTOP_GEOMETRY", False
);
301 net_desktop_viewport
= XInternAtom(display
, "_NET_DESKTOP_VIEWPORT", False
);
302 net_current_desktop
= XInternAtom(display
, "_NET_CURRENT_DESKTOP", False
);
303 net_desktop_names
= XInternAtom(display
, "_NET_DESKTOP_NAMES", False
);
304 net_active_window
= XInternAtom(display
, "_NET_ACTIVE_WINDOW", False
);
305 net_workarea
= XInternAtom(display
, "_NET_WORKAREA", False
);
306 net_supporting_wm_check
= XInternAtom(display
, "_NET_SUPPORTING_WM_CHECK", False
);
307 net_virtual_roots
= XInternAtom(display
, "_NET_VIRTUAL_ROOTS", False
);
309 net_close_window
= XInternAtom(display
, "_NET_CLOSE_WINDOW", False
);
310 net_wm_moveresize
= XInternAtom(display
, "_NET_WM_MOVERESIZE", False
);
312 net_properties
= XInternAtom(display
, "_NET_PROPERTIES", False
);
313 net_wm_name
= XInternAtom(display
, "_NET_WM_NAME", False
);
314 net_wm_desktop
= XInternAtom(display
, "_NET_WM_DESKTOP", False
);
315 net_wm_window_type
= XInternAtom(display
, "_NET_WM_WINDOW_TYPE", False
);
316 net_wm_state
= XInternAtom(display
, "_NET_WM_STATE", False
);
317 net_wm_strut
= XInternAtom(display
, "_NET_WM_STRUT", False
);
318 net_wm_icon_geometry
= XInternAtom(display
, "_NET_WM_ICON_GEOMETRY", False
);
319 net_wm_icon
= XInternAtom(display
, "_NET_WM_ICON", False
);
320 net_wm_pid
= XInternAtom(display
, "_NET_WM_PID", False
);
321 net_wm_handled_icons
= XInternAtom(display
, "_NET_WM_HANDLED_ICONS", False
);
323 net_wm_ping
= XInternAtom(display
, "_NET_WM_PING", False
);
327 cursor
.session
= XCreateFontCursor(display
, XC_left_ptr
);
328 cursor
.move
= XCreateFontCursor(display
, XC_fleur
);
329 cursor
.ll_angle
= XCreateFontCursor(display
, XC_ll_angle
);
330 cursor
.lr_angle
= XCreateFontCursor(display
, XC_lr_angle
);
331 cursor
.ul_angle
= XCreateFontCursor(display
, XC_ul_angle
);
332 cursor
.ur_angle
= XCreateFontCursor(display
, XC_ur_angle
);
334 XSetErrorHandler((XErrorHandler
) handleXErrors
);
336 timerList
= new LinkedList
<BTimer
>;
338 screenInfoList
= new LinkedList
<ScreenInfo
>;
339 for (int i
= 0; i
< number_of_screens
; i
++) {
340 ScreenInfo
*screeninfo
= new ScreenInfo(this, i
);
341 screenInfoList
->insert(screeninfo
);
345 NumLockMask
= ScrollLockMask
= 0;
347 const XModifierKeymap
* const modmap
= XGetModifierMapping(display
);
348 if (modmap
&& modmap
->max_keypermod
> 0) {
349 const int mask_table
[] = {
350 ShiftMask
, LockMask
, ControlMask
, Mod1Mask
,
351 Mod2Mask
, Mod3Mask
, Mod4Mask
, Mod5Mask
353 const size_t size
= (sizeof(mask_table
) / sizeof(mask_table
[0])) *
354 modmap
->max_keypermod
;
355 // get the values of the keyboard lock modifiers
356 // Note: Caps lock is not retrieved the same way as Scroll and Num lock
357 // since it doesn't need to be.
358 const KeyCode num_lock_code
= XKeysymToKeycode(display
, XK_Num_Lock
);
359 const KeyCode scroll_lock_code
= XKeysymToKeycode(display
, XK_Scroll_Lock
);
361 for (size_t cnt
= 0; cnt
< size
; ++cnt
) {
362 if (! modmap
->modifiermap
[cnt
]) continue;
364 if (num_lock_code
== modmap
->modifiermap
[cnt
])
365 NumLockMask
= mask_table
[cnt
/ modmap
->max_keypermod
];
366 if (scroll_lock_code
== modmap
->modifiermap
[cnt
])
367 ScrollLockMask
= mask_table
[cnt
/ modmap
->max_keypermod
];
372 MaskList
[1] = LockMask
;
373 MaskList
[2] = NumLockMask
;
374 MaskList
[3] = ScrollLockMask
;
375 MaskList
[4] = LockMask
| NumLockMask
;
376 MaskList
[5] = NumLockMask
| ScrollLockMask
;
377 MaskList
[6] = LockMask
| ScrollLockMask
;
378 MaskList
[7] = LockMask
| NumLockMask
| ScrollLockMask
;
379 MaskListLength
= sizeof(MaskList
) / sizeof(MaskList
[0]);
381 if (modmap
) XFreeModifiermap(const_cast<XModifierKeymap
*>(modmap
));
386 BaseDisplay::~BaseDisplay(void) {
387 while (screenInfoList
->count()) {
388 ScreenInfo
*si
= screenInfoList
->first();
390 screenInfoList
->remove(si
);
394 delete screenInfoList
;
396 // we don't create the BTimers, we don't delete them
397 while (timerList
->count())
398 timerList
->remove(0);
402 XCloseDisplay(display
);
406 void BaseDisplay::eventLoop(void) {
409 int xfd
= ConnectionNumber(display
);
411 while ((! _shutdown
) && (! internal_error
)) {
412 if (XPending(display
)) {
414 XNextEvent(display
, &e
);
416 if (last_bad_window
!= None
&& e
.xany
.window
== last_bad_window
) {
418 fprintf(stderr
, i18n
->getMessage(BaseDisplaySet
,
419 BaseDisplayBadWindowRemove
,
420 "BaseDisplay::eventLoop(): removing bad window "
421 "from event queue\n"));
424 last_bad_window
= None
;
429 timeval now
, tm
, *timeout
= (timeval
*) 0;
434 if (timerList
->count()) {
435 gettimeofday(&now
, 0);
437 tm
.tv_sec
= tm
.tv_usec
= 0l;
439 BTimer
*timer
= timerList
->first();
441 tm
.tv_sec
= timer
->getStartTime().tv_sec
+
442 timer
->getTimeout().tv_sec
- now
.tv_sec
;
443 tm
.tv_usec
= timer
->getStartTime().tv_usec
+
444 timer
->getTimeout().tv_usec
- now
.tv_usec
;
446 while (tm
.tv_usec
>= 1000000) {
448 tm
.tv_usec
-= 1000000;
451 while (tm
.tv_usec
< 0) {
454 tm
.tv_usec
+= 1000000;
464 select(xfd
+ 1, &rfds
, 0, 0, timeout
);
466 // check for timer timeout
467 gettimeofday(&now
, 0);
469 LinkedListIterator
<BTimer
> it(timerList
);
470 for(BTimer
*timer
= it
.current(); timer
; it
++, timer
= it
.current()) {
471 tm
.tv_sec
= timer
->getStartTime().tv_sec
+
472 timer
->getTimeout().tv_sec
;
473 tm
.tv_usec
= timer
->getStartTime().tv_usec
+
474 timer
->getTimeout().tv_usec
;
476 if ((now
.tv_sec
< tm
.tv_sec
) ||
477 (now
.tv_sec
== tm
.tv_sec
&& now
.tv_usec
< tm
.tv_usec
))
480 timer
->fireTimeout();
482 // restart the current timer so that the start time is updated
483 if (! timer
->doOnce()) timer
->start();
491 const Bool
BaseDisplay::validateWindow(Window window
) {
493 if (XCheckTypedWindowEvent(display
, window
, DestroyNotify
, &event
)) {
494 XPutBackEvent(display
, &event
);
503 void BaseDisplay::grab(void) {
504 if (! server_grabs
++)
505 XGrabServer(display
);
509 void BaseDisplay::ungrab(void) {
510 if (! --server_grabs
)
511 XUngrabServer(display
);
513 if (server_grabs
< 0) server_grabs
= 0;
517 void BaseDisplay::addTimer(BTimer
*timer
) {
520 LinkedListIterator
<BTimer
> it(timerList
);
522 for (BTimer
*tmp
= it
.current(); tmp
; it
++, index
++, tmp
= it
.current())
523 if ((tmp
->getTimeout().tv_sec
> timer
->getTimeout().tv_sec
) ||
524 ((tmp
->getTimeout().tv_sec
== timer
->getTimeout().tv_sec
) &&
525 (tmp
->getTimeout().tv_usec
>= timer
->getTimeout().tv_usec
)))
528 timerList
->insert(timer
, index
);
532 void BaseDisplay::removeTimer(BTimer
*timer
) {
533 timerList
->remove(timer
);
538 * Grabs a button, but also grabs the button in every possible combination with
539 * the keyboard lock keys, so that they do not cancel out the event.
541 void BaseDisplay::grabButton(unsigned int button
, unsigned int modifiers
,
542 Window grab_window
, Bool owner_events
,
543 unsigned int event_mask
, int pointer_mode
,
544 int keybaord_mode
, Window confine_to
,
548 for (size_t cnt
= 0; cnt
< MaskListLength
; ++cnt
)
549 XGrabButton(display
, button
, modifiers
| MaskList
[cnt
], grab_window
,
550 owner_events
, event_mask
, pointer_mode
, keybaord_mode
,
553 XGrabButton(display
, button
, modifiers
, grab_window
,
554 owner_events
, event_mask
, pointer_mode
, keybaord_mode
,
560 * Releases the grab on a button, and ungrabs all possible combinations of the
561 * keyboard lock keys.
563 void BaseDisplay::ungrabButton(unsigned int button
, unsigned int modifiers
,
564 Window grab_window
) const {
566 for (size_t cnt
= 0; cnt
< MaskListLength
; ++cnt
)
567 XUngrabButton(display
, button
, modifiers
| MaskList
[cnt
], grab_window
);
569 XUngrabButton(display
, button
, modifiers
, grab_window
);
574 ScreenInfo::ScreenInfo(BaseDisplay
*d
, int num
) {
578 root_window
= RootWindow(basedisplay
->getXDisplay(), screen_number
);
579 depth
= DefaultDepth(basedisplay
->getXDisplay(), screen_number
);
582 WidthOfScreen(ScreenOfDisplay(basedisplay
->getXDisplay(), screen_number
));
584 HeightOfScreen(ScreenOfDisplay(basedisplay
->getXDisplay(), screen_number
));
586 // search for a TrueColor Visual... if we can't find one... we will use the
587 // default visual for the screen
588 XVisualInfo vinfo_template
, *vinfo_return
;
591 vinfo_template
.screen
= screen_number
;
592 vinfo_template
.c_class
= TrueColor
;
594 visual
= (Visual
*) 0;
596 if ((vinfo_return
= XGetVisualInfo(basedisplay
->getXDisplay(),
597 VisualScreenMask
| VisualClassMask
,
598 &vinfo_template
, &vinfo_nitems
)) &&
600 for (int i
= 0; i
< vinfo_nitems
; i
++) {
601 if (depth
< (vinfo_return
+ i
)->depth
) {
602 depth
= (vinfo_return
+ i
)->depth
;
603 visual
= (vinfo_return
+ i
)->visual
;
611 colormap
= XCreateColormap(basedisplay
->getXDisplay(), root_window
,
614 visual
= DefaultVisual(basedisplay
->getXDisplay(), screen_number
);
615 colormap
= DefaultColormap(basedisplay
->getXDisplay(), screen_number
);