src/openbox.i

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 %module openbox
   4
   5 %{
   6 #ifdef HAVE_CONFIG_H
   7 #  include "../config.h"
   8 #endif
   9
  10 #include "openbox.hh"
  11 #include "screen.hh"
  12 #include "client.hh"
  13 #include "bindings.hh"
  14 #include "actions.hh"
  15 %}
  16
  17 %include "stl.i"
  18 %include "exception.i"
  19 //%include std_list.i
  20 //%template(ClientList) std::list<OBClient*>;
  21
  22 %ignore ob::Openbox::instance;
  23 %inline %{
  24   ob::Openbox *Openbox_instance() { return ob::Openbox::instance; }
  25 %};
  26
  27 // stuff for scripting callbacks!
  28 %inline %{
  29   enum ActionType {
  30     Action_ButtonPress,
  31     Action_Click,
  32     Action_DoubleClick,
  33     Action_EnterWindow,
  34     Action_LeaveWindow,
  35     Action_KeyPress,
  36     Action_MouseMotion,
  37     Action_NewWindow,
  38     Action_CloseWindow
  39   };
  40   enum WidgetType {
  41     Type_Frame,
  42     Type_Titlebar,
  43     Type_Handle,
  44     Type_Plate,
  45     Type_Label,
  46     Type_MaximizeButton,
  47     Type_CloseButton,
  48     Type_IconifyButton,
  49     Type_StickyButton,
  50     Type_LeftGrip,
  51     Type_RightGrip,
  52     Type_Window,
  53     Type_Root
  54   };
  55 %}
  56 %rename(register) python_register;
  57 %inline %{
  58 /*PyObject * python_register(int action, PyObject *func, bool infront = false)
  59 {
  60   if (!PyCallable_Check(func)) {
  61     PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
  62     return NULL;
  63   }
  64
  65   if (!ob::Openbox::instance->actions()->registerCallback(
  66         (ob::OBActions::ActionType)action, func, infront)) {
  67     PyErr_SetString(PyExc_RuntimeError, "Unable to register action callback.");
  68     return NULL;
  69   }
  70   Py_INCREF(Py_None); return Py_None;
  71 }
  72
  73 PyObject * unregister(int action, PyObject *func)
  74 {
  75   if (!PyCallable_Check(func)) {
  76     PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
  77     return NULL;
  78   }
  79
  80   if (!ob::Openbox::instance->actions()->unregisterCallback(
  81         (ob::OBActions::ActionType)action, func)) {
  82     PyErr_SetString(PyExc_RuntimeError, "Unable to unregister action callback.");
  83     return NULL;
  84   }
  85   Py_INCREF(Py_None); return Py_None;
  86 }
  87
  88 PyObject * unregister_all(int action)
  89 {
  90   if (!ob::Openbox::instance->actions()->unregisterAllCallbacks(
  91         (ob::OBActions::ActionType)action)) {
  92     PyErr_SetString(PyExc_RuntimeError,
  93                     "Unable to unregister action callbacks.");
  94     return NULL;
  95   }
  96   Py_INCREF(Py_None); return Py_None;
  97 }
  98 */
  99 PyObject * mbind(const std::string &button, MouseContext context,
 100                  PyObject *func)
 101 {
 102   if (!PyCallable_Check(func)) {
 103     PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
 104     return NULL;
 105   }
 106
 107   if (!ob::Openbox::instance->bindings()->add(vectkeylist, func)) {
 108     PyErr_SetString(PyExc_RuntimeError,"Unable to add binding.");
 109     return NULL;
 110   }
 111   Py_INCREF(Py_None); return Py_None;
 112 }
 113
 114 PyObject * kbind(PyObject *keylist, KeyContext context, PyObject *func)
 115 {
 116   if (!PyCallable_Check(func)) {
 117     PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
 118     return NULL;
 119   }
 120   if (!PyList_Check(keylist)) {
 121     PyErr_SetString(PyExc_TypeError, "Invalid keylist. Not a list.");
 122     return NULL;
 123   }
 124
 125   ob::OBBindings::StringVect vectkeylist;
 126   for (int i = 0, end = PyList_Size(keylist); i < end; ++i) {
 127     PyObject *str = PyList_GetItem(keylist, i);
 128     if (!PyString_Check(str)) {
 129       PyErr_SetString(PyExc_TypeError,
 130                      "Invalid keylist. It must contain only strings.");
 131       return NULL;
 132     }
 133     vectkeylist.push_back(PyString_AsString(str));
 134   }
 135
 136   if (!ob::Openbox::instance->bindings()->add(vectkeylist, func)) {
 137     PyErr_SetString(PyExc_RuntimeError,"Unable to add binding.");
 138     return NULL;
 139   }
 140   Py_INCREF(Py_None); return Py_None;
 141 }
 142
 143 PyObject * kunbind(PyObject *keylist)
 144 {
 145   if (!PyList_Check(keylist)) {
 146     PyErr_SetString(PyExc_TypeError, "Invalid keylist. Not a list.");
 147     return NULL;
 148   }
 149
 150   ob::OBBindings::StringVect vectkeylist;
 151   for (int i = 0, end = PyList_Size(keylist); i < end; ++i) {
 152     PyObject *str = PyList_GetItem(keylist, i);
 153     if (!PyString_Check(str)) {
 154       PyErr_SetString(PyExc_TypeError,
 155                      "Invalid keylist. It must contain only strings.");
 156       return NULL;
 157     }
 158     vectkeylist.push_back(PyString_AsString(str));
 159   }
 160
 161   ob::Openbox::instance->bindings()->remove(vectkeylist);
 162   Py_INCREF(Py_None); return Py_None;
 163 }
 164
 165 void kunbind_all()
 166 {
 167   ob::Openbox::instance->bindings()->removeAll();
 168 }
 169
 170 void set_reset_key(const std::string &key)
 171 {
 172   ob::Openbox::instance->bindings()->setResetKey(key);
 173 }
 174 %}
 175
 176 %ignore ob::OBScreen::clients;
 177 %{
 178   #include <iterator>
 179 %}
 180 %extend ob::OBScreen {
 181   OBClient *client(int i) {
 182     if (i >= (int)self->clients.size())
 183       return NULL;
 184     ob::OBScreen::ClientList::iterator it = self->clients.begin();
 185     std::advance(it,i);
 186     return *it;
 187   }
 188   int clientCount() const {
 189     return (int) self->clients.size();
 190   }
 191 };
 192
 193 %import "../otk/eventdispatcher.hh"
 194 %import "../otk/eventhandler.hh"
 195 %import "widget.hh"
 196 %import "actions.hh"
 197
 198 %include "openbox.hh"
 199 %include "screen.hh"
 200 %include "client.hh"
 201 %include "python.hh"
 202
 203 // for Mod1Mask etc
 204 %include "X11/X.h"