Logo Search packages:      
Sourcecode: xblast-tnt version File versions  Download package

w32_keysym.c

/*
 * file w32_keysym.c - create X11 like keysmbol names for virtual keys
 * 
 * $Id: w32_keysym.c,v 1.2 2004/05/14 10:00:35 alfie Exp $
 *
 * Program XBLAST 
 * (C) by Oliver Vogel (e-mail: m.vogel@ndh.net)
 *
 * 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 2; or (at your option)
 * any later version
 *
 * This program is distributed in the hope that it will be entertaining,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILTY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.
 * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "w32_keysym.h"
#include "gui.h"

/*
 * local types
 */
typedef struct {
  UINT        code;
  const char *name;
} KeyNameTable;

typedef struct {
  ATOM atom;
  UINT code;
} AtomCodeTable;

/*
 * local variables
 */
static int numKeys              = 0;
static AtomCodeTable *atomTable = NULL;
static AtomCodeTable *codeTable = NULL;
static KeyNameTable keyTable[]  = {
  { VK_BACK,      "BackSpace" },
  { VK_TAB,       "Tab" },
  { VK_RETURN,    "Return" },
  { VK_SHIFT,     "Shift" },
  { VK_CONTROL,   "Control" },
  { VK_PAUSE,     "Pause" },
  { VK_CAPITAL,   "Caps_Lock" },
  { VK_ESCAPE,    "Escape" },
  { VK_SPACE,     "space" },
  { VK_PRIOR,     "Prior" },
  { VK_NEXT,      "Next" },
  { VK_END,       "End" },
  { VK_HOME,      "Home" },
  { VK_LEFT,      "Left" },
  { VK_UP,        "Up" },
  { VK_RIGHT,     "Right" },
  { VK_DOWN,      "Down" },
  { VK_PRINT,     "Print" },
  { VK_INSERT,    "Insert" },
  { VK_DELETE,    "Delete" },
  { '0',      "0" },
  { '1',      "1" },
  { '2',      "2" },
  { '3',      "3" },
  { '4',      "4" },
  { '5',      "5" },
  { '6',      "6" },
  { '7',      "7" },
  { '8',      "8" },
  { '9',      "9" },
  { 'A',      "A" },
  { 'B',      "B" },
  { 'C',      "C" },
  { 'D',      "D" },
  { 'E',      "E" },
  { 'F',      "F" },
  { 'G',      "G" },
  { 'H',      "H" },
  { 'I',      "I" },
  { 'J',      "J" },
  { 'K',      "K" },
  { 'L',      "L" },
  { 'M',      "M" },
  { 'N',      "N" },
  { 'O',      "O" },
  { 'P',      "P" },
  { 'Q',      "Q" },
  { 'R',      "R" },
  { 'S',      "S" },
  { 'T',      "T" },
  { 'U',      "U" },
  { 'V',      "V" },
  { 'W',      "W" },
  { 'X',      "X" },
  { 'Y',      "Y" },
  { 'Z',      "Z" },
  { VK_NUMPAD0,   "KP_0" },
  { VK_NUMPAD1,   "KP_1" },
  { VK_NUMPAD2,   "KP_2" },
  { VK_NUMPAD3,   "KP_3" },
  { VK_NUMPAD4,   "KP_4" },
  { VK_NUMPAD5,   "KP_5" },
  { VK_NUMPAD6,   "KP_6" },
  { VK_NUMPAD7,   "KP_7" },
  { VK_NUMPAD8,   "KP_8" },
  { VK_NUMPAD9,   "KP_9" },
  { VK_MULTIPLY,  "KP_Multiply" },
  { VK_ADD,       "KP_Add" },
  { VK_SUBTRACT,  "KP_Subtract" },
  { VK_DECIMAL,   "KP_Decimal" },
  { VK_DIVIDE,    "KP_Divide" },
  { VK_F1,        "F1" },
  { VK_F2,        "F2" },
  { VK_F3,        "F3" },
  { VK_F4,        "F4" },
  { VK_F5,        "F5" },
  { VK_F6,        "F6" },
  { VK_F7,        "F7" },
  { VK_F8,        "F8" },
  { VK_F9,        "F9" },
  { VK_F10,       "F10" },
  { VK_F11,       "F11" },
  { VK_F12,       "F12" },
  { VK_F13,       "F13" },
  { VK_F14,       "F14" },
  { VK_F15,       "F15" },
  { VK_F16,       "F16" },
  { VK_F17,       "F17" },
  { VK_F18,       "F18" },
  { VK_F19,       "F19" },
  { VK_F20,       "F20" },
  { VK_F21,       "F21" },
  { VK_F22,       "F22" },
  { VK_F23,       "F23" },
  { VK_F24,       "F24" },
  /* terminator */
  { 0,            NULL },
};

/*
 * compare by code
 */
static int
CompareByCode (const void *a, const void *b)
{
  return ((AtomCodeTable *) a)->code - ((AtomCodeTable *) b)->code;
} /* CompareByCode */

/*
 * compare by atom
 */
static int
CompareByAtom (const void *a, const void *b)
{
  return ((AtomCodeTable *) a)->atom - ((AtomCodeTable *) b)->atom;
} /* CompareByAtom */

/*
 * init keysyms
 */
XBBool
InitKeysym (void)
{
  int i;

  /* count keys */
  for (numKeys = 0; keyTable[numKeys].name != NULL; numKeys ++) continue;
  /* alloc tables */
  atomTable = calloc (numKeys, sizeof (AtomCodeTable));
  assert (NULL != atomTable);
  codeTable = calloc (numKeys, sizeof (AtomCodeTable));
  assert (NULL != codeTable);
  /* fill tables */
  for (i = 0; i < numKeys; i ++) {
    XBAtom atom = GUI_StringToAtom (keyTable[i].name);
    atomTable[i].code = codeTable[i].code = keyTable[i].code;
    atomTable[i].atom = codeTable[i].atom = atom;
  }
  /* sort tables */
  qsort (atomTable, numKeys, sizeof (AtomCodeTable), CompareByAtom);
  qsort (codeTable, numKeys, sizeof (AtomCodeTable), CompareByCode);
  /* that's all */
  return XBTrue;
} /* InitKeysym */

/*
 *
 */
void
FinishKeysym (void)
{
  if (NULL != atomTable) {
    free (atomTable);
    atomTable = NULL;
  }
  if (NULL != codeTable) {
    free (codeTable);
    codeTable = NULL;
  }
} /* FinishKeysym */

/*
 * convert string to keycode
 */ 
UINT
StringToVirtualKey (const char *name)
{
  AtomCodeTable key;
  AtomCodeTable *result;
  XBAtom atom;
  
  atom     = GUI_StringToAtom (name);
  key.atom = atom;
  result   = bsearch (&key, atomTable, numKeys, sizeof (AtomCodeTable), CompareByAtom);
  if (NULL == result) {
    return 0;
  }
  return result->code;
} /* StringToVirtualKey */

/*
 * convert keycode to string
 */ 
XBAtom
VirtualKeyToAtom (UINT code)
{
  AtomCodeTable key;
  AtomCodeTable *result;
  XBAtom atom;

  key.code = code;
  result   = bsearch (&key, codeTable, numKeys, sizeof (AtomCodeTable), CompareByCode);
  if (NULL == result) {
    return ATOM_INVALID;
  }
  atom = result->atom;
  return atom;
} /* StringToVirtualKey */

/*
 * end of file w32_keysym.c
 */

Generated by  Doxygen 1.6.0   Back to index