X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=util%2Fepist%2Fkeytree.cc;h=94b542b0e3c057a59826e2d27520fd276101e7c5;hb=eb19a6b69e89c6adae1b99705b0a26edc344c87a;hp=2649740ed3744350470db2daffd5a000995ecb25;hpb=6d40002093a5d8e665d4f310ea028d22e93e88cb;p=chaz%2Fopenbox diff --git a/util/epist/keytree.cc b/util/epist/keytree.cc index 2649740e..94b542b0 100644 --- a/util/epist/keytree.cc +++ b/util/epist/keytree.cc @@ -1,5 +1,5 @@ -// -*- mode: C++; indent-tabs-mode: nil; -*- -// keytree.cc for Epistophy - a key handler for NETWM/EWMH window managers. +// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*- +// keytree.cc for Epistrophy - a key handler for NETWM/EWMH window managers. // Copyright (c) 2002 - 2002 Ben Jansens // // Permission is hereby granted, free of charge, to any person obtaining a @@ -20,19 +20,45 @@ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. +#ifdef HAVE_CONFIG_H +# include "../../config.h" +#endif // HAVE_CONFIG_H + #include "keytree.hh" +#include "epist.hh" +#include "config.hh" + +#include +#include + +using std::string; -keytree::keytree(Display *display) : _display(display) +keytree::keytree(Display *display, epist *ep) + : _display(display), _timeout_screen(NULL), _timer(NULL), _epist(ep) { _head = new keynode; _head->parent = NULL; _head->action = NULL; // head's action is always NULL _current = _head; + // for complete initialization, initialize() has to be called as well. We + // call initialize() when we are certain that the config object (which the + // timer uses) has been fully initialized. (see parser::parse()) } keytree::~keytree() { clearTree(_head); + delete _timer; +} + +void keytree::unloadBindings() +{ + ChildList::iterator it, end = _head->children.end(); + for (it = _head->children.begin(); it != end; ++it) + clearTree(*it); + + _head->children.clear(); + reset(); } void keytree::clearTree(keynode *node) @@ -44,9 +70,12 @@ void keytree::clearTree(keynode *node) for (it = node->children.begin(); it != end; ++it) clearTree(*it); + node->children.clear(); + if (node->action) delete node->action; delete node; + node = NULL; } void keytree::grabDefaults(screen *scr) @@ -54,20 +83,57 @@ void keytree::grabDefaults(screen *scr) grabChildren(_head, scr); } +void keytree::ungrabDefaults(screen *scr) +{ + Action *act; + + ChildList::const_iterator it, end = _head->children.end(); + for (it = _head->children.begin(); it != end; ++it) { + act = (*it)->action; + if (act && act->type() != Action::toggleGrabs) + scr->ungrabKey(act->keycode(), act->modifierMask()); + } +} + void keytree::grabChildren(keynode *node, screen *scr) { + Action *act; + ChildList::const_iterator it, end = node->children.end(); - for (it = node->children.begin(); it != end; ++it) - if ( (*it)->action ) - scr->grabKey( (*it)->action->keycode(), (*it)->action->modifierMask() ); + for (it = node->children.begin(); it != end; ++it) { + act = (*it)->action; + if (act) + scr->grabKey(act->keycode(), act->modifierMask()); + } } void keytree::ungrabChildren(keynode *node, screen *scr) { + ChildList::const_iterator head_it, head_end = _head->children.end(); ChildList::const_iterator it, end = node->children.end(); - for (it = node->children.begin(); it != end; ++it) - if ( (*it)->action ) - scr->ungrabKey( (*it)->action->keycode(), (*it)->action->modifierMask()); + bool ungrab = true; + + // when ungrabbing children, make sure that we don't ungrab any topmost keys + // (children of the head node) This would render those topmost keys useless. + // Topmost keys are _never_ ungrabbed, since they are only grabbed at startup + + for (it = node->children.begin(); it != end; ++it) { + if ( (*it)->action ) { + for (head_it = _head->children.begin(); head_it != head_end; ++head_it) { + if ( (*it)->action->modifierMask() == (*head_it)->action->modifierMask() && + (*it)->action->keycode() == (*head_it)->action->keycode()) + { + ungrab = false; + break; + } + } + + if (ungrab) + scr->ungrabKey( (*it)->action->keycode(), (*it)->action->modifierMask()); + + ungrab = true; + } + } } const Action * keytree::getAction(const XEvent &e, unsigned int state, @@ -75,23 +141,40 @@ const Action * keytree::getAction(const XEvent &e, unsigned int state, { Action *act; + // we're done with the children. ungrab them if (_current != _head) ungrabChildren(_current, scr); - + ChildList::const_iterator it, end = _current->children.end(); for (it = _current->children.begin(); it != end; ++it) { act = (*it)->action; if (e.xkey.keycode == act->keycode() && state == act->modifierMask()) { - if ( isLeaf(*it) ) { - if (_current != _head) - ungrabChildren(_current, scr); - _current = _head; - return act; + if (act->type() == Action::cancelChain) { + // user is cancelling the chain explicitly + _current = _head; + return (const Action *)NULL; + } + else if ( isLeaf(*it) ) { + // node is a leaf, so an action will be executed + if (_timer->isTiming()) { + _timer->stop(); + _timeout_screen = NULL; + } + + _current = _head; + return act; } else { - _current = *it; - grabChildren(_current, scr); - return (const Action *)NULL; + // node is not a leaf, so we advance down the tree, and grab the + // children of the new current node. no action is executed + if (_timer->isTiming()) + _timer->stop(); + _timer->start(); + _timeout_screen = scr; + + _current = *it; + grabChildren(_current, scr); + return (const Action *)NULL; } } } @@ -104,15 +187,19 @@ const Action * keytree::getAction(const XEvent &e, unsigned int state, void keytree::addAction(Action::ActionType action, unsigned int mask, string key, string arg) { - // can't grab non-modifier as topmost key - if (_current == _head && (mask == 0 || mask == ShiftMask)) + if (action == Action::toggleGrabs && _current != _head) { + // the toggleGrabs key can only be set up as a root key, since if + // it was a chain key, we'd have to not ungrab the whole chain up + // to that key. which kinda defeats the purpose of this function. return; + } + KeySym sym = XStringToKeysym(key.c_str()); keynode *tmp = new keynode; + tmp->action = new Action(action, - XKeysymToKeycode(_display, - XStringToKeysym(key.c_str())), - mask, arg); + XKeysymToKeycode(_display, sym), + mask, arg); tmp->parent = _current; _current->children.push_back(tmp); } @@ -137,8 +224,33 @@ void keytree::setCurrentNodeProps(Action::ActionType action, unsigned int mask, { if (_current->action) delete _current->action; + + KeySym sym = XStringToKeysym(key.c_str()); _current->action = new Action(action, - XKeysymToKeycode(_display, - XStringToKeysym(key.c_str())), - mask, arg); + XKeysymToKeycode(_display, sym), + mask, arg); +} + +void keytree::initialize(void) +{ + int tval = 0; + + _epist->getConfig()->getValue(Config::chainTimeout, tval); + _timer = new BTimer(_epist, this); + + if (tval <= 0) + tval = 3000; // set default timeout to 3 seconds + + _timer->setTimeout(tval); +} + +void keytree::timeout(void) +{ + assert(_timeout_screen != NULL); + + if (_current != _head) { + ungrabChildren(_current, _timeout_screen); + _current = _head; + } + _timeout_screen = NULL; }