Dogcows Code - chaz/openbox/blob - openbox/grab.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    grab.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   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.
  11
  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.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "grab.h"
  21 #include "openbox.h"
  22 #include "event.h"
  23 #include "screen.h"
  24 #include "debug.h"
  25 #include "obt/display.h"
  26 #include "obt/keyboard.h"
  27
  28 #include <glib.h>
  29 #include <X11/Xlib.h>
  30
  31 #define GRAB_PTR_MASK (ButtonPressMask | ButtonReleaseMask | PointerMotionMask)
  32 #define GRAB_KEY_MASK (KeyPressMask | KeyReleaseMask)
  33
  34 #define MASK_LIST_SIZE 8
  35
  36 /*! A list of all possible combinations of keyboard lock masks */
  37 static guint mask_list[MASK_LIST_SIZE];
  38 static guint kgrabs = 0;
  39 static guint pgrabs = 0;
  40 /*! The time at which the last grab was made */
  41 static Time  grab_time = CurrentTime;
  42 static gint passive_count = 0;
  43
  44 static Time ungrab_time(void)
  45 {
  46     Time t = event_curtime;
  47     if (grab_time == CurrentTime ||
  48         !(t == CurrentTime || event_time_after(t, grab_time)))
  49         /* When the time moves backward on the server, then we can't use
  50            the grab time because that will be in the future. So instead we
  51            have to use CurrentTime.
  52
  53            "XUngrabPointer does not release the pointer if the specified time
  54            is earlier than the last-pointer-grab time or is later than the
  55            current X server time."
  56         */
  57         t = CurrentTime; /*grab_time;*/
  58     return t;
  59 }
  60
  61 gboolean grab_on_keyboard(void)
  62 {
  63     return kgrabs > 0;
  64 }
  65
  66 gboolean grab_on_pointer(void)
  67 {
  68     return pgrabs > 0;
  69 }
  70
  71 gboolean grab_keyboard_full(gboolean grab)
  72 {
  73     gboolean ret = FALSE;
  74
  75     if (grab) {
  76         if (kgrabs++ == 0) {
  77             ret = XGrabKeyboard(obt_display, obt_root(ob_screen),
  78                                 False, GrabModeAsync, GrabModeAsync,
  79                                 event_curtime) == Success;
  80             if (!ret)
  81                 --kgrabs;
  82             else {
  83                 passive_count = 0;
  84                 grab_time = event_curtime;
  85             }
  86         } else
  87             ret = TRUE;
  88     } else if (kgrabs > 0) {
  89         if (--kgrabs == 0) {
  90             XUngrabKeyboard(obt_display, ungrab_time());
  91         }
  92         ret = TRUE;
  93     }
  94
  95     return ret;
  96 }
  97
  98 gboolean grab_pointer_full(gboolean grab, gboolean owner_events,
  99                            gboolean confine, ObCursor cur)
 100 {
 101     gboolean ret = FALSE;
 102
 103     if (grab) {
 104         if (pgrabs++ == 0) {
 105             ret = XGrabPointer(obt_display, screen_support_win, owner_events,
 106                                GRAB_PTR_MASK,
 107                                GrabModeAsync, GrabModeAsync,
 108                                (confine ? obt_root(ob_screen) : None),
 109                                ob_cursor(cur), event_curtime) == Success;
 110             if (!ret)
 111                 --pgrabs;
 112             else
 113                 grab_time = event_curtime;
 114         } else
 115             ret = TRUE;
 116     } else if (pgrabs > 0) {
 117         if (--pgrabs == 0) {
 118             XUngrabPointer(obt_display, ungrab_time());
 119         }
 120         ret = TRUE;
 121     }
 122     return ret;
 123 }
 124
 125 gint grab_server(gboolean grab)
 126 {
 127     static guint sgrabs = 0;
 128     if (grab) {
 129         if (sgrabs++ == 0) {
 130             XGrabServer(obt_display);
 131             XSync(obt_display, FALSE);
 132         }
 133     } else if (sgrabs > 0) {
 134         if (--sgrabs == 0) {
 135             XUngrabServer(obt_display);
 136             XFlush(obt_display);
 137         }
 138     }
 139     return sgrabs;
 140 }
 141
 142 void grab_startup(gboolean reconfig)
 143 {
 144     guint i = 0;
 145     guint num, caps, scroll;
 146
 147     num = obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_NUMLOCK);
 148     caps = obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_CAPSLOCK);
 149     scroll = obt_keyboard_modkey_to_modmask(OBT_KEYBOARD_MODKEY_SCROLLLOCK);
 150
 151     mask_list[i++] = 0;
 152     mask_list[i++] = num;
 153     mask_list[i++] = caps;
 154     mask_list[i++] = scroll;
 155     mask_list[i++] = num | caps;
 156     mask_list[i++] = num | scroll;
 157     mask_list[i++] = caps | scroll;
 158     mask_list[i++] = num | caps | scroll;
 159     g_assert(i == MASK_LIST_SIZE);
 160 }
 161
 162 void grab_shutdown(gboolean reconfig)
 163 {
 164     if (reconfig) return;
 165
 166     while (ungrab_keyboard());
 167     while (ungrab_pointer());
 168     while (grab_server(FALSE));
 169 }
 170
 171 void grab_button_full(guint button, guint state, Window win, guint mask,
 172                       gint pointer_mode, ObCursor cur)
 173 {
 174     guint i;
 175
 176     /* can get BadAccess from these */
 177     obt_display_ignore_errors(TRUE);
 178     for (i = 0; i < MASK_LIST_SIZE; ++i)
 179         XGrabButton(obt_display, button, state | mask_list[i], win, False,
 180                     mask, pointer_mode, GrabModeAsync, None, ob_cursor(cur));
 181     obt_display_ignore_errors(FALSE);
 182     if (obt_display_error_occured)
 183         ob_debug("Failed to grab button %d modifiers %d", button, state);
 184 }
 185
 186 void ungrab_button(guint button, guint state, Window win)
 187 {
 188     guint i;
 189
 190     for (i = 0; i < MASK_LIST_SIZE; ++i)
 191         XUngrabButton(obt_display, button, state | mask_list[i], win);
 192 }
 193
 194 void grab_key(guint keycode, guint state, Window win, gint keyboard_mode)
 195 {
 196     guint i;
 197
 198     /* can get BadAccess' from these */
 199     obt_display_ignore_errors(TRUE);
 200     for (i = 0; i < MASK_LIST_SIZE; ++i)
 201         XGrabKey(obt_display, keycode, state | mask_list[i], win, FALSE,
 202                  GrabModeAsync, keyboard_mode);
 203     obt_display_ignore_errors(FALSE);
 204     if (obt_display_error_occured)
 205         ob_debug("Failed to grab keycode %d modifiers %d", keycode, state);
 206 }
 207
 208 void ungrab_all_keys(Window win)
 209 {
 210     XUngrabKey(obt_display, AnyKey, AnyModifier, win);
 211 }
 212
 213 void grab_key_passive_count(int change)
 214 {
 215     if (grab_on_keyboard()) return;
 216     passive_count += change;
 217     if (passive_count < 0) passive_count = 0;
 218 }
 219
 220 void ungrab_passive_key(void)
 221 {
 222     /*ob_debug("ungrabbing %d passive grabs\n", passive_count);*/
 223     if (passive_count) {
 224         /* kill our passive grab */
 225         XUngrabKeyboard(obt_display, event_curtime);
 226         passive_count = 0;
 227     }
 228 }