src/actions.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 "actions.hh"
   8 #include "widget.hh"
   9 #include "openbox.hh"
  10 #include "client.hh"
  11 #include "python.hh"
  12 #include "bindings.hh"
  13 #include "otk/display.hh"
  14
  15 #include <stdio.h>
  16
  17 namespace ob {
  18
  19 const unsigned int OBActions::DOUBLECLICKDELAY = 300;
  20 const int OBActions::BUTTONS;
  21
  22 OBActions::OBActions()
  23   : _button(0)
  24 {
  25   for (int i=0; i<BUTTONS; ++i)
  26     _posqueue[i] = new ButtonPressAction();
  27 }
  28
  29
  30 OBActions::~OBActions()
  31 {
  32   for (int i=0; i<BUTTONS; ++i)
  33     delete _posqueue[i];
  34 }
  35
  36
  37 void OBActions::insertPress(const XButtonEvent &e)
  38 {
  39   ButtonPressAction *a = _posqueue[BUTTONS - 1];
  40   for (int i=BUTTONS-1; i>0;)
  41     _posqueue[i] = _posqueue[--i];
  42   _posqueue[0] = a;
  43   a->button = e.button;
  44   a->pos.setPoint(e.x_root, e.y_root);
  45
  46   OBClient *c = Openbox::instance->findClient(e.window);
  47   if (c) a->clientarea = c->area();
  48   printf("press %d x:%d y:%d winx:%d winy:%d\n", e.button, e.x_root, e.y_root, c->area().x(), c->area().y());
  49 }
  50
  51 void OBActions::removePress(const XButtonEvent &e)
  52 {
  53   ButtonPressAction *a = 0;
  54   for (int i=0; i<BUTTONS; ++i) {
  55     if (_posqueue[i]->button == e.button)
  56       a = _posqueue[i];
  57     if (a) // found one and removed it
  58       _posqueue[i] = _posqueue[i+1];
  59   }
  60   if (a) { // found one
  61     _posqueue[BUTTONS-1] = a;
  62     a->button = 0;
  63   }
  64 }
  65
  66 void OBActions::buttonPressHandler(const XButtonEvent &e)
  67 {
  68   OtkEventHandler::buttonPressHandler(e);
  69   insertPress(e);
  70
  71   // run the PRESS python hook
  72   OBWidget *w = dynamic_cast<OBWidget*>
  73     (Openbox::instance->findHandler(e.window));
  74   assert(w); // everything should be a widget
  75
  76   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
  77                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
  78   ButtonData *data = new_button_data(e.window, e.time, state, e.button,
  79                                      w->mcontext(), MousePress);
  80   Openbox::instance->bindings()->fire(data);
  81   Py_DECREF((PyObject*)data);
  82
  83   if (_button) return; // won't count toward CLICK events
  84
  85   _button = e.button;
  86 }
  87
  88
  89 void OBActions::buttonReleaseHandler(const XButtonEvent &e)
  90 {
  91   OtkEventHandler::buttonReleaseHandler(e);
  92   removePress(e);
  93
  94   OBWidget *w = dynamic_cast<OBWidget*>
  95     (Openbox::instance->findHandler(e.window));
  96   assert(w); // everything should be a widget
  97
  98   // not for the button we're watching?
  99   if (_button != e.button) return;
 100
 101   _button = 0;
 102
 103   // find the area of the window
 104   XWindowAttributes attr;
 105   if (!XGetWindowAttributes(otk::OBDisplay::display, e.window, &attr)) return;
 106
 107   // if not on the window any more, it isnt a CLICK
 108   if (!(e.same_screen && e.x >= 0 && e.y >= 0 &&
 109         e.x < attr.width && e.y < attr.height))
 110     return;
 111
 112   // run the CLICK python hook
 113   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 114                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 115   ButtonData *data = new_button_data(e.window, e.time, state, e.button,
 116                                      w->mcontext(), MouseClick);
 117   Openbox::instance->bindings()->fire(data);
 118
 119
 120   if (e.time - _release.time < DOUBLECLICKDELAY &&
 121       _release.win == e.window && _release.button == e.button) {
 122
 123     // run the DOUBLECLICK python hook
 124     data->action = MouseDoubleClick;
 125     Openbox::instance->bindings()->fire(data);
 126
 127     // reset so you cant triple click for 2 doubleclicks
 128     _release.win = 0;
 129     _release.button = 0;
 130     _release.time = 0;
 131   } else {
 132     // save the button release, might be part of a double click
 133     _release.win = e.window;
 134     _release.button = e.button;
 135     _release.time = e.time;
 136   }
 137
 138   Py_DECREF((PyObject*)data);
 139 }
 140
 141
 142 void OBActions::enterHandler(const XCrossingEvent &e)
 143 {
 144   OtkEventHandler::enterHandler(e);
 145
 146   OBWidget *w = dynamic_cast<OBWidget*>
 147     (Openbox::instance->findHandler(e.window));
 148
 149   // run the ENTER python hook
 150   doCallback(Action_EnterWindow, e.window,
 151              (OBWidget::WidgetType)(w ? w->type():-1), e.state, 0, 0, 0, 0);
 152 }
 153
 154
 155 void OBActions::leaveHandler(const XCrossingEvent &e)
 156 {
 157   OtkEventHandler::leaveHandler(e);
 158
 159   OBWidget *w = dynamic_cast<OBWidget*>
 160     (Openbox::instance->findHandler(e.window));
 161
 162   // run the LEAVE python hook
 163   doCallback(Action_LeaveWindow, e.window,
 164              (OBWidget::WidgetType)(w ? w->type():-1), e.state, 0, 0, 0, 0);
 165 }
 166
 167
 168 void OBActions::keyPressHandler(const XKeyEvent &e)
 169 {
 170 //  OBWidget *w = dynamic_cast<OBWidget*>
 171 //    (Openbox::instance->findHandler(e.window));
 172
 173   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 174                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 175   Openbox::instance->bindings()->fire(state, e.keycode, e.time);
 176 }
 177
 178
 179 void OBActions::motionHandler(const XMotionEvent &e)
 180 {
 181   if (!e.same_screen) return; // this just gets stupid
 182
 183   int x_root = e.x_root, y_root = e.y_root;
 184
 185   // compress changes to a window into a single change
 186   XEvent ce;
 187   while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
 188     if (ce.xmotion.window != e.window) {
 189       XPutBackEvent(otk::OBDisplay::display, &ce);
 190       break;
 191     } else {
 192       x_root = e.x_root;
 193       y_root = e.y_root;
 194     }
 195   }
 196
 197   OBWidget *w = dynamic_cast<OBWidget*>
 198     (Openbox::instance->findHandler(e.window));
 199   assert(w); // everything should be a widget
 200
 201   // run the MOTION python hook
 202   unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
 203                                   Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
 204   unsigned int button = _posqueue[0]->button;
 205   printf("motion %d x:%d y:%d winx:%d winy:%d\n", button, x_root, y_root,
 206          _posqueue[0]->clientarea.x(), _posqueue[0]->clientarea.y());
 207   MotionData *data = new_motion_data(e.window, e.time, state, button,
 208                                      w->mcontext(), MouseMotion,
 209                                      x_root, y_root, _posqueue[0]->pos,
 210                                      _posqueue[0]->clientarea);
 211   Openbox::instance->bindings()->fire((ButtonData*)data);
 212   Py_DECREF((PyObject*)data);
 213 }
 214
 215 void OBActions::mapRequestHandler(const XMapRequestEvent &e)
 216 {
 217   doCallback(Action_NewWindow, e.window, (OBWidget::WidgetType)-1,
 218              0, 0, 0, 0, 0);
 219 }
 220
 221 void OBActions::unmapHandler(const XUnmapEvent &e)
 222 {
 223   (void)e;
 224   doCallback(Action_CloseWindow, e.window, (OBWidget::WidgetType)-1,
 225              0, 0, 0, 0, 0);
 226 }
 227
 228 void OBActions::destroyHandler(const XDestroyWindowEvent &e)
 229 {
 230   (void)e;
 231   doCallback(Action_CloseWindow, e.window, (OBWidget::WidgetType)-1,
 232              0, 0, 0, 0, 0);
 233 }
 234
 235 void OBActions::doCallback(ActionType action, Window window,
 236                            OBWidget::WidgetType type, unsigned int state,
 237                            unsigned int button, int xroot, int yroot,
 238                            Time time)
 239 {
 240   std::pair<CallbackMap::iterator, CallbackMap::iterator> it_pair =
 241     _callbacks.equal_range(action);
 242
 243   CallbackMap::iterator it;
 244 //  for (it = it_pair.first; it != it_pair.second; ++it)
 245 //    python_callback(it->second, action, window, type, state,
 246 //                    button, xroot, yroot, time);
 247   // XXX do a callback
 248 }
 249
 250 bool OBActions::registerCallback(ActionType action, PyObject *func,
 251                                  bool atfront)
 252 {
 253   if (action < 0 || action >= OBActions::NUM_ACTIONS) {
 254     return false;
 255   }
 256   if (!func)
 257     return false;
 258
 259   std::pair<CallbackMap::iterator, CallbackMap::iterator> it_pair =
 260     _callbacks.equal_range(action);
 261
 262   CallbackMap::iterator it;
 263   for (it = it_pair.first; it != it_pair.second; ++it)
 264     if (it->second == func)
 265       return true; // already in there
 266   if (atfront)
 267     _callbacks.insert(_callbacks.begin(), CallbackMapPair(action, func));
 268   else
 269     _callbacks.insert(CallbackMapPair(action, func));
 270   Py_INCREF(func);
 271   return true;
 272 }
 273
 274 bool OBActions::unregisterCallback(ActionType action, PyObject *func)
 275 {
 276   if (action < 0 || action >= OBActions::NUM_ACTIONS) {
 277     return false;
 278   }
 279   if (!func)
 280     return false;
 281
 282   std::pair<CallbackMap::iterator, CallbackMap::iterator> it_pair =
 283     _callbacks.equal_range(action);
 284
 285   CallbackMap::iterator it;
 286   for (it = it_pair.first; it != it_pair.second; ++it)
 287     if (it->second == func)
 288       break;
 289   if (it != it_pair.second) { // its been registered before
 290     Py_DECREF(func);
 291     _callbacks.erase(it);
 292   }
 293   return true;
 294 }
 295
 296 bool OBActions::unregisterAllCallbacks(ActionType action)
 297 {
 298   if (action < 0 || action >= OBActions::NUM_ACTIONS) {
 299     return false;
 300   }
 301
 302   while (!_callbacks.empty()) {
 303     CallbackMap::iterator it = _callbacks.begin();
 304     Py_DECREF(it->second);
 305     _callbacks.erase(it);
 306   }
 307   return true;
 308 }
 309
 310 }