use the c++ std cheaders
[dana/openbox.git] / src / bindings.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #include "config.h"
4
5 #include "bindings.hh"
6 #include "screen.hh"
7 #include "openbox.hh"
8 #include "client.hh"
9 #include "frame.hh"
10 #include "otk/display.hh"
11
12 extern "C" {
13 #include <X11/Xlib.h>
14
15 #include "gettext.h"
16 #define _(str) gettext(str)
17 }
18
19 #include <algorithm>
20
21 namespace ob {
22
23 static bool buttonvalue(const std::string &button, unsigned int *val)
24 {
25   if (button == "Left" || button == "1" || button == "Button1") {
26     *val |= Button1;
27   } else if (button == "Middle" || button == "2" || button == "Button2") {
28     *val |= Button2;
29   } else if (button == "Right" || button == "3" || button == "Button3") {
30     *val |= Button3;
31   } else if (button == "Up" || button == "4" || button == "Button4") {
32     *val |= Button4;
33   } else if (button == "Down" || button == "5" || button == "Button5") {
34     *val |= Button5;
35   } else
36     return false;
37   return true;
38 }
39
40 static bool modvalue(const std::string &mod, unsigned int *val)
41 {
42   if (mod == "C") {           // control
43     *val |= ControlMask;
44   } else if (mod == "S") {    // shift
45     *val |= ShiftMask;
46   } else if (mod == "A" ||    // alt/mod1
47              mod == "M" ||
48              mod == "Mod1" ||
49              mod == "M1") {
50     *val |= Mod1Mask;
51   } else if (mod == "Mod2" ||   // mod2
52              mod == "M2") {
53     *val |= Mod2Mask;
54   } else if (mod == "Mod3" ||   // mod3
55              mod == "M3") {
56     *val |= Mod3Mask;
57   } else if (mod == "W" ||    // windows/mod4
58              mod == "Mod4" ||
59              mod == "M4") {
60     *val |= Mod4Mask;
61   } else if (mod == "Mod5" ||   // mod5
62              mod == "M5") {
63     *val |= Mod5Mask;
64   } else {                    // invalid
65     return false;
66   }
67   return true;
68 }
69
70 bool Bindings::translate(const std::string &str, Binding &b,bool askey) const
71 {
72   // parse out the base key name
73   std::string::size_type keybegin = str.find_last_of('-');
74   keybegin = (keybegin == std::string::npos) ? 0 : keybegin + 1;
75   std::string key(str, keybegin);
76
77   // parse out the requested modifier keys
78   unsigned int modval = 0;
79   std::string::size_type begin = 0, end;
80   while (begin != keybegin) {
81     end = str.find_first_of('-', begin);
82
83     std::string mod(str, begin, end-begin);
84     if (!modvalue(mod, &modval)) {
85       printf(_("Invalid modifier element in key binding: %s\n"), mod.c_str());
86       return false;
87     }
88     
89     begin = end + 1;
90   }
91
92   // set the binding
93   b.modifiers = modval;
94   if (askey) {
95     KeySym sym = XStringToKeysym(const_cast<char *>(key.c_str()));
96     if (sym == NoSymbol) {
97       printf(_("Invalid Key name in key binding: %s\n"), key.c_str());
98       return false;
99     }
100     if (!(b.key = XKeysymToKeycode(**otk::display, sym)))
101       printf(_("No valid keycode for Key in key binding: %s\n"), key.c_str());
102     return b.key != 0;
103   } else {
104     return buttonvalue(key, &b.key);
105   }
106 }
107
108 static void destroytree(KeyBindingTree *tree)
109 {
110   while (tree) {
111     KeyBindingTree *c = tree->first_child;
112     delete tree;
113     tree = c;
114   }
115 }
116
117 KeyBindingTree *Bindings::buildtree(const StringVect &keylist,
118                                     KeyCallback callback, void *data) const
119 {
120   if (keylist.empty()) return 0; // nothing in the list.. return 0
121
122   KeyBindingTree *ret = 0, *p;
123
124   StringVect::const_reverse_iterator it, end = keylist.rend();
125   for (it = keylist.rbegin(); it != end; ++it) {
126     p = ret;
127     ret = new KeyBindingTree();
128     if (!p) {
129       // this is the first built node, the bottom node of the tree
130       ret->chain = false;
131       ret->callbacks.push_back(KeyCallbackData(callback, data));
132     }
133     ret->first_child = p;
134     if (!translate(*it, ret->binding)) {
135       destroytree(ret);
136       ret = 0;
137       break;
138     }
139   }
140   return ret;
141 }
142
143
144 Bindings::Bindings()
145   : _curpos(&_keytree),
146     _resetkey(0,0),
147     _timer((otk::Timer *) 0),
148     _keybgrab_callback(0, 0)
149 {
150 //  setResetKey("C-g"); // set the default reset key
151 }
152
153
154 Bindings::~Bindings()
155 {
156   if (_timer)
157     delete _timer;
158
159   removeAllKeys();
160   //removeAllButtons(); // this is done by each client as they are unmanaged
161   removeAllEvents();
162 }
163
164
165 void Bindings::assimilate(KeyBindingTree *node)
166 {
167   KeyBindingTree *a, *b, *tmp, *last;
168
169   if (!_keytree.first_child) {
170     // there are no nodes at this level yet
171     _keytree.first_child = node;
172   } else {
173     a = _keytree.first_child;
174     last = a;
175     b = node;
176     while (a) {
177       last = a;
178       if (a->binding != b->binding) {
179         a = a->next_sibling;
180       } else {
181         tmp = b;
182         b = b->first_child;
183         delete tmp;
184         a = a->first_child;
185       }
186     }
187     if (last->binding != b->binding)
188       last->next_sibling = b;
189     else {
190       last->first_child = b->first_child;
191       delete b;
192     }
193   }
194 }
195
196
197 KeyBindingTree *Bindings::find(KeyBindingTree *search,
198                                  bool *conflict) const {
199   *conflict = false;
200   KeyBindingTree *a, *b;
201   a = _keytree.first_child;
202   b = search;
203   while (a && b) {
204     if (a->binding != b->binding) {
205       a = a->next_sibling;
206     } else {
207       if (a->chain == b->chain) {
208         if (!a->chain) {
209           // found it! (return the actual id, not the search's)
210           return a;
211         }
212       } else {
213         *conflict = true;
214         return 0; // the chain status' don't match (conflict!)
215       }
216       b = b->first_child;
217       a = a->first_child;
218     }
219   }
220   return 0; // it just isn't in here
221 }
222
223
224 bool Bindings::addKey(const StringVect &keylist, KeyCallback callback,
225                       void *data)
226 {
227   KeyBindingTree *tree, *t;
228   bool conflict;
229
230   if (!(tree = buildtree(keylist, callback, data)))
231     return false; // invalid binding requested
232
233   t = find(tree, &conflict);
234   if (conflict) {
235     // conflicts with another binding
236     destroytree(tree);
237     return false;
238   }
239
240   if (t) {
241     // already bound to something
242     t->callbacks.push_back(KeyCallbackData(callback, data));
243     destroytree(tree);
244   } else {
245     // grab the server here to make sure no key pressed go missed
246     otk::display->grab();
247     grabKeys(false);
248
249     // assimilate this built tree into the main tree
250     assimilate(tree); // assimilation destroys/uses the tree
251
252     grabKeys(true); 
253     otk::display->ungrab();
254   }
255  
256   return true;
257 }
258
259 /*
260 bool Bindings::removeKey(const StringVect &keylist, KeyCallback callback, void *data)
261 {
262   assert(false); // XXX: function not implemented yet
263
264   KeyBindingTree *tree;
265   bool conflict;
266
267   if (!(tree = buildtree(keylist, 0)))
268     return false; // invalid binding requested
269
270   KeyBindingTree *t = find(tree, &conflict);
271   if (t) {
272     KeyCallbackList::iterator it = std::find(t->callbacks.begin(),
273                                              t->callbacks.end(),
274                                              callback);
275     if (it != t->callbacks.end()) {
276       // grab the server here to make sure no key pressed go missed
277       otk::display->grab();
278       grabKeys(false);
279       
280       _curpos = &_keytree;
281       
282       // XXX do shit here ...
283       Py_XDECREF(*it);
284       
285       grabKeys(true);
286       otk::display->ungrab();
287       
288       return true;
289     }
290   }
291   return false;
292 }
293 */
294
295 void Bindings::setResetKey(const std::string &key)
296 {
297   Binding b(0, 0);
298   if (translate(key, b)) {
299     // grab the server here to make sure no key pressed go missed
300     otk::display->grab();
301     grabKeys(false);
302     _resetkey.key = b.key;
303     _resetkey.modifiers = b.modifiers;
304     grabKeys(true);
305     otk::display->ungrab();
306   }
307 }
308
309
310 static void remove_branch(KeyBindingTree *first)
311 {
312   KeyBindingTree *p = first;
313
314   while (p) {
315     if (p->first_child)
316       remove_branch(p->first_child);
317     KeyBindingTree *s = p->next_sibling;
318     while(!p->callbacks.empty()) {
319       p->callbacks.pop_front();
320     }
321     delete p;
322     p = s;
323   }
324 }
325
326
327 void Bindings::removeAllKeys()
328 {
329   grabKeys(false);
330   if (_keytree.first_child) {
331     remove_branch(_keytree.first_child);
332     _keytree.first_child = 0;
333   }
334   grabKeys(true);
335 }
336
337
338 void Bindings::grabKeys(bool grab)
339 {
340   for (int i = 0; i < ScreenCount(**otk::display); ++i) {
341     Screen *sc = openbox->screen(i);
342     if (!sc) continue; // not a managed screen
343     Window root = otk::display->screenInfo(i)->rootWindow();
344
345     KeyBindingTree *p = _curpos->first_child;
346     while (p) {
347       if (grab) {
348         otk::display->grabKey(p->binding.key, p->binding.modifiers,
349                                 root, false, GrabModeAsync, GrabModeAsync,
350                                 false);
351       }
352       else
353         otk::display->ungrabKey(p->binding.key, p->binding.modifiers,
354                                   root);
355       p = p->next_sibling;
356     }
357
358     if (_resetkey.key)
359       if (grab)
360         otk::display->grabKey(_resetkey.key, _resetkey.modifiers,
361                                 root, false, GrabModeAsync, GrabModeAsync,
362                                 false);
363       else
364         otk::display->ungrabKey(_resetkey.key, _resetkey.modifiers,
365                                   root);
366   }
367 }
368
369
370 bool Bindings::grabKeyboard(int screen, KeyCallback callback, void *data)
371 {
372   assert(callback);
373   if (_keybgrab_callback.callback) return false; // already grabbed
374
375   if (!openbox->screen(screen))
376     return false; // the screen is not managed
377   
378   Window root = otk::display->screenInfo(screen)->rootWindow();
379   if (XGrabKeyboard(**otk::display, root, false, GrabModeAsync,
380                     GrabModeAsync, CurrentTime))
381     return false;
382   _keybgrab_callback.callback = callback;
383   _keybgrab_callback.data = data;
384   return true;
385 }
386
387
388 void Bindings::ungrabKeyboard()
389 {
390   if (!_keybgrab_callback.callback) return; // not grabbed
391
392   _keybgrab_callback = KeyCallbackData(0, 0);
393   XUngrabKeyboard(**otk::display, CurrentTime);
394   XUngrabPointer(**otk::display, CurrentTime);
395 }
396
397
398 bool Bindings::grabPointer(int screen)
399 {
400   if (!openbox->screen(screen))
401     return false; // the screen is not managed
402   
403   Window root = otk::display->screenInfo(screen)->rootWindow();
404   XGrabPointer(**otk::display, root, false, 0, GrabModeAsync,
405                GrabModeAsync, None, None, CurrentTime);
406   return true;
407 }
408
409
410 void Bindings::ungrabPointer()
411 {
412   XUngrabPointer(**otk::display, CurrentTime);
413 }
414
415
416 void Bindings::fireKey(int screen, unsigned int modifiers, unsigned int key,
417                        Time time, KeyAction::KA action)
418 {
419   if (_keybgrab_callback.callback) {
420     Client *c = openbox->focusedClient();
421     KeyData data(screen, c, time, modifiers, key, action);
422     _keybgrab_callback.fire(&data);
423   }
424   
425   // KeyRelease events only occur during keyboard grabs
426   if (action == KeyAction::Release) return;
427     
428   if (key == _resetkey.key && modifiers == _resetkey.modifiers) {
429     resetChains(this);
430   } else {
431     KeyBindingTree *p = _curpos->first_child;
432     while (p) {
433       if (p->binding.key == key && p->binding.modifiers == modifiers) {
434         if (p->chain) {
435           if (_timer)
436             delete _timer;
437           _timer = new otk::Timer(5000, // 5 second timeout
438                                   (otk::Timer::TimeoutHandler)resetChains,
439                                   this);
440           // grab the server here to make sure no key presses get missed
441           otk::display->grab();
442           grabKeys(false);
443           _curpos = p;
444           grabKeys(true);
445           otk::display->ungrab();
446         } else {
447           Client *c = openbox->focusedClient();
448           KeyData data(screen, c, time, modifiers, key, action);
449           KeyCallbackList::iterator it, end = p->callbacks.end();
450           for (it = p->callbacks.begin(); it != end; ++it)
451             it->fire(&data);
452           resetChains(this);
453         }
454         break;
455       }
456       p = p->next_sibling;
457     }
458   }
459 }
460
461 void Bindings::resetChains(Bindings *self)
462 {
463   if (self->_timer) {
464     delete self->_timer;
465     self->_timer = (otk::Timer *) 0;
466   }
467   // grab the server here to make sure no key pressed go missed
468   otk::display->grab();
469   self->grabKeys(false);
470   self->_curpos = &self->_keytree;
471   self->grabKeys(true);
472   otk::display->ungrab();
473 }
474
475
476 bool Bindings::addButton(const std::string &but, MouseContext::MC context,
477                          MouseAction::MA action, MouseCallback callback,
478                          void *data)
479 {
480   assert(context >= 0 && context < MouseContext::NUM_MOUSE_CONTEXT);
481   assert(action >= 0 && action < MouseAction::NUM_MOUSE_ACTION);
482   
483   Binding b(0,0);
484   if (!translate(but, b, false))
485     return false;
486
487   ButtonBindingList::iterator it, end = _buttons[context].end();
488
489   // look for a duplicate binding
490   for (it = _buttons[context].begin(); it != end; ++it)
491     if ((*it)->binding.key == b.key &&
492         (*it)->binding.modifiers == b.modifiers) {
493       break;
494     }
495
496   ButtonBinding *bind;
497   
498   // the binding didnt exist yet, add it
499   if (it == end) {
500     bind = new ButtonBinding();
501     bind->binding.key = b.key;
502     bind->binding.modifiers = b.modifiers;
503     _buttons[context].push_back(bind);
504     // grab the button on all clients
505     for (int sn = 0; sn < ScreenCount(**otk::display); ++sn) {
506       Screen *s = openbox->screen(sn);
507       if (!s) continue; // not managed
508       Client::List::iterator c_it, c_end = s->clients.end();
509       for (c_it = s->clients.begin(); c_it != c_end; ++c_it) {
510         grabButton(true, bind->binding, context, *c_it);
511       }
512     }
513   } else
514     bind = *it;
515   bind->callbacks[action].push_back(MouseCallbackData(callback, data));
516   return true;
517 }
518
519 void Bindings::removeAllButtons()
520 {
521   for (int i = 0; i < MouseContext::NUM_MOUSE_CONTEXT; ++i) {
522     ButtonBindingList::iterator it, end = _buttons[i].end();
523     for (it = _buttons[i].begin(); it != end; ++it) {
524       for (int a = 0; a < MouseAction::NUM_MOUSE_ACTION; ++a) {
525         while (!(*it)->callbacks[a].empty()) {
526           (*it)->callbacks[a].pop_front();
527         }
528       }
529       // ungrab the button on all clients
530       for (int sn = 0; sn < ScreenCount(**otk::display); ++sn) {
531         Screen *s = openbox->screen(sn);
532         if (!s) continue; // not managed
533         Client::List::iterator c_it, c_end = s->clients.end();
534         for (c_it = s->clients.begin(); c_it != c_end; ++c_it) {
535           grabButton(false, (*it)->binding, (MouseContext::MC)i, *c_it);
536         }
537       }
538     }
539   }
540 }
541
542 void Bindings::grabButton(bool grab, const Binding &b,
543                           MouseContext::MC context, Client *client)
544 {
545   Window win;
546   int mode = GrabModeAsync;
547   unsigned int mask;
548   switch(context) {
549   case MouseContext::Frame:
550     win = client->frame->window();
551     mask = ButtonPressMask | ButtonMotionMask | ButtonReleaseMask;
552     break;
553   case MouseContext::Window:
554     win = client->frame->plate();
555     mode = GrabModeSync; // this is handled in fireButton
556     mask = ButtonPressMask; // can't catch more than this with Sync mode
557                             // the release event is manufactured by the
558                             // master buttonPressHandler
559     break;
560   default:
561     // any other elements already get button events, don't grab on them
562     return;
563   }
564   if (grab)
565     otk::display->grabButton(b.key, b.modifiers, win, false, mask, mode,
566                              GrabModeAsync, None, None, false);
567   else
568     otk::display->ungrabButton(b.key, b.modifiers, win);
569 }
570
571 void Bindings::grabButtons(bool grab, Client *client)
572 {
573   for (int i = 0; i < MouseContext::NUM_MOUSE_CONTEXT; ++i) {
574     ButtonBindingList::iterator it, end = _buttons[i].end();
575     for (it = _buttons[i].begin(); it != end; ++it)
576       grabButton(grab, (*it)->binding, (MouseContext::MC)i, client);
577   }
578 }
579
580 void Bindings::fireButton(MouseData *data)
581 {
582   if (data->context == MouseContext::Window) {
583     // Replay the event, so it goes to the client
584     XAllowEvents(**otk::display, ReplayPointer, data->time);
585   }
586   
587   ButtonBindingList::iterator it, end = _buttons[data->context].end();
588   for (it = _buttons[data->context].begin(); it != end; ++it)
589     if ((*it)->binding.key == data->button &&
590         (*it)->binding.modifiers == data->state) {
591       MouseCallbackList::iterator c_it,
592         c_end = (*it)->callbacks[data->action].end();
593       for (c_it = (*it)->callbacks[data->action].begin();
594            c_it != c_end; ++c_it)
595         c_it->fire(data);
596     }
597 }
598
599
600 bool Bindings::addEvent(EventAction::EA action, EventCallback callback,
601                         void *data)
602 {
603   if (action < 0 || action >= EventAction::NUM_EVENT_ACTION) {
604     return false;
605   }
606 #ifdef    XKB
607   if (action == EventAction::Bell && _eventlist[action].empty())
608     XkbSelectEvents(**otk::display, XkbUseCoreKbd,
609                     XkbBellNotifyMask, XkbBellNotifyMask);
610 #endif // XKB
611   _eventlist[action].push_back(EventCallbackData(callback, data));
612   return true;
613 }
614
615 bool Bindings::removeEvent(EventAction::EA action, EventCallback callback,
616                            void *data)
617 {
618   if (action < 0 || action >= EventAction::NUM_EVENT_ACTION) {
619     return false;
620   }
621   
622   EventCallbackList::iterator it = std::find(_eventlist[action].begin(),
623                                              _eventlist[action].end(),
624                                              EventCallbackData(callback,
625                                                                data));
626   if (it != _eventlist[action].end()) {
627     _eventlist[action].erase(it);
628 #ifdef    XKB
629     if (action == EventAction::Bell && _eventlist[action].empty())
630       XkbSelectEvents(**otk::display, XkbUseCoreKbd,
631                       XkbBellNotifyMask, 0);
632 #endif // XKB
633     return true;
634   }
635   return false;
636 }
637
638 void Bindings::removeAllEvents()
639 {
640   for (int i = 0; i < EventAction::NUM_EVENT_ACTION; ++i) {
641     while (!_eventlist[i].empty()) {
642       _eventlist[i].pop_front();
643     }
644   }
645 }
646
647 void Bindings::fireEvent(EventData *data)
648 {
649   EventCallbackList::iterator c_it, c_end = _eventlist[data->action].end();
650   for (c_it = _eventlist[data->action].begin(); c_it != c_end; ++c_it)
651     c_it->fire(data);
652 }
653
654 }