src/actions.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 #include "config.h"
   4
   5 #include "actions.hh"
   6 #include "openbox.hh"
   7 #include "client.hh"
   8 #include "frame.hh"
   9 #include "screen.hh"
  10 #include "python.hh"
  11 #include "bindings.hh"
  12 #include "otk/display.hh"
  13
  14 #include <cstdio>
  15 #include <algorithm>
  16
  17 namespace ob {
  18
  19 Actions::Actions()
  20   : _dragging(false)
  21 {
  22 }
  23
  24
  25 Actions::~Actions()
  26 {
  27 }
  28
  29
  30 void Actions::buttonPressHandler(const XButtonEvent &e)
  31 {
  32   otk::EventHandler::buttonPressHandler(e);
  33
  34   MouseContext::MC context;
  35   EventHandler *h = openbox->findHandler(e.window);
  36   Frame *f = dynamic_cast<Frame*>(h);
  37   if (f)
  38     context= f->mouseContext(e.window);
  39   else if (dynamic_cast<Client*>(h))
  40     context = MouseContext::Window;
  41   else if (dynamic_cast<Screen*>(h))
  42     context = MouseContext::Root;
  43   else
  44     return; // not a valid mouse context
  45
  46   if (_press.button) {
  47     unsigned int mask;
  48     switch(_press.button) {
  49     case Button1: mask = Button1Mask; break;
  50     case Button2: mask = Button2Mask; break;
  51     case Button3: mask = Button3Mask; break;
  52     case Button4: mask = Button4Mask; break;
  53     case Button5: mask = Button5Mask; break;
  54     default: mask = 0; // on other buttons we have to assume its not pressed...
  55     }
  56     // was the button released but we didnt get the event? (pointergrabs cause
  57     // this)
  58     if (!(e.state & mask))
  59       _press.button = 0;
  60   }
  61
  62   // run the PRESS python hook
  63   // kill off the Button1Mask etc, only want the modifiers
  64   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
  65                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
  66   int screen;
  67   Client *c = openbox->findClient(e.window);
  68   if (c)
  69     screen = c->screen();
  70   else
  71     screen = otk::display->findScreen(e.root)->screen();
  72   MouseData data(screen, c, e.time, state, e.button, context,
  73                  MouseAction::Press);
  74   openbox->bindings()->fireButton(&data);
  75
  76   if (_press.button) return; // won't count toward CLICK events
  77
  78   _press.win = e.window;
  79   _press.button = e.button;
  80   _press.pos = otk::Point(e.x_root, e.y_root);
  81   if (c)
  82     _press.clientarea = c->area();
  83
  84   printf("press queue %u pressed %u\n", _press.button, e.button);
  85
  86   if (context == MouseContext::Window) {
  87     /*
  88       Because of how events are grabbed on the client window, we can't get
  89       ButtonRelease events, so instead we simply manufacture them here, so that
  90       clicks/doubleclicks etc still work.
  91     */
  92     //XButtonEvent ev = e;
  93     //ev.type = ButtonRelease;
  94     buttonReleaseHandler(e);
  95   }
  96 }
  97
  98
  99 void Actions::buttonReleaseHandler(const XButtonEvent &e)
 100 {
 101   otk::EventHandler::buttonReleaseHandler(e);
 102
 103   MouseContext::MC context;
 104   EventHandler *h = openbox->findHandler(e.window);
 105   Frame *f = dynamic_cast<Frame*>(h);
 106   if (f)
 107     context= f->mouseContext(e.window);
 108   else if (dynamic_cast<Client*>(h))
 109     context = MouseContext::Window;
 110   else if (dynamic_cast<Screen*>(h))
 111     context = MouseContext::Root;
 112   else
 113     return; // not a valid mouse context
 114
 115   // run the RELEASE python hook
 116   // kill off the Button1Mask etc, only want the modifiers
 117   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 118                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 119   int screen;
 120   Client *c = openbox->findClient(e.window);
 121   if (c)
 122     screen = c->screen();
 123   else
 124     screen = otk::display->findScreen(e.root)->screen();
 125   MouseData data(screen, c, e.time, state, e.button, context,
 126                  MouseAction::Release);
 127   openbox->bindings()->fireButton(&data);
 128
 129   // not for the button we're watching?
 130   if (_press.button != e.button) return;
 131
 132   _press.button = 0;
 133   _dragging = false;
 134
 135   // find the area of the window
 136   XWindowAttributes attr;
 137   if (!XGetWindowAttributes(**otk::display, e.window, &attr)) return;
 138
 139   // if not on the window any more, it isnt a CLICK
 140   if (!(e.same_screen && e.x >= 0 && e.y >= 0 &&
 141         e.x < attr.width && e.y < attr.height))
 142     return;
 143
 144   // run the CLICK python hook
 145   data.action = MouseAction::Click;
 146   openbox->bindings()->fireButton(&data);
 147
 148   long dblclick = 0;
 149   python_get_long("double_click_delay", &dblclick);
 150   if (e.time - _release.time < (unsigned)dblclick &&
 151       _release.win == e.window && _release.button == e.button) {
 152
 153     // run the DOUBLECLICK python hook
 154     data.action = MouseAction::DoubleClick;
 155     openbox->bindings()->fireButton(&data);
 156
 157     // reset so you cant triple click for 2 doubleclicks
 158     _release.win = 0;
 159     _release.button = 0;
 160     _release.time = 0;
 161   } else {
 162     // save the button release, might be part of a double click
 163     _release.win = e.window;
 164     _release.button = e.button;
 165     _release.time = e.time;
 166   }
 167 }
 168
 169
 170 void Actions::enterHandler(const XCrossingEvent &e)
 171 {
 172   otk::EventHandler::enterHandler(e);
 173
 174   // run the ENTER python hook
 175   int screen;
 176   Client *c = openbox->findClient(e.window);
 177   if (c)
 178     screen = c->screen();
 179   else
 180     screen = otk::display->findScreen(e.root)->screen();
 181   EventData data(screen, c, EventAction::EnterWindow, e.state);
 182   openbox->bindings()->fireEvent(&data);
 183 }
 184
 185
 186 void Actions::leaveHandler(const XCrossingEvent &e)
 187 {
 188   otk::EventHandler::leaveHandler(e);
 189
 190   // run the LEAVE python hook
 191   int screen;
 192   Client *c = openbox->findClient(e.window);
 193   if (c)
 194     screen = c->screen();
 195   else
 196     screen = otk::display->findScreen(e.root)->screen();
 197   EventData data(screen, c, EventAction::LeaveWindow, e.state);
 198   openbox->bindings()->fireEvent(&data);
 199 }
 200
 201
 202 void Actions::keyPressHandler(const XKeyEvent &e)
 203 {
 204   otk::EventHandler::keyPressHandler(e);
 205
 206   // kill off the Button1Mask etc, only want the modifiers
 207   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 208                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 209
 210   // add to the state the mask of the modifier being pressed, if it is
 211   // a modifier key being pressed (this is a little ugly..)
 212   const XModifierKeymap *map = otk::display->modifierMap();
 213   const int mask_table[] = {
 214     ShiftMask, LockMask, ControlMask, Mod1Mask,
 215     Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
 216   };
 217   KeyCode *kp = map->modifiermap;
 218   for (int i = 0, n = sizeof(mask_table)/sizeof(mask_table[0]); i < n; ++i) {
 219     for (int k = 0; k < map->max_keypermod; ++k) {
 220       if (*kp == e.keycode) { // found the keycode
 221         state |= mask_table[i]; // add the mask for it
 222         i = n; // cause the first loop to break;
 223         break; // get outta here!
 224       }
 225       ++kp;
 226     }
 227   }
 228
 229   openbox->bindings()->
 230     fireKey(otk::display->findScreen(e.root)->screen(),
 231             state, e.keycode, e.time, KeyAction::Press);
 232 }
 233
 234
 235 void Actions::keyReleaseHandler(const XKeyEvent &e)
 236 {
 237   otk::EventHandler::keyReleaseHandler(e);
 238
 239   // kill off the Button1Mask etc, only want the modifiers
 240   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 241                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 242
 243   // remove from the state the mask of the modifier being released, if it is
 244   // a modifier key being released (this is a little ugly..)
 245   const XModifierKeymap *map = otk::display->modifierMap();
 246   const int mask_table[] = {
 247     ShiftMask, LockMask, ControlMask, Mod1Mask,
 248     Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
 249   };
 250   KeyCode *kp = map->modifiermap;
 251   for (int i = 0, n = sizeof(mask_table)/sizeof(mask_table[0]); i < n; ++i) {
 252     for (int k = 0; k < map->max_keypermod; ++k) {
 253       if (*kp == e.keycode) { // found the keycode
 254         state &= ~mask_table[i]; // remove the mask for it
 255         i = n; // cause the first loop to break;
 256         break; // get outta here!
 257       }
 258       ++kp;
 259     }
 260   }
 261
 262   openbox->bindings()->
 263     fireKey(otk::display->findScreen(e.root)->screen(),
 264             state, e.keycode, e.time, KeyAction::Release);
 265 }
 266
 267
 268 void Actions::motionHandler(const XMotionEvent &e)
 269 {
 270   otk::EventHandler::motionHandler(e);
 271
 272   if (!e.same_screen) return; // this just gets stupid
 273
 274   if (e.window != _press.win) return;
 275
 276   MouseContext::MC context;
 277   EventHandler *h = openbox->findHandler(e.window);
 278   Frame *f = dynamic_cast<Frame*>(h);
 279   if (f)
 280     context= f->mouseContext(e.window);
 281   else if (dynamic_cast<Client*>(h))
 282     context = MouseContext::Window;
 283   else if (dynamic_cast<Screen*>(h))
 284     context = MouseContext::Root;
 285   else
 286     return; // not a valid mouse context
 287
 288   int x_root = e.x_root, y_root = e.y_root;
 289
 290   // compress changes to a window into a single change
 291   XEvent ce;
 292   while (XCheckTypedWindowEvent(**otk::display, e.window, e.type, &ce)) {
 293     x_root = ce.x_root;
 294     y_root = ce.y_root;
 295   }
 296
 297   int screen;
 298   Client *c = openbox->findClient(e.window);
 299   if (c)
 300     screen = c->screen();
 301   else
 302     screen = otk::display->findScreen(e.root)->screen();
 303
 304   if (!_dragging) {
 305     int dx = x_root - _press.pos.x();
 306     int dy = y_root - _press.pos.y();
 307     long threshold = 0;
 308     python_get_long("drag_threshold", &threshold);
 309     if (!(std::abs(dx) >= threshold || std::abs(dy) >= threshold))
 310       return; // not at the threshold yet
 311   }
 312   _dragging = true; // in a drag now
 313
 314   // check if the movement is more than the threshold
 315
 316   // run the MOTION python hook
 317   // kill off the Button1Mask etc, only want the modifiers
 318   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 319                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 320   unsigned int button = _press.button;
 321   MouseData data(screen, c, e.time, state, button, context,
 322                  MouseAction::Motion, x_root, y_root,
 323                  _press.pos, _press.clientarea);
 324   openbox->bindings()->fireButton(&data);
 325 }
 326
 327 #ifdef    XKB
 328 void Actions::xkbHandler(const XkbEvent &e)
 329 {
 330   Window w;
 331   int screen;
 332
 333   otk::EventHandler::xkbHandler(e);
 334
 335   switch (((XkbAnyEvent*)&e)->xkb_type) {
 336   case XkbBellNotify:
 337     w = ((XkbBellNotifyEvent*)&e)->window;
 338     Client *c = openbox->findClient(w);
 339     if (c)
 340       screen = c->screen();
 341     else
 342       screen = openbox->focusedScreen()->number();
 343     EventData data(screen, c, EventAction::Bell, 0);
 344     openbox->bindings()->fireEvent(&data);
 345     break;
 346   }
 347 }
 348 #endif // XKB
 349
 350 }
 351