include/library/keyboard-mapper.hpp

   1 #ifndef _library__keyboard_mapper__hpp__included__
   2 #define _library__keyboard_mapper__hpp__included__
   3
   4 #include <set>
   5 #include <list>
   6 #include <stdexcept>
   7 #include <string>
   8 #include "keyboard.hpp"
   9
  10 namespace command
  11 {
  12         class group;
  13 }
  14
  15 namespace keyboard
  16 {
  17 class invbind;
  18 class ctrlrkey;
  19
  20 std::pair<key*, unsigned> keymapper_lookup_subkey(keyboard& kbd, const std::string& name,
  21         bool axis) throw(std::bad_alloc, std::runtime_error);
  22
  23 /**
  24  * Key specifier
  25  */
  26 struct keyspec
  27 {
  28 /**
  29  * Create a new key specifier (invalid).
  30  */
  31         keyspec() throw(std::bad_alloc);
  32 /**
  33  * Create a new key specifier from keyspec.
  34  *
  35  * Parameter keyspec: The key specifier.
  36  */
  37         keyspec(const std::string& keyspec) throw(std::bad_alloc, std::runtime_error);
  38 /**
  39  * Get the key specifier as a keyspec.
  40  */
  41         operator std::string() throw(std::bad_alloc);
  42 /**
  43  * Is valid?
  44  */
  45         operator bool() throw();
  46 /**
  47  * Is not valid?
  48  */
  49         bool operator!() throw();
  50 /**
  51  * Clear the keyspec.
  52  */
  53         void clear() throw();
  54 /**
  55  * Compare for equality.
  56  */
  57         bool operator==(const keyspec& keyspec);
  58 /**
  59  * Compare for not-equality.
  60  */
  61         bool operator!=(const keyspec& keyspec);
  62 /**
  63  * The modifier.
  64  */
  65         std::string mod;
  66 /**
  67  * The mask.
  68  */
  69         std::string mask;
  70 /**
  71  * The key itself.
  72  */
  73         std::string key;
  74 };
  75
  76 class invbind_set;
  77 class invbind_info;
  78
  79 class invbind_info;
  80
  81 /**
  82  * Inverse bind set.
  83  */
  84 class invbind_set
  85 {
  86 public:
  87 /**
  88  * Set add/drop listener.
  89  */
  90         class listener
  91         {
  92         public:
  93 /**
  94  * Dtor.
  95  */
  96                 virtual ~listener();
  97 /**
  98  * New item in set.
  99  */
 100                 virtual void create(invbind_set& s, const std::string& name, invbind_info& ibinfo) = 0;
 101 /**
 102  * Deleted item from set.
 103  */
 104                 virtual void destroy(invbind_set& s, const std::string& name) = 0;
 105 /**
 106  * Destroyed the entiere set.
 107  */
 108                 virtual void kill(invbind_set& s) = 0;
 109         };
 110 /**
 111  * Create a set.
 112  */
 113         invbind_set();
 114 /**
 115  * Destructor.
 116  */
 117         ~invbind_set();
 118 /**
 119  * Register a inverse bind.
 120  */
 121         void do_register(const std::string& name, invbind_info& info);
 122 /**
 123  * Unregister a inverse bind.
 124  */
 125         void do_unregister(const std::string& name, invbind_info& info);
 126 /**
 127  * Add a callback on new invese bind.
 128  */
 129         void add_callback(listener& listener) throw(std::bad_alloc);
 130 /**
 131  * Drop a callback on new inverse bind.
 132  */
 133         void drop_callback(listener& listener);
 134 };
 135
 136 /**
 137  * Keyboard mapper. Maps keyboard keys into commands.
 138  */
 139 class mapper : public event_listener
 140 {
 141 public:
 142 /**
 143  * Create new keyboard mapper.
 144  */
 145         mapper(keyboard& kbd, command::group& domain) throw(std::bad_alloc);
 146 /**
 147  * Destroy a keyboard mapper.
 148  */
 149         ~mapper() throw();
 150 /**
 151  * Binds a key, erroring out if binding would conflict with existing one.
 152  *
 153  * parameter mod: Modifier set to require to be pressed.
 154  * parameter modmask: Modifier set to take into account.
 155  * parameter keyname: Key to bind the action to.
 156  * parameter command: The command to bind.
 157  * throws std::bad_alloc: Not enough memory.
 158  * throws std::runtime_error: The binding would conflict with existing one or invalid modifier/key.
 159  */
 160         void bind(std::string mod, std::string modmask, std::string keyname, std::string command)
 161                 throw(std::bad_alloc, std::runtime_error);
 162 /**
 163  * Unbinds a key, erroring out if binding does not exist.
 164  *
 165  * parameter mod: Modifier set to require to be pressed.
 166  * parameter modmask: Modifier set to take into account.
 167  * parameter keyname: Key to bind the action to.
 168  * throws std::bad_alloc: Not enough memory.
 169  * throws std::runtime_error: The binding does not exist.
 170  */
 171         void unbind(std::string mod, std::string modmask, std::string keyname) throw(std::bad_alloc,
 172                 std::runtime_error);
 173 /**
 174  * Get keys bound.
 175  *
 176  * Returns: The set of keyspecs that are bound.
 177  */
 178         std::list<keyspec> get_bindings() throw(std::bad_alloc);
 179 /**
 180  * Get command for key.
 181  */
 182         std::string get(const keyspec& keyspec) throw(std::bad_alloc);
 183 /**
 184  * Bind command for key.
 185  *
 186  * Parameter keyspec: The key specifier to bind to.
 187  * Parameter cmd: The command to bind. If "", the key is unbound.
 188  */
 189         void set(const keyspec& keyspec, const std::string& cmd) throw(std::bad_alloc, std::runtime_error);
 190 /**
 191  * Get set of inverse binds.
 192  *
 193  * Returns: The set of all inverses.
 194  */
 195         std::set<invbind*> get_inverses() throw(std::bad_alloc);
 196 /**
 197  * Find inverse bind by command.
 198  *
 199  * Parameter command: The command.
 200  * Returns: The inverse bind, or NULL if none.
 201  */
 202         invbind* get_inverse(const std::string& command) throw(std::bad_alloc);
 203 /**
 204  * Get set of controller keys.
 205  *
 206  * Returns: The set of all controller keys.
 207  */
 208         std::set<ctrlrkey*> get_controller_keys() throw(std::bad_alloc);
 209 /**
 210  * Get specific controller key.
 211  */
 212         ctrlrkey* get_controllerkey(const std::string& command) throw(std::bad_alloc);
 213 /**
 214  * Get list of controller keys for specific keyboard key.
 215  */
 216         std::list<ctrlrkey*> get_controllerkeys_kbdkey(key* kbdkey) throw(std::bad_alloc);
 217 /**
 218  * Register inverse bind.
 219  */
 220         void do_register(const std::string& name, invbind& bind) throw(std::bad_alloc);
 221 /**
 222  * Unregister inverse bind.
 223  */
 224         void do_unregister(const std::string& name, invbind& bind) throw(std::bad_alloc);
 225 /**
 226  * Register controller key.
 227  */
 228         void do_register(const std::string& name, ctrlrkey& ckey) throw(std::bad_alloc);
 229 /**
 230  * Unregister inverse bind.
 231  */
 232         void do_unregister(const std::string& name, ctrlrkey& ckey) throw(std::bad_alloc);
 233 /**
 234  * Get keyboard.
 235  */
 236         keyboard& get_keyboard() throw();
 237 /**
 238  * Get command group to run commands in..
 239  */
 240         command::group& get_command_group() throw();
 241 /**
 242  * Fixup command based on polarity.
 243  *
 244  * Parameter cmd: The raw command.
 245  * Parameter polarity: Polarity (true is rising edge, false is falling edge).
 246  * Returns: The fixed command, or "" if nothing should be run.
 247  */
 248         static std::string fixup_command_polarity(std::string cmd, bool polarity) throw(std::bad_alloc);
 249 /**
 250  * Add a set of inverse binds.
 251  */
 252         void add_invbind_set(invbind_set& set);
 253 /**
 254  * Drop a set of inverse binds.
 255  */
 256         void drop_invbind_set(invbind_set& set);
 257 /**
 258  * Key triplet.
 259  */
 260         struct triplet
 261         {
 262                 triplet(modifier_set mod, modifier_set mask, key& kkey, unsigned subkey);
 263                 triplet(key& kkey, unsigned subkey);
 264                 triplet(keyboard& k, const keyspec& spec);
 265                 bool operator<(const struct triplet& a) const;
 266                 bool operator==(const struct triplet& a) const;
 267                 bool operator<=(const struct triplet& a) const { return !(a > *this); }
 268                 bool operator!=(const struct triplet& a) const { return !(a == *this); }
 269                 bool operator>=(const struct triplet& a) const { return !(a < *this); }
 270                 bool operator>(const struct triplet& a) const { return (a < *this); }
 271                 keyspec as_keyspec() const throw(std::bad_alloc);
 272                 bool index;
 273                 modifier_set mod;
 274                 modifier_set mask;
 275                 key* _key;
 276                 unsigned subkey;
 277         };
 278 private:
 279         class listener : public invbind_set::listener
 280         {
 281         public:
 282                 listener(mapper& _grp);
 283                 ~listener();
 284                 void create(invbind_set& s, const std::string& name, invbind_info& ibinfo);
 285                 void destroy(invbind_set& s, const std::string& name);
 286                 void kill(invbind_set& s);
 287         private:
 288                 mapper& grp;
 289         } _listener;
 290         void change_command(const keyspec& spec, const std::string& old, const std::string& newc);
 291         void on_key_event(modifier_set& mods, key& key, event& event);
 292         void on_key_event_subkey(modifier_set& mods, key& key, unsigned skey, bool polarity);
 293         mapper(const mapper&);
 294         mapper& operator=(const mapper&);
 295         std::set<key*> listening;
 296         keyboard& kbd;
 297         command::group& domain;
 298 };
 299
 300
 301 /**
 302  * Inverse bind info.
 303  */
 304 class invbind_info
 305 {
 306 public:
 307 /**
 308  * Create inverse bind.
 309  *
 310  * Parameter set: The set to be in.
 311  * Parameter _command: Command this is for.
 312  * Parameter _name: Name of inverse key.
 313  */
 314         invbind_info(invbind_set& set, const std::string& _command, const std::string& _name)
 315                 throw(std::bad_alloc);
 316 /**
 317  * Destructor.
 318  */
 319         ~invbind_info() throw();
 320 /**
 321  * Make inverse bind out of this.
 322  */
 323         invbind* make(mapper& m);
 324 /**
 325  * Notify set dying.
 326  */
 327         void set_died();
 328 private:
 329         invbind_set* in_set;
 330         std::string command;
 331         std::string name;
 332 };
 333
 334 /**
 335  * Inverse bind. Can map up to 2 keys to some command (and follows forward binds).
 336  */
 337 class invbind
 338 {
 339 public:
 340 /**
 341  * Create inverse bind.
 342  *
 343  * Parameter mapper: The keyboard mapper to follow.
 344  * Parameter command: Command this is for.
 345  * Parameter name: Name of inverse key.
 346  */
 347         invbind(mapper& kmapper, const std::string& command, const std::string& name, bool dynamic = false)
 348                 throw(std::bad_alloc);
 349 /**
 350  * Destructor.
 351  */
 352         ~invbind() throw();
 353 /**
 354  * Get keyspec.
 355  *
 356  * Parameter index: Index of the keyspec to get.
 357  * Returns: The keyspec.
 358  */
 359         keyspec get(unsigned index) throw(std::bad_alloc);
 360 /**
 361  * Clear key (subsequent keys fill the gap).
 362  *
 363  * Parameter index: Index of key to clear.
 364  */
 365         void clear(unsigned index) throw(std::bad_alloc);
 366 /**
 367  * Add key to set.
 368  *
 369  * Parameter keyspec: The new keyspec.
 370  */
 371         void append(const keyspec& keyspec) throw(std::bad_alloc);
 372 /**
 373  * Get name for command.
 374  *
 375  * Returns: The name.
 376  */
 377         std::string getname() throw(std::bad_alloc);
 378 /**
 379  * Notify mapper dying.
 380  */
 381         void mapper_died();
 382 private:
 383         friend class mapper;
 384         invbind(const invbind&);
 385         invbind& operator=(const invbind&);
 386         void addkey(const keyspec& keyspec);
 387         mapper* _mapper;
 388         std::string cmd;
 389         std::string oname;
 390         std::vector<keyspec> specs;
 391         bool is_dynamic;
 392 };
 393
 394 /**
 395  * A controller key.
 396  *
 397  * Can overlap with any other bind.
 398  */
 399 class ctrlrkey : public event_listener
 400 {
 401 public:
 402 /**
 403  * Create a new controller key.
 404  *
 405  * Parameter mapper: The keyboard mapper to follow.
 406  * Parameter command: Command to run.
 407  * Parameter name: Name of controller key.
 408  * Parameter axis: If true, create a axis-type key.
 409  */
 410         ctrlrkey(mapper& kmapper, const std::string& command, const std::string& name,
 411                 bool axis = false) throw(std::bad_alloc);
 412 /**
 413  * Destructor.
 414  */
 415         ~ctrlrkey() throw();
 416 /**
 417  * Get the trigger key.
 418  */
 419         std::pair<key*, unsigned> get(unsigned index) throw();
 420 /**
 421  * Get the trigger key.
 422  */
 423         std::string get_string(unsigned index) throw(std::bad_alloc);
 424 /**
 425  * Set the trigger key (appends).
 426  */
 427         void append(key* key, unsigned subkey) throw();
 428 /**
 429  * Set the trigger key (appends).
 430  */
 431         void append(const std::string& key) throw(std::bad_alloc, std::runtime_error);
 432 /**
 433  * Remove the trigger key.
 434  */
 435         void remove(key* key, unsigned subkey) throw();
 436 /**
 437  * Get the command.
 438  */
 439         const std::string& get_command() const throw() { return cmd; }
 440 /**
 441  * Get the name.
 442  */
 443         const std::string& get_name() const throw() { return oname; }
 444 /**
 445  * Is axis-type?
 446  */
 447         bool is_axis() const throw() { return axis; }
 448 private:
 449         void on_key_event(modifier_set& mods, key& key, event& event);
 450         mapper& _mapper;
 451         std::string cmd;
 452         std::string oname;
 453         std::vector<std::pair<key*, unsigned>> keys;
 454         bool axis;
 455 };
 456 }
 457
 458 #endif