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);
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)
@ -70,16 +71,14 @@ void OBActions::buttonPressHandler(const XButtonEvent &e)
// run the PRESS python hook
OBWidget *w = dynamic_cast<OBWidget*>
(Openbox::instance->findHandler(e.window));
assert(w); // everything should be a widget
/* 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?
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
@ -94,6 +93,7 @@ void OBActions::buttonReleaseHandler(const XButtonEvent &e)
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;
@ -110,29 +110,19 @@ void OBActions::buttonReleaseHandler(const XButtonEvent &e)
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;
@ -144,6 +134,8 @@ void OBActions::buttonReleaseHandler(const XButtonEvent &e)
_release.button = e.button;
_release.time = e.time;
}
Py_DECREF((PyObject*)data);
}
@ -178,7 +170,9 @@ void OBActions::keyPressHandler(const XKeyEvent &e)
// 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);
}
@ -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*>
(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
// 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?
// 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)

3
src/actions.hh
View file

@ -64,8 +64,6 @@ private:
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);
@ -99,7 +97,6 @@ public:
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

78
src/bindings.cc
View file

@ -350,7 +350,9 @@ void OBBindings::fire(unsigned int modifiers, unsigned int key, Time time)
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;
@ -424,25 +426,15 @@ void OBBindings::grabButtons(bool grab, OBClient *client)
case MC_Window:
win[0] = client->frame->plate();
break;
case MC_Handle:
win[0] = client->frame->handle();
break;
case MC_MaximizeButton:
// win[0] = client->frame->button_max();
break;
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:
@ -465,58 +457,18 @@ void OBBindings::grabButtons(bool grab, OBClient *client)
}
}
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);
}
}

4
src/bindings.hh
View file

@ -120,9 +120,7 @@ public:
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);
};
}

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 *)"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},

305
src/python.cc
View file

@ -22,61 +22,36 @@ static PyObject *obdict = NULL;
// 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)
static void dealloc(PyObject *self)
{
PyObject_Del((PyObject*)self);
PyObject_Del(self);
}
static void BindingDataDealloc(BindingData *self)
{
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)
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;
@ -91,57 +66,112 @@ PyObject *ActionData_button(ActionData *self, PyObject *args)
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);
}
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_modifiers(BindingData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":modifiers")) return NULL;
return PyLong_FromUnsignedLong(self->state);
}
PyObject *BindingData_key(BindingData *self, PyObject *args)
PyObject *KeyData_key(KeyData *self, PyObject *args)
{
if(!PyArg_ParseTuple(args,":key")) return NULL;
return PyString_FromString(
@ -149,58 +179,117 @@ PyObject *BindingData_key(BindingData *self, PyObject *args)
}
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(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)
0,
"ActionData",
sizeof(ActionData),
"MotionData",
sizeof(MotionData),
0,
(destructor)ActionDataDealloc,
dealloc,
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
};
static PyTypeObject BindingData_Type = {
static PyTypeObject ButtonData_Type = {
PyObject_HEAD_INIT(NULL)
0,
"BindingData",
sizeof(BindingData),
"ButtonData",
sizeof(ButtonData),
0,
(destructor)BindingDataDealloc,
dealloc,
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
};
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 //
// **************** //
@ -219,8 +308,9 @@ void python_init(char *argv0)
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()
@ -240,7 +330,7 @@ bool python_exec(const std::string &path)
return true;
}
static void call(PyObject *func, PyObject *data)
void python_callback(PyObject *func, PyObject *data)
{
PyObject *arglist;
PyObject *result;
@ -258,42 +348,6 @@ static void call(PyObject *func, PyObject *data)
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));
@ -438,4 +492,5 @@ void set_reset_key(const std::string &key)
{
ob::Openbox::instance->bindings()->setResetKey(key);
}
}

61
src/python.hh
View file

@ -6,6 +6,9 @@
@brief wee
*/
#include "otk/point.hh"
#include "otk/rect.hh"
extern "C" {
#include <X11/Xlib.h>
#include <Python.h>
@ -19,6 +22,7 @@ namespace ob {
enum MouseContext {
MC_Frame,
MC_Titlebar,
MC_Handle,
MC_Window,
MC_MaximizeButton,
MC_CloseButton,
@ -45,18 +49,61 @@ enum KeyContext {
};
#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);

35
src/widget.hh
View file

@ -2,6 +2,8 @@
#ifndef __obwidget_hh
#define __obwidget_hh
#include "python.hh"
namespace ob {
class OBWidget {
@ -30,6 +32,39 @@ public:
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
}
}
};
}