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