+++ /dev/null
-def def_click_client(data):
- client = Openbox_findClient(openbox, data.window())
- if not client: return
-
- button = data.button()
- type = data.target()
- if button == 1 and type == Type_CloseButton:
- OBClient_close(client)
- elif button <= 3 and type == Type_MaximizeButton:
- print "OBClient_maximize(client)"
- elif button == 1 and type == Type_IconifyButton:
- print "OBClient_iconify(client)"
- elif button == 1 and type == Type_StickyButton:
- print "OBClient_sendtodesktop(client, 0xffffffff)"
- elif type == Type_Titlebar or type == Type_CloseButton or \
- type == Type_MaximizeButton or type == Type_IconifyButton or \
- type == Type_StickyButton or type == Type_Label:
- if button == 4:
- print "OBClient_shade(client)"
- elif button == 5:
- print "OBClient_unshade(client)"
-
-def def_press_model(data):
- if data.button() != 1: return
- client = Openbox_findClient(openbox, data.window())
- if not client or (type == Type_StickyButton or
- type == Type_IconifyButton or
- type == Type_MaximizeButton or
- type == Type_CloseButton):
- return
- if click_focus != 0:
- OBClient_focus(client)
- if click_raise != 0:
- print "OBClient_raise(client)"
-
-def def_press_root(data):
- button = data.button()
- if type == Type_Root:
- if button == 1:
- print "nothing probly.."
- client = Openbox_focusedClient(openbox)
- if client: OBClient_unfocus(client)
- elif button == 2:
- print "workspace menu"
- elif button == 3:
- print "root menu"
- elif button == 4:
- print "next workspace"
- elif button == 5:
- print "previous workspace"
-
-def def_doubleclick_client(data):
- client = Openbox_findClient(openbox, data.window())
- if not client: return
-
- button = data.button()
- if button == 1 and (type == Type_Titlebar or type == Type_Label):
- print "OBClient_toggleshade(client)"
-
-
-register(Action_ButtonPress, def_press_model, 1)
-register(Action_Click, def_click_client)
-register(Action_ButtonPress, def_press_root)
-register(Action_DoubleClick, def_doubleclick_client)
-
-print "Loaded clicks.py"
+++ /dev/null
-posqueue = [];
-
-def def_motion_press(data):
- client = Openbox_findClient(openbox, data.window())
-
- global posqueue
- newi = [data.button(), data.xroot(), data.yroot()]
- if client:
- newi.append(new_Rect(OBClient_area(client)))
- posqueue.append(newi)
-
-def def_motion_release(data):
- global posqueue
- button = data.button()
- for i in posqueue:
- if i[0] == button:
- client = Openbox_findClient(openbox, data.window())
- if client:
- delete_Rect(i[3])
- posqueue.remove(i)
- break
-
-def def_do_move(xroot, yroot, client):
- global posqueue
- dx = xroot - posqueue[0][1]
- dy = yroot - posqueue[0][2]
- area = posqueue[0][3] # A Rect
- OBClient_move(client, Rect_x(area) + dx, Rect_y(area) + dy)
-
-def def_do_resize(xroot, yroot, client, anchor_corner):
- global posqueue
- dx = xroot - posqueue[0][1]
- dy = yroot - posqueue[0][2]
- OBClient_resize(client, anchor_corner,
- Rect_width(area) - dx, Rect_height(area) + dy)
-
-def def_motion(data):
- client = Openbox_findClient(openbox, data.window())
- if not client: return
-
- global posqueue
- if not posqueue[0][0] == 1: return
-
- type = data.target()
- if (type == Type_Titlebar) or (type == Type_Label) or \
- (type == Type_Plate) or (type == Type_Handle):
- def_do_move(data.xroot(), data.yroot(), client)
- elif type == Type_LeftGrip:
- def_do_resize(data.xroot(), data.yroot(), client,
- OBClient_TopRight)
- elif type == Type_RightGrip:
- def_do_resize(data.xroot(), data.yroot(), client,
- OBClient_TopLeft)
-
-def def_enter(data):
- client = Openbox_findClient(openbox, data.window())
- if not client: return
- if enter_focus != 0:
- OBClient_focus(client)
-
-def def_leave(data):
- client = Openbox_findClient(openbox, data.window())
- if not client: return
- if leave_unfocus != 0:
- OBClient_unfocus(client)
-
-
-register(Action_EnterWindow, def_enter)
-register(Action_LeaveWindow, def_leave)
-
-register(Action_ButtonPress, def_motion_press)
-register(Action_ButtonRelease, def_motion_release)
-register(Action_MouseMotion, def_motion)
-
-print "Loaded clientmotion.py"
OBClient *c = Openbox::instance->findClient(e.window);
if (c) a->clientarea = c->area();
+ 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());
}
void OBActions::removePress(const XButtonEvent &e)
// run the PRESS python hook
OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window));
-
-/* doCallback(Action_ButtonPress, e.window,
- (OBWidget::WidgetType)(w ? w->type():-1),
- e.state, e.button, e.x_root, e.y_root, e.time);*/
- if (w) {
- Openbox::instance->bindings()->fire(MousePress, w->type(), e.window,
- e.state, e.button,
- e.x_root, e.y_root, e.time);
- } else
- assert(false); // why isnt there a type?
+ assert(w); // everything should be a widget
+
+ unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
+ Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
+ ButtonData *data = new_button_data(e.window, e.time, state, e.button,
+ w->mcontext(), MousePress);
+ Openbox::instance->bindings()->fire(data);
+ Py_DECREF((PyObject*)data);
if (_button) return; // won't count toward CLICK events
OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window));
+ assert(w); // everything should be a widget
// not for the button we're watching?
if (_button != e.button) return;
return;
// run the CLICK python hook
-/* doCallback(Action_Click, e.window,
- (OBWidget::WidgetType)(w ? w->type():-1),
- e.state, e.button, e.x_root, e.y_root, e.time);*/
- if (w) {
- Openbox::instance->bindings()->fire(MouseClick, w->type(), e.window,
- e.state, e.button,
- e.x_root, e.y_root, e.time);
- } else
- assert(false); // why isnt there a type?
+ unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
+ Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
+ ButtonData *data = new_button_data(e.window, e.time, state, e.button,
+ w->mcontext(), MouseClick);
+ Openbox::instance->bindings()->fire(data);
+
if (e.time - _release.time < DOUBLECLICKDELAY &&
_release.win == e.window && _release.button == e.button) {
// run the DOUBLECLICK python hook
-/* doCallback(Action_DoubleClick, e.window,
- (OBWidget::WidgetType)(w ? w->type():-1),
- e.state, e.button, e.x_root, e.y_root, e.time);*/
- if (w) {
- Openbox::instance->bindings()->fire(MouseDoubleClick, w->type(),
- e.window, e.state, e.button,
- e.x_root, e.y_root, e.time);
- } else
- assert(false); // why isnt there a type?
+ data->action = MouseDoubleClick;
+ Openbox::instance->bindings()->fire(data);
// reset so you cant triple click for 2 doubleclicks
_release.win = 0;
_release.button = e.button;
_release.time = e.time;
}
+
+ Py_DECREF((PyObject*)data);
}
// OBWidget *w = dynamic_cast<OBWidget*>
// (Openbox::instance->findHandler(e.window));
- Openbox::instance->bindings()->fire(e.state, e.keycode, e.time);
+ unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
+ Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
+ Openbox::instance->bindings()->fire(state, e.keycode, e.time);
}
}
}
- _dx = x_root - _posqueue[0]->pos.x(); _posqueue[0]->pos.setX(x_root);
- _dy = y_root - _posqueue[0]->pos.y(); _posqueue[0]->pos.setY(y_root);
-
OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window));
-
- // XXX: i can envision all sorts of crazy shit with this.. gestures, etc
- // maybe that should all be done via python tho.. (or radial menus!)
- // run the simple MOTION python hook for now...
-/* doCallback(Action_MouseMotion, e.window,
- (OBWidget::WidgetType)(w ? w->type():-1),
- e.state, (unsigned)-1, x_root, y_root, e.time);*/
- if (w) {
- Openbox::instance->bindings()->fire(MouseMotion, w->type(), e.window,
- e.state, _posqueue[0]->button,
- _dx, _dy, e.time);
- } else
- assert(false); // why isnt there a type?
+ assert(w); // everything should be a widget
+
+ // run the MOTION python hook
+ unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
+ Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
+ unsigned int button = _posqueue[0]->button;
+ printf("motion %d x:%d y:%d winx:%d winy:%d\n", button, x_root, y_root,
+ _posqueue[0]->clientarea.x(), _posqueue[0]->clientarea.y());
+ MotionData *data = new_motion_data(e.window, e.time, state, button,
+ w->mcontext(), MouseMotion,
+ x_root, y_root, _posqueue[0]->pos,
+ _posqueue[0]->clientarea);
+ Openbox::instance->bindings()->fire((ButtonData*)data);
+ Py_DECREF((PyObject*)data);
}
void OBActions::mapRequestHandler(const XMapRequestEvent &e)
Used for motion events as the starting position.
*/
ButtonPressAction *_posqueue[BUTTONS];
- //! The delta x/y of the last motion sequence
- int _dx, _dy;
void insertPress(const XButtonEvent &e);
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
Window win = None;
OBClient *c = Openbox::instance->focusedClient();
if (c) win = c->window();
- python_callback(p->callback, win, modifiers, key, time);
+ KeyData *data = new_key_data(win, time, modifiers, key);
+ python_callback(p->callback, (PyObject*)data);
+ Py_DECREF((PyObject*)data);
reset(this);
}
break;
case MC_Window:
win[0] = client->frame->plate();
break;
- case MC_MaximizeButton:
-// win[0] = client->frame->button_max();
+ case MC_Handle:
+ win[0] = client->frame->handle();
break;
+ case MC_MaximizeButton:
case MC_CloseButton:
-// win[0] = client->frame->button_close();
- break;
case MC_IconifyButton:
-// win[0] = client->frame->button_iconify();
- break;
case MC_StickyButton:
-// win[0] = client->frame->button_stick();
- break;
case MC_Grip:
-// win[0] = client->frame->grip_left();
-// win[1] = client->frame->grip_right();
- break;
case MC_Root:
-// win[0] = otk::OBDisplay::screenInfo(client->screen())->rootWindow();
- break;
case MC_MenuItem:
break;
default:
}
}
-void OBBindings::fire(MouseAction action, OBWidget::WidgetType type,
- Window win, unsigned int modifiers, unsigned int button,
- int xroot, int yroot, Time time)
+void OBBindings::fire(ButtonData *data)
{
- assert(action >= 0 && action < NUM_MOUSE_ACTION);
-
- MouseContext context;
- switch (type) {
- case OBWidget::Type_Frame:
- context = MC_Frame; break;
- case OBWidget::Type_Titlebar:
- context = MC_Titlebar; break;
- case OBWidget::Type_Handle:
- context = MC_Frame; break;
- case OBWidget::Type_Plate:
- context = MC_Window; break;
- case OBWidget::Type_Label:
- context = MC_Titlebar; break;
- case OBWidget::Type_MaximizeButton:
- context = MC_MaximizeButton; break;
- case OBWidget::Type_CloseButton:
- context = MC_CloseButton; break;
- case OBWidget::Type_IconifyButton:
- context = MC_IconifyButton; break;
- case OBWidget::Type_StickyButton:
- context = MC_StickyButton; break;
- case OBWidget::Type_LeftGrip:
- context = MC_Grip; break;
- case OBWidget::Type_RightGrip:
- context = MC_Grip; break;
- case OBWidget::Type_Client:
- context = MC_Window; break;
- case OBWidget::Type_Root:
- context = MC_Root; break;
- default:
- assert(false); // unhandled type
- }
-
- modifiers &= (ControlMask | ShiftMask | Mod1Mask | Mod2Mask | Mod3Mask |
- Mod4Mask | Mod5Mask);
-
- printf("but.mods %d.%d\n", button, modifiers);
+ printf("but.mods %d.%d\n", data->button, data->state);
- ButtonBindingList::iterator it, end = _buttons[context].end();
- for (it = _buttons[context].begin(); it != end; ++it)
- if ((*it)->binding.key == button &&
- (*it)->binding.modifiers == modifiers) {
+ ButtonBindingList::iterator it, end = _buttons[data->context].end();
+ for (it = _buttons[data->context].begin(); it != end; ++it)
+ if ((*it)->binding.key == data->button &&
+ (*it)->binding.modifiers == data->state) {
ButtonBinding::CallbackList::iterator c_it,
- c_end = (*it)->callback[action].end();
- for (c_it = (*it)->callback[action].begin(); c_it != c_end; ++c_it)
- python_callback(*c_it, action, win, context, modifiers,
- button, xroot, yroot, time);
+ c_end = (*it)->callback[data->action].end();
+ for (c_it = (*it)->callback[data->action].begin(); c_it != c_end; ++c_it)
+ python_callback(*c_it, (PyObject*)data);
}
}
void grabButtons(bool grab, OBClient *client);
- void fire(MouseAction action, OBWidget::WidgetType type, Window win,
- unsigned int modifiers, unsigned int button,
- int xroot, int yroot, Time time);
+ void fire(ButtonData *data);
};
}
{ SWIG_PY_INT, (char *)"OBClient_no_propagate_mask", (long) ob::OBClient::no_propagate_mask, 0, 0, 0},
{ SWIG_PY_INT, (char *)"MC_Frame", (long) ob::MC_Frame, 0, 0, 0},
{ SWIG_PY_INT, (char *)"MC_Titlebar", (long) ob::MC_Titlebar, 0, 0, 0},
+{ SWIG_PY_INT, (char *)"MC_Handle", (long) ob::MC_Handle, 0, 0, 0},
{ SWIG_PY_INT, (char *)"MC_Window", (long) ob::MC_Window, 0, 0, 0},
{ SWIG_PY_INT, (char *)"MC_MaximizeButton", (long) ob::MC_MaximizeButton, 0, 0, 0},
{ SWIG_PY_INT, (char *)"MC_CloseButton", (long) ob::MC_CloseButton, 0, 0, 0},
// Define some custom types which are passed to python callbacks //
// ************************************************************* //
-typedef struct {
- PyObject_HEAD;
- MouseAction action;
- Window window;
- MouseContext context;
- unsigned int state;
- unsigned int button;
- int xroot;
- int yroot;
- Time time;
-} ActionData;
-
-typedef struct {
- PyObject_HEAD;
- Window window;
- unsigned int state;
- unsigned int key;
- Time time;
-} BindingData;
-
-static void ActionDataDealloc(ActionData *self)
-{
- PyObject_Del((PyObject*)self);
-}
-
-static void BindingDataDealloc(BindingData *self)
+static void dealloc(PyObject *self)
{
- PyObject_Del((PyObject*)self);
+ PyObject_Del(self);
}
-PyObject *ActionData_action(ActionData *self, PyObject *args)
-{
- if(!PyArg_ParseTuple(args,":action")) return NULL;
- return PyLong_FromLong((int)self->action);
-}
-
-PyObject *ActionData_window(ActionData *self, PyObject *args)
+PyObject *MotionData_window(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":window")) return NULL;
return PyLong_FromLong(self->window);
}
-PyObject *ActionData_context(ActionData *self, PyObject *args)
+PyObject *MotionData_context(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":context")) return NULL;
return PyLong_FromLong((int)self->context);
}
-PyObject *ActionData_modifiers(ActionData *self, PyObject *args)
+PyObject *MotionData_action(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":action")) return NULL;
+ return PyLong_FromLong((int)self->action);
+}
+
+PyObject *MotionData_modifiers(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":modifiers")) return NULL;
return PyLong_FromUnsignedLong(self->state);
}
-PyObject *ActionData_button(ActionData *self, PyObject *args)
+PyObject *MotionData_button(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":button")) return NULL;
int b = 0;
return PyLong_FromLong(b);
}
-PyObject *ActionData_xroot(ActionData *self, PyObject *args)
+PyObject *MotionData_xroot(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":xroot")) return NULL;
return PyLong_FromLong(self->xroot);
}
-PyObject *ActionData_yroot(ActionData *self, PyObject *args)
+PyObject *MotionData_yroot(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":yroot")) return NULL;
return PyLong_FromLong(self->yroot);
}
-PyObject *ActionData_time(ActionData *self, PyObject *args)
+PyObject *MotionData_pressx(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":pressx")) return NULL;
+ return PyLong_FromLong(self->pressx);
+}
+
+PyObject *MotionData_pressy(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":pressy")) return NULL;
+ return PyLong_FromLong(self->pressy);
+}
+
+
+PyObject *MotionData_press_clientx(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":press_clientx")) return NULL;
+ return PyLong_FromLong(self->press_clientx);
+}
+
+PyObject *MotionData_press_clienty(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":press_clienty")) return NULL;
+ return PyLong_FromLong(self->press_clienty);
+}
+
+PyObject *MotionData_press_clientwidth(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":press_clientwidth")) return NULL;
+ return PyLong_FromLong(self->press_clientwidth);
+}
+
+PyObject *MotionData_press_clientheight(MotionData *self, PyObject *args)
+{
+ if(!PyArg_ParseTuple(args,":press_clientheight")) return NULL;
+ return PyLong_FromLong(self->press_clientheight);
+}
+
+PyObject *MotionData_time(MotionData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":time")) return NULL;
return PyLong_FromLong(self->time);
}
-static PyMethodDef ActionData_methods[] = {
- {"action", (PyCFunction)ActionData_action, METH_VARARGS,
+static PyMethodDef MotionData_methods[] = {
+ {"action", (PyCFunction)MotionData_action, METH_VARARGS,
"Return the action being executed."},
- {"window", (PyCFunction)ActionData_window, METH_VARARGS,
+ {"window", (PyCFunction)MotionData_window, METH_VARARGS,
"Return the client window id."},
- {"context", (PyCFunction)ActionData_context, METH_VARARGS,
+ {"context", (PyCFunction)MotionData_context, METH_VARARGS,
"Return the context that the action is occuring in."},
- {"modifiers", (PyCFunction)ActionData_modifiers, METH_VARARGS,
+ {"modifiers", (PyCFunction)MotionData_modifiers, METH_VARARGS,
"Return the modifier keys state."},
- {"button", (PyCFunction)ActionData_button, METH_VARARGS,
+ {"button", (PyCFunction)MotionData_button, METH_VARARGS,
"Return the number of the pressed button (1-5)."},
- {"xroot", (PyCFunction)ActionData_xroot, METH_VARARGS,
+ {"xroot", (PyCFunction)MotionData_xroot, METH_VARARGS,
"Return the X-position of the mouse cursor on the root window."},
- {"yroot", (PyCFunction)ActionData_yroot, METH_VARARGS,
+ {"yroot", (PyCFunction)MotionData_yroot, METH_VARARGS,
"Return the Y-position of the mouse cursor on the root window."},
- {"time", (PyCFunction)ActionData_time, METH_VARARGS,
+ {"pressx", (PyCFunction)MotionData_pressx, METH_VARARGS,
+ "Return the X-position of the mouse cursor at the start of the drag."},
+ {"pressy", (PyCFunction)MotionData_pressy, METH_VARARGS,
+ "Return the Y-position of the mouse cursor at the start of the drag."},
+ {"press_clientx", (PyCFunction)MotionData_press_clientx, METH_VARARGS,
+ "Return the X-position of the client at the start of the drag."},
+ {"press_clienty", (PyCFunction)MotionData_press_clienty, METH_VARARGS,
+ "Return the Y-position of the client at the start of the drag."},
+ {"press_clientwidth", (PyCFunction)MotionData_press_clientwidth,
+ METH_VARARGS,
+ "Return the width of the client at the start of the drag."},
+ {"press_clientheight", (PyCFunction)MotionData_press_clientheight,
+ METH_VARARGS,
+ "Return the height of the client at the start of the drag."},
+ {"time", (PyCFunction)MotionData_time, METH_VARARGS,
"Return the time at which the event occured."},
{NULL, NULL, 0, NULL}
};
-PyObject *BindingData_window(BindingData *self, PyObject *args)
-{
- if(!PyArg_ParseTuple(args,":window")) return NULL;
- return PyLong_FromLong(self->window);
-}
-
-PyObject *BindingData_modifiers(BindingData *self, PyObject *args)
-{
- if(!PyArg_ParseTuple(args,":modifiers")) return NULL;
- return PyLong_FromUnsignedLong(self->state);
-}
+static PyMethodDef ButtonData_methods[] = {
+ {"action", (PyCFunction)MotionData_action, METH_VARARGS,
+ "Return the action being executed."},
+ {"context", (PyCFunction)MotionData_context, METH_VARARGS,
+ "Return the context that the action is occuring in."},
+ {"window", (PyCFunction)MotionData_window, METH_VARARGS,
+ "Return the client window id."},
+ {"modifiers", (PyCFunction)MotionData_modifiers, METH_VARARGS,
+ "Return the modifier keys state."},
+ {"button", (PyCFunction)MotionData_button, METH_VARARGS,
+ "Return the number of the pressed button (1-5)."},
+ {"time", (PyCFunction)MotionData_time, METH_VARARGS,
+ "Return the time at which the event occured."},
+ {NULL, NULL, 0, NULL}
+};
-PyObject *BindingData_key(BindingData *self, PyObject *args)
+PyObject *KeyData_key(KeyData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":key")) return NULL;
return PyString_FromString(
}
-PyObject *BindingData_time(BindingData *self, PyObject *args)
-{
- if(!PyArg_ParseTuple(args,":time")) return NULL;
- return PyLong_FromLong(self->time);
-}
-
-static PyMethodDef BindingData_methods[] = {
- {"window", (PyCFunction)BindingData_window, METH_VARARGS,
+static PyMethodDef KeyData_methods[] = {
+ {"window", (PyCFunction)MotionData_window, METH_VARARGS,
"Return the client window id."},
- {"modifiers", (PyCFunction)BindingData_modifiers, METH_VARARGS,
+ {"modifiers", (PyCFunction)MotionData_modifiers, METH_VARARGS,
"Return the modifier keys state."},
- {"key", (PyCFunction)BindingData_key, METH_VARARGS,
+ {"key", (PyCFunction)KeyData_key, METH_VARARGS,
"Return the name of the pressed key."},
- {"time", (PyCFunction)BindingData_time, METH_VARARGS,
+ {"time", (PyCFunction)MotionData_time, METH_VARARGS,
"Return the time at which the event occured."},
{NULL, NULL, 0, NULL}
};
-static PyObject *ActionDataGetAttr(PyObject *obj, char *name)
+static PyObject *MotionDataGetAttr(PyObject *obj, char *name)
+{
+ return Py_FindMethod(MotionData_methods, obj, name);
+}
+
+static PyObject *ButtonDataGetAttr(PyObject *obj, char *name)
{
- return Py_FindMethod(ActionData_methods, obj, name);
+ return Py_FindMethod(ButtonData_methods, obj, name);
}
-static PyObject *BindingDataGetAttr(PyObject *obj, char *name)
+static PyObject *KeyDataGetAttr(PyObject *obj, char *name)
{
- return Py_FindMethod(BindingData_methods, obj, name);
+ return Py_FindMethod(KeyData_methods, obj, name);
}
-static PyTypeObject ActionData_Type = {
+static PyTypeObject MotionData_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "MotionData",
+ sizeof(MotionData),
+ 0,
+ dealloc,
+ 0,
+ (getattrfunc)MotionDataGetAttr,
+ 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 ButtonData_Type = {
PyObject_HEAD_INIT(NULL)
0,
- "ActionData",
- sizeof(ActionData),
+ "ButtonData",
+ sizeof(ButtonData),
0,
- (destructor)ActionDataDealloc,
+ dealloc,
0,
- (getattrfunc)ActionDataGetAttr,
+ (getattrfunc)ButtonDataGetAttr,
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 BindingData_Type = {
+static PyTypeObject KeyData_Type = {
PyObject_HEAD_INIT(NULL)
0,
- "BindingData",
- sizeof(BindingData),
+ "KeyData",
+ sizeof(KeyData),
0,
- (destructor)BindingDataDealloc,
+ dealloc,
0,
- (getattrfunc)BindingDataGetAttr,
+ (getattrfunc)KeyDataGetAttr,
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
};
+MotionData *new_motion_data(Window window, Time time, unsigned int state,
+ unsigned int button, MouseContext context,
+ MouseAction action, int xroot, int yroot,
+ const otk::Point &initpos, const otk::Rect &initarea)
+{
+ MotionData *data = PyObject_New(MotionData, &MotionData_Type);
+ data->window = window;
+ data->time = time;
+ data->state = state;
+ data->button = button;
+ data->context= context;
+ data->action = action;
+ data->xroot = xroot;
+ data->yroot = yroot;
+ data->pressx = initpos.x();
+ data->pressy = initpos.y();
+ data->press_clientx = initarea.x();
+ data->press_clienty = initarea.y();
+ data->press_clientwidth = initarea.width();
+ data->press_clientheight = initarea.height();
+ return data;
+}
+
+ButtonData *new_button_data(Window window, Time time, unsigned int state,
+ unsigned int button, MouseContext context,
+ MouseAction action)
+{
+ ButtonData *data = PyObject_New(ButtonData, &ButtonData_Type);
+ data->window = window;
+ data->time = time;
+ data->state = state;
+ data->button = button;
+ data->context= context;
+ data->action = action;
+ return data;
+}
+
+KeyData *new_key_data(Window window, Time time, unsigned int state,
+ unsigned int key)
+{
+ KeyData *data = PyObject_New(KeyData, &KeyData_Type);
+ data->window = window;
+ data->time = time;
+ data->state = state;
+ data->key = key;
+ return data;
+}
+
// **************** //
// End custom types //
// **************** //
obdict = PyModule_GetDict(obmodule);
// set up the custom types
- ActionData_Type.ob_type = &PyType_Type;
- BindingData_Type.ob_type = &PyType_Type;
+ MotionData_Type.ob_type = &PyType_Type;
+ ButtonData_Type.ob_type = &PyType_Type;
+ KeyData_Type.ob_type = &PyType_Type;
}
void python_destroy()
return true;
}
-static void call(PyObject *func, PyObject *data)
+void python_callback(PyObject *func, PyObject *data)
{
PyObject *arglist;
PyObject *result;
Py_DECREF(arglist);
}
-void python_callback(PyObject *func, MouseAction action,
- Window window, MouseContext context,
- unsigned int state, unsigned int button,
- int xroot, int yroot, Time time)
-{
- assert(func);
-
- ActionData *data = PyObject_New(ActionData, &ActionData_Type);
- data->action = action;
- data->window = window;
- data->context= context;
- data->state = state;
- data->button = button;
- data->xroot = xroot;
- data->yroot = yroot;
- data->time = time;
-
- call(func, (PyObject*)data);
- Py_DECREF(data);
-}
-
-void python_callback(PyObject *func, Window window, unsigned int state,
- unsigned int key, Time time)
-{
- if (!func) return;
-
- BindingData *data = PyObject_New(BindingData, &BindingData_Type);
- data->window = window;
- data->state = state;
- data->key = key;
- data->time = time;
-
- call(func, (PyObject*)data);
- Py_DECREF(data);
-}
-
bool python_get_string(const char *name, std::string *value)
{
PyObject *val = PyDict_GetItemString(obdict, const_cast<char*>(name));
{
ob::Openbox::instance->bindings()->setResetKey(key);
}
+
}
@brief wee
*/
+#include "otk/point.hh"
+#include "otk/rect.hh"
+
extern "C" {
#include <X11/Xlib.h>
#include <Python.h>
enum MouseContext {
MC_Frame,
MC_Titlebar,
+ MC_Handle,
MC_Window,
MC_MaximizeButton,
MC_CloseButton,
};
#ifndef SWIG
+
+// *** MotionData can be (and is) cast ButtonData!! (in actions.cc) *** //
+typedef struct {
+ PyObject_HEAD;
+ Window window;
+ Time time;
+ unsigned int state;
+ unsigned int button;
+ MouseContext context;
+ MouseAction action;
+ int xroot;
+ int yroot;
+ int pressx;
+ int pressy;
+ int press_clientx;
+ int press_clienty;
+ int press_clientwidth;
+ int press_clientheight;
+} MotionData;
+
+// *** MotionData can be (and is) cast ButtonData!! (in actions.cc) *** //
+typedef struct {
+ PyObject_HEAD;
+ Window window;
+ Time time;
+ unsigned int state;
+ unsigned int button;
+ MouseContext context;
+ MouseAction action;
+} ButtonData;
+
+typedef struct {
+ PyObject_HEAD;
+ Window window;
+ Time time;
+ unsigned int state;
+ unsigned int key;
+} KeyData;
+
void python_init(char *argv0);
void python_destroy();
bool python_exec(const std::string &path);
-void python_callback(PyObject *func, MouseAction action,
- Window window, MouseContext context,
- unsigned int state, unsigned int button,
- int xroot, int yroot, Time time);
-
-void python_callback(PyObject *func, Window window, unsigned int state,
- unsigned int key, Time time);
+MotionData *new_motion_data(Window window, Time time, unsigned int state,
+ unsigned int button, MouseContext context,
+ MouseAction action, int xroot, int yroot,
+ const otk::Point &initpos,
+ const otk::Rect &initarea);
+ButtonData *new_button_data(Window window, Time time, unsigned int state,
+ unsigned int button, MouseContext context,
+ MouseAction action);
+KeyData *new_key_data(Window window, Time time, unsigned int state,
+ unsigned int key);
+void python_callback(PyObject *func, PyObject *data);
bool python_get_string(const char *name, std::string *value);
bool python_get_stringlist(const char *name, std::vector<std::string> *value);
#ifndef __obwidget_hh
#define __obwidget_hh
+#include "python.hh"
+
namespace ob {
class OBWidget {
OBWidget(WidgetType type) : _type(type) {}
inline WidgetType type() const { return _type; }
+
+ inline MouseContext mcontext() const {
+ switch (_type) {
+ case Type_Frame:
+ return MC_Frame;
+ case Type_Titlebar:
+ return MC_Titlebar;
+ case Type_Handle:
+ return MC_Handle;
+ case Type_Plate:
+ return MC_Window;
+ case Type_Label:
+ return MC_Titlebar;
+ case Type_MaximizeButton:
+ return MC_MaximizeButton;
+ case Type_CloseButton:
+ return MC_CloseButton;
+ case Type_IconifyButton:
+ return MC_IconifyButton;
+ case Type_StickyButton:
+ return MC_StickyButton;
+ case Type_LeftGrip:
+ return MC_Grip;
+ case Type_RightGrip:
+ return MC_Grip;
+ case Type_Client:
+ return MC_Window;
+ case Type_Root:
+ return MC_Root;
+ default:
+ assert(false); // unhandled type
+ }
+ }
};
}
projects / chaz / openbox / commitdiff
