Back to index

im-sdk  12.3.91
Public Member Functions | Private Member Functions | Private Attributes
IMKeyParser Class Reference

#include <IMKeyUtils.hh>

List of all members.

Public Member Functions

std::string generate_key (IMKeySpec &spec)
IMKeySpecListget_parsedkeys ()
 IMKeyParser (const char *strings)
 ~IMKeyParser ()

Private Member Functions

void parse_key (std::string &s)

Private Attributes

IMKeySpecList keys

Detailed Description

Definition at line 73 of file IMKeyUtils.hh.


Constructor & Destructor Documentation

IMKeyParser::IMKeyParser ( const char *  strings)

Definition at line 63 of file IMKeyUtils.cpp.

{
       char *ptop, *pend;
       IMKeySpec *key;
       std::string s;

       ptop = (char *) strings;
       while (ptop) {
              if ((pend = strchr(ptop, ',')) != NULL) {
                     s.assign(ptop, pend - ptop);
                     ptop = pend + 1;
              } else {
                     s.assign(ptop);
                     ptop = NULL;
              }
                parse_key(s);
       }
}

Here is the call graph for this function:

Definition at line 83 of file IMKeyUtils.hh.

{};

Member Function Documentation

std::string IMKeyParser::generate_key ( IMKeySpec spec)

Definition at line 146 of file IMKeyUtils.cpp.

{
       int keycode = spec.get_keycode();
       int modifier = spec.get_modifier();
       std::string key;
       static struct {
              const char *symbol;
              int modifier;
       } modifiers[] = {
              {"Shift", 1}, {"Control", 2}, {"Alt", 4}, {NULL, 0}
       };
#include "keysyms.h"

       for (int i = 0; modifiers[i].symbol != NULL; i++) {
              if (modifier & modifiers[i].modifier) {
                     key += std::string("<") + std::string(modifiers[i].symbol) + std::string(">");
              }
       }
       for (int j = 0; keysymtable[j].keyname != NULL; j++) {
              if (keysymtable[j].keysym == keycode) {
                     key += std::string(keysymtable[j].keyname);
                     return key;
              }
       }
       key = "";

       return key;
}

Here is the call graph for this function:

Definition at line 80 of file IMKeyUtils.hh.

              { return keys; }
void IMKeyParser::parse_key ( std::string &  s) [private]

Definition at line 83 of file IMKeyUtils.cpp.

{
       std::string token, mtoken;
       int j, pos, size, mod = 0;
       static struct {
              const char *symbol;
              int modifier;
       } modifiers[] = {
              {"shift", 1}, {"sh", 1}, {"s", 1},
              {"control", 2}, {"ctrl", 2}, {"c", 2},
              {"alt", 4},
              {NULL, 0},
       };
#include "keysyms.h"

       size = s.size();
       for (j = 0; j < size; j++) {
              if (s[j] == '<') {
                     pos = s.find('>', j + 1);
                     if (pos > j) {
                            mtoken = s.substr(j + 1, pos - j - 1);
                            for (int i = 0; modifiers[i].symbol != NULL; i++) {
                                   if (!strcasecmp(modifiers[i].symbol, mtoken.c_str())) {
                                          mod |= modifiers[i].modifier;
                                          j = pos;
                                   }
                            }
                            if (pos > j) {
                                   LOG_DEBUG("unknown modifier symbol: %s\n", mtoken.c_str());
                            }
                     }
              } else {
                     if (token.size() > 0) {
                            LOG_DEBUG("duplicated key definition. ignoring a previous key(%s)\n", token.c_str());
                     }
                     pos = s.find('<', j + 1);
                     if (pos > j) {
                            token = s.substr(j, pos - j);
                            j = pos - 1;
                     } else {
                            token = s.substr(j);
                            break;
                     }
              }
       }
       if (token.size() > 0) {
              for (j = 0; keysymtable[j].keyname != NULL; j++) {
                     if (!strcasecmp (keysymtable[j].keyname, token.c_str())) {
                            /* FIXME: xkb's keycode and IIIMF's keycode seems different. */
                                keys.push_back(IMKeySpec(keysymtable[j].keysym,
                                               keysymtable[j].keysym,
                                               mod,
                                               0));
                                return;
                     }
              }
              LOG_DEBUG("cannot parse the unknown key(%s)\n", token.c_str());
       }

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Definition at line 75 of file IMKeyUtils.hh.


The documentation for this class was generated from the following files: