Dogcows Code - chaz/openbox/blob - plugins/keyboard/keyboard.c

   1 #include "kernel/focus.h"
   2 #include "kernel/dispatch.h"
   3 #include "kernel/openbox.h"
   4 #include "kernel/event.h"
   5 #include "kernel/grab.h"
   6 #include "kernel/action.h"
   7 #include "kernel/parse.h"
   8 #include "kernel/timer.h"
   9 #include "tree.h"
  10 #include "keyboard.h"
  11 #include "keyparse.h"
  12 #include "translate.h"
  13 #include <glib.h>
  14
  15 void plugin_setup_config()
  16 {
  17     parse_reg_section("keyboard", keyparse, NULL);
  18 }
  19
  20 KeyBindingTree *firstnode = NULL;
  21
  22 static KeyBindingTree *curpos;
  23 static guint reset_key, reset_state, button_return, button_escape;
  24 static Timer *chain_timer;
  25
  26 static void grab_keys()
  27 {
  28     KeyBindingTree *p;
  29
  30     ungrab_all_keys();
  31
  32     p = curpos ? curpos->first_child : firstnode;
  33     while (p) {
  34         grab_key(p->key, p->state, GrabModeAsync);
  35         p = p->next_sibling;
  36     }
  37     grab_key(reset_key, reset_state, GrabModeAsync);
  38 }
  39
  40 static void reset_chains()
  41 {
  42     if (chain_timer) {
  43         timer_stop(chain_timer);
  44         chain_timer = NULL;
  45     }
  46     if (curpos) {
  47         curpos = NULL;
  48         grab_keys();
  49     }
  50 }
  51
  52 static void chain_timeout(void *data)
  53 {
  54     reset_chains();
  55 }
  56
  57 gboolean kbind(GList *keylist, Action *action)
  58 {
  59     KeyBindingTree *tree, *t;
  60     gboolean conflict;
  61
  62     g_assert(keylist != NULL);
  63     g_assert(action != NULL);
  64
  65     if (!(tree = tree_build(keylist)))
  66         return FALSE;
  67
  68     if ((t = tree_find(tree, &conflict)) != NULL) {
  69         /* already bound to something, use the existing tree */
  70         tree_destroy(tree);
  71         tree = NULL;
  72     } else
  73         t = tree;
  74     while (t->first_child) t = t->first_child;
  75
  76     if (conflict) {
  77         g_message("conflict with binding");
  78         tree_destroy(tree);
  79         return FALSE;
  80     }
  81
  82     /* set the action */
  83     t->actions = g_slist_append(t->actions, action);
  84     /* assimilate this built tree into the main tree. assimilation
  85        destroys/uses the tree */
  86     if (tree) tree_assimilate(tree);
  87
  88     return TRUE;
  89 }
  90
  91 static void event(ObEvent *e, void *foo)
  92 {
  93     static KeyBindingTree *grabbed_key = NULL;
  94
  95     if (grabbed_key) {
  96         gboolean done = FALSE;
  97
  98         if ((e->type == Event_X_KeyRelease &&
  99              !(grabbed_key->state & e->data.x.e->xkey.state)))
 100             done = TRUE;
 101         else if (e->type == Event_X_KeyPress) {
 102             if (e->data.x.e->xkey.keycode == button_return)
 103                 done = TRUE;
 104             else if (e->data.x.e->xkey.keycode == button_escape) {
 105                 GSList *it;
 106                 for (it = grabbed_key->actions; it; it = it->next) {
 107                     Action *act = it->data;
 108                     act->data.cycle.cancel = TRUE;
 109                 }
 110                 done = TRUE;
 111             }
 112         }
 113         if (done) {
 114             GSList *it;
 115             for (it = grabbed_key->actions; it; it = it->next) {
 116                 Action *act = it->data;
 117                 act->data.cycle.final = TRUE;
 118                 act->func(&act->data);
 119                 grabbed_key = NULL;
 120                 grab_keyboard(FALSE);
 121                 reset_chains();
 122                 return;
 123             }
 124         }
 125     }
 126     if (e->type == Event_X_KeyRelease)
 127         return;
 128
 129     g_assert(e->type == Event_X_KeyPress);
 130
 131     if (e->data.x.e->xkey.keycode == reset_key &&
 132         e->data.x.e->xkey.state == reset_state) {
 133         reset_chains();
 134     } else {
 135         KeyBindingTree *p;
 136         if (curpos == NULL)
 137             p = firstnode;
 138         else
 139             p = curpos->first_child;
 140         while (p) {
 141             if (p->key == e->data.x.e->xkey.keycode &&
 142                 p->state == e->data.x.e->xkey.state) {
 143                 if (p->first_child != NULL) { /* part of a chain */
 144                     if (chain_timer) timer_stop(chain_timer);
 145                     /* 5 second timeout for chains */
 146                     chain_timer = timer_start(5000*1000, chain_timeout,
 147                                               NULL);
 148                     curpos = p;
 149                     grab_keys();
 150                 } else {
 151                     GSList *it;
 152                     for (it = p->actions; it; it = it->next) {
 153                         Action *act = it->data;
 154                         if (act->func != NULL) {
 155                             act->data.any.c = focus_client;
 156
 157                             if (act->func == action_cycle_windows) {
 158                                 act->data.cycle.final = FALSE;
 159                                 act->data.cycle.cancel = FALSE;
 160                             }
 161
 162                             act->func(&act->data);
 163
 164                             if (act->func == action_cycle_windows &&
 165                                 !grabbed_key) {
 166                                 grabbed_key = p;
 167                                 grab_keyboard(TRUE);
 168                                 break;
 169                             }
 170                         }
 171                     }
 172
 173                     reset_chains();
 174                 }
 175                 break;
 176             }
 177             p = p->next_sibling;
 178         }
 179     }
 180 }
 181
 182 void plugin_startup()
 183 {
 184     guint i;
 185
 186     curpos = NULL;
 187     chain_timer = NULL;
 188
 189     dispatch_register(Event_X_KeyPress | Event_X_KeyRelease,
 190                       (EventHandler)event, NULL);
 191
 192     translate_key("C-g", &reset_state, &reset_key);
 193     translate_key("Escape", &i, &button_escape);
 194     translate_key("Return", &i, &button_return);
 195
 196     grab_keys();
 197 }
 198
 199 void plugin_shutdown()
 200 {
 201     dispatch_register(0, (EventHandler)event, NULL);
 202
 203     tree_destroy(firstnode);
 204     firstnode = NULL;
 205     ungrab_all_keys();
 206 }
 207