X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=util%2Fepist%2Fkeytree.cc;h=94b542b0e3c057a59826e2d27520fd276101e7c5;hb=eb19a6b69e89c6adae1b99705b0a26edc344c87a;hp=7c954c510eaa19d475da18db91ababe6abcb8a42;hpb=97e86c912ee33e9e75e68f9c193d78879f91d542;p=chaz%2Fopenbox diff --git a/util/epist/keytree.cc b/util/epist/keytree.cc index 7c954c51..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,24 +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) @@ -49,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) @@ -59,12 +83,28 @@ 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) @@ -104,26 +144,41 @@ const Action * keytree::getAction(const XEvent &e, unsigned int state, // 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 (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 { // 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; } } } - + // action not found. back to the head _current = _head; return (const Action *)NULL; @@ -132,15 +187,18 @@ 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 - // XXX: do we allow Esc to be grabbed at the top? - 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())), + XKeysymToKeycode(_display, sym), mask, arg); tmp->parent = _current; _current->children.push_back(tmp); @@ -166,9 +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())), + 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; +}