nilix/openbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

moving a window is possible once again

Browse source
This commit is contained in:
Dana Jansens 2003-01-03 05:26:04 +00:00
parent b35dae95a5
commit ca3e463057
10 changed files with 321 additions and 385 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
scripts/clicks.py
View file

@ -1,66 +0,0 @@
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"

75
scripts/clientmotion.py
View file

@ -1,75 +0,0 @@
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"

78
src/actions.cc
View file

@ -45,6 +45,7 @@ void OBActions::insertPress(const XButtonEvent &e)
OBClient *c = Openbox::instance->findClient(e.window); OBClient *c = Openbox::instance->findClient(e.window);
if (c) a->clientarea = c->area(); 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) void OBActions::removePress(const XButtonEvent &e)
@ -70,16 +71,14 @@ void OBActions::buttonPressHandler(const XButtonEvent &e)
// run the PRESS python hook // run the PRESS python hook
OBWidget *w = dynamic_cast<OBWidget*> OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window)); (Openbox::instance->findHandler(e.window));
assert(w); // everything should be a widget
/* doCallback(Action_ButtonPress, e.window, unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
(OBWidget::WidgetType)(w ? w->type():-1), Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
e.state, e.button, e.x_root, e.y_root, e.time);*/ ButtonData *data = new_button_data(e.window, e.time, state, e.button,
if (w) { w->mcontext(), MousePress);
Openbox::instance->bindings()->fire(MousePress, w->type(), e.window, Openbox::instance->bindings()->fire(data);
e.state, e.button, Py_DECREF((PyObject*)data);
e.x_root, e.y_root, e.time);
} else
assert(false); // why isnt there a type?
if (_button) return; // won't count toward CLICK events if (_button) return; // won't count toward CLICK events
@ -94,6 +93,7 @@ void OBActions::buttonReleaseHandler(const XButtonEvent &e)
OBWidget *w = dynamic_cast<OBWidget*> OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window)); (Openbox::instance->findHandler(e.window));
assert(w); // everything should be a widget
// not for the button we're watching? // not for the button we're watching?
if (_button != e.button) return; if (_button != e.button) return;
@ -110,29 +110,19 @@ void OBActions::buttonReleaseHandler(const XButtonEvent &e)
return; return;
// run the CLICK python hook // run the CLICK python hook
/* doCallback(Action_Click, e.window, unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
(OBWidget::WidgetType)(w ? w->type():-1), Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
e.state, e.button, e.x_root, e.y_root, e.time);*/ ButtonData *data = new_button_data(e.window, e.time, state, e.button,
if (w) { w->mcontext(), MouseClick);
Openbox::instance->bindings()->fire(MouseClick, w->type(), e.window, Openbox::instance->bindings()->fire(data);
e.state, e.button,
e.x_root, e.y_root, e.time);
} else
assert(false); // why isnt there a type?
if (e.time - _release.time < DOUBLECLICKDELAY && if (e.time - _release.time < DOUBLECLICKDELAY &&
_release.win == e.window && _release.button == e.button) { _release.win == e.window && _release.button == e.button) {
// run the DOUBLECLICK python hook // run the DOUBLECLICK python hook
/* doCallback(Action_DoubleClick, e.window, data->action = MouseDoubleClick;
(OBWidget::WidgetType)(w ? w->type():-1), Openbox::instance->bindings()->fire(data);
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?
// reset so you cant triple click for 2 doubleclicks // reset so you cant triple click for 2 doubleclicks
_release.win = 0; _release.win = 0;
@ -144,6 +134,8 @@ void OBActions::buttonReleaseHandler(const XButtonEvent &e)
_release.button = e.button; _release.button = e.button;
_release.time = e.time; _release.time = e.time;
} }
Py_DECREF((PyObject*)data);
} }
@ -178,7 +170,9 @@ void OBActions::keyPressHandler(const XKeyEvent &e)
// OBWidget *w = dynamic_cast<OBWidget*> // OBWidget *w = dynamic_cast<OBWidget*>
// (Openbox::instance->findHandler(e.window)); // (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);
} }
@ -200,24 +194,22 @@ void OBActions::motionHandler(const XMotionEvent &e)
} }
} }
_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*> OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window)); (Openbox::instance->findHandler(e.window));
assert(w); // everything should be a widget
// XXX: i can envision all sorts of crazy shit with this.. gestures, etc // run the MOTION python hook
// maybe that should all be done via python tho.. (or radial menus!) unsigned int state = e.state & (ControlMask | ShiftMask | Mod1Mask |
// run the simple MOTION python hook for now... Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
/* doCallback(Action_MouseMotion, e.window, unsigned int button = _posqueue[0]->button;
(OBWidget::WidgetType)(w ? w->type():-1), printf("motion %d x:%d y:%d winx:%d winy:%d\n", button, x_root, y_root,
e.state, (unsigned)-1, x_root, y_root, e.time);*/ _posqueue[0]->clientarea.x(), _posqueue[0]->clientarea.y());
if (w) { MotionData *data = new_motion_data(e.window, e.time, state, button,
Openbox::instance->bindings()->fire(MouseMotion, w->type(), e.window, w->mcontext(), MouseMotion,
e.state, _posqueue[0]->button, x_root, y_root, _posqueue[0]->pos,
_dx, _dy, e.time); _posqueue[0]->clientarea);
} else Openbox::instance->bindings()->fire((ButtonData*)data);
assert(false); // why isnt there a type? Py_DECREF((PyObject*)data);
} }
void OBActions::mapRequestHandler(const XMapRequestEvent &e) void OBActions::mapRequestHandler(const XMapRequestEvent &e)

3
src/actions.hh
View file

@ -64,8 +64,6 @@ private:
Used for motion events as the starting position. Used for motion events as the starting position.
*/ */
ButtonPressAction *_posqueue[BUTTONS]; ButtonPressAction *_posqueue[BUTTONS];
//! The delta x/y of the last motion sequence
int _dx, _dy;
void insertPress(const XButtonEvent &e); void insertPress(const XButtonEvent &e);
@ -99,7 +97,6 @@ public:
virtual void unmapHandler(const XUnmapEvent &e); virtual void unmapHandler(const XUnmapEvent &e);
virtual void destroyHandler(const XDestroyWindowEvent &e); virtual void destroyHandler(const XDestroyWindowEvent &e);
//! Add a callback funtion to the back of the hook list //! Add a callback funtion to the back of the hook list
/*! /*!
Registering functions for KeyPress events is pointless. Use Registering functions for KeyPress events is pointless. Use

78
src/bindings.cc
View file

@ -350,7 +350,9 @@ void OBBindings::fire(unsigned int modifiers, unsigned int key, Time time)
Window win = None; Window win = None;
OBClient *c = Openbox::instance->focusedClient(); OBClient *c = Openbox::instance->focusedClient();
if (c) win = c->window(); 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); reset(this);
} }
break; break;
@ -424,25 +426,15 @@ void OBBindings::grabButtons(bool grab, OBClient *client)
case MC_Window: case MC_Window:
win[0] = client->frame->plate(); win[0] = client->frame->plate();
break; break;
case MC_Handle:
win[0] = client->frame->handle();
break;
case MC_MaximizeButton: case MC_MaximizeButton:
// win[0] = client->frame->button_max();
break;
case MC_CloseButton: case MC_CloseButton:
// win[0] = client->frame->button_close();
break;
case MC_IconifyButton: case MC_IconifyButton:
// win[0] = client->frame->button_iconify();
break;
case MC_StickyButton: case MC_StickyButton:
// win[0] = client->frame->button_stick();
break;
case MC_Grip: case MC_Grip:
// win[0] = client->frame->grip_left();
// win[1] = client->frame->grip_right();
break;
case MC_Root: case MC_Root:
// win[0] = otk::OBDisplay::screenInfo(client->screen())->rootWindow();
break;
case MC_MenuItem: case MC_MenuItem:
break; break;
default: default:
@ -465,58 +457,18 @@ void OBBindings::grabButtons(bool grab, OBClient *client)
} }
} }
void OBBindings::fire(MouseAction action, OBWidget::WidgetType type, void OBBindings::fire(ButtonData *data)
Window win, unsigned int modifiers, unsigned int button,
int xroot, int yroot, Time time)
{ {
assert(action >= 0 && action < NUM_MOUSE_ACTION); printf("but.mods %d.%d\n", data->button, data->state);
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);
ButtonBindingList::iterator it, end = _buttons[context].end(); ButtonBindingList::iterator it, end = _buttons[data->context].end();
for (it = _buttons[context].begin(); it != end; ++it) for (it = _buttons[data->context].begin(); it != end; ++it)
if ((*it)->binding.key == button && if ((*it)->binding.key == data->button &&
(*it)->binding.modifiers == modifiers) { (*it)->binding.modifiers == data->state) {
ButtonBinding::CallbackList::iterator c_it, ButtonBinding::CallbackList::iterator c_it,
c_end = (*it)->callback[action].end(); c_end = (*it)->callback[data->action].end();
for (c_it = (*it)->callback[action].begin(); c_it != c_end; ++c_it) for (c_it = (*it)->callback[data->action].begin(); c_it != c_end; ++c_it)
python_callback(*c_it, action, win, context, modifiers, python_callback(*c_it, (PyObject*)data);
button, xroot, yroot, time);
} }
} }

4
src/bindings.hh
View file

@ -120,9 +120,7 @@ public:
void grabButtons(bool grab, OBClient *client); void grabButtons(bool grab, OBClient *client);
void fire(MouseAction action, OBWidget::WidgetType type, Window win, void fire(ButtonData *data);
unsigned int modifiers, unsigned int button,
int xroot, int yroot, Time time);
}; };
} }

1
src/openbox_wrap.cc
View file

@ -2805,6 +2805,7 @@ static swig_const_info swig_const_table[] = {
{ SWIG_PY_INT, (char *)"OBClient_no_propagate_mask", (long) ob::OBClient::no_propagate_mask, 0, 0, 0}, { 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_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_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_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_MaximizeButton", (long) ob::MC_MaximizeButton, 0, 0, 0},
{ SWIG_PY_INT, (char *)"MC_CloseButton", (long) ob::MC_CloseButton, 0, 0, 0}, { SWIG_PY_INT, (char *)"MC_CloseButton", (long) ob::MC_CloseButton, 0, 0, 0},

305
src/python.cc
View file

@ -22,61 +22,36 @@ static PyObject *obdict = NULL;
// Define some custom types which are passed to python callbacks // // Define some custom types which are passed to python callbacks //
// ************************************************************* // // ************************************************************* //
typedef struct { static void dealloc(PyObject *self)
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); PyObject_Del(self);
} }
static void BindingDataDealloc(BindingData *self) PyObject *MotionData_window(MotionData *self, PyObject *args)
{
PyObject_Del((PyObject*)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)
{ {
if(!PyArg_ParseTuple(args,":window")) return NULL; if(!PyArg_ParseTuple(args,":window")) return NULL;
return PyLong_FromLong(self->window); 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; if(!PyArg_ParseTuple(args,":context")) return NULL;
return PyLong_FromLong((int)self->context); 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; if(!PyArg_ParseTuple(args,":modifiers")) return NULL;
return PyLong_FromUnsignedLong(self->state); 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; if(!PyArg_ParseTuple(args,":button")) return NULL;
int b = 0; int b = 0;
@ -91,57 +66,112 @@ PyObject *ActionData_button(ActionData *self, PyObject *args)
return PyLong_FromLong(b); 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; if(!PyArg_ParseTuple(args,":xroot")) return NULL;
return PyLong_FromLong(self->xroot); 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; if(!PyArg_ParseTuple(args,":yroot")) return NULL;
return PyLong_FromLong(self->yroot); 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; if(!PyArg_ParseTuple(args,":time")) return NULL;
return PyLong_FromLong(self->time); return PyLong_FromLong(self->time);
} }
static PyMethodDef ActionData_methods[] = { static PyMethodDef MotionData_methods[] = {
{"action", (PyCFunction)ActionData_action, METH_VARARGS, {"action", (PyCFunction)MotionData_action, METH_VARARGS,
"Return the action being executed."}, "Return the action being executed."},
{"window", (PyCFunction)ActionData_window, METH_VARARGS, {"window", (PyCFunction)MotionData_window, METH_VARARGS,
"Return the client window id."}, "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."}, "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."}, "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)."}, "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."}, "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."}, "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."}, "Return the time at which the event occured."},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
PyObject *BindingData_window(BindingData *self, PyObject *args) static PyMethodDef ButtonData_methods[] = {
{ {"action", (PyCFunction)MotionData_action, METH_VARARGS,
if(!PyArg_ParseTuple(args,":window")) return NULL; "Return the action being executed."},
return PyLong_FromLong(self->window); {"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_modifiers(BindingData *self, PyObject *args) PyObject *KeyData_key(KeyData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":modifiers")) return NULL;
return PyLong_FromUnsignedLong(self->state);
}
PyObject *BindingData_key(BindingData *self, PyObject *args)
{ {
if(!PyArg_ParseTuple(args,":key")) return NULL; if(!PyArg_ParseTuple(args,":key")) return NULL;
return PyString_FromString( return PyString_FromString(
@ -149,58 +179,117 @@ PyObject *BindingData_key(BindingData *self, PyObject *args)
} }
PyObject *BindingData_time(BindingData *self, PyObject *args) static PyMethodDef KeyData_methods[] = {
{ {"window", (PyCFunction)MotionData_window, METH_VARARGS,
if(!PyArg_ParseTuple(args,":time")) return NULL;
return PyLong_FromLong(self->time);
}
static PyMethodDef BindingData_methods[] = {
{"window", (PyCFunction)BindingData_window, METH_VARARGS,
"Return the client window id."}, "Return the client window id."},
{"modifiers", (PyCFunction)BindingData_modifiers, METH_VARARGS, {"modifiers", (PyCFunction)MotionData_modifiers, METH_VARARGS,
"Return the modifier keys state."}, "Return the modifier keys state."},
{"key", (PyCFunction)BindingData_key, METH_VARARGS, {"key", (PyCFunction)KeyData_key, METH_VARARGS,
"Return the name of the pressed key."}, "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."}, "Return the time at which the event occured."},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
static PyObject *ActionDataGetAttr(PyObject *obj, char *name) static PyObject *MotionDataGetAttr(PyObject *obj, char *name)
{ {
return Py_FindMethod(ActionData_methods, obj, name); return Py_FindMethod(MotionData_methods, obj, name);
} }
static PyObject *BindingDataGetAttr(PyObject *obj, char *name) static PyObject *ButtonDataGetAttr(PyObject *obj, char *name)
{ {
return Py_FindMethod(BindingData_methods, obj, name); return Py_FindMethod(ButtonData_methods, obj, name);
} }
static PyTypeObject ActionData_Type = { static PyObject *KeyDataGetAttr(PyObject *obj, char *name)
{
return Py_FindMethod(KeyData_methods, obj, name);
}
static PyTypeObject MotionData_Type = {
PyObject_HEAD_INIT(NULL) PyObject_HEAD_INIT(NULL)
0, 0,
"ActionData", "MotionData",
sizeof(ActionData), sizeof(MotionData),
0, 0,
(destructor)ActionDataDealloc, dealloc,
0, 0,
(getattrfunc)ActionDataGetAttr, (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 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 ButtonData_Type = {
PyObject_HEAD_INIT(NULL) PyObject_HEAD_INIT(NULL)
0, 0,
"BindingData", "ButtonData",
sizeof(BindingData), sizeof(ButtonData),
0, 0,
(destructor)BindingDataDealloc, dealloc,
0, 0,
(getattrfunc)BindingDataGetAttr, (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 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,
"KeyData",
sizeof(KeyData),
0,
dealloc,
0,
(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 // // End custom types //
// **************** // // **************** //
@ -219,8 +308,9 @@ void python_init(char *argv0)
obdict = PyModule_GetDict(obmodule); obdict = PyModule_GetDict(obmodule);
// set up the custom types // set up the custom types
ActionData_Type.ob_type = &PyType_Type; MotionData_Type.ob_type = &PyType_Type;
BindingData_Type.ob_type = &PyType_Type; ButtonData_Type.ob_type = &PyType_Type;
KeyData_Type.ob_type = &PyType_Type;
} }
void python_destroy() void python_destroy()
@ -240,7 +330,7 @@ bool python_exec(const std::string &path)
return true; return true;
} }
static void call(PyObject *func, PyObject *data) void python_callback(PyObject *func, PyObject *data)
{ {
PyObject *arglist; PyObject *arglist;
PyObject *result; PyObject *result;
@ -258,42 +348,6 @@ static void call(PyObject *func, PyObject *data)
Py_DECREF(arglist); 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) bool python_get_string(const char *name, std::string *value)
{ {
PyObject *val = PyDict_GetItemString(obdict, const_cast<char*>(name)); PyObject *val = PyDict_GetItemString(obdict, const_cast<char*>(name));
@ -438,4 +492,5 @@ void set_reset_key(const std::string &key)
{ {
ob::Openbox::instance->bindings()->setResetKey(key); ob::Openbox::instance->bindings()->setResetKey(key);
} }
} }

61
src/python.hh
View file

@ -6,6 +6,9 @@
@brief wee @brief wee
*/ */
#include "otk/point.hh"
#include "otk/rect.hh"
extern "C" { extern "C" {
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <Python.h> #include <Python.h>
@ -19,6 +22,7 @@ namespace ob {
enum MouseContext { enum MouseContext {
MC_Frame, MC_Frame,
MC_Titlebar, MC_Titlebar,
MC_Handle,
MC_Window, MC_Window,
MC_MaximizeButton, MC_MaximizeButton,
MC_CloseButton, MC_CloseButton,
@ -45,18 +49,61 @@ enum KeyContext {
}; };
#ifndef SWIG #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_init(char *argv0);
void python_destroy(); void python_destroy();
bool python_exec(const std::string &path); bool python_exec(const std::string &path);
void python_callback(PyObject *func, MouseAction action, MotionData *new_motion_data(Window window, Time time, unsigned int state,
Window window, MouseContext context, unsigned int button, MouseContext context,
unsigned int state, unsigned int button, MouseAction action, int xroot, int yroot,
int xroot, int yroot, Time time); const otk::Point &initpos,
const otk::Rect &initarea);
void python_callback(PyObject *func, Window window, unsigned int state, ButtonData *new_button_data(Window window, Time time, unsigned int state,
unsigned int key, Time time); 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_string(const char *name, std::string *value);
bool python_get_stringlist(const char *name, std::vector<std::string> *value); bool python_get_stringlist(const char *name, std::vector<std::string> *value);

35
src/widget.hh
View file

@ -2,6 +2,8 @@
#ifndef __obwidget_hh #ifndef __obwidget_hh
#define __obwidget_hh #define __obwidget_hh
#include "python.hh"
namespace ob { namespace ob {
class OBWidget { class OBWidget {
@ -30,6 +32,39 @@ public:
OBWidget(WidgetType type) : _type(type) {} OBWidget(WidgetType type) : _type(type) {}
inline WidgetType type() const { return _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
}
}
}; };
} }