keymap.h

   1 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
   2 // keymap.h\r
   3 \r
   4 \r
   5 #ifndef _KEYMAP_H\r
   6 #  define _KEYMAP_H\r
   7 \r
   8 #  include "keyboard.h"\r
   9 #  include "function.h"\r
  10 #  include <vector>\r
  11 \r
  12 \r
  13 ///\r
  14 class Action\r
  15 {\r
  16 public:\r
  17         ///\r
  18         enum Type {\r
  19                 Type_key,                                       ///\r
  20                 Type_keySeq,                            ///\r
  21                 Type_function,                          ///\r
  22         };\r
  23 \r
  24 private:\r
  25         Action(const Action &i_action);\r
  26 \r
  27 public:\r
  28         Action() { }\r
  29         ///\r
  30         virtual ~Action() { }\r
  31         ///\r
  32         virtual Type getType() const = 0;\r
  33         /// create clone\r
  34         virtual Action *clone() const = 0;\r
  35         /// stream output\r
  36         virtual tostream &output(tostream &i_ost) const = 0;\r
  37 };\r
  38 \r
  39 ///\r
  40 tostream &operator<<(tostream &i_ost, const Action &i_action);\r
  41 \r
  42 ///\r
  43 class ActionKey : public Action\r
  44 {\r
  45 public:\r
  46         ///\r
  47         const ModifiedKey m_modifiedKey;\r
  48 \r
  49 private:\r
  50         ActionKey(const ActionKey &i_actionKey);\r
  51 \r
  52 public:\r
  53         ///\r
  54         ActionKey(const ModifiedKey &i_mk);\r
  55         ///\r
  56         virtual Type getType() const;\r
  57         /// create clone\r
  58         virtual Action *clone() const;\r
  59         /// stream output\r
  60         virtual tostream &output(tostream &i_ost) const;\r
  61 };\r
  62 \r
  63 \r
  64 class KeySeq;\r
  65 ///\r
  66 class ActionKeySeq : public Action\r
  67 {\r
  68 public:\r
  69         KeySeq * const m_keySeq;                        ///\r
  70 \r
  71 private:\r
  72         ActionKeySeq(const ActionKeySeq &i_actionKeySeq);\r
  73 \r
  74 public:\r
  75         ///\r
  76         ActionKeySeq(KeySeq *i_keySeq);\r
  77         ///\r
  78         virtual Type getType() const;\r
  79         /// create clone\r
  80         virtual Action *clone() const;\r
  81         /// stream output\r
  82         virtual tostream &output(tostream &i_ost) const;\r
  83 };\r
  84 \r
  85 \r
  86 ///\r
  87 class ActionFunction : public Action\r
  88 {\r
  89 public:\r
  90         FunctionData * const m_functionData;            /// function data\r
  91         const Modifier m_modifier;                      /// modifier for &Sync\r
  92 \r
  93 private:\r
  94         ActionFunction(const ActionFunction &i_actionFunction);\r
  95 \r
  96 public:\r
  97         ///\r
  98         ActionFunction(FunctionData *i_functionData,\r
  99                                    Modifier i_modifier = Modifier());\r
 100         ///\r
 101         virtual ~ActionFunction();\r
 102         ///\r
 103         virtual Type getType() const;\r
 104         /// create clone\r
 105         virtual Action *clone() const;\r
 106         /// stream output\r
 107         virtual tostream &output(tostream &i_ost) const;\r
 108 };\r
 109 \r
 110 \r
 111 ///\r
 112 class KeySeq\r
 113 {\r
 114 public:\r
 115         typedef std::vector<Action *> Actions;  ///\r
 116 \r
 117 private:\r
 118         Actions m_actions;                              ///\r
 119         tstringi m_name;                                ///\r
 120         Modifier::Type m_mode;                  /** Either Modifier::Type_KEYSEQ\r
 121                                                     or Modifier::Type_ASSIGN */\r
 122 \r
 123 private:\r
 124         ///\r
 125         void copy();\r
 126         ///\r
 127         void clear();\r
 128 \r
 129 public:\r
 130         ///\r
 131         KeySeq(const tstringi &i_name);\r
 132         ///\r
 133         KeySeq(const KeySeq &i_ks);\r
 134         ///\r
 135         ~KeySeq();\r
 136 \r
 137         ///\r
 138         const Actions &getActions() const {\r
 139                 return m_actions;\r
 140         }\r
 141 \r
 142         ///\r
 143         KeySeq &operator=(const KeySeq &i_ks);\r
 144 \r
 145         /// add\r
 146         KeySeq &add(const Action &i_action);\r
 147 \r
 148         /// get the first modified key of this key sequence\r
 149         ModifiedKey getFirstModifiedKey() const;\r
 150 \r
 151         ///\r
 152         const tstringi &getName() const {\r
 153                 return m_name;\r
 154         }\r
 155 \r
 156         /// stream output\r
 157         friend tostream &operator<<(tostream &i_ost, const KeySeq &i_ks);\r
 158 \r
 159         ///\r
 160         bool isCorrectMode(Modifier::Type i_mode) {\r
 161                 return m_mode <= i_mode;\r
 162         }\r
 163 \r
 164         ///\r
 165         void setMode(Modifier::Type i_mode) {\r
 166                 if (m_mode < i_mode)\r
 167                         m_mode = i_mode;\r
 168                 ASSERT( m_mode == Modifier::Type_KEYSEQ ||\r
 169                                 m_mode == Modifier::Type_ASSIGN);\r
 170         }\r
 171 \r
 172         ///\r
 173         Modifier::Type getMode() const {\r
 174                 return m_mode;\r
 175         }\r
 176 };\r
 177 \r
 178 \r
 179 ///\r
 180 class Keymap\r
 181 {\r
 182 public:\r
 183         ///\r
 184         enum Type {\r
 185                 Type_keymap,                            /// this is keymap\r
 186                 Type_windowAnd,                         /// this is window &amp;&amp;\r
 187                 Type_windowOr,                          /// this is window ||\r
 188         };\r
 189         ///\r
 190         enum AssignOperator {\r
 191                 AO_new,                                 /// =\r
 192                 AO_add,                                 /// +=\r
 193                 AO_sub,                                 /// -=\r
 194                 AO_overwrite,                           /// !, !!\r
 195         };\r
 196         ///\r
 197         enum AssignMode {\r
 198                 AM_notModifier,                         ///    not modifier\r
 199                 AM_normal,                                      ///    normal modifier\r
 200                 AM_true,                                        /** !  true modifier(doesn't\r
 201                                                     generate scan code) */\r
 202                 AM_oneShot,                                     /// !! one shot modifier\r
 203                 AM_oneShotRepeatable,                   /// !!! one shot modifier\r
 204         };\r
 205 \r
 206         /// key assignment\r
 207         class KeyAssignment\r
 208         {\r
 209         public:\r
 210                 ModifiedKey m_modifiedKey;      ///\r
 211                 KeySeq *m_keySeq;               ///\r
 212 \r
 213         public:\r
 214                 ///\r
 215                 KeyAssignment(const ModifiedKey &i_modifiedKey, KeySeq *i_keySeq)\r
 216                                 : m_modifiedKey(i_modifiedKey), m_keySeq(i_keySeq) { }\r
 217                 ///\r
 218                 KeyAssignment(const KeyAssignment &i_o)\r
 219                                 : m_modifiedKey(i_o.m_modifiedKey), m_keySeq(i_o.m_keySeq) { }\r
 220                 ///\r
 221                 bool operator<(const KeyAssignment &i_o) const {\r
 222                         return m_modifiedKey < i_o.m_modifiedKey;\r
 223                 }\r
 224         };\r
 225 \r
 226         /// modifier assignments\r
 227         class ModAssignment\r
 228         {\r
 229         public:\r
 230                 AssignOperator m_assignOperator;        ///\r
 231                 AssignMode m_assignMode;                ///\r
 232                 Key *m_key;                             ///\r
 233         };\r
 234         typedef std::list<ModAssignment> ModAssignments; ///\r
 235 \r
 236         /// parameter for describe();\r
 237         class DescribeParam\r
 238         {\r
 239         private:\r
 240                 typedef std::list<ModifiedKey> DescribedKeys;\r
 241                 typedef std::list<const Keymap *> DescribedKeymap;\r
 242                 friend class Keymap;\r
 243 \r
 244         private:\r
 245                 DescribedKeys m_dk;\r
 246                 DescribedKeymap m_dkeymap;\r
 247                 bool m_doesDescribeModifiers;\r
 248 \r
 249         public:\r
 250                 DescribeParam() : m_doesDescribeModifiers(true) { }\r
 251         };\r
 252 \r
 253 private:\r
 254         /// key assignments (hashed by first scan code)\r
 255         typedef std::list<KeyAssignment> KeyAssignments;\r
 256         enum {\r
 257                 HASHED_KEY_ASSIGNMENT_SIZE = 32,        ///\r
 258         };\r
 259 \r
 260 private:\r
 261         KeyAssignments m_hashedKeyAssignments[HASHED_KEY_ASSIGNMENT_SIZE];      ///\r
 262 \r
 263         /// modifier assignments\r
 264         ModAssignments m_modAssignments[Modifier::Type_ASSIGN];\r
 265 \r
 266         Type m_type;                                    /// type\r
 267         tstringi m_name;                                /// keymap name\r
 268         tregex m_windowClass;                           /// window class name regexp\r
 269         tregex m_windowTitle;                           /// window title name regexp\r
 270 \r
 271         KeySeq *m_defaultKeySeq;                        /// default keySeq\r
 272         Keymap *m_parentKeymap;                 /// parent keymap\r
 273 \r
 274 private:\r
 275         ///\r
 276         KeyAssignments &getKeyAssignments(const ModifiedKey &i_mk);\r
 277         ///\r
 278         const KeyAssignments &getKeyAssignments(const ModifiedKey &i_mk) const;\r
 279 \r
 280 public:\r
 281         ///\r
 282         Keymap(Type i_type,\r
 283                    const tstringi &i_name,\r
 284                    const tstringi &i_windowClass,\r
 285                    const tstringi &i_windowTitle,\r
 286                    KeySeq *i_defaultKeySeq,\r
 287                    Keymap *i_parentKeymap);\r
 288 \r
 289         /// add a key assignment;\r
 290         void addAssignment(const ModifiedKey &i_mk, KeySeq *i_keySeq);\r
 291 \r
 292         /// add modifier\r
 293         void addModifier(Modifier::Type i_mt, AssignOperator i_ao,\r
 294                                          AssignMode i_am, Key *i_key);\r
 295 \r
 296         /// search\r
 297         const KeyAssignment *searchAssignment(const ModifiedKey &i_mk) const;\r
 298 \r
 299         /// get\r
 300         const KeySeq *getDefaultKeySeq() const {\r
 301                 return m_defaultKeySeq;\r
 302         }\r
 303         ///\r
 304         Keymap *getParentKeymap() const {\r
 305                 return m_parentKeymap;\r
 306         }\r
 307         ///\r
 308         const tstringi &getName() const {\r
 309                 return m_name;\r
 310         }\r
 311 \r
 312         /// does same window\r
 313         bool doesSameWindow(const tstringi i_className,\r
 314                                                 const tstringi &i_titleName);\r
 315 \r
 316         /// adjust modifier\r
 317         void adjustModifier(Keyboard &i_keyboard);\r
 318 \r
 319         /// get modAssignments\r
 320         const ModAssignments &getModAssignments(Modifier::Type i_mt) const {\r
 321                 return m_modAssignments[i_mt];\r
 322         }\r
 323 \r
 324         /// describe\r
 325         void describe(tostream &i_ost, DescribeParam *i_dp) const;\r
 326 \r
 327         /// set default keySeq and parent keymap if default keySeq has not been set\r
 328         bool setIfNotYet(KeySeq *i_keySeq, Keymap *i_parentKeymap);\r
 329 };\r
 330 \r
 331 \r
 332 /// stream output\r
 333 extern tostream &operator<<(tostream &i_ost, const Keymap *i_keymap);\r
 334 \r
 335 \r
 336 ///\r
 337 class Keymaps\r
 338 {\r
 339 public:\r
 340         typedef std::list<Keymap *> KeymapPtrList;      ///\r
 341 \r
 342 private:\r
 343         typedef std::list<Keymap> KeymapList;           ///\r
 344 \r
 345 private:\r
 346         KeymapList m_keymapList;                        /** pointer into keymaps may\r
 347                                                     exist */\r
 348 \r
 349 public:\r
 350         ///\r
 351         Keymaps();\r
 352 \r
 353         /// search by name\r
 354         Keymap *searchByName(const tstringi &i_name);\r
 355 \r
 356         /// search window\r
 357         void searchWindow(KeymapPtrList *o_keymapPtrList,\r
 358                                           const tstringi &i_className,\r
 359                                           const tstringi &i_titleName);\r
 360 \r
 361         /// add keymap\r
 362         Keymap *add(const Keymap &i_keymap);\r
 363 \r
 364         /// adjust modifier\r
 365         void adjustModifier(Keyboard &i_keyboard);\r
 366 };\r
 367 \r
 368 \r
 369 ///\r
 370 class KeySeqs\r
 371 {\r
 372 private:\r
 373         typedef std::list<KeySeq> KeySeqList;           ///\r
 374 \r
 375 private:\r
 376         KeySeqList m_keySeqList;                        ///\r
 377 \r
 378 public:\r
 379         /// add a named keyseq (name can be empty)\r
 380         KeySeq *add(const KeySeq &i_keySeq);\r
 381 \r
 382         /// search by name\r
 383         KeySeq *searchByName(const tstringi &i_name);\r
 384 };\r
 385 \r
 386 \r
 387 #endif // !_KEYMAP_H\r