X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=src%2Fbindings.cc;h=167d0a854439ded9415da00bde70c404bc3b7fb5;hb=7c8c9e998ffc3a9b22e15feeffe77823142ce531;hp=fade3e6957db76ff8e7e72584b70f0cc730d4998;hpb=66a26917a0631463df7f72c34cbeb39df466918a;p=chaz%2Fopenbox diff --git a/src/bindings.cc b/src/bindings.cc index fade3e69..167d0a85 100644 --- a/src/bindings.cc +++ b/src/bindings.cc @@ -9,7 +9,6 @@ #include "openbox.hh" #include "client.hh" #include "frame.hh" -#include "python.hh" #include "otk/display.hh" extern "C" { @@ -19,19 +18,21 @@ extern "C" { #define _(str) gettext(str) } +#include + namespace ob { static bool buttonvalue(const std::string &button, unsigned int *val) { - if (button == "1" || button == "Button1") { + if (button == "Left" || button == "1" || button == "Button1") { *val |= Button1; - } else if (button == "2" || button == "Button2") { + } else if (button == "Middle" || button == "2" || button == "Button2") { *val |= Button2; - } else if (button == "3" || button == "Button3") { + } else if (button == "Right" || button == "3" || button == "Button3") { *val |= Button3; - } else if (button == "4" || button == "Button4") { + } else if (button == "Up" || button == "4" || button == "Button4") { *val |= Button4; - } else if (button == "5" || button == "Button5") { + } else if (button == "Down" || button == "5" || button == "Button5") { *val |= Button5; } else return false; @@ -68,7 +69,7 @@ static bool modvalue(const std::string &mod, unsigned int *val) return true; } -bool OBBindings::translate(const std::string &str, Binding &b) const +bool Bindings::translate(const std::string &str, Binding &b,bool askey) const { // parse out the base key name std::string::size_type keybegin = str.find_last_of('-'); @@ -92,37 +93,45 @@ bool OBBindings::translate(const std::string &str, Binding &b) const // set the binding b.modifiers = modval; - KeySym sym = XStringToKeysym(const_cast(key.c_str())); - if (sym == NoSymbol) { - printf(_("Invalid Key name in key binding: %s\n"), key.c_str()); - return false; + if (askey) { + KeySym sym = XStringToKeysym(const_cast(key.c_str())); + if (sym == NoSymbol) { + printf(_("Invalid Key name in key binding: %s\n"), key.c_str()); + return false; + } + if (!(b.key = XKeysymToKeycode(**otk::display, sym))) + printf(_("No valid keycode for Key in key binding: %s\n"), key.c_str()); + return b.key != 0; + } else { + return buttonvalue(key, &b.key); } - if (!(b.key = XKeysymToKeycode(otk::OBDisplay::display, sym))) - printf(_("No valid keycode for Key in key binding: %s\n"), key.c_str()); - return b.key != 0; } -static void destroytree(BindingTree *tree) +static void destroytree(KeyBindingTree *tree) { while (tree) { - BindingTree *c = tree->first_child; + KeyBindingTree *c = tree->first_child; delete tree; tree = c; } } -BindingTree *OBBindings::buildtree(const StringVect &keylist, - PyObject *callback) const +KeyBindingTree *Bindings::buildtree(const StringVect &keylist, + KeyCallback callback, void *data) const { if (keylist.empty()) return 0; // nothing in the list.. return 0 - BindingTree *ret = 0, *p; + KeyBindingTree *ret = 0, *p; StringVect::const_reverse_iterator it, end = keylist.rend(); for (it = keylist.rbegin(); it != end; ++it) { p = ret; - ret = new BindingTree(callback); - if (!p) ret->chain = false; // only the first built node + ret = new KeyBindingTree(); + if (!p) { + // this is the first built node, the bottom node of the tree + ret->chain = false; + ret->callbacks.push_back(KeyCallbackData(callback, data)); + } ret->first_child = p; if (!translate(*it, ret->binding)) { destroytree(ret); @@ -134,34 +143,36 @@ BindingTree *OBBindings::buildtree(const StringVect &keylist, } -OBBindings::OBBindings() - : _curpos(&_tree), +Bindings::Bindings() + : _curpos(&_keytree), _resetkey(0,0), - _timer(Openbox::instance->timerManager(), - (otk::OBTimeoutHandler)reset, this) + _timer((otk::Timer *) 0), + _keybgrab_callback(0, 0) { - _timer.setTimeout(5000); // chains reset after 5 seconds - - setResetKey("C-g"); // set the default reset key +// setResetKey("C-g"); // set the default reset key } -OBBindings::~OBBindings() +Bindings::~Bindings() { - grabKeys(false); - removeAll(); + if (_timer) + delete _timer; + + removeAllKeys(); + //removeAllButtons(); // this is done by each client as they are unmanaged + removeAllEvents(); } -void OBBindings::assimilate(BindingTree *node) +void Bindings::assimilate(KeyBindingTree *node) { - BindingTree *a, *b, *tmp, *last; + KeyBindingTree *a, *b, *tmp, *last; - if (!_tree.first_child) { + if (!_keytree.first_child) { // there are no nodes at this level yet - _tree.first_child = node; + _keytree.first_child = node; } else { - a = _tree.first_child; + a = _keytree.first_child; last = a; b = node; while (a) { @@ -185,10 +196,11 @@ void OBBindings::assimilate(BindingTree *node) } -PyObject *OBBindings::find(BindingTree *search, bool *conflict) const { +KeyBindingTree *Bindings::find(KeyBindingTree *search, + bool *conflict) const { *conflict = false; - BindingTree *a, *b; - a = _tree.first_child; + KeyBindingTree *a, *b; + a = _keytree.first_child; b = search; while (a && b) { if (a->binding != b->binding) { @@ -197,7 +209,7 @@ PyObject *OBBindings::find(BindingTree *search, bool *conflict) const { if (a->chain == b->chain) { if (!a->chain) { // found it! (return the actual id, not the search's) - return a->callback; + return a; } } else { *conflict = true; @@ -211,143 +223,235 @@ PyObject *OBBindings::find(BindingTree *search, bool *conflict) const { } -bool OBBindings::add(const StringVect &keylist, PyObject *callback) +bool Bindings::addKey(const StringVect &keylist, KeyCallback callback, + void *data) { - BindingTree *tree; + KeyBindingTree *tree, *t; bool conflict; - if (!(tree = buildtree(keylist, callback))) + if (!(tree = buildtree(keylist, callback, data))) return false; // invalid binding requested - if (find(tree, &conflict) || conflict) { + t = find(tree, &conflict); + if (conflict) { // conflicts with another binding destroytree(tree); return false; } - grabKeys(false); - - // assimilate this built tree into the main tree - assimilate(tree); // assimilation destroys/uses the tree + if (t) { + // already bound to something + t->callbacks.push_back(KeyCallbackData(callback, data)); + destroytree(tree); + } else { + // grab the server here to make sure no key pressed go missed + otk::display->grab(); + grabKeys(false); - Py_INCREF(callback); + // assimilate this built tree into the main tree + assimilate(tree); // assimilation destroys/uses the tree - grabKeys(true); + grabKeys(true); + otk::display->ungrab(); + } return true; } - -bool OBBindings::remove(const StringVect &keylist) +/* +bool Bindings::removeKey(const StringVect &keylist, KeyCallback callback, void *data) { assert(false); // XXX: function not implemented yet - BindingTree *tree; + KeyBindingTree *tree; bool conflict; if (!(tree = buildtree(keylist, 0))) return false; // invalid binding requested - PyObject *func = find(tree, &conflict); - if (func) { - grabKeys(false); - - _curpos = &_tree; - - // XXX do shit here ... - Py_DECREF(func); - - grabKeys(true); - return true; + KeyBindingTree *t = find(tree, &conflict); + if (t) { + 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(); + grabKeys(false); + + _curpos = &_keytree; + + // XXX do shit here ... + Py_XDECREF(*it); + + grabKeys(true); + otk::display->ungrab(); + + return true; + } } return false; } +*/ - -void OBBindings::setResetKey(const std::string &key) +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(); } } -static void remove_branch(BindingTree *first) +static void remove_branch(KeyBindingTree *first) { - BindingTree *p = first; + KeyBindingTree *p = first; while (p) { if (p->first_child) remove_branch(p->first_child); - BindingTree *s = p->next_sibling; - Py_XDECREF(p->callback); + KeyBindingTree *s = p->next_sibling; + while(!p->callbacks.empty()) { + p->callbacks.pop_front(); + } delete p; p = s; } } -void OBBindings::removeAll() +void Bindings::removeAllKeys() { - if (_tree.first_child) { - remove_branch(_tree.first_child); - _tree.first_child = 0; + grabKeys(false); + if (_keytree.first_child) { + remove_branch(_keytree.first_child); + _keytree.first_child = 0; } + grabKeys(true); } -void OBBindings::grabKeys(bool grab) +void Bindings::grabKeys(bool grab) { - for (int i = 0; i < Openbox::instance->screenCount(); ++i) { - Window root = otk::OBDisplay::screenInfo(i)->rootWindow(); + for (int i = 0; i < ScreenCount(**otk::display); ++i) { + Screen *sc = openbox->screen(i); + if (!sc) continue; // not a managed screen + Window root = otk::display->screenInfo(i)->rootWindow(); - BindingTree *p = _curpos->first_child; + KeyBindingTree *p = _curpos->first_child; while (p) { if (grab) { - otk::OBDisplay::grabKey(p->binding.key, p->binding.modifiers, + otk::display->grabKey(p->binding.key, p->binding.modifiers, root, false, GrabModeAsync, GrabModeAsync, false); } else - otk::OBDisplay::ungrabKey(p->binding.key, p->binding.modifiers, + otk::display->ungrabKey(p->binding.key, p->binding.modifiers, root); p = p->next_sibling; } - if (grab) - otk::OBDisplay::grabKey(_resetkey.key, _resetkey.modifiers, - root, true, GrabModeAsync, GrabModeAsync, - false); - else - otk::OBDisplay::ungrabKey(_resetkey.key, _resetkey.modifiers, - root); + 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); } } -void OBBindings::fire(unsigned int modifiers, unsigned int key, Time time) +bool Bindings::grabKeyboard(int screen, KeyCallback callback, void *data) { + assert(callback); + if (_keybgrab_callback.callback) return false; // already grabbed + + if (!openbox->screen(screen)) + return false; // the screen is not managed + + Window root = otk::display->screenInfo(screen)->rootWindow(); + if (XGrabKeyboard(**otk::display, root, false, GrabModeAsync, + GrabModeAsync, CurrentTime)) + return false; + _keybgrab_callback.callback = callback; + _keybgrab_callback.data = data; + return true; +} + + +void Bindings::ungrabKeyboard() +{ + if (!_keybgrab_callback.callback) return; // not grabbed + + _keybgrab_callback = KeyCallbackData(0, 0); + XUngrabKeyboard(**otk::display, CurrentTime); + XUngrabPointer(**otk::display, CurrentTime); +} + + +bool Bindings::grabPointer(int screen) +{ + if (!openbox->screen(screen)) + return false; // the screen is not managed + + Window root = otk::display->screenInfo(screen)->rootWindow(); + XGrabPointer(**otk::display, root, false, 0, GrabModeAsync, + GrabModeAsync, None, None, CurrentTime); + return true; +} + + +void Bindings::ungrabPointer() +{ + XUngrabPointer(**otk::display, CurrentTime); +} + + +void Bindings::fireKey(int screen, unsigned int modifiers, unsigned int key, + Time time, KeyAction::KA action) +{ + if (_keybgrab_callback.callback) { + Client *c = openbox->focusedClient(); + KeyData data(screen, c, time, modifiers, key, action); + _keybgrab_callback.fire(&data); + } + + // KeyRelease events only occur during keyboard grabs + if (action == KeyAction::Release) return; + if (key == _resetkey.key && modifiers == _resetkey.modifiers) { - reset(this); + resetChains(this); } else { - BindingTree *p = _curpos->first_child; + KeyBindingTree *p = _curpos->first_child; while (p) { if (p->binding.key == key && p->binding.modifiers == modifiers) { if (p->chain) { - _timer.start(); // start/restart the timer + if (_timer) + delete _timer; + _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); _curpos = p; grabKeys(true); + otk::display->ungrab(); } else { - Window win = None; - OBClient *c = Openbox::instance->focusedClient(); - if (c) win = c->window(); - python_callback(p->callback, win, modifiers, key, time); - reset(this); + Client *c = openbox->focusedClient(); + KeyData data(screen, c, time, modifiers, key, action); + KeyCallbackList::iterator it, end = p->callbacks.end(); + for (it = p->callbacks.begin(); it != end; ++it) + it->fire(&data); + resetChains(this); } break; } @@ -356,12 +460,197 @@ void OBBindings::fire(unsigned int modifiers, unsigned int key, Time time) } } -void OBBindings::reset(OBBindings *self) +void Bindings::resetChains(Bindings *self) { - self->_timer.stop(); + if (self->_timer) { + 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->_tree; + self->_curpos = &self->_keytree; self->grabKeys(true); + otk::display->ungrab(); +} + + +bool Bindings::addButton(const std::string &but, MouseContext::MC context, + 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)) + return false; + + ButtonBindingList::iterator it, end = _buttons[context].end(); + + // look for a duplicate binding + for (it = _buttons[context].begin(); it != end; ++it) + if ((*it)->binding.key == b.key && + (*it)->binding.modifiers == b.modifiers) { + break; + } + + ButtonBinding *bind; + + // the binding didnt exist yet, add it + if (it == end) { + bind = new ButtonBinding(); + bind->binding.key = b.key; + bind->binding.modifiers = b.modifiers; + _buttons[context].push_back(bind); + // grab the button on all clients + for (int sn = 0; sn < ScreenCount(**otk::display); ++sn) { + Screen *s = openbox->screen(sn); + if (!s) continue; // not managed + Client::List::iterator c_it, c_end = s->clients.end(); + for (c_it = s->clients.begin(); c_it != c_end; ++c_it) { + grabButton(true, bind->binding, context, *c_it); + } + } + } else + bind = *it; + bind->callbacks[action].push_back(MouseCallbackData(callback, data)); + return true; +} + +void Bindings::removeAllButtons() +{ + for (int i = 0; i < MouseContext::NUM_MOUSE_CONTEXT; ++i) { + ButtonBindingList::iterator it, end = _buttons[i].end(); + for (it = _buttons[i].begin(); it != end; ++it) { + for (int a = 0; a < MouseAction::NUM_MOUSE_ACTION; ++a) { + while (!(*it)->callbacks[a].empty()) { + (*it)->callbacks[a].pop_front(); + } + } + // ungrab the button on all clients + for (int sn = 0; sn < ScreenCount(**otk::display); ++sn) { + Screen *s = openbox->screen(sn); + if (!s) continue; // not managed + Client::List::iterator c_it, c_end = s->clients.end(); + for (c_it = s->clients.begin(); c_it != c_end; ++c_it) { + grabButton(false, (*it)->binding, (MouseContext::MC)i, *c_it); + } + } + } + } +} + +void Bindings::grabButton(bool grab, const Binding &b, + MouseContext::MC context, Client *client) +{ + Window win; + int mode = GrabModeAsync; + unsigned int mask; + switch(context) { + case MouseContext::Frame: + win = client->frame->window(); + mask = ButtonPressMask | ButtonMotionMask | ButtonReleaseMask; + break; + case MouseContext::Window: + win = client->frame->plate(); + mode = GrabModeSync; // this is handled in fireButton + mask = ButtonPressMask; // can't catch more than this with Sync mode + // the release event is manufactured by the + // master buttonPressHandler + break; + default: + // any other elements already get button events, don't grab on them + return; + } + if (grab) + otk::display->grabButton(b.key, b.modifiers, win, false, mask, mode, + GrabModeAsync, None, None, false); + else + otk::display->ungrabButton(b.key, b.modifiers, win); +} + +void Bindings::grabButtons(bool grab, Client *client) +{ + for (int i = 0; i < MouseContext::NUM_MOUSE_CONTEXT; ++i) { + ButtonBindingList::iterator it, end = _buttons[i].end(); + for (it = _buttons[i].begin(); it != end; ++it) + grabButton(grab, (*it)->binding, (MouseContext::MC)i, client); + } +} + +void Bindings::fireButton(MouseData *data) +{ + if (data->context == MouseContext::Window) { + // Replay the event, so it goes to the client + XAllowEvents(**otk::display, ReplayPointer, data->time); + } + + 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) { + 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) + c_it->fire(data); + } +} + + +bool Bindings::addEvent(EventAction::EA action, EventCallback callback, + void *data) +{ + if (action < 0 || action >= EventAction::NUM_EVENT_ACTION) { + return false; + } +#ifdef XKB + if (action == EventAction::Bell && _eventlist[action].empty()) + XkbSelectEvents(**otk::display, XkbUseCoreKbd, + XkbBellNotifyMask, XkbBellNotifyMask); +#endif // XKB + _eventlist[action].push_back(EventCallbackData(callback, data)); + return true; +} + +bool Bindings::removeEvent(EventAction::EA action, EventCallback callback, + void *data) +{ + if (action < 0 || action >= EventAction::NUM_EVENT_ACTION) { + return false; + } + + EventCallbackList::iterator it = std::find(_eventlist[action].begin(), + _eventlist[action].end(), + EventCallbackData(callback, + data)); + if (it != _eventlist[action].end()) { + _eventlist[action].erase(it); +#ifdef XKB + if (action == EventAction::Bell && _eventlist[action].empty()) + XkbSelectEvents(**otk::display, XkbUseCoreKbd, + XkbBellNotifyMask, 0); +#endif // XKB + return true; + } + return false; +} + +void Bindings::removeAllEvents() +{ + for (int i = 0; i < EventAction::NUM_EVENT_ACTION; ++i) { + while (!_eventlist[i].empty()) { + _eventlist[i].pop_front(); + } + } +} + +void Bindings::fireEvent(EventData *data) +{ + EventCallbackList::iterator c_it, c_end = _eventlist[data->action].end(); + for (c_it = _eventlist[data->action].begin(); c_it != c_end; ++c_it) + c_it->fire(data); } }