KeyMap.cpp

Go to the documentation of this file.

/*
 * KeyMap.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy 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 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY 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 Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../Include/KeyMap.h"
#include "../Include/Utility.h"
#include "../Include/Globals.h"
#include "../Include/Ui.h"

using namespace std;


//
// CKeyDefinition
//
CKeyDefinition::CKeyDefinition (void)
: kyid (0), code (0), user (true), enab (true), cb (NULL)
{
  strcpy (name, "");
}

int CKeyDefinition::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'kyid':
    // Key unique ID
    ReadTag (&kyid, stream);
    rc = TAG_READ;
    break;

  case 'name':
    // Key name
    ReadString (name, 64, stream);
    rc = TAG_READ;
    break;

  case 'code':
    // Key code and modifier
    ReadInt (&code, stream);
    rc = TAG_READ;
    break;

  case 'user':
    // User-mappable?
    {
      int i;
      ReadInt (&i, stream);
      user = (i != 0);
    }
    rc = TAG_READ;
    break;

  case 'enab':
    // Enabled?
    {
      int i;
      ReadInt (&i, stream);
      enab = (i != 0);
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CKeyDefinition::Read : Unknown tag %s", s);
  }
  
  return rc;
}

char* CKeyDefinition::GetName (void)
{
  return name;
}

int CKeyDefinition::GetCode (void)
{
  return code;
}


//
// CKeySet
//
CKeySet::CKeySet (Tag tag)
: kset (tag), user (true), enab (true)
{
  strcpy (name, "");
}

CKeySet::~CKeySet (void)
{
  // Delete key definitions
  map<Tag,CKeyDefinition*>::iterator i;
  for (i=kkey.begin(); i!=kkey.end(); i++) {
    delete i->second;
  }
}

int CKeySet::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'name':
    // Key set name
    ReadString (name, 64, stream);
    rc = TAG_READ;
    break;

  case 'user':
    // Are keys in this key set user-mappable?
    {
      int i;
      ReadInt (&i, stream);
      user = (i != 0);
    }
    rc = TAG_READ;
    break;

  case 'enab':
    // Is this key set enabled?
    {
      int i;
      ReadInt (&i, stream);
      enab = (i != 0);
    }
    rc = TAG_READ;
    break;

  case 'kkey':
    // Key definition sub-object
    {
      CKeyDefinition *kkeyObj = new CKeyDefinition;
      ReadFrom (kkeyObj, stream);
      kkey[kkeyObj->kyid] = kkeyObj;
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CKeySet::Read : Unknown tag %s", s);
  }

  return rc;
}

char* CKeySet::GetName (void)
{
  return name;
}

bool CKeySet::GetUserModifiableState (void)
{
  return user;
}

bool CKeySet::GetEnabledState (void)
{
  return enab;
}

int CKeySet::GetNumKeyDefinitions (void)
{
  return kkey.size();
}


CKeyDefinition* CKeySet::GetKeyDefinition (int i)
{
  CKeyDefinition *rc = NULL;

  if (i <= GetNumKeyDefinitions()) {
    map<Tag,CKeyDefinition*>::iterator iter = kkey.begin();
    for (int count=i; count>0; count--, iter++);
    rc = iter->second;
  }

  return rc;
}


//
// CKeyMap
//
CKeyMap::CKeyMap (const char* keyFilename)
: vers (0)
{
  SStream *s = new SStream;
  strcpy (s->filename, keyFilename);
  strcpy (s->mode, "r");
  OpenStream (s);
  if (s->stream) {
    ReadFrom (this, s);
  } else {
    gtfo ("ERROR : Could not read key mappings from System\\Default.key");
  }
  CloseStream (s);
  delete s;
}

CKeyMap::~CKeyMap (void)
{
  // Delete key sets
  map<Tag,CKeySet*>::iterator i;
  for (i=kset.begin(); i!=kset.end(); i++) {
    delete i->second;
  }
}

int CKeyMap::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'vers':
    // Version
    ReadInt (&vers, stream);
    rc = TAG_READ;
    break;

  case 'kset':
    // KeySet sub-object
    {
      Tag ksetTag;
      ReadTag (&ksetTag, stream);
      CKeySet *ksetObj = new CKeySet (ksetTag);
      ReadFrom (ksetObj, stream);
      kset[ksetObj->kset] = ksetObj;
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CKeyMap::Read : Unknown tag %s", s);
  }

  return rc;
}

typedef struct {
  EKeyboardKeys kbkey;
  char      *name;
} SKeyCodeFormatEntry;

static SKeyCodeFormatEntry keyCodeFormatTable[] =
{
  { KB_KEY_ESC,                   "Esc" },
  { KB_KEY_1,                     "1" },
  { KB_KEY_2,                     "2" },
  { KB_KEY_3,                     "3" },
  { KB_KEY_4,                     "4" },
  { KB_KEY_5,                     "5" },
  { KB_KEY_6,                     "6" },
  { KB_KEY_7,                     "7" },
  { KB_KEY_8,                     "8" },
  { KB_KEY_9,                     "9" },
  { KB_KEY_0,                     "0" },
  { KB_KEY_MINUS,                 "-" },
  { KB_KEY_EQUALS,                "=" },
  { KB_KEY_BACKSPACE,             "Backspace" },
  { KB_KEY_TAB,                   "Tab" },
  { KB_KEY_Q,                     "Q" },
  { KB_KEY_W,                     "W" },
  { KB_KEY_E,                     "E" },
  { KB_KEY_R,                     "R" },
  { KB_KEY_T,                     "T" },
  { KB_KEY_Y,                     "Y" },
  { KB_KEY_U,                     "U" },
  { KB_KEY_I,                     "I" },
  { KB_KEY_O,                     "O" },
  { KB_KEY_P,                     "P" },
  { KB_KEY_FORWARD_BRACKET,       "]" },
  { KB_KEY_REVERSE_BRACKET,       "[" },
  { KB_KEY_ENTER,                 "Enter" },
  { KB_KEY_LCTRL,                 "LeftCtrl" },
  { KB_KEY_A,                     "A" },
  { KB_KEY_S,                     "S" },
  { KB_KEY_D,                     "D" },
  { KB_KEY_F,                     "F" },
  { KB_KEY_G,                     "G" },
  { KB_KEY_H,                     "H" },
  { KB_KEY_J,                     "J" },
  { KB_KEY_K,                     "K" },
  { KB_KEY_L,                     "L" },
  { KB_KEY_SEMI_COLON,            ";" },
  { KB_KEY_SINGLE_QUOTE,          "'" },
  { KB_KEY_REVERSE_SINGLE_QUOTE,  "`" },
  { KB_KEY_LSHIFT,                "LeftShift" },
  { KB_KEY_BACKSLASH,             "\\" },
  { KB_KEY_Z,                     "Z" },
  { KB_KEY_X,                     "X" },
  { KB_KEY_C,                     "C" },
  { KB_KEY_V,                     "V" },
  { KB_KEY_B,                     "B" },
  { KB_KEY_N,                     "N" },
  { KB_KEY_M,                     "M" },
  { KB_KEY_COMMA,                 "," },
  { KB_KEY_PERIOD,                "." },
  { KB_KEY_SLASH,                 "/" },
  { KB_KEY_RSHIFT,                "RightShift" },
  { KB_KEY_STAR,                  "Star" },
  { KB_KEY_LALT,                  "LeftAlt" },
  { KB_KEY_SPACE,                 "Space" },
  { KB_KEY_CAPSLOCK,              "CapsLock" },
  { KB_KEY_F1,                    "F1" },
  { KB_KEY_F2,                    "F2" },
  { KB_KEY_F3,                    "F3" },
  { KB_KEY_F4,                    "F4" },
  { KB_KEY_F5,                    "F5" },
  { KB_KEY_F6,                    "F6" },
  { KB_KEY_F7,                    "F7" },
  { KB_KEY_F8,                    "F8" },
  { KB_KEY_F9,                    "F9" },
  { KB_KEY_F10,                   "F10" },
  { KB_KEY_NUMLOCK,               "NumLock" },
  { KB_KEY_SCROLLLOCK,            "ScrollLock" },
  { KB_KEY_HOME,                  "KeypadHome" },
  { KB_KEY_UP,                    "KeypadUpArrow" },
  { KB_KEY_PGUP,                  "KeypadPageUp" },
  { KB_KEY_KEYPAD_MINUS,          "KeypadMinus" },
  { KB_KEY_LEFT,                  "KeypadLeftArrow" },
  { KB_KEY_CENTER,                "KeypadCenter" },
  { KB_KEY_RIGHT,                 "KeypadRightArrow" },
  { KB_KEY_KEYPAD_PLUS,           "KeypadPlus" },
  { KB_KEY_END,                   "KeypadEnd" },
  { KB_KEY_DOWN,                  "KeypadDownArrow" },
  { KB_KEY_PGDN,                  "KeypadPageDown" },
  { KB_KEY_INSERT,                "KeypadIns" },
  { KB_KEY_DEL,                   "KeypadDel" },
  { KB_KEY_F11,                   "F11" },
  { KB_KEY_F12,                   "F12" },
  { KB_KEY_KEYPAD_ENTER,          "KeypadEnter" },
  { KB_KEY_RCTRL,                 "RightCtrl" },
  { KB_KEY_KEYPAD_SLASH,          "KeypadSlash" },
  { KB_KEY_RALT,                  "RightAlt" },
  { KB_KEY_EXT_NUMLOCK,           "ExtNumLock" },
  { KB_KEY_GRAY_HOME,             "GrayHome" },
  { KB_KEY_GRAY_UP,               "GrayUpArrow" },
  { KB_KEY_GRAY_PGUP,             "GrayPageUp" },
  { KB_KEY_GRAY_LEFT,             "GrayLeftArrow" },
  { KB_KEY_GRAY_RIGHT,            "GrayRightArrow" },
  { KB_KEY_GRAY_END,              "GrayEnd" },
  { KB_KEY_GRAY_DOWN,             "GrayDownArrow" },
  { KB_KEY_GRAY_PGDN,             "GrayPageDown" },
  { KB_KEY_GRAY_INS,              "GrayIns" },
  { KB_KEY_GRAY_DEL,              "GrayDel" },
  { KB_KEY_META,                  "Meta" }
};


void formatKeyCode (char *s, int code)
{
  strcpy (s, "");

  // Format modifiers
  int iMod = (code & 0xFFFF0000) >> 16;
  if (iMod & KB_MODIFIER_CTRL) strcat (s, "Ctrl ");
  if (iMod & KB_MODIFIER_ALT)  strcat (s, "Alt ");
  if (iMod & KB_MODIFIER_SHIFT) strcat (s, "Shift ");
  if (iMod & KB_MODIFIER_META)  strcat (s, "Meta ");

  int nKeys = sizeof(keyCodeFormatTable) / sizeof(SKeyCodeFormatEntry);
  int kbkey = (code & 0x0000FFFF);
  for (int i=0; i<nKeys; i++) {
    SKeyCodeFormatEntry *p = &keyCodeFormatTable[i];
    if (p->kbkey == kbkey) {
      strcat (s, p->name);
      break;
    }
  }
  return;
}


void CKeyMap::Print (FILE* f)
{
  // Iterate over keysets
  map<Tag,CKeySet*>::iterator i;
  for (i=kset.begin(); i!=kset.end(); i++) {
    CKeySet *pKeySet = i->second;

    // Format key set unique ID
    char s[16];
    TagToString (s, pKeySet->kset);
    fprintf (f, "KeySet '%s' %s\n", s, pKeySet->name);

    // Iterate over key definitions within the keyset
    map<Tag,CKeyDefinition*>::iterator j;
    for (j=pKeySet->kkey.begin(); j!=pKeySet->kkey.end(); j++) {
      CKeyDefinition *pKeyDef = j->second;

      // Format key definition unique ID
      char sId[16];
      TagToString (sId, pKeyDef->kyid);

      // Format key code
      char sCode[32];
      formatKeyCode (sCode, pKeyDef->code);

      fprintf (f, "  '%s' %-40s  %s\n", sId, pKeyDef->name, sCode);
    }
  }
}


CKeyDefinition* CKeyMap::FindKeyDefinitionById (Tag id)
{
  CKeyDefinition *rc = NULL;

  map<Tag,CKeySet*>::iterator i;
  for (i=kset.begin(); i!=kset.end(); i++) {
    CKeySet *pKeySet = i->second;

    // Search for key definition in this keyset
    map<Tag,CKeyDefinition*>::iterator j = pKeySet->kkey.find(id);
    if (j != pKeySet->kkey.end()) {
      // Found a match
      rc = j->second;
    }
  }

  return rc;
}


void CKeyMap::Bind (Tag id, KeyCallbackPtr f)
{
  CKeyDefinition *def = FindKeyDefinitionById (id);
  if (def) def->cb = f;
}


void CKeyMap::KeyPress (EKeyboardKeys key, EKeyboardModifiers mod)
{
  // Translate key and modifier into keycode
  int code = (mod << 16) + key;


  bool handled = false;
  map<Tag,CKeySet*>::iterator i;
  for (i=kset.begin(); i!=kset.end() && !handled; i++) {
    CKeySet *pKeySet = i->second;

    map<Tag,CKeyDefinition*>::iterator j;
    for (j=pKeySet->kkey.begin(); j!=pKeySet->kkey.end() && !handled; j++) {
      CKeyDefinition *pKeyDef = j->second;

      if (pKeyDef->code == code) {
        // Found a match; call its callback which will return true if
        //   the key is consumed
        if (pKeyDef->cb) {
          handled = pKeyDef->cb (pKeyDef->kyid, key, mod);
        }
      }
    }
  }
}


int CKeyMap::GetNumKeySets (void)
{
  return kset.size();
}


CKeySet* CKeyMap::GetKeySet (int i)
{
  CKeySet *rc = NULL;

  if (i <= GetNumKeySets()) {
    map<Tag,CKeySet*>::iterator iter = kset.begin();
    for (int count=i; count > 0; count--, iter++);
    rc = iter->second;
  }

  return rc;
}

Documentation generated by