// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
-#ifdef HAVE_CONFIG_H
-# include "../config.h"
-#endif
+#include "config.h"
#include "bindings.hh"
#include "screen.hh"
#include "openbox.hh"
#include "client.hh"
#include "frame.hh"
-#include "python.hh"
#include "otk/display.hh"
extern "C" {
#define _(str) gettext(str)
}
+#include <cstdlib>
#include <algorithm>
namespace ob {
static bool buttonvalue(const std::string &button, unsigned int *val)
{
- if (button == "Left" || button == "1" || button == "Button1") {
- *val |= Button1;
- } else if (button == "Middle" || button == "2" || button == "Button2") {
- *val |= Button2;
- } else if (button == "Right" || button == "3" || button == "Button3") {
- *val |= Button3;
- } else if (button == "Up" || button == "4" || button == "Button4") {
- *val |= Button4;
- } else if (button == "Down" || button == "5" || button == "Button5") {
- *val |= Button5;
- } else
- return false;
+ if (button == "Left")
+ *val = 1;
+ else if (button == "Middle")
+ *val = 2;
+ else if (button == "Right")
+ *val = 3;
+ else if (button == "Up")
+ *val = 4;
+ else if (button == "Down")
+ *val = 5;
+ else {
+ // try convert to number
+ int i = atoi(button.c_str());
+ if (i <= 0)
+ return false;
+ *val = i;
+ }
return true;
}
}
KeyBindingTree *Bindings::buildtree(const StringVect &keylist,
- PyObject *callback) const
+ KeyCallback callback, void *data) const
{
if (keylist.empty()) return 0; // nothing in the list.. return 0
if (!p) {
// this is the first built node, the bottom node of the tree
ret->chain = false;
- ret->callbacks.push_back(callback);
+ ret->callbacks.push_back(KeyCallbackData(callback, data));
}
ret->first_child = p;
if (!translate(*it, ret->binding)) {
: _curpos(&_keytree),
_resetkey(0,0),
_timer((otk::Timer *) 0),
- _keybgrab_callback(0)
+ _keybgrab_callback(0, 0),
+ _grabbed(0)
{
-// setResetKey("C-g"); // set the default reset key
+ setResetKey("C-g"); // set the default reset key
}
{
if (_timer)
delete _timer;
-
+ if (_grabbed) {
+ _grabbed = false;
+ XUngrabKeyboard(**otk::display, CurrentTime);
+ }
removeAllKeys();
//removeAllButtons(); // this is done by each client as they are unmanaged
removeAllEvents();
}
-bool Bindings::addKey(const StringVect &keylist, PyObject *callback)
+bool Bindings::addKey(const StringVect &keylist, KeyCallback callback,
+ void *data)
{
KeyBindingTree *tree, *t;
bool conflict;
- if (!(tree = buildtree(keylist, callback)))
+ if (!(tree = buildtree(keylist, callback, data)))
return false; // invalid binding requested
t = find(tree, &conflict);
if (t) {
// already bound to something
- // XXX: look if callback is already bound to this key?
- t->callbacks.push_back(callback);
+ t->callbacks.push_back(KeyCallbackData(callback, data));
destroytree(tree);
} else {
// grab the server here to make sure no key pressed go missed
otk::display->ungrab();
}
- Py_INCREF(callback);
-
return true;
}
-
-bool Bindings::removeKey(const StringVect &keylist, PyObject *callback)
+/*
+bool Bindings::removeKey(const StringVect &keylist, KeyCallback callback, void *data)
{
assert(false); // XXX: function not implemented yet
KeyBindingTree *t = find(tree, &conflict);
if (t) {
- CallbackList::iterator it = std::find(t->callbacks.begin(),
- t->callbacks.end(),
- callback);
+ KeyCallbackList::iterator it = std::find(t->callbacks.begin(),
+ t->callbacks.end(),
+ callback);
if (it != t->callbacks.end()) {
// grab the server here to make sure no key pressed go missed
otk::display->grab();
}
return false;
}
-
+*/
void Bindings::setResetKey(const std::string &key)
{
Binding b(0, 0);
if (translate(key, b)) {
- // grab the server here to make sure no key pressed go missed
- otk::display->grab();
- grabKeys(false);
_resetkey.key = b.key;
_resetkey.modifiers = b.modifiers;
- grabKeys(true);
- otk::display->ungrab();
}
}
remove_branch(p->first_child);
KeyBindingTree *s = p->next_sibling;
while(!p->callbacks.empty()) {
- Py_XDECREF(p->callbacks.front());
p->callbacks.pop_front();
}
delete p;
Screen *sc = openbox->screen(i);
if (!sc) continue; // not a managed screen
Window root = otk::display->screenInfo(i)->rootWindow();
-
- KeyBindingTree *p = _curpos->first_child;
+ if (!grab) {
+ otk::display->ungrabAllKeys(root);
+ continue;
+ }
+ KeyBindingTree *p = _keytree.first_child;
while (p) {
- if (grab) {
- otk::display->grabKey(p->binding.key, p->binding.modifiers,
- root, false, GrabModeAsync, GrabModeAsync,
- false);
- }
- else
- otk::display->ungrabKey(p->binding.key, p->binding.modifiers,
- root);
+ otk::display->grabKey(p->binding.key, p->binding.modifiers,
+ root, false, GrabModeAsync, GrabModeSync,
+ false);
p = p->next_sibling;
}
-
- if (_resetkey.key)
- if (grab)
- otk::display->grabKey(_resetkey.key, _resetkey.modifiers,
- root, false, GrabModeAsync, GrabModeAsync,
- false);
- else
- otk::display->ungrabKey(_resetkey.key, _resetkey.modifiers,
- root);
}
}
-bool Bindings::grabKeyboard(int screen, PyObject *callback)
+bool Bindings::grabKeyboard(int screen, KeyCallback callback, void *data)
{
assert(callback);
- if (_keybgrab_callback) return false; // already grabbed
+ if (_keybgrab_callback.callback) return false; // already grabbed
if (!openbox->screen(screen))
return false; // the screen is not managed
if (XGrabKeyboard(**otk::display, root, false, GrabModeAsync,
GrabModeAsync, CurrentTime))
return false;
- _keybgrab_callback = callback;
+ _keybgrab_callback.callback = callback;
+ _keybgrab_callback.data = data;
return true;
}
void Bindings::ungrabKeyboard()
{
- if (!_keybgrab_callback) return; // not grabbed
+ if (!_keybgrab_callback.callback) return; // not grabbed
- _keybgrab_callback = 0;
- XUngrabKeyboard(**otk::display, CurrentTime);
+ _keybgrab_callback = KeyCallbackData(0, 0);
+ if (!_grabbed) /* don't release out from under keychains */
+ XUngrabKeyboard(**otk::display, CurrentTime);
XUngrabPointer(**otk::display, CurrentTime);
}
void Bindings::fireKey(int screen, unsigned int modifiers, unsigned int key,
Time time, KeyAction::KA action)
{
- if (_keybgrab_callback) {
+ if (_keybgrab_callback.callback) {
Client *c = openbox->focusedClient();
KeyData data(screen, c, time, modifiers, key, action);
- python_callback(_keybgrab_callback, &data);
+ _keybgrab_callback.fire(&data);
}
-
+
// KeyRelease events only occur during keyboard grabs
if (action == KeyAction::Release) return;
if (key == _resetkey.key && modifiers == _resetkey.modifiers) {
resetChains(this);
+ XAllowEvents(**otk::display, AsyncKeyboard, CurrentTime);
} else {
KeyBindingTree *p = _curpos->first_child;
while (p) {
_timer = new otk::Timer(5000, // 5 second timeout
(otk::Timer::TimeoutHandler)resetChains,
this);
- // grab the server here to make sure no key presses get missed
- otk::display->grab();
- grabKeys(false);
+ if (!_grabbed && !_keybgrab_callback.callback) {
+ Window root = otk::display->screenInfo(screen)->rootWindow();
+ //grab should never fail because we should have a sync grab at
+ //this point
+ XGrabKeyboard(**otk::display, root, 0, GrabModeAsync,
+ GrabModeSync, CurrentTime);
+ }
+ _grabbed = true;
_curpos = p;
- grabKeys(true);
- otk::display->ungrab();
+ XAllowEvents(**otk::display, AsyncKeyboard, CurrentTime);
} else {
Client *c = openbox->focusedClient();
KeyData data(screen, c, time, modifiers, key, action);
- CallbackList::iterator it, end = p->callbacks.end();
+ KeyCallbackList::iterator it, end = p->callbacks.end();
for (it = p->callbacks.begin(); it != end; ++it)
- python_callback(*it, &data);
+ it->fire(&data);
+ XAllowEvents(**otk::display, AsyncKeyboard, CurrentTime);
resetChains(this);
}
break;
delete self->_timer;
self->_timer = (otk::Timer *) 0;
}
- // grab the server here to make sure no key pressed go missed
- otk::display->grab();
- self->grabKeys(false);
self->_curpos = &self->_keytree;
- self->grabKeys(true);
- otk::display->ungrab();
+ if (self->_grabbed) {
+ self->_grabbed = false;
+ if (!self->_keybgrab_callback.callback)
+ XUngrabKeyboard(**otk::display, CurrentTime);
+ }
}
bool Bindings::addButton(const std::string &but, MouseContext::MC context,
- MouseAction::MA action, PyObject *callback)
+ MouseAction::MA action, MouseCallback callback,
+ void *data)
{
assert(context >= 0 && context < MouseContext::NUM_MOUSE_CONTEXT);
+ assert(action >= 0 && action < MouseAction::NUM_MOUSE_ACTION);
Binding b(0,0);
if (!translate(but, b, false))
}
} else
bind = *it;
- bind->callbacks[action].push_back(callback);
- Py_INCREF(callback);
+ bind->callbacks[action].push_back(MouseCallbackData(callback, data));
return true;
}
for (it = _buttons[i].begin(); it != end; ++it) {
for (int a = 0; a < MouseAction::NUM_MOUSE_ACTION; ++a) {
while (!(*it)->callbacks[a].empty()) {
- Py_XDECREF((*it)->callbacks[a].front());
(*it)->callbacks[a].pop_front();
}
}
for (it = _buttons[data->context].begin(); it != end; ++it)
if ((*it)->binding.key == data->button &&
(*it)->binding.modifiers == data->state) {
- CallbackList::iterator c_it,c_end = (*it)->callbacks[data->action].end();
+ MouseCallbackList::iterator c_it,
+ c_end = (*it)->callbacks[data->action].end();
for (c_it = (*it)->callbacks[data->action].begin();
c_it != c_end; ++c_it)
- python_callback(*c_it, data);
+ c_it->fire(data);
}
}
-bool Bindings::addEvent(EventAction::EA action, PyObject *callback)
+bool Bindings::addEvent(EventAction::EA action, EventCallback callback,
+ void *data)
{
- if (action < 0 || action >= EventAction::NUM_EVENTS) {
+ if (action < 0 || action >= EventAction::NUM_EVENT_ACTION) {
return false;
}
#ifdef XKB
XkbSelectEvents(**otk::display, XkbUseCoreKbd,
XkbBellNotifyMask, XkbBellNotifyMask);
#endif // XKB
- _eventlist[action].push_back(callback);
- Py_INCREF(callback);
+ _eventlist[action].push_back(EventCallbackData(callback, data));
return true;
}
-bool Bindings::removeEvent(EventAction::EA action, PyObject *callback)
+bool Bindings::removeEvent(EventAction::EA action, EventCallback callback,
+ void *data)
{
- if (action < 0 || action >= EventAction::NUM_EVENTS) {
+ if (action < 0 || action >= EventAction::NUM_EVENT_ACTION) {
return false;
}
- CallbackList::iterator it = std::find(_eventlist[action].begin(),
- _eventlist[action].end(),
- callback);
+ EventCallbackList::iterator it = std::find(_eventlist[action].begin(),
+ _eventlist[action].end(),
+ EventCallbackData(callback,
+ data));
if (it != _eventlist[action].end()) {
- Py_XDECREF(*it);
_eventlist[action].erase(it);
#ifdef XKB
if (action == EventAction::Bell && _eventlist[action].empty())
void Bindings::removeAllEvents()
{
- for (int i = 0; i < EventAction::NUM_EVENTS; ++i) {
+ for (int i = 0; i < EventAction::NUM_EVENT_ACTION; ++i) {
while (!_eventlist[i].empty()) {
- Py_XDECREF(_eventlist[i].front());
_eventlist[i].pop_front();
}
}
void Bindings::fireEvent(EventData *data)
{
- CallbackList::iterator c_it, c_end = _eventlist[data->action].end();
+ EventCallbackList::iterator c_it, c_end = _eventlist[data->action].end();
for (c_it = _eventlist[data->action].begin(); c_it != c_end; ++c_it)
- python_callback(*c_it, data);
+ c_it->fire(data);
}
}
projects / chaz / openbox / blobdiff