# the end by Openbox.
titlebar_layout = "ILC"
+# double_click_delay - the number of milliseconds in which 2 clicks are
+# perceived as a double-click
+double_click_delay = 300
+
#############################################################################
### Options that can be modified by the user to change the default hooks' ###
### behaviors. ###
namespace ob {
-const unsigned int OBActions::DOUBLECLICKDELAY = 300;
const int OBActions::BUTTONS;
OBActions::OBActions()
{
for (int i=0; i<BUTTONS; ++i)
_posqueue[i] = new ButtonPressAction();
+
+ for (int i = 0; i < NUM_EVENTS; ++i)
+ _callback[i] = 0;
}
Openbox::instance->bindings()->fireButton(data);
- if (e.time - _release.time < DOUBLECLICKDELAY &&
+ // XXX: dont load this every time!!@*
+ long dblclick;
+ if (!python_get_long("double_click_delay", &dblclick))
+ dblclick = 300;
+
+ if (e.time - _release.time < (unsigned)dblclick &&
_release.win == e.window && _release.button == e.button) {
// run the DOUBLECLICK python hook
{
OtkEventHandler::enterHandler(e);
- OBWidget *w = dynamic_cast<OBWidget*>
- (Openbox::instance->findHandler(e.window));
-
// run the ENTER python hook
- doCallback(Action_EnterWindow, e.window,
- (OBWidget::WidgetType)(w ? w->type():-1), e.state, 0, 0, 0, 0);
+ if (_callback[EventEnterWindow]) {
+ EventData *data = new_event_data(e.window, EventEnterWindow, e.state);
+ python_callback(_callback[EventEnterWindow], (PyObject*)data);
+ Py_DECREF((PyObject*)data);
+ }
}
{
OtkEventHandler::leaveHandler(e);
- OBWidget *w = dynamic_cast<OBWidget*>
- (Openbox::instance->findHandler(e.window));
-
// run the LEAVE python hook
- doCallback(Action_LeaveWindow, e.window,
- (OBWidget::WidgetType)(w ? w->type():-1), e.state, 0, 0, 0, 0);
+ if (_callback[EventLeaveWindow]) {
+ EventData *data = new_event_data(e.window, EventLeaveWindow, e.state);
+ python_callback(_callback[EventLeaveWindow], (PyObject*)data);
+ Py_DECREF((PyObject*)data);
+ }
}
void OBActions::keyPressHandler(const XKeyEvent &e)
{
-// OBWidget *w = dynamic_cast<OBWidget*>
-// (Openbox::instance->findHandler(e.window));
+ OtkEventHandler::keyPressHandler(e);
unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
void OBActions::motionHandler(const XMotionEvent &e)
{
+ OtkEventHandler::motionHandler(e);
+
if (!e.same_screen) return; // this just gets stupid
int x_root = e.x_root, y_root = e.y_root;
void OBActions::mapRequestHandler(const XMapRequestEvent &e)
{
- doCallback(Action_NewWindow, e.window, (OBWidget::WidgetType)-1,
- 0, 0, 0, 0, 0);
+ OtkEventHandler::mapRequestHandler(e);
+
+ if (_callback[EventNewWindow]) {
+ EventData *data = new_event_data(e.window, EventNewWindow, 0);
+ python_callback(_callback[EventNewWindow], (PyObject*)data);
+ Py_DECREF((PyObject*)data);
+ }
}
void OBActions::unmapHandler(const XUnmapEvent &e)
{
- (void)e;
- doCallback(Action_CloseWindow, e.window, (OBWidget::WidgetType)-1,
- 0, 0, 0, 0, 0);
+ OtkEventHandler::unmapHandler(e);
+
+ if (_callback[EventCloseWindow]) {
+ EventData *data = new_event_data(e.window, EventCloseWindow, 0);
+ python_callback(_callback[EventCloseWindow], (PyObject*)data);
+ Py_DECREF((PyObject*)data);
+ }
}
void OBActions::destroyHandler(const XDestroyWindowEvent &e)
{
- (void)e;
- doCallback(Action_CloseWindow, e.window, (OBWidget::WidgetType)-1,
- 0, 0, 0, 0, 0);
-}
+ OtkEventHandler::destroyHandler(e);
-void OBActions::doCallback(ActionType action, Window window,
- OBWidget::WidgetType type, unsigned int state,
- unsigned int button, int xroot, int yroot,
- Time time)
-{
- std::pair<CallbackMap::iterator, CallbackMap::iterator> it_pair =
- _callbacks.equal_range(action);
-
- CallbackMap::iterator it;
-// for (it = it_pair.first; it != it_pair.second; ++it)
-// python_callback(it->second, action, window, type, state,
-// button, xroot, yroot, time);
- // XXX do a callback
+ if (_callback[EventCloseWindow]) {
+ EventData *data = new_event_data(e.window, EventCloseWindow, 0);
+ python_callback(_callback[EventCloseWindow], (PyObject*)data);
+ Py_DECREF((PyObject*)data);
+ }
}
-bool OBActions::registerCallback(ActionType action, PyObject *func,
- bool atfront)
+bool OBActions::bind(EventAction action, PyObject *func)
{
- if (action < 0 || action >= OBActions::NUM_ACTIONS) {
+ if (action < 0 || action >= NUM_EVENTS) {
return false;
}
- if (!func)
- return false;
- std::pair<CallbackMap::iterator, CallbackMap::iterator> it_pair =
- _callbacks.equal_range(action);
-
- CallbackMap::iterator it;
- for (it = it_pair.first; it != it_pair.second; ++it)
- if (it->second == func)
- return true; // already in there
- if (atfront)
- _callbacks.insert(_callbacks.begin(), CallbackMapPair(action, func));
- else
- _callbacks.insert(CallbackMapPair(action, func));
+ Py_XDECREF(_callback[action]);
+ _callback[action] = func;
Py_INCREF(func);
return true;
}
-bool OBActions::unregisterCallback(ActionType action, PyObject *func)
+bool OBActions::unbind(EventAction action)
{
- if (action < 0 || action >= OBActions::NUM_ACTIONS) {
+ if (action < 0 || action >= NUM_EVENTS) {
return false;
}
- if (!func)
- return false;
-
- std::pair<CallbackMap::iterator, CallbackMap::iterator> it_pair =
- _callbacks.equal_range(action);
- CallbackMap::iterator it;
- for (it = it_pair.first; it != it_pair.second; ++it)
- if (it->second == func)
- break;
- if (it != it_pair.second) { // its been registered before
- Py_DECREF(func);
- _callbacks.erase(it);
- }
+ Py_XDECREF(_callback[action]);
+ _callback[action] = 0;
return true;
}
-bool OBActions::unregisterAllCallbacks(ActionType action)
+void OBActions::unbindAll()
{
- if (action < 0 || action >= OBActions::NUM_ACTIONS) {
- return false;
+ for (int i = 0; i < NUM_EVENTS; ++i) {
+ Py_XDECREF(_callback[i]);
+ _callback[i] = 0;
}
-
- while (!_callbacks.empty()) {
- CallbackMap::iterator it = _callbacks.begin();
- Py_DECREF(it->second);
- _callbacks.erase(it);
- }
- return true;
}
}
*/
class OBActions : public otk::OtkEventHandler {
public:
- // update the same enum in openbox.i when making changes to this
- enum ActionType {
- Action_EnterWindow,
- Action_LeaveWindow,
- Action_NewWindow,
- Action_CloseWindow,
- NUM_ACTIONS
- };
-
+#ifndef SWIG // get rid of a swig warning
struct ButtonReleaseAction {
Window win;
unsigned int button;
otk::Rect clientarea;
ButtonPressAction() { button = 0; }
};
-
+#endif // SWIG
private:
// milliseconds XXX: config option
- static const unsigned int DOUBLECLICKDELAY;
static const int BUTTONS = 5;
//! The mouse button currently being watched from a press for a CLICK
void insertPress(const XButtonEvent &e);
void removePress(const XButtonEvent &e);
-
- typedef std::multimap<ActionType, PyObject*> CallbackMap;
- typedef std::pair<ActionType, PyObject*> CallbackMapPair;
- CallbackMap _callbacks;
- void doCallback(ActionType action, Window window, OBWidget::WidgetType type,
- unsigned int state, unsigned int button,
- int xroot, int yroot, Time time);
-
+ PyObject *_callback[NUM_EVENTS];
+
public:
//! Constructs an OBActions object
OBActions();
virtual void unmapHandler(const XUnmapEvent &e);
virtual void destroyHandler(const XDestroyWindowEvent &e);
- //! Add a callback funtion to the back of the hook list
- /*!
- Registering functions for KeyPress events is pointless. Use
- OBSCript::bindKey instead to do this.
- */
- bool registerCallback(ActionType action, PyObject *func, bool atfront);
+ //! Bind a callback for an action
+ bool bind(EventAction action, PyObject *func);
- //! Remove a callback function from the hook list
- bool unregisterCallback(ActionType action, PyObject *func);
+ //! Unbind the callback function from an action
+ bool unbind(EventAction action);
- //! Remove all callback functions from the hook list
- bool unregisterAllCallbacks(ActionType action);
+ //! Remove all callback functions
+ void unbindAll();
};
}
ob::Openbox *Openbox_instance() { return ob::Openbox::instance; }
%};
-%rename(register) python_register;
-
%ignore ob::OBScreen::clients;
%{
#include <iterator>
}
-static PyObject *_wrap_kunbind(PyObject *self, PyObject *args) {
+static PyObject *_wrap_ebind(PyObject *self, PyObject *args) {
PyObject *resultobj;
- PyObject *arg1 = (PyObject *) 0 ;
+ int arg1 ;
+ PyObject *arg2 = (PyObject *) 0 ;
PyObject *result;
- PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
- if(!PyArg_ParseTuple(args,(char *)"O:kunbind",&obj0)) goto fail;
- arg1 = obj0;
- result = (PyObject *)ob::kunbind(arg1);
+ if(!PyArg_ParseTuple(args,(char *)"iO:ebind",&arg1,&obj1)) goto fail;
+ arg2 = obj1;
+ result = (PyObject *)ob::ebind((ob::EventAction )arg1,arg2);
resultobj = result;
return resultobj;
}
-static PyObject *_wrap_kunbind_all(PyObject *self, PyObject *args) {
- PyObject *resultobj;
-
- if(!PyArg_ParseTuple(args,(char *)":kunbind_all")) goto fail;
- ob::kunbind_all();
-
- Py_INCREF(Py_None); resultobj = Py_None;
- return resultobj;
- fail:
- return NULL;
-}
-
-
static PyObject *_wrap_set_reset_key(PyObject *self, PyObject *args) {
PyObject *resultobj;
std::string *arg1 = 0 ;
{ (char *)"OBClient_swigregister", OBClient_swigregister, METH_VARARGS },
{ (char *)"mbind", _wrap_mbind, METH_VARARGS },
{ (char *)"kbind", _wrap_kbind, METH_VARARGS },
- { (char *)"kunbind", _wrap_kunbind, METH_VARARGS },
- { (char *)"kunbind_all", _wrap_kunbind_all, METH_VARARGS },
+ { (char *)"ebind", _wrap_ebind, METH_VARARGS },
{ (char *)"set_reset_key", _wrap_set_reset_key, METH_VARARGS },
{ NULL, NULL }
};
{ SWIG_PY_INT, (char *)"KC_Menu", (long) ob::KC_Menu, 0, 0, 0},
{ SWIG_PY_INT, (char *)"KC_All", (long) ob::KC_All, 0, 0, 0},
{ SWIG_PY_INT, (char *)"NUM_KEY_CONTEXT", (long) ob::NUM_KEY_CONTEXT, 0, 0, 0},
+{ SWIG_PY_INT, (char *)"EventEnterWindow", (long) ob::EventEnterWindow, 0, 0, 0},
+{ SWIG_PY_INT, (char *)"EventLeaveWindow", (long) ob::EventLeaveWindow, 0, 0, 0},
+{ SWIG_PY_INT, (char *)"EventNewWindow", (long) ob::EventNewWindow, 0, 0, 0},
+{ SWIG_PY_INT, (char *)"EventCloseWindow", (long) ob::EventCloseWindow, 0, 0, 0},
+{ SWIG_PY_INT, (char *)"NUM_EVENTS", (long) ob::NUM_EVENTS, 0, 0, 0},
{ SWIG_PY_INT, (char *)"X_PROTOCOL", (long) 11, 0, 0, 0},
{ SWIG_PY_INT, (char *)"X_PROTOCOL_REVISION", (long) 0, 0, 0, 0},
{ SWIG_PY_INT, (char *)"None", (long) 0L, 0, 0, 0},
{NULL, NULL, 0, NULL}
};
+PyObject *EventData_action(EventData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":action")) return NULL;
+ return PyLong_FromLong((int)self->action);
+}
+
+PyObject *EventData_modifiers(EventData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":modifiers")) return NULL;
+ return PyLong_FromUnsignedLong(self->state);
+}
+
+static PyMethodDef EventData_methods[] = {
+ {"window", (PyCFunction)MotionData_window, METH_VARARGS,
+ "Return the client window id."},
+ {"action", (PyCFunction)EventData_action, METH_VARARGS,
+ "Return the action being executed."},
+ {"modifiers", (PyCFunction)EventData_modifiers, METH_VARARGS,
+ "Return the modifier keys state."},
+ {NULL, NULL, 0, NULL}
+};
+
PyObject *KeyData_key(KeyData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":key")) return NULL;
return Py_FindMethod(ButtonData_methods, obj, name);
}
+static PyObject *EventDataGetAttr(PyObject *obj, char *name)
+{
+ return Py_FindMethod(EventData_methods, obj, name);
+}
+
static PyObject *KeyDataGetAttr(PyObject *obj, char *name)
{
return Py_FindMethod(KeyData_methods, obj, name);
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
+static PyTypeObject EventData_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "EventData",
+ sizeof(EventData),
+ 0,
+ dealloc,
+ 0,
+ (getattrfunc)EventDataGetAttr,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+};
+
static PyTypeObject KeyData_Type = {
PyObject_HEAD_INIT(NULL)
0,
return data;
}
+EventData *new_event_data(Window window, EventAction action,
+ unsigned int state)
+{
+ EventData *data = PyObject_New(EventData, &EventData_Type);
+ data->window = window;
+ data->action = action;
+ data->state = state;
+ return data;
+}
+
KeyData *new_key_data(Window window, Time time, unsigned int state,
unsigned int key)
{
Py_DECREF(arglist);
}
+bool python_get_long(const char *name, long *value)
+{
+ PyObject *val = PyDict_GetItemString(obdict, const_cast<char*>(name));
+ if (!(val && PyLong_Check(val))) return false;
+
+ *value = PyLong_AsLong(val);
+ return true;
+}
+
bool python_get_string(const char *name, std::string *value)
{
PyObject *val = PyDict_GetItemString(obdict, const_cast<char*>(name));
// Stuff for calling from Python scripts //
// ************************************* //
-/*
-PyObject * python_register(int action, PyObject *func, bool infront = false)
-{
- if (!PyCallable_Check(func)) {
- PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
- return NULL;
- }
-
- if (!ob::Openbox::instance->actions()->registerCallback(
- (ob::OBActions::ActionType)action, func, infront)) {
- PyErr_SetString(PyExc_RuntimeError, "Unable to register action callback.");
- return NULL;
- }
- Py_INCREF(Py_None); return Py_None;
-}
-
-PyObject *unregister(int action, PyObject *func)
+PyObject *mbind(const std::string &button, ob::MouseContext context,
+ ob::MouseAction action, PyObject *func)
{
if (!PyCallable_Check(func)) {
PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
return NULL;
}
-
- if (!ob::Openbox::instance->actions()->unregisterCallback(
- (ob::OBActions::ActionType)action, func)) {
- PyErr_SetString(PyExc_RuntimeError, "Unable to unregister action callback.");
+
+ if (!ob::Openbox::instance->bindings()->addButton(button, context,
+ action, func)) {
+ PyErr_SetString(PyExc_RuntimeError,"Unable to add binding.");
return NULL;
}
Py_INCREF(Py_None); return Py_None;
}
-PyObject *unregister_all(int action)
-{
- if (!ob::Openbox::instance->actions()->unregisterAllCallbacks(
- (ob::OBActions::ActionType)action)) {
- PyErr_SetString(PyExc_RuntimeError,
- "Unable to unregister action callbacks.");
- return NULL;
- }
- Py_INCREF(Py_None); return Py_None;
-}
-*/
-PyObject * mbind(const std::string &button, ob::MouseContext context,
- ob::MouseAction action, PyObject *func)
+PyObject *ebind(ob::EventAction action, PyObject *func)
{
if (!PyCallable_Check(func)) {
PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
return NULL;
}
- if (!ob::Openbox::instance->bindings()->addButton(button, context,
- action, func)) {
+ if (!ob::Openbox::instance->actions()->bind(action, func)) {
PyErr_SetString(PyExc_RuntimeError,"Unable to add binding.");
return NULL;
}
Py_INCREF(Py_None); return Py_None;
}
-PyObject * kbind(PyObject *keylist, ob::KeyContext context, PyObject *func)
+PyObject *kbind(PyObject *keylist, ob::KeyContext context, PyObject *func)
{
if (!PyCallable_Check(func)) {
PyErr_SetString(PyExc_TypeError, "Invalid callback function.");
Py_INCREF(Py_None); return Py_None;
}
-PyObject * kunbind(PyObject *keylist)
+PyObject *kunbind(PyObject *keylist)
{
if (!PyList_Check(keylist)) {
PyErr_SetString(PyExc_TypeError, "Invalid keylist. Not a list.");
NUM_KEY_CONTEXT
};
+enum EventAction {
+ EventEnterWindow,
+ EventLeaveWindow,
+ EventNewWindow,
+ EventCloseWindow,
+ NUM_EVENTS
+};
+
#ifndef SWIG
// *** MotionData can be (and is) cast ButtonData!! (in actions.cc) *** //
MouseAction action;
} ButtonData;
+typedef struct {
+ PyObject_HEAD;
+ Window window;
+ unsigned int state;
+ EventAction action;
+} EventData;
+
typedef struct {
PyObject_HEAD;
Window window;
ButtonData *new_button_data(Window window, Time time, unsigned int state,
unsigned int button, MouseContext context,
MouseAction action);
+EventData *new_event_data(Window window, EventAction action,
+ unsigned int state);
KeyData *new_key_data(Window window, Time time, unsigned int state,
unsigned int key);
void python_callback(PyObject *func, PyObject *data);
+bool python_get_long(const char *name, long *value);
bool python_get_string(const char *name, std::string *value);
bool python_get_stringlist(const char *name, std::vector<std::string> *value);
#endif
-PyObject * mbind(const std::string &button, ob::MouseContext context,
- ob::MouseAction action, PyObject *func);
+PyObject *mbind(const std::string &button, ob::MouseContext context,
+ ob::MouseAction action, PyObject *func);
+
+PyObject *kbind(PyObject *keylist, ob::KeyContext context, PyObject *func);
+
+PyObject *ebind(ob::EventAction action, PyObject *func);
-PyObject * kbind(PyObject *keylist, ob::KeyContext context, PyObject *func);
-PyObject * kunbind(PyObject *keylist);
-void kunbind_all();
void set_reset_key(const std::string &key);
}
projects / chaz / openbox / commitdiff
