merge

1 files changed, 309 insertions, 0 deletions

diff --git a/src/keys.cc b/src/keys.cc
new file mode 100644
index 00000000..93bec708
--- /dev/null
+++ b/src/keys.cc
@@ -0,0 +1,309 @@
+/*
+ * Key parser
+ *
+ * Copyright (C) 2009 Jorge Arellano Cid <jcid@dillo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <fltk/events.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "dlib/dlib.h"
+#include "keys.hh"
+#include "msg.h"
+
+/*
+ *  Local data types
+ */
+typedef struct {
+   const char *name;
+   int cmd, modifier, key;
+} KeyBinding_t;
+
+typedef struct {
+   const char *name;
+   const int value;
+} Mapping_t;
+
+
+/*
+ *  Local data
+ */
+static const Mapping_t keyNames[] = {
+   { "Backspace",   fltk::BackSpaceKey },
+   { "Delete",      fltk::DeleteKey    },
+   { "Down",        fltk::DownKey      },
+   { "End",         fltk::EndKey       },
+   { "Esc",         fltk::EscapeKey    },
+   { "F1",          fltk::F1Key        },
+   { "F2",          fltk::F2Key        },
+   { "F3",          fltk::F3Key        },
+   { "F4",          fltk::F4Key        },
+   { "F5",          fltk::F5Key        },
+   { "F6",          fltk::F6Key        },
+   { "F7",          fltk::F7Key        },
+   { "F8",          fltk::F8Key        },
+   { "F9",          fltk::F9Key        },
+   { "F10",         fltk::F10Key       },
+   { "F11",         fltk::F11Key       },
+   { "F12",         fltk::F12Key       },
+   { "Home",        fltk::HomeKey      },
+   { "Insert",      fltk::InsertKey    },
+   { "Left",        fltk::LeftKey      },
+   { "PageDown",    fltk::PageDownKey  },
+   { "PageUp",      fltk::PageUpKey    },
+   { "Print",       fltk::PrintKey     },
+   { "Return",      fltk::ReturnKey    },
+   { "Right",       fltk::RightKey     },
+   { "Space",       fltk::SpaceKey     },
+   { "Tab",         fltk::TabKey       },
+   { "Up",          fltk::UpKey        }
+};
+
+static const Mapping_t modifierNames[] = {
+   { "Shift",   fltk::SHIFT   },
+   { "Ctrl",    fltk::CTRL    },
+   { "Alt",     fltk::ALT     },
+   { "Meta",    fltk::META    },
+   { "Button1", fltk::BUTTON1 },
+   { "Button2", fltk::BUTTON2 },
+   { "Button3", fltk::BUTTON3 }
+};
+
+static KeyBinding_t default_keys[] = {
+   { "open"         , KEYS_OPEN         , fltk::CTRL   , 'o'                },
+   { "new-window"   , KEYS_NEW_WINDOW   , fltk::CTRL   , 'n'                },
+   { "new-tab"      , KEYS_NEW_TAB      , fltk::CTRL   , 't'                },
+   { "left-tab"     , KEYS_LEFT_TAB     , fltk::SHIFT  , fltk::TabKey       },
+   { "right-tab"    , KEYS_RIGHT_TAB    , fltk::CTRL   , fltk::TabKey       },
+   { "close-tab"    , KEYS_CLOSE_TAB    , fltk::CTRL   , 'q'                },
+   { "find"         , KEYS_FIND         , fltk::CTRL   , 'f'                },
+   { "websearch"    , KEYS_WEBSEARCH    , fltk::CTRL   , 's'                },
+   { "bookmarks"    , KEYS_BOOKMARKS    , fltk::CTRL   , 'b'                },
+   { "fullscreen"   , KEYS_FULLSCREEN   , fltk::CTRL   , fltk::SpaceKey     },
+   { "reload"       , KEYS_RELOAD       , fltk::CTRL   , 'r'                },
+   { "hide-panels"  , KEYS_HIDE_PANELS  , 0            , fltk::EscapeKey    },
+   { "file-menu"    , KEYS_FILE_MENU    , fltk::ALT    , 'f'                },
+   { "close-all"    , KEYS_CLOSE_ALL    , fltk::ALT    , 'q'                },
+   { "back"         , KEYS_BACK         , 0            , fltk::BackSpaceKey },
+   { "back"         , KEYS_BACK         , 0            , ','                },
+   { "forward"      , KEYS_FORWARD      , fltk::SHIFT  , fltk::BackSpaceKey },
+   { "forward"      , KEYS_FORWARD      , 0            , '.'                },
+   { "goto"         , KEYS_GOTO         , fltk::CTRL   , 'l'                },
+   { "home"         , KEYS_HOME         , fltk::CTRL   , 'h'                }
+};
+
+static Dlist *bindings;
+
+
+
+/*
+ * Initialize the bindings list
+ */
+void Keys::init()
+{
+   KeyBinding_t *node;
+
+   // Fill our key bindings list
+   bindings = dList_new(32);
+   for (uint_t i = 0; i < sizeof(default_keys) / sizeof(KeyBinding_t); i++) {
+      node = dNew(KeyBinding_t, 1);
+      node->name = dStrdup(default_keys[i].name);
+      node->cmd = default_keys[i].cmd;
+      node->modifier = default_keys[i].modifier;
+      node->key = default_keys[i].key;
+      dList_insert_sorted(bindings, node, nodeByKeyCmp);
+   }
+}
+
+/*
+ * Free data
+ */
+void Keys::free()
+{
+   KeyBinding_t *node;
+
+   while ((node = (KeyBinding_t*)dList_nth_data(bindings, 0)))
+      dFree((char*)node->name);
+   dList_free(bindings);
+}
+
+/*
+ * Compare function by {key,modifier} pairs.
+ */
+int Keys::nodeByKeyCmp(const void *node, const void *key)
+{
+   KeyBinding_t *n = (KeyBinding_t*)node, *k = (KeyBinding_t*)key;
+   _MSG("Keys::nodeByKeyCmp modifier=%d\n", k->modifier);
+   return (n->key != k->key) ? (n->key - k->key) : (n->modifier - k->modifier);
+}
+
+/*
+ * Look if the just pressed key is bound to a command.
+ * Return value: The command if found, KEYS_NOP otherwise.
+ */
+int Keys::getKeyCmd()
+{
+   int ret = KEYS_NOP;
+   KeyBinding_t keyNode;
+   keyNode.key = fltk::event_key();
+   keyNode.modifier = fltk::event_state();
+
+   void *data = dList_find_sorted(bindings, &keyNode,
+                                  (dCompareFunc)nodeByKeyCmp);
+   if (data)
+      ret = ((KeyBinding_t*)data)->cmd;
+   return ret;
+}
+
+/*
+ * Remove a key binding from the table.
+ */
+void Keys::delKeyCmd(int key, int mod)
+{
+   KeyBinding_t keyNode;
+   keyNode.key = key;
+   keyNode.modifier = mod;
+
+   void *data = dList_find_sorted(bindings, &keyNode,
+                                  (dCompareFunc)nodeByKeyCmp);
+   if (data)
+      dList_remove(bindings, data);
+}
+
+/*
+ * Takes a key name and looks it up in the mapping table. If
+ * found, its key code is returned. Otherwise -1 is given
+ * back.
+ */
+int Keys::getKeyCode(char *keyName)
+{
+   uint_t i;
+   for (i = 0; i < sizeof(keyNames) / sizeof(Mapping_t); i++) {
+      if (!strcasecmp(keyNames[i].name, keyName)) {
+         return keyNames[i].value;
+      }
+   }
+
+   return -1;
+}
+
+/*
+ * Takes a command name and searches it in the mapping table.
+ * Return value: command code if found, -1 otherwise
+ */
+int Keys::getCmdCode(const char *commandName)
+{
+   uint_t i;
+
+   for (i = 0; i < sizeof(default_keys) / sizeof(KeyBinding_t); i++) {
+      if (!strcasecmp(default_keys[i].name, commandName))
+         return default_keys[i].cmd;
+   }
+   return -1;
+}
+
+/*
+ * Takes a modifier name and looks it up in the mapping table. If
+ * found, its key code is returned. Otherwise -1 is given back.
+ */
+int Keys::getModifier(char *modifierName)
+{
+   uint_t i;
+   for (i = 0; i < sizeof(modifierNames) / sizeof(Mapping_t); i++) {
+      if (!strcasecmp(modifierNames[i].name, modifierName)) {
+         return modifierNames[i].value;
+      }
+   }
+
+   return -1;
+}
+
+/*
+ * Parse a key-combination/command-name pair, and
+ * insert it into the bindings list.
+ */
+void Keys::parseKey(char *key, char *commandName)
+{
+   char *p, *modstr, *keystr;
+   int st, symcode = 0, keymod = 0, keycode = 0;
+
+   _MSG("Keys::parseKey key='%s' commandName='%s'\n", key, commandName);
+
+   // Get command code
+   if ((st = getCmdCode(commandName)) == -1) {
+      MSG("Invalid command name: '%s'\n", commandName);
+      return;
+   } else
+      symcode = st;
+
+   // Skip space
+   for (  ; isspace(*key); ++key) ;
+   // Get modifiers
+   while(*key == '<' && (p = strchr(++key, '>'))) {
+      modstr = strndup(key, p - key);
+      if ((st = getModifier(modstr)) == -1) {
+         MSG("Keys::parseKey unknown modifier: %s\n", modstr);
+      } else {
+         keymod |= st;
+      }
+      dFree(modstr);
+      key = p + 1;
+   }
+   // Allow trailing space after keyname
+   keystr = (*key && (p = strchr(key + 1, ' '))) ? strndup(key, p - key - 1) :
+                                                   dStrdup(key);
+   // Get key code
+   if (!key[1]) {
+      keycode = *key;
+   } else if ((st = getKeyCode(keystr)) == -1) {
+      MSG("Keys::parseKey unknown keyname: %s\n", keystr);
+   } else {
+      keycode = st;
+   }
+   dFree(keystr);
+
+   // Set binding
+   if (keycode) {
+      delKeyCmd(keycode, keymod);
+      if (symcode != KEYS_NOP) {
+         KeyBinding_t *node = dNew(KeyBinding_t, 1);
+         node->name = dStrdup(commandName);
+         node->cmd = symcode;
+         node->modifier = keymod;
+         node->key = keycode;
+         dList_insert_sorted(bindings, node, nodeByKeyCmp);
+      }
+   }
+}
+
+/*
+ * Parse the keysrc.
+ */
+void Keys::parse(FILE *fp)
+{
+   char *line, *keycomb, *command;
+   int st;
+
+   // scan the file line by line
+   while ((line = dGetline(fp)) != NULL) {
+      st = dParser_parse_rc_line(&line, &keycomb, &command);
+
+      if (st == 0) {
+         _MSG("Keys::parse: keycomb=%s, command=%s\n", keycomb, command);
+         parseKey(keycomb, command);
+      } else if (st < 0) {
+         MSG("Keys::parse: Syntax error in keysrc: "
+             "keycomb=\"%s\" command=\"%s\"\n", keycomb, command);
+      }
+
+      dFree(line);
+   }
+   fclose(fp);
+}