openbox/pointer.c

   1 #include "pointer.h"
   2 #include "keyboard.h"
   3 #include "frame.h"
   4 #include "engine.h"
   5 #include "openbox.h"
   6 #include "hooks.h"
   7
   8 #include <glib.h>
   9 #include <Python.h>
  10 #include <structmember.h> /* for PyMemberDef stuff */
  11 #ifdef HAVE_STDLIB_H
  12 #  include <stdlib.h>
  13 #endif
  14
  15 typedef enum {
  16     Action_Press,
  17     Action_Release,
  18     Action_Click,
  19     Action_DoubleClick,
  20     Action_Motion,
  21     NUM_ACTIONS
  22 } Action;
  23
  24 /* GData of GSList*s of PointerBinding*s. */
  25 static GData *bound_contexts;
  26 static gboolean grabbed;
  27 static int double_click_rate, drag_threshold;
  28 PyObject *grab_func;
  29
  30 struct foreach_grab_temp {
  31     Client *client;
  32     gboolean grab;
  33 };
  34
  35 typedef struct {
  36     guint state;
  37     guint button;
  38     Action action;
  39     char *name;
  40     GSList *funcs[NUM_ACTIONS];
  41 } PointerBinding;
  42
  43 /***************************************************************************
  44
  45    Define the type 'ButtonData'
  46
  47  ***************************************************************************/
  48
  49 typedef struct PointerData {
  50     PyObject_HEAD
  51     Action action;
  52     GQuark context;
  53     char *button;
  54     guint state;
  55     guint buttonnum;
  56     int posx, posy;
  57     int pressposx, pressposy;
  58     int pcareax, pcareay, pcareaw, pcareah;
  59 } PointerData;
  60
  61 staticforward PyTypeObject PointerDataType;
  62
  63 /***************************************************************************
  64
  65    Type methods/struct
  66
  67  ***************************************************************************/
  68
  69 static PyObject *ptrdata_new(char *button, GQuark context, Action action,
  70                              guint state, guint buttonnum, int posx, int posy,
  71                              int pressposx, int pressposy, int pcareax,
  72                              int pcareay, int pcareaw, int pcareah)
  73 {
  74     PointerData *self = PyObject_New(PointerData, &PointerDataType);
  75     self->button = g_strdup(button);
  76     self->context = context;
  77     self->action = action;
  78     self->state = state;
  79     self->buttonnum = buttonnum;
  80     self->posx = posx;
  81     self->posy = posy;
  82     self->pressposx = pressposx;
  83     self->pressposy = pressposy;
  84     self->pcareax = pcareax;
  85     self->pcareay = pcareay;
  86     self->pcareaw = pcareaw;
  87     self->pcareah = pcareah;
  88     return (PyObject*) self;
  89 }
  90
  91 static void ptrdata_dealloc(PointerData *self)
  92 {
  93     g_free(self->button);
  94     PyObject_Del((PyObject*)self);
  95 }
  96
  97 static PyObject *ptrdata_getattr(PointerData *self, char *name)
  98 {
  99     if (!strcmp(name, "button"))
 100         return PyString_FromString(self->button);
 101     if (!strcmp(name, "action"))
 102         return PyInt_FromLong(self->action);
 103     if (!strcmp(name, "context"))
 104         return PyString_FromString(g_quark_to_string(self->context));
 105     if (!strcmp(name, "state"))
 106         return PyInt_FromLong(self->state);
 107     if (!strcmp(name, "buttonnum"))
 108         return PyInt_FromLong(self->buttonnum);
 109
 110     if (self->action == Action_Motion) { /* the rest are only for motions */
 111         if (!strcmp(name, "pos")) {
 112             PyObject *pos = PyTuple_New(2);
 113             PyTuple_SET_ITEM(pos, 0, PyInt_FromLong(self->posx));
 114             PyTuple_SET_ITEM(pos, 1, PyInt_FromLong(self->posy));
 115             return pos;
 116         }
 117         if (!strcmp(name, "presspos")) {
 118             PyObject *presspos = PyTuple_New(2);
 119             PyTuple_SET_ITEM(presspos, 0, PyInt_FromLong(self->pressposx));
 120             PyTuple_SET_ITEM(presspos, 1, PyInt_FromLong(self->pressposy));
 121             return presspos;
 122         }
 123         if (!strcmp(name, "pressclientarea")) {
 124             if (self->pcareaw < 0) { /* < 0 indicates no client */
 125                 Py_INCREF(Py_None);
 126                 return Py_None;
 127             } else {
 128                 PyObject *ca = PyTuple_New(4);
 129                 PyTuple_SET_ITEM(ca, 0, PyInt_FromLong(self->pcareax));
 130                 PyTuple_SET_ITEM(ca, 1, PyInt_FromLong(self->pcareay));
 131                 PyTuple_SET_ITEM(ca, 2, PyInt_FromLong(self->pcareaw));
 132                 PyTuple_SET_ITEM(ca, 3, PyInt_FromLong(self->pcareah));
 133                 return ca;
 134             }
 135         }
 136     }
 137
 138     PyErr_Format(PyExc_AttributeError, "no such attribute '%s'", name);
 139     return NULL;
 140 }
 141
 142 static PyTypeObject PointerDataType = {
 143     PyObject_HEAD_INIT(NULL)
 144     0,
 145     "PointerData",
 146     sizeof(PointerData),
 147     0,
 148     (destructor) ptrdata_dealloc,   /*tp_dealloc*/
 149     0,                              /*tp_print*/
 150     (getattrfunc) ptrdata_getattr,  /*tp_getattr*/
 151     0,                              /*tp_setattr*/
 152     0,                              /*tp_compare*/
 153     0,                              /*tp_repr*/
 154     0,                              /*tp_as_number*/
 155     0,                              /*tp_as_sequence*/
 156     0,                              /*tp_as_mapping*/
 157     0,                              /*tp_hash */
 158 };
 159
 160 /***************************************************************************/
 161
 162 static gboolean translate(char *str, guint *state, guint *button)
 163 {
 164     char **parsed;
 165     char *l;
 166     int i;
 167     gboolean ret = FALSE;
 168
 169     parsed = g_strsplit(str, "-", -1);
 170
 171     /* first, find the button (last token) */
 172     l = NULL;
 173     for (i = 0; parsed[i] != NULL; ++i)
 174         l = parsed[i];
 175     if (l == NULL)
 176         goto translation_fail;
 177
 178     /* figure out the mod mask */
 179     *state = 0;
 180     for (i = 0; parsed[i] != l; ++i) {
 181         guint m = keyboard_translate_modifier(parsed[i]);
 182         if (!m) goto translation_fail;
 183         *state |= m;
 184     }
 185
 186     /* figure out the button */
 187     *button = atoi(l);
 188     if (!*button) {
 189         g_warning("Invalid button '%s' in pointer binding.", l);
 190         goto translation_fail;
 191     }
 192
 193     ret = TRUE;
 194
 195 translation_fail:
 196     g_strfreev(parsed);
 197     return ret;
 198 }
 199
 200 static void grab_button(Client *client, guint state, guint button,
 201                         GQuark context, gboolean grab)
 202 {
 203     Window win;
 204     int mode = GrabModeAsync;
 205     unsigned int mask;
 206
 207     if (context == g_quark_try_string("frame")) {
 208         win = client->frame->window;
 209         mask = ButtonPressMask | ButtonMotionMask | ButtonReleaseMask;
 210     } else if (context == g_quark_try_string("client")) {
 211         win = client->frame->plate;
 212         mode = GrabModeSync; /* this is handled in pointer_event */
 213         mask = ButtonPressMask; /* can't catch more than this with Sync mode
 214                                    the release event is manufactured in
 215                                    pointer_fire */
 216     } else return;
 217
 218     if (grab)
 219         XGrabButton(ob_display, button, state, win, FALSE, mask, mode,
 220                     GrabModeAsync, None, None);
 221     else
 222         XUngrabButton(ob_display, button, state, win);
 223 }
 224
 225 static void foreach_grab(GQuark key, gpointer data, gpointer user_data)
 226 {
 227     struct foreach_grab_temp *d = user_data;
 228     GSList *it;
 229     for (it = data; it != NULL; it = it->next) {
 230         PointerBinding *b = it->data;
 231         grab_button(d->client, b->state, b->button, key, d->grab);
 232     }
 233 }
 234
 235 void pointer_grab_all(Client *client, gboolean grab)
 236 {
 237     struct foreach_grab_temp bt;
 238     bt.client = client;
 239     bt.grab = grab;
 240     g_datalist_foreach(&bound_contexts, foreach_grab, &bt);
 241 }
 242
 243 static void grab_all_clients(gboolean grab)
 244 {
 245     GSList *it;
 246
 247     for (it = client_list; it != NULL; it = it->next)
 248         pointer_grab_all(it->data, grab);
 249 }
 250
 251 static gboolean grab_pointer(gboolean grab)
 252 {
 253     gboolean ret = TRUE;
 254     if (grab)
 255         ret = XGrabPointer(ob_display, ob_root, FALSE, (ButtonPressMask |
 256                                                         ButtonReleaseMask |
 257                                                         ButtonMotionMask |
 258                                                         PointerMotionMask),
 259                            GrabModeAsync, GrabModeAsync, None, None,
 260                            CurrentTime) == GrabSuccess;
 261     else
 262         XUngrabPointer(ob_display, CurrentTime);
 263     if (ret) grabbed = grab;
 264     return ret;
 265 }
 266
 267 static void foreach_clear(GQuark key, gpointer data, gpointer user_data)
 268 {
 269     GSList *it;
 270     user_data = user_data;
 271     for (it = data; it != NULL; it = it->next) {
 272         int i;
 273
 274         PointerBinding *b = it->data;
 275         for (i = 0; i < NUM_ACTIONS; ++i)
 276             while (b->funcs[i] != NULL) {
 277                 Py_DECREF((PyObject*)b->funcs[i]->data);
 278                 b->funcs[i] = g_slist_delete_link(b->funcs[i], b->funcs[i]);
 279             }
 280         g_free(b->name);
 281         g_free(b);
 282     }
 283     g_slist_free(data);
 284 }
 285
 286 static void clearall()
 287 {
 288     grab_all_clients(FALSE);
 289     g_datalist_foreach(&bound_contexts, foreach_clear, NULL);
 290 }
 291
 292 static void fire_event(char *button, GQuark context, Action action,
 293                        guint state, guint buttonnum, int posx, int posy,
 294                        int pressposx, int pressposy, int pcareax,
 295                        int pcareay, int pcareaw, int pcareah,
 296                        PyObject *client, GSList *functions)
 297 {
 298     PyObject *ptrdata, *args, *ret;
 299     GSList *it;
 300
 301     ptrdata = ptrdata_new(button, context, action,
 302                           state, buttonnum, posx, posy, pressposx, pressposy,
 303                           pcareax, pcareay, pcareaw, pcareah);
 304     args = Py_BuildValue("OO", ptrdata, client);
 305
 306     if (grabbed) {
 307         ret = PyObject_CallObject(grab_func, args);
 308         if (ret == NULL) PyErr_Print();
 309         Py_XDECREF(ret);
 310     } else {
 311         for (it = functions; it != NULL; it = it->next) {
 312             ret = PyObject_CallObject(it->data, args);
 313             if (ret == NULL) PyErr_Print();
 314             Py_XDECREF(ret);
 315         }
 316     }
 317
 318     Py_DECREF(args);
 319     Py_DECREF(ptrdata);
 320 }
 321
 322 void pointer_event(XEvent *e, Client *c)
 323 {
 324     static guint button = 0, lastbutton = 0;
 325     static Time time = 0;
 326     static Rect carea;
 327     static guint pressx, pressy;
 328     GQuark contextq;
 329     gboolean click = FALSE, dblclick = FALSE;
 330     PyObject *client;
 331     GString *str = g_string_sized_new(0);
 332     guint state;
 333     GSList *it = NULL;
 334     PointerBinding *b = NULL;
 335
 336     contextq = engine_get_context(c, e->xany.window);
 337
 338     /* pick a button, figure out clicks/double clicks */
 339     switch (e->type) {
 340     case ButtonPress:
 341         if (!button) {
 342             button = e->xbutton.button;
 343             if (c != NULL) carea = c->frame->area;
 344             else carea.width = -1; /* indicates no client */
 345             pressx = e->xbutton.x_root;
 346             pressy = e->xbutton.y_root;
 347         }
 348         state = e->xbutton.state;
 349         break;
 350     case ButtonRelease:
 351         state = e->xbutton.state;
 352         break;
 353     case MotionNotify:
 354         state = e->xmotion.state;
 355         break;
 356     default:
 357         g_assert_not_reached();
 358         return;
 359     }
 360
 361     if (!grabbed) {
 362         for (it = g_datalist_id_get_data(&bound_contexts, contextq);
 363              it != NULL; it = it->next) {
 364             b = it->data;
 365             if (b->state == state && b->button == button)
 366                 break;
 367         }
 368         /* if not grabbed and not bound, then nothing to do! */
 369         if (it == NULL) return;
 370     }
 371
 372     if (c) client = clientwrap_new(c);
 373     else client = Py_None;
 374
 375     /* build the button string */
 376     if (state & ControlMask) g_string_append(str, "C-");
 377     if (state & ShiftMask)   g_string_append(str, "S-");
 378     if (state & Mod1Mask)    g_string_append(str, "Mod1-");
 379     if (state & Mod2Mask)    g_string_append(str, "Mod2-");
 380     if (state & Mod3Mask)    g_string_append(str, "Mod3-");
 381     if (state & Mod4Mask)    g_string_append(str, "Mod4-");
 382     if (state & Mod5Mask)    g_string_append(str, "Mod5-");
 383     g_string_append_printf(str, "%d", button);
 384
 385     /* figure out clicks/double clicks */
 386     switch (e->type) {
 387     case ButtonRelease:
 388         if (button == e->xbutton.button) {
 389             /* determine if this is a valid 'click'. Its not if the release is
 390              not over the window, or if a drag occured. */
 391             if (ABS(e->xbutton.x_root - pressx) < (unsigned)drag_threshold &&
 392                 ABS(e->xbutton.y_root - pressy) < (unsigned)drag_threshold &&
 393                 e->xbutton.x >= 0 && e->xbutton.y >= 0) {
 394                 int junk;
 395                 Window wjunk;
 396                 guint ujunk, w, h;
 397                 XGetGeometry(ob_display, e->xany.window, &wjunk, &junk, &junk,
 398                              &w, &h, &ujunk, &ujunk);
 399                 if (e->xbutton.x < (signed)w && e->xbutton.y < (signed)h)
 400                     click =TRUE;
 401             }
 402
 403             /* determine if this is a valid 'double-click' */
 404             if (click) {
 405                 if (lastbutton == button &&
 406                     e->xbutton.time - double_click_rate < time) {
 407                     dblclick = TRUE;
 408                     lastbutton = 0;
 409                 } else
 410                     lastbutton = button;
 411             } else
 412                 lastbutton = 0;
 413             time = e->xbutton.time;
 414             pressx = pressy = 0;
 415             button = 0;
 416             carea.x = carea.y = carea.width = carea.height = 0;
 417         }
 418         break;
 419     }
 420
 421     /* fire off the events */
 422     switch (e->type) {
 423     case ButtonPress:
 424         fire_event(str->str, contextq, Action_Press,
 425                    state, button, 0, 0, 0, 0, 0, 0, 0, 0,
 426                    client, b == NULL ? NULL : b->funcs[Action_Press]);
 427         break;
 428     case ButtonRelease:
 429         fire_event(str->str, contextq, Action_Release,
 430                    state, button, 0, 0, 0, 0, 0, 0, 0, 0,
 431                    client, b == NULL ? NULL : b->funcs[Action_Release]);
 432         break;
 433     case MotionNotify:
 434         /* watch out for the drag threshold */
 435         if (ABS(e->xmotion.x_root - pressx) < (unsigned)drag_threshold &&
 436             ABS(e->xmotion.y_root - pressy) < (unsigned)drag_threshold)
 437             break;
 438         fire_event(str->str, contextq, Action_Motion,
 439                    state, button, e->xmotion.x_root,
 440                    e->xmotion.y_root, pressx, pressy,
 441                    carea.x, carea.y, carea.width, carea.height,
 442                    client, b == NULL ? NULL : b->funcs[Action_Motion]);
 443         break;
 444     }
 445
 446     if (click)
 447         fire_event(str->str, contextq, Action_Click,
 448                    state, button, 0, 0, 0, 0, 0, 0, 0, 0,
 449                    client, b == NULL ? NULL : b->funcs[Action_Click]);
 450     if (dblclick)
 451         fire_event(str->str, contextq, Action_DoubleClick,
 452                    state, button, 0, 0, 0, 0, 0, 0, 0, 0,
 453                    client, b == NULL ? NULL : b->funcs[Action_DoubleClick]);
 454
 455     g_string_free(str, TRUE);
 456     if (client != Py_None) { Py_DECREF(client); }
 457
 458     if (contextq == g_quark_try_string("client")) {
 459         /* Replay the event, so it goes to the client*/
 460         XAllowEvents(ob_display, ReplayPointer, CurrentTime);
 461         /* generate a release event since we don't get real ones */
 462         if (e->type == ButtonPress) {
 463             e->type = ButtonRelease;
 464             pointer_event(e, c);
 465         }
 466     }
 467 }
 468
 469 /***************************************************************************
 470
 471    Define the type 'Pointer'
 472
 473  ***************************************************************************/
 474
 475 #define IS_POINTER(v)  ((v)->ob_type == &PointerType)
 476 #define CHECK_POINTER(self, funcname) { \
 477     if (!IS_POINTER(self)) { \
 478         PyErr_SetString(PyExc_TypeError, \
 479                         "descriptor '" funcname "' requires a 'Pointer' " \
 480                         "object"); \
 481         return NULL; \
 482     } \
 483 }
 484
 485 typedef struct Pointer {
 486     PyObject_HEAD
 487     Action press;
 488     Action release;
 489     Action click;
 490     Action doubleclick;
 491     Action motion;
 492 } Pointer;
 493
 494 staticforward PyTypeObject PointerType;
 495
 496 static PyObject *ptr_bind(Pointer *self, PyObject *args)
 497 {
 498     char *buttonstr;
 499     char *contextstr;
 500     guint state, button;
 501     PointerBinding *b;
 502     GSList *it;
 503     GQuark context;
 504     PyObject *func;
 505     Action action;
 506     int i;
 507
 508     CHECK_POINTER(self, "grab");
 509     if (!PyArg_ParseTuple(args, "ssiO:grab",
 510                           &buttonstr, &contextstr, &action, &func))
 511         return NULL;
 512
 513     if (!translate(buttonstr, &state, &button)) {
 514         PyErr_SetString(PyExc_ValueError, "invalid button");
 515         return NULL;
 516     }
 517
 518     context = g_quark_try_string(contextstr);
 519     if (!context) {
 520         PyErr_SetString(PyExc_ValueError, "invalid context");
 521         return NULL;
 522     }
 523
 524     if (action < 0 || action >= NUM_ACTIONS) {
 525         PyErr_SetString(PyExc_ValueError, "invalid action");
 526         return NULL;
 527     }
 528
 529     if (!PyCallable_Check(func)) {
 530         PyErr_SetString(PyExc_ValueError, "expected a callable object");
 531         return NULL;
 532     }
 533
 534     for (it = g_datalist_id_get_data(&bound_contexts, context);
 535          it != NULL; it = it->next){
 536         b = it->data;
 537         if (b->state == state && b->button == button) {
 538             /* already bound */
 539             b->funcs[action] = g_slist_append(b->funcs[action], func);
 540             Py_INCREF(Py_None);
 541             return Py_None;
 542         }
 543     }
 544
 545     grab_all_clients(FALSE);
 546
 547     /* add the binding */
 548     b = g_new(PointerBinding, 1);
 549     b->state = state;
 550     b->button = button;
 551     b->name = g_strdup(buttonstr);
 552     for (i = 0; i < NUM_ACTIONS; ++i)
 553         if (i != (signed)action) b->funcs[i] = NULL;
 554     b->funcs[action] = g_slist_append(NULL, func);
 555     g_datalist_id_set_data(&bound_contexts, context,
 556         g_slist_append(g_datalist_id_get_data(&bound_contexts, context), b));
 557     grab_all_clients(TRUE);
 558
 559     Py_INCREF(Py_None);
 560     return Py_None;
 561 }
 562
 563 static PyObject *ptr_clearBinds(Pointer *self, PyObject *args)
 564 {
 565     CHECK_POINTER(self, "clearBinds");
 566     if (!PyArg_ParseTuple(args, ":clearBinds"))
 567         return NULL;
 568     clearall();
 569     Py_INCREF(Py_None);
 570     return Py_None;
 571 }
 572
 573 static PyObject *ptr_grab(Pointer *self, PyObject *args)
 574 {
 575     PyObject *func;
 576
 577     CHECK_POINTER(self, "grab");
 578     if (!PyArg_ParseTuple(args, "O:grab", &func))
 579         return NULL;
 580     if (!PyCallable_Check(func)) {
 581         PyErr_SetString(PyExc_ValueError, "expected a callable object");
 582         return NULL;
 583     }
 584     if (!grab_pointer(TRUE)) {
 585         PyErr_SetString(PyExc_RuntimeError, "failed to grab pointer");
 586         return NULL;
 587     }
 588     grab_func = func;
 589     Py_INCREF(grab_func);
 590     Py_INCREF(Py_None);
 591     return Py_None;
 592 }
 593
 594 static PyObject *ptr_ungrab(Pointer *self, PyObject *args)
 595 {
 596     CHECK_POINTER(self, "ungrab");
 597     if (!PyArg_ParseTuple(args, ":ungrab"))
 598         return NULL;
 599     grab_pointer(FALSE);
 600     Py_XDECREF(grab_func);
 601     grab_func = NULL;
 602     Py_INCREF(Py_None);
 603     return Py_None;
 604 }
 605
 606 #define METH(n, d) {#n, (PyCFunction)ptr_##n, METH_VARARGS, #d}
 607
 608 static PyMethodDef PointerMethods[] = {
 609     METH(bind,
 610          "bind(button, context, func)\n\n"
 611          "Binds a pointer button for a context to a function. See the "
 612          "Terminology section for a decription and list of common contexts. "
 613          "The button is a string which defines a modifier and button "
 614          "combination with the format [Modifier-]...[Button]. Modifiers can "
 615          "be 'mod1', 'mod2', 'mod3', 'mod4', 'mod5', 'control', and 'shift'. "
 616          "The keys on your keyboard that are bound to each of these modifiers "
 617          "can be found by running 'xmodmap'. The button is the number of the "
 618          "button. Button numbers can be found by running 'xev', pressing the "
 619          "button with the pointer over its window, and watching its output. "
 620          "Here are some examples of valid buttons: 'control-1', '2', "
 621          "'mod1-shift-5'. The func must have a definition similar to "
 622          "'def func(keydata, client)'. A button and context may be bound to "
 623          "more than one function."),
 624     METH(clearBinds,
 625          "clearBinds()\n\n"
 626          "Removes all bindings that were previously made by bind()."),
 627     METH(grab,
 628          "grab(func)\n\n"
 629          "Grabs the pointer device, causing all possible pointer events to be "
 630          "sent to the given function. CAUTION: Be sure when you grab() that "
 631          "you also have an ungrab() that will execute, or you will not be "
 632          "able to use the pointer device until you restart Openbox. The func "
 633          "must have a definition similar to 'def func(keydata)'. The pointer "
 634          "cannot be grabbed if it is already grabbed."),
 635     METH(ungrab,
 636          "ungrab()\n\n"
 637          "Ungrabs the pointer. The pointer cannot be ungrabbed if it is not "
 638          "grabbed."),
 639     { NULL, NULL, 0, NULL }
 640 };
 641
 642 static PyMemberDef PointerMembers[] = {
 643     {"Action_Press", T_INT, offsetof(Pointer, press), READONLY,
 644      "a pointer button press"},
 645     {"Action_Release", T_INT, offsetof(Pointer, release), READONLY,
 646      "a pointer button release"},
 647     {"Action_Click", T_INT, offsetof(Pointer, click), READONLY,
 648      "a pointer button click (press-release)"},
 649     {"Action_DoubleClick", T_INT, offsetof(Pointer, doubleclick), READONLY,
 650      "a pointer button double-click"},
 651     {"Action_Motion", T_INT, offsetof(Pointer, motion), READONLY,
 652      "a pointer drag"},
 653     {NULL}
 654 };
 655
 656 /***************************************************************************
 657
 658    Type methods/struct
 659
 660  ***************************************************************************/
 661
 662 static void ptr_dealloc(PyObject *self)
 663 {
 664     PyObject_Del(self);
 665 }
 666
 667 static PyTypeObject PointerType = {
 668     PyObject_HEAD_INIT(NULL)
 669     0,
 670     "Pointer",
 671     sizeof(Pointer),
 672     0,
 673     (destructor) ptr_dealloc,       /*tp_dealloc*/
 674     0,                              /*tp_print*/
 675     0,                              /*tp_getattr*/
 676     0,                              /*tp_setattr*/
 677     0,                              /*tp_compare*/
 678     0,                              /*tp_repr*/
 679     0,                              /*tp_as_number*/
 680     0,                              /*tp_as_sequence*/
 681     0,                              /*tp_as_mapping*/
 682     0,                              /*tp_hash */
 683 };
 684
 685 /**************************************************************************/
 686
 687 void pointer_startup()
 688 {
 689     PyObject *input, *inputdict;
 690     Pointer *ptr;
 691
 692     grabbed = FALSE;
 693     double_click_rate = 300;
 694     drag_threshold = 3;
 695     g_datalist_init(&bound_contexts);
 696
 697     PointerType.ob_type = &PyType_Type;
 698     PointerType.tp_methods = PointerMethods;
 699     PointerType.tp_members = PointerMembers;
 700     PyType_Ready(&PointerType);
 701     PyType_Ready(&PointerDataType);
 702
 703     /* get the input module/dict */
 704     input = PyImport_ImportModule("input"); /* new */
 705     g_assert(input != NULL);
 706     inputdict = PyModule_GetDict(input); /* borrowed */
 707     g_assert(inputdict != NULL);
 708
 709     /* add a Pointer instance to the input module */
 710     ptr = PyObject_New(Pointer, &PointerType);
 711     ptr->press = Action_Press;
 712     ptr->release = Action_Release;
 713     ptr->click = Action_Click;
 714     ptr->doubleclick = Action_DoubleClick;
 715     ptr->motion = Action_Motion;
 716     PyDict_SetItemString(inputdict, "Pointer", (PyObject*) ptr);
 717     Py_DECREF(ptr);
 718
 719     Py_DECREF(input);
 720 }
 721
 722 void pointer_shutdown()
 723 {
 724     if (grabbed)
 725         grab_pointer(FALSE);
 726     clearall();
 727     g_datalist_clear(&bound_contexts);
 728 }
 729