supply python routines for next/prev workspace
[dana/openbox.git] / otk / display.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #ifdef HAVE_CONFIG_H
4 # include "../config.h"
5 #endif
6
7 #include "display.hh"
8 #include "screeninfo.hh"
9 #include "gccache.hh"
10
11 extern "C" {
12 #include <X11/keysym.h>
13
14 #ifdef    SHAPE
15 #include <X11/extensions/shape.h>
16 #endif // SHAPE
17
18 #ifdef    HAVE_STDIO_H
19 #  include <stdio.h>
20 #endif // HAVE_STDIO_H
21
22 #ifdef    HAVE_STDLIB_H
23 #  include <stdlib.h>
24 #endif // HAVE_STDLIB_H
25
26 #ifdef    HAVE_SIGNAL_H
27 #  include <signal.h>
28 #endif // HAVE_SIGNAL_H
29
30 #ifdef    HAVE_FCNTL_H
31 #  include <fcntl.h>
32 #endif // HAVE_FCNTL_H
33
34 #ifdef    HAVE_UNISTD_H
35 #  include <sys/types.h>
36 #  include <unistd.h>
37 #endif // HAVE_UNISTD_H
38
39 #include "gettext.h"
40 #define _(str) gettext(str)
41 }
42
43 namespace otk {
44
45
46 Display *OBDisplay::display = (Display*) 0;
47 bool OBDisplay::_shape = false;
48 int  OBDisplay::_shape_event_basep = 0;
49 bool OBDisplay::_xinerama = false;
50 int  OBDisplay::_xinerama_event_basep = 0;
51 unsigned int OBDisplay::_mask_list[8];
52 unsigned int OBDisplay::_scrollLockMask = 0;
53 unsigned int OBDisplay::_numLockMask = 0;
54 OBDisplay::ScreenInfoList OBDisplay::_screenInfoList;
55 BGCCache *OBDisplay::_gccache = (BGCCache*) 0;
56 int OBDisplay::_grab_count = 0;
57
58
59 int OBDisplay::xerrorHandler(Display *d, XErrorEvent *e)
60 {
61 #ifdef DEBUG
62   char errtxt[128];
63
64   //if (e->error_code != BadWindow)
65   {
66     XGetErrorText(d, e->error_code, errtxt, 128);
67     printf("X Error: %s\n", errtxt);
68   }
69 #else
70   (void)d;
71   (void)e;
72 #endif
73
74   return false;
75 }
76
77
78 void OBDisplay::initialize(char *name)
79 {
80   int junk;
81   (void)junk;
82
83   // Open the X display
84   if (!(display = XOpenDisplay(name))) {
85     printf(_("Unable to open connection to the X server. Please set the \n\
86 DISPLAY environment variable approriately, or use the '-display' command \n\
87 line argument.\n\n"));
88     ::exit(1);
89   }
90   if (fcntl(ConnectionNumber(display), F_SETFD, 1) == -1) {
91     printf(_("Couldn't mark display connection as close-on-exec.\n\n"));
92     ::exit(1);
93   }
94
95   // set our error handler for X errors
96   XSetErrorHandler(xerrorHandler);
97
98   // set the DISPLAY environment variable for any lauched children, to the
99   // display we're using, so they open in the right place.
100   // XXX rm -> std::string dtmp = "DISPLAY=" + DisplayString(display);
101   if (putenv(const_cast<char*>((std::string("DISPLAY=") +
102                                 DisplayString(display)).c_str()))) {
103     printf(_("warning: couldn't set environment variable 'DISPLAY'\n"));
104     perror("putenv()");
105   }
106   
107   // find the availability of X extensions we like to use
108 #ifdef SHAPE
109   _shape = XShapeQueryExtension(display, &_shape_event_basep, &junk);
110 #endif
111
112 #ifdef XINERAMA
113   _xinerama = XineramaQueryExtension(display, &_xinerama_event_basep, &junk);
114 #endif // XINERAMA
115
116   // get lock masks that are defined by the display (not constant)
117   XModifierKeymap *modmap;
118
119   modmap = XGetModifierMapping(display);
120   if (modmap && modmap->max_keypermod > 0) {
121     const int mask_table[] = {
122       ShiftMask, LockMask, ControlMask, Mod1Mask,
123       Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
124     };
125     const size_t size = (sizeof(mask_table) / sizeof(mask_table[0])) *
126       modmap->max_keypermod;
127     // get the values of the keyboard lock modifiers
128     // Note: Caps lock is not retrieved the same way as Scroll and Num lock
129     // since it doesn't need to be.
130     const KeyCode num_lock = XKeysymToKeycode(display, XK_Num_Lock);
131     const KeyCode scroll_lock = XKeysymToKeycode(display, XK_Scroll_Lock);
132
133     for (size_t cnt = 0; cnt < size; ++cnt) {
134       if (! modmap->modifiermap[cnt]) continue;
135
136       if (num_lock == modmap->modifiermap[cnt])
137         _numLockMask = mask_table[cnt / modmap->max_keypermod];
138       if (scroll_lock == modmap->modifiermap[cnt])
139         _scrollLockMask = mask_table[cnt / modmap->max_keypermod];
140     }
141   }
142
143   if (modmap) XFreeModifiermap(modmap);
144
145   _mask_list[0] = 0;
146   _mask_list[1] = LockMask;
147   _mask_list[2] = _numLockMask;
148   _mask_list[3] = LockMask | _numLockMask;
149   _mask_list[4] = _scrollLockMask;
150   _mask_list[5] = _scrollLockMask | LockMask;
151   _mask_list[6] = _scrollLockMask | _numLockMask;
152   _mask_list[7] = _scrollLockMask | LockMask | _numLockMask;
153
154   // Get information on all the screens which are available.
155   _screenInfoList.reserve(ScreenCount(display));
156   for (int i = 0; i < ScreenCount(display); ++i)
157     _screenInfoList.push_back(ScreenInfo(i));
158
159   _gccache = new BGCCache(_screenInfoList.size());
160 }
161
162
163 void OBDisplay::destroy()
164 {
165   delete _gccache;
166   while (_grab_count > 0)
167     ungrab();
168   XCloseDisplay(display);
169 }
170
171
172 const ScreenInfo* OBDisplay::screenInfo(int snum) {
173   assert(snum >= 0);
174   assert(snum < static_cast<int>(_screenInfoList.size()));
175   return &_screenInfoList[snum];
176 }
177
178
179 const ScreenInfo* OBDisplay::findScreen(Window root)
180 {
181   ScreenInfoList::iterator it, end = _screenInfoList.end();
182   for (it = _screenInfoList.begin(); it != end; ++it)
183     if (it->rootWindow() == root)
184       return &(*it);
185   return 0;
186 }
187
188
189 void OBDisplay::grab()
190 {
191   if (_grab_count == 0)
192     XGrabServer(display);
193   _grab_count++;
194 }
195
196
197 void OBDisplay::ungrab()
198 {
199   if (_grab_count == 0) return;
200   _grab_count--;
201   if (_grab_count == 0)
202     XUngrabServer(display);
203 }
204
205
206
207
208
209
210
211 /*
212  * Grabs a button, but also grabs the button in every possible combination
213  * with the keyboard lock keys, so that they do not cancel out the event.
214
215  * if allow_scroll_lock is true then only the top half of the lock mask
216  * table is used and scroll lock is ignored.  This value defaults to false.
217  */
218 void OBDisplay::grabButton(unsigned int button, unsigned int modifiers,
219                          Window grab_window, bool owner_events,
220                          unsigned int event_mask, int pointer_mode,
221                          int keyboard_mode, Window confine_to,
222                          Cursor cursor, bool allow_scroll_lock) {
223   unsigned int length = (allow_scroll_lock) ? 8 / 2:
224                                               8;
225   for (size_t cnt = 0; cnt < length; ++cnt)
226     XGrabButton(otk::OBDisplay::display, button, modifiers | _mask_list[cnt],
227                 grab_window, owner_events, event_mask, pointer_mode,
228                 keyboard_mode, confine_to, cursor);
229 }
230
231
232 /*
233  * Releases the grab on a button, and ungrabs all possible combinations of the
234  * keyboard lock keys.
235  */
236 void OBDisplay::ungrabButton(unsigned int button, unsigned int modifiers,
237                            Window grab_window) {
238   for (size_t cnt = 0; cnt < 8; ++cnt)
239     XUngrabButton(otk::OBDisplay::display, button, modifiers | _mask_list[cnt],
240                   grab_window);
241 }
242
243 void OBDisplay::grabKey(unsigned int keycode, unsigned int modifiers,
244                         Window grab_window, bool owner_events,
245                         int pointer_mode, int keyboard_mode,
246                         bool allow_scroll_lock)
247 {
248   unsigned int length = (allow_scroll_lock) ? 8 / 2:
249                                               8;
250   for (size_t cnt = 0; cnt < length; ++cnt)
251     XGrabKey(otk::OBDisplay::display, keycode, modifiers | _mask_list[cnt],
252                 grab_window, owner_events, pointer_mode, keyboard_mode);
253 }
254
255 void OBDisplay::ungrabKey(unsigned int keycode, unsigned int modifiers,
256                           Window grab_window)
257 {
258   for (size_t cnt = 0; cnt < 8; ++cnt)
259     XUngrabKey(otk::OBDisplay::display, keycode, modifiers | _mask_list[cnt],
260                grab_window);
261 }
262
263 }