include/library/keymapper.hpp

   1 #ifndef _library__keymapper__hpp__included__
   2 #define _library__keymapper__hpp__included__
   3
   4 #include "commands.hpp"
   5 #include <set>
   6 #include <list>
   7 #include <stdexcept>
   8 #include <string>
   9 #include "keyboard.hpp"
  10
  11 class inverse_bind;
  12 class controller_key;
  13
  14 std::pair<keyboard_key*, unsigned> keymapper_lookup_subkey(keyboard& kbd, const std::string& name, bool axis)
  15         throw(std::bad_alloc, std::runtime_error);
  16
  17 /**
  18  * Key specifier
  19  */
  20 struct key_specifier
  21 {
  22 /**
  23  * Create a new key specifier (invalid).
  24  */
  25         key_specifier() throw(std::bad_alloc);
  26 /**
  27  * Create a new key specifier from keyspec.
  28  *
  29  * Parameter keyspec: The key specifier.
  30  */
  31         key_specifier(const std::string& keyspec) throw(std::bad_alloc, std::runtime_error);
  32 /**
  33  * Get the key specifier as a keyspec.
  34  */
  35         operator std::string() throw(std::bad_alloc);
  36 /**
  37  * Is valid?
  38  */
  39         operator bool() throw();
  40 /**
  41  * Is not valid?
  42  */
  43         bool operator!() throw();
  44 /**
  45  * Clear the keyspec.
  46  */
  47         void clear() throw();
  48 /**
  49  * Compare for equality.
  50  */
  51         bool operator==(const key_specifier& keyspec);
  52 /**
  53  * Compare for not-equality.
  54  */
  55         bool operator!=(const key_specifier& keyspec);
  56 /**
  57  * The modifier.
  58  */
  59         std::string mod;
  60 /**
  61  * The mask.
  62  */
  63         std::string mask;
  64 /**
  65  * The key itself.
  66  */
  67         std::string key;
  68 };
  69
  70
  71 /**
  72  * Keyboard mapper. Maps keyboard keys into commands.
  73  */
  74 class keyboard_mapper : public keyboard_event_listener
  75 {
  76 public:
  77 /**
  78  * Create new keyboard mapper.
  79  */
  80         keyboard_mapper(keyboard& kbd, command_group& domain) throw(std::bad_alloc);
  81 /**
  82  * Destroy a keyboard mapper.
  83  */
  84         ~keyboard_mapper() throw();
  85 /**
  86  * Binds a key, erroring out if binding would conflict with existing one.
  87  *
  88  * parameter mod: Modifier set to require to be pressed.
  89  * parameter modmask: Modifier set to take into account.
  90  * parameter keyname: Key to bind the action to.
  91  * parameter command: The command to bind.
  92  * throws std::bad_alloc: Not enough memory.
  93  * throws std::runtime_error: The binding would conflict with existing one or invalid modifier/key.
  94  */
  95         void bind(std::string mod, std::string modmask, std::string keyname, std::string command)
  96                 throw(std::bad_alloc, std::runtime_error);
  97 /**
  98  * Unbinds a key, erroring out if binding does not exist.
  99  *
 100  * parameter mod: Modifier set to require to be pressed.
 101  * parameter modmask: Modifier set to take into account.
 102  * parameter keyname: Key to bind the action to.
 103  * throws std::bad_alloc: Not enough memory.
 104  * throws std::runtime_error: The binding does not exist.
 105  */
 106         void unbind(std::string mod, std::string modmask, std::string keyname) throw(std::bad_alloc,
 107                 std::runtime_error);
 108 /**
 109  * Get keys bound.
 110  *
 111  * Returns: The set of keyspecs that are bound.
 112  */
 113         std::list<key_specifier> get_bindings() throw(std::bad_alloc);
 114 /**
 115  * Get command for key.
 116  */
 117         std::string get(const key_specifier& keyspec) throw(std::bad_alloc);
 118 /**
 119  * Bind command for key.
 120  *
 121  * Parameter keyspec: The key specifier to bind to.
 122  * Parameter cmd: The command to bind. If "", the key is unbound.
 123  */
 124         void set(const key_specifier& keyspec, const std::string& cmd) throw(std::bad_alloc, std::runtime_error);
 125 /**
 126  * Get set of inverse binds.
 127  *
 128  * Returns: The set of all inverses.
 129  */
 130         std::set<inverse_bind*> get_inverses() throw(std::bad_alloc);
 131 /**
 132  * Find inverse bind by command.
 133  *
 134  * Parameter command: The command.
 135  * Returns: The inverse bind, or NULL if none.
 136  */
 137         inverse_bind* get_inverse(const std::string& command) throw(std::bad_alloc);
 138 /**
 139  * Get set of controller keys.
 140  *
 141  * Returns: The set of all controller keys.
 142  */
 143         std::set<controller_key*> get_controller_keys() throw(std::bad_alloc);
 144 /**
 145  * Get specific controller key.
 146  */
 147         controller_key* get_controllerkey(const std::string& command) throw(std::bad_alloc);
 148 /**
 149  * Get list of controller keys for specific keyboard key.
 150  */
 151         std::list<controller_key*> get_controllerkeys_kbdkey(keyboard_key* kbdkey) throw(std::bad_alloc);
 152 /**
 153  * Proxy for inverse bind registrations.
 154  */
 155         struct _inverse_proxy
 156         {
 157                 _inverse_proxy(keyboard_mapper& mapper) : _mapper(mapper) {}
 158                 void do_register(const std::string& name, inverse_bind& ibind)
 159                 {
 160                         _mapper.do_register_inverse(name, ibind);
 161                 }
 162                 void do_unregister(const std::string& name)
 163                 {
 164                         _mapper.do_unregister_inverse(name);
 165                 }
 166         private:
 167                 keyboard_mapper& _mapper;
 168         } inverse_proxy;
 169 /**
 170  * Proxy for controller key registrations.
 171  */
 172         struct _controllerkey_proxy
 173         {
 174                 _controllerkey_proxy(keyboard_mapper& mapper) : _mapper(mapper) {}
 175                 void do_register(const std::string& name, controller_key& ckey)
 176                 {
 177                         _mapper.do_register_ckey(name, ckey);
 178                 }
 179                 void do_unregister(const std::string& name)
 180                 {
 181                         _mapper.do_unregister_ckey(name);
 182                 }
 183         private:
 184                 keyboard_mapper& _mapper;
 185         } controllerkey_proxy;
 186 /**
 187  * Register inverse bind.
 188  */
 189         void do_register_inverse(const std::string& name, inverse_bind& bind) throw(std::bad_alloc);
 190 /**
 191  * Unregister inverse bind.
 192  */
 193         void do_unregister_inverse(const std::string& name) throw(std::bad_alloc);
 194 /**
 195  * Register controller key.
 196  */
 197         void do_register_ckey(const std::string& name, controller_key& ckey) throw(std::bad_alloc);
 198 /**
 199  * Unregister inverse bind.
 200  */
 201         void do_unregister_ckey(const std::string& name) throw(std::bad_alloc);
 202 /**
 203  * Get keyboard.
 204  */
 205         keyboard& get_keyboard() throw();
 206 /**
 207  * Get command group to run commands in..
 208  */
 209         command_group& get_command_group() throw();
 210 /**
 211  * Fixup command based on polarity.
 212  *
 213  * Parameter cmd: The raw command.
 214  * Parameter polarity: Polarity (true is rising edge, false is falling edge).
 215  * Returns: The fixed command, or "" if nothing should be run.
 216  */
 217         static std::string fixup_command_polarity(std::string cmd, bool polarity) throw(std::bad_alloc);
 218 private:
 219         struct triplet
 220         {
 221                 triplet(keyboard_modifier_set mod, keyboard_modifier_set mask, keyboard_key& key, unsigned subkey);
 222                 triplet(keyboard_key& key, unsigned subkey);
 223                 triplet(keyboard& k, const key_specifier& spec);
 224                 bool operator<(const struct triplet& a) const;
 225                 bool operator==(const struct triplet& a) const;
 226                 bool operator<=(const struct triplet& a) const { return !(a > *this); }
 227                 bool operator!=(const struct triplet& a) const { return !(a == *this); }
 228                 bool operator>=(const struct triplet& a) const { return !(a < *this); }
 229                 bool operator>(const struct triplet& a) const { return (a < *this); }
 230                 key_specifier as_keyspec() const throw(std::bad_alloc);
 231                 bool index;
 232                 keyboard_modifier_set mod;
 233                 keyboard_modifier_set mask;
 234                 keyboard_key* key;
 235                 unsigned subkey;
 236         };
 237         void change_command(const key_specifier& spec, const std::string& old, const std::string& newc);
 238         void on_key_event(keyboard_modifier_set& mods, keyboard_key& key, keyboard_event& event);
 239         void on_key_event_subkey(keyboard_modifier_set& mods, keyboard_key& key, unsigned skey, bool polarity);
 240         keyboard_mapper(const keyboard_mapper&);
 241         keyboard_mapper& operator=(const keyboard_mapper&);
 242         std::map<std::string, inverse_bind*> ibinds;
 243         std::map<std::string, controller_key*> ckeys;
 244         std::map<triplet, std::string> bindings;
 245         std::set<keyboard_key*> listening;
 246         keyboard& kbd;
 247         command_group& domain;
 248         mutex_class mutex;
 249 };
 250
 251 /**
 252  * Inverse bind. Can map up to 2 keys to some command (and follows forward binds).
 253  */
 254 class inverse_bind
 255 {
 256 public:
 257 /**
 258  * Create inverse bind.
 259  *
 260  * Parameter mapper: The keyboard mapper to follow.
 261  * Parameter command: Command this is for.
 262  * Parameter name: Name of inverse key.
 263  */
 264         inverse_bind(keyboard_mapper& mapper, const std::string& command, const std::string& name)
 265                 throw(std::bad_alloc);
 266 /**
 267  * Destructor.
 268  */
 269         ~inverse_bind() throw();
 270 /**
 271  * Get keyspec.
 272  *
 273  * Parameter index: Index of the keyspec to get.
 274  * Returns: The keyspec.
 275  */
 276         key_specifier get(unsigned index) throw(std::bad_alloc);
 277 /**
 278  * Clear key (subsequent keys fill the gap).
 279  *
 280  * Parameter index: Index of key to clear.
 281  */
 282         void clear(unsigned index) throw(std::bad_alloc);
 283 /**
 284  * Add key to set.
 285  *
 286  * Parameter keyspec: The new keyspec.
 287  */
 288         void append(const key_specifier& keyspec) throw(std::bad_alloc);
 289 /**
 290  * Get name for command.
 291  *
 292  * Returns: The name.
 293  */
 294         std::string getname() throw(std::bad_alloc);
 295 private:
 296         friend class keyboard_mapper;
 297         inverse_bind(const inverse_bind&);
 298         inverse_bind& operator=(const inverse_bind&);
 299         void addkey(const key_specifier& keyspec);
 300         keyboard_mapper& mapper;
 301         std::string cmd;
 302         std::string oname;
 303         std::vector<key_specifier> specs;
 304         mutex_class mutex;
 305 };
 306
 307 /**
 308  * A controller key.
 309  *
 310  * Can overlap with any other bind.
 311  */
 312 class controller_key : public keyboard_event_listener
 313 {
 314 public:
 315 /**
 316  * Create a new controller key.
 317  *
 318  * Parameter mapper: The keyboard mapper to follow.
 319  * Parameter command: Command to run.
 320  * Parameter name: Name of controller key.
 321  * Parameter axis: If true, create a axis-type key.
 322  */
 323         controller_key(keyboard_mapper& mapper, const std::string& command, const std::string& name,
 324                 bool axis = false) throw(std::bad_alloc);
 325 /**
 326  * Destructor.
 327  */
 328         ~controller_key() throw();
 329 /**
 330  * Get the trigger key.
 331  */
 332         std::pair<keyboard_key*, unsigned> get(unsigned index) throw();
 333 /**
 334  * Get the trigger key.
 335  */
 336         std::string get_string(unsigned index) throw(std::bad_alloc);
 337 /**
 338  * Set the trigger key (appends).
 339  */
 340         void append(keyboard_key* key, unsigned subkey) throw();
 341 /**
 342  * Set the trigger key (appends).
 343  */
 344         void append(const std::string& key) throw(std::bad_alloc, std::runtime_error);
 345 /**
 346  * Remove the trigger key.
 347  */
 348         void remove(keyboard_key* key, unsigned subkey) throw();
 349 /**
 350  * Get the command.
 351  */
 352         const std::string& get_command() const throw() { return cmd; }
 353 /**
 354  * Get the name.
 355  */
 356         const std::string& get_name() const throw() { return oname; }
 357 /**
 358  * Is axis-type?
 359  */
 360         bool is_axis() const throw() { return axis; }
 361 private:
 362         void on_key_event(keyboard_modifier_set& mods, keyboard_key& key, keyboard_event& event);
 363         keyboard_mapper& mapper;
 364         std::string cmd;
 365         std::string oname;
 366         std::vector<std::pair<keyboard_key*, unsigned>> keys;
 367         bool axis;
 368         mutex_class mutex;
 369 };
 370
 371 #endif