gui/keymap.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: keymap.cc,v 1.23 2008/02/15 22:05:40 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2002 MandrakeSoft S.A.
   6 //
   7 //  This library is free software; you can redistribute it and/or
   8 //  modify it under the terms of the GNU Lesser General Public
   9 //  License as published by the Free Software Foundation; either
  10 //  version 2 of the License, or (at your option) any later version.
  11 //
  12 //  This library is distributed in the hope that it will be useful,
  13 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 //  Lesser General Public License for more details.
  16 //
  17 //  You should have received a copy of the GNU Lesser General Public
  18 //  License along with this library; if not, write to the Free Software
  19 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20
  21 /////////////////////////////////////////////////////////////////////////
  22 //
  23 // Todo
  24 //  . Currently supported by sdl, wxGTK and x11. Check if other guis need mapping.
  25 //  . Tables look-up should be optimised.
  26 //
  27
  28 #include "bochs.h"
  29
  30 // Table of bochs "BX_KEY_*" symbols
  31 // the table must be in BX_KEY_* order
  32 const char *bx_key_symbol[BX_KEY_NBKEYS] = {
  33   "BX_KEY_CTRL_L",         "BX_KEY_SHIFT_L",        "BX_KEY_F1",
  34   "BX_KEY_F2",             "BX_KEY_F3",             "BX_KEY_F4",
  35   "BX_KEY_F5",             "BX_KEY_F6",             "BX_KEY_F7",
  36   "BX_KEY_F8",             "BX_KEY_F9",             "BX_KEY_F10",
  37   "BX_KEY_F11",            "BX_KEY_F12",            "BX_KEY_CTRL_R",
  38   "BX_KEY_SHIFT_R",        "BX_KEY_CAPS_LOCK",      "BX_KEY_NUM_LOCK",
  39   "BX_KEY_ALT_L",          "BX_KEY_ALT_R",          "BX_KEY_A",
  40   "BX_KEY_B",              "BX_KEY_C",              "BX_KEY_D",
  41   "BX_KEY_E",              "BX_KEY_F",              "BX_KEY_G",
  42   "BX_KEY_H",              "BX_KEY_I",              "BX_KEY_J",
  43   "BX_KEY_K",              "BX_KEY_L",              "BX_KEY_M",
  44   "BX_KEY_N",              "BX_KEY_O",              "BX_KEY_P",
  45   "BX_KEY_Q",              "BX_KEY_R",              "BX_KEY_S",
  46   "BX_KEY_T",              "BX_KEY_U",              "BX_KEY_V",
  47   "BX_KEY_W",              "BX_KEY_X",              "BX_KEY_Y",
  48   "BX_KEY_Z",              "BX_KEY_0",              "BX_KEY_1",
  49   "BX_KEY_2",              "BX_KEY_3",              "BX_KEY_4",
  50   "BX_KEY_5",              "BX_KEY_6",              "BX_KEY_7",
  51   "BX_KEY_8",              "BX_KEY_9",              "BX_KEY_ESC",
  52   "BX_KEY_SPACE",          "BX_KEY_SINGLE_QUOTE",   "BX_KEY_COMMA",
  53   "BX_KEY_PERIOD",         "BX_KEY_SLASH",          "BX_KEY_SEMICOLON",
  54   "BX_KEY_EQUALS",         "BX_KEY_LEFT_BRACKET",   "BX_KEY_BACKSLASH",
  55   "BX_KEY_RIGHT_BRACKET",  "BX_KEY_MINUS",          "BX_KEY_GRAVE",
  56   "BX_KEY_BACKSPACE",      "BX_KEY_ENTER",          "BX_KEY_TAB",
  57   "BX_KEY_LEFT_BACKSLASH", "BX_KEY_PRINT",          "BX_KEY_SCRL_LOCK",
  58   "BX_KEY_PAUSE",          "BX_KEY_INSERT",         "BX_KEY_DELETE",
  59   "BX_KEY_HOME",           "BX_KEY_END",            "BX_KEY_PAGE_UP",
  60   "BX_KEY_PAGE_DOWN",      "BX_KEY_KP_ADD",         "BX_KEY_KP_SUBTRACT",
  61   "BX_KEY_KP_END",         "BX_KEY_KP_DOWN",        "BX_KEY_KP_PAGE_DOWN",
  62   "BX_KEY_KP_LEFT",        "BX_KEY_KP_RIGHT",       "BX_KEY_KP_HOME",
  63   "BX_KEY_KP_UP",          "BX_KEY_KP_PAGE_UP",     "BX_KEY_KP_INSERT",
  64   "BX_KEY_KP_DELETE",      "BX_KEY_KP_5",           "BX_KEY_UP",
  65   "BX_KEY_DOWN",           "BX_KEY_LEFT",           "BX_KEY_RIGHT",
  66   "BX_KEY_KP_ENTER",       "BX_KEY_KP_MULTIPLY",    "BX_KEY_KP_DIVIDE",
  67   "BX_KEY_WIN_L",          "BX_KEY_WIN_R",          "BX_KEY_MENU",
  68   "BX_KEY_ALT_SYSREQ",     "BX_KEY_CTRL_BREAK",     "BX_KEY_INT_BACK",
  69   "BX_KEY_INT_FORWARD",    "BX_KEY_INT_STOP",       "BX_KEY_INT_MAIL",
  70   "BX_KEY_INT_SEARCH",     "BX_KEY_INT_FAV",        "BX_KEY_INT_HOME",
  71   "BX_KEY_POWER_MYCOMP",   "BX_KEY_POWER_CALC",     "BX_KEY_POWER_SLEEP",
  72   "BX_KEY_POWER_POWER",    "BX_KEY_POWER_WAKE",
  73 };
  74
  75 bx_keymap_c bx_keymap;
  76
  77 #define LOG_THIS bx_keymap.
  78
  79 bx_keymap_c::bx_keymap_c(void)
  80 {
  81     put("KMAP");
  82
  83     keymapCount = 0;
  84     keymapTable = (BXKeyEntry *)NULL;
  85 }
  86
  87 bx_keymap_c::~bx_keymap_c(void)
  88 {
  89     if(keymapTable != NULL) {
  90       free(keymapTable);
  91       keymapTable = (BXKeyEntry *)NULL;
  92     }
  93     keymapCount = 0;
  94 }
  95
  96 void bx_keymap_c::loadKeymap(Bit32u stringToSymbol(const char*))
  97 {
  98   if (SIM->get_param_bool(BXPN_KBD_USEMAPPING)->get()) {
  99     loadKeymap(stringToSymbol, SIM->get_param_string(BXPN_KBD_KEYMAP)->getptr());
 100   }
 101 }
 102
 103 bx_bool bx_keymap_c::isKeymapLoaded ()
 104 {
 105   return (keymapCount > 0);
 106 }
 107
 108
 109 ///////////////////
 110 // I'll add these to the keymap object in a minute.
 111 static unsigned char *lineptr = NULL;
 112 static int lineCount;
 113
 114 static void init_parse()
 115 {
 116   lineCount = 0;
 117 }
 118
 119 static void init_parse_line(char *line_to_parse)
 120 {
 121   // chop off newline
 122   lineptr = (unsigned char *)line_to_parse;
 123   char *nl;
 124   if ((nl = strchr(line_to_parse,'\n')) != NULL) {
 125     *nl = 0;
 126   }
 127 }
 128
 129 static Bit32s get_next_word(char *output)
 130 {
 131   char *copyp = output;
 132   // find first nonspace
 133   while (*lineptr && isspace(*lineptr))
 134     lineptr++;
 135   if (!*lineptr)
 136     return -1;  // nothing but spaces until end of line
 137   if (*lineptr == '#')
 138     return -1;  // nothing but a comment
 139   // copy nonspaces into the output
 140   while (*lineptr && !isspace(*lineptr))
 141     *copyp++ = *lineptr++;
 142   *copyp=0;  // null terminate the copy
 143   // there must be at least one nonspace, since that's why we stopped the
 144   // first loop!
 145   BX_ASSERT (copyp != output);
 146   return 0;
 147 }
 148
 149 static Bit32s get_next_keymap_line (FILE *fp, char *bxsym, char *modsym, Bit32s *ascii, char *hostsym)
 150 {
 151   char line[256];
 152   char buf[256];
 153   line[0] = 0;
 154   while (1) {
 155     lineCount++;
 156     if (!fgets(line, sizeof(line)-1, fp)) return -1;  // EOF
 157     init_parse_line (line);
 158     if (get_next_word (bxsym) >= 0) {
 159       modsym[0] = 0;
 160       char *p;
 161       if ((p = strchr (bxsym, '+')) != NULL) {
 162         *p = 0;  // truncate bxsym.
 163         p++;  // move one char beyond the +
 164         strcpy (modsym, p);  // copy the rest to modsym
 165       }
 166       if (get_next_word (buf) < 0) {
 167         BX_PANIC (("keymap line %d: expected 3 columns", lineCount));
 168         return -1;
 169       }
 170       if (buf[0] == '\'' && buf[2] == '\'' && buf[3]==0) {
 171         *ascii = (Bit8u) buf[1];
 172       } else if (!strcmp(buf, "space")) {
 173         *ascii = ' ';
 174       } else if (!strcmp(buf, "return")) {
 175         *ascii = '\n';
 176       } else if (!strcmp(buf, "tab")) {
 177         *ascii = '\t';
 178       } else if (!strcmp(buf, "backslash")) {
 179         *ascii = '\\';
 180       } else if (!strcmp(buf, "apostrophe")) {
 181         *ascii = '\'';
 182       } else if (!strcmp(buf, "none")) {
 183         *ascii = -1;
 184       } else {
 185         BX_PANIC (("keymap line %d: ascii equivalent is \"%s\" but it must be char constant like 'x', or one of space,tab,return,none", lineCount, buf));
 186       }
 187       if (get_next_word (hostsym) < 0) {
 188         BX_PANIC (("keymap line %d: expected 3 columns", lineCount));
 189         return -1;
 190       }
 191       return 0;
 192     }
 193     // no words on this line, keep reading.
 194   }
 195 }
 196
 197 void bx_keymap_c::loadKeymap(Bit32u stringToSymbol(const char*), const char* filename)
 198 {
 199   FILE   *keymapFile;
 200   char baseSym[256], modSym[256], hostSym[256];
 201   Bit32s ascii = 0;
 202   Bit32u baseKey, modKey, hostKey;
 203   struct stat status;
 204
 205   if (stat(filename, &status)) {
 206     BX_PANIC(("Can not stat keymap file '%s'.",filename));
 207   }
 208
 209   if (!(S_ISREG(status.st_mode))) {
 210     BX_PANIC(("Keymap file '%s' is not a file",filename));
 211   }
 212
 213   if((keymapFile = fopen(filename,"r"))==NULL) {
 214     BX_PANIC(("Can not open keymap file '%s'.",filename));
 215   }
 216
 217   BX_INFO(("Loading keymap from '%s'",filename));
 218   init_parse();
 219
 220   // Read keymap file one line at a time
 221   while(1) {
 222     if (get_next_keymap_line (keymapFile,
 223           baseSym, modSym, &ascii, hostSym) < 0) { break; }
 224
 225     // convert X_KEY_* symbols to values
 226     baseKey = convertStringToBXKey(baseSym);
 227     modKey = convertStringToBXKey(modSym);
 228     hostKey = 0;
 229     if (stringToSymbol != NULL)
 230       hostKey = stringToSymbol(hostSym);
 231
 232     BX_DEBUG(("baseKey='%s' (%d), modSym='%s' (%d), ascii=%d, guisym='%s' (%d)", baseSym, baseKey, modSym, modKey, ascii, hostSym, hostKey));
 233
 234     // Check if data is valid
 235     if (baseKey==BX_KEYMAP_UNKNOWN) {
 236       BX_PANIC (("line %d: unknown BX_KEY constant '%s'",lineCount,baseSym));
 237       continue;
 238     }
 239
 240     if (hostKey==BX_KEYMAP_UNKNOWN) {
 241       BX_PANIC (("line %d: unknown host key name '%s' (wrong keymap ?)",lineCount,hostSym));
 242       continue;
 243     }
 244
 245     keymapTable=(BXKeyEntry*)realloc(keymapTable,(keymapCount+1) * sizeof(BXKeyEntry));
 246
 247     if (keymapTable==NULL)
 248       BX_PANIC(("Can not allocate memory for keymap table."));
 249
 250     keymapTable[keymapCount].baseKey=baseKey;
 251     keymapTable[keymapCount].modKey=modKey;
 252     keymapTable[keymapCount].ascii=ascii;
 253     keymapTable[keymapCount].hostKey=hostKey;
 254
 255     keymapCount++;
 256   }
 257
 258   BX_INFO(("Loaded %d symbols",keymapCount));
 259
 260   fclose(keymapFile);
 261 }
 262
 263 Bit32u bx_keymap_c::convertStringToBXKey(const char* string)
 264 {
 265   // We look through the bx_key_symbol table to find the searched string
 266   for (Bit16u i=0; i<BX_KEY_NBKEYS; i++) {
 267     if (strcmp(string,bx_key_symbol[i])==0) {
 268       return i;
 269     }
 270   }
 271
 272   // Key is not known
 273   return BX_KEYMAP_UNKNOWN;
 274 }
 275
 276 BXKeyEntry *bx_keymap_c::findHostKey(Bit32u key)
 277 {
 278   // We look through the keymap table to find the searched key
 279   for (Bit16u i=0; i<keymapCount; i++) {
 280     if (keymapTable[i].hostKey == key) {
 281       BX_DEBUG (("key 0x%02x matches hostKey for entry #%d", key, i));
 282       return &keymapTable[i];
 283     }
 284   }
 285   BX_DEBUG(("key %02x matches no entries", key));
 286
 287   // Return default
 288   return NULL;
 289 }
 290
 291 BXKeyEntry *bx_keymap_c::findAsciiChar(Bit8u ch)
 292 {
 293   BX_DEBUG (("findAsciiChar (0x%02x)", ch));
 294
 295   // We look through the keymap table to find the searched key
 296   for (Bit16u i=0; i<keymapCount; i++) {
 297     if (keymapTable[i].ascii == ch) {
 298       BX_DEBUG (("key %02x matches ascii for entry #%d", ch, i));
 299       return &keymapTable[i];
 300     }
 301   }
 302   BX_DEBUG (("key 0x%02x matches no entries", ch));
 303
 304   // Return default
 305   return NULL;
 306 }
 307
 308 const char *bx_keymap_c::getBXKeyName(Bit32u key)
 309 {
 310   return bx_key_symbol[key & 0x7fffffff];
 311 }