simgear/canvas/events/KeyboardEvent.cxx

   1 // Keyboard event
   2 //
   3 // Copyright (C) 2014  Thomas Geymayer <tomgey@gmail.com>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Library General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2 of the License, or (at your option) any later version.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Library General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Library General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  18
  19 #include "KeyboardEvent.hxx"
  20
  21 #include <osgGA/GUIEventAdapter>
  22
  23 #include <boost/container/flat_map.hpp>
  24 #include <boost/container/flat_set.hpp>
  25 #include <boost/locale/encoding_utf.hpp>
  26
  27 namespace simgear
  28 {
  29 namespace canvas
  30 {
  31   typedef osgGA::GUIEventAdapter EA;
  32
  33   // TODO check Win/Mac keycode for altgr/ISO Level3 Shift
  34   const uint32_t KEY_AltGraph = 0xfe03;
  35
  36   //----------------------------------------------------------------------------
  37   KeyboardEvent::KeyboardEvent():
  38     _key(0),
  39     _unmodified_key(0),
  40     _repeat(false),
  41     _location(DOM_KEY_LOCATION_STANDARD)
  42   {
  43
  44   }
  45
  46   //----------------------------------------------------------------------------
  47   KeyboardEvent::KeyboardEvent(const osgGA::GUIEventAdapter& ea):
  48     DeviceEvent(ea),
  49     _key(ea.getKey()),
  50     _unmodified_key(ea.getUnmodifiedKey()),
  51     _repeat(false),
  52     _location(DOM_KEY_LOCATION_STANDARD)
  53   {
  54     if( ea.getEventType() == EA::KEYDOWN )
  55       type = KEY_DOWN;
  56     else if( ea.getEventType() == EA::KEYUP )
  57       type = KEY_UP;
  58 //    else
  59 //      // TODO what to do with wrong event type?
  60   }
  61
  62   //----------------------------------------------------------------------------
  63   void KeyboardEvent::setKey(uint32_t key)
  64   {
  65     _name.clear();
  66     _key = key;
  67   }
  68
  69   //----------------------------------------------------------------------------
  70   void KeyboardEvent::setUnmodifiedKey(uint32_t key)
  71   {
  72     _name.clear();
  73     _unmodified_key = key;
  74   }
  75
  76   //----------------------------------------------------------------------------
  77   void KeyboardEvent::setRepeat(bool repeat)
  78   {
  79     _repeat = repeat;
  80   }
  81
  82   //----------------------------------------------------------------------------
  83   std::string KeyboardEvent::key() const
  84   {
  85     if( !_name.empty() )
  86       return _name;
  87
  88     // We need to make sure only valid const char* pointers are passed. The best
  89     // way is just to use string constants.
  90     // Use an empty string ("") to just use the value reported by the operating
  91     // system.
  92     typedef std::pair<const char*, uint8_t> InternalKeyInfo;
  93     typedef boost::container::flat_map<int, InternalKeyInfo> InternalKeyMap;
  94     typedef boost::container::flat_set<int> KeyList;
  95
  96     static InternalKeyMap key_map;
  97     static KeyList num_pad_keys;
  98
  99     if( key_map.empty() )
 100     {
 101       const uint8_t S = DOM_KEY_LOCATION_STANDARD,
 102                     L = DOM_KEY_LOCATION_LEFT,
 103                     R = DOM_KEY_LOCATION_RIGHT,
 104                     N = DOM_KEY_LOCATION_NUMPAD;
 105
 106       key_map[ EA::KEY_BackSpace    ] = std::make_pair("Backspace", S);
 107       key_map[ EA::KEY_Tab          ] = std::make_pair("Tab", S);
 108       key_map[ EA::KEY_Linefeed     ] = std::make_pair("Linefeed", S);
 109       key_map[ EA::KEY_Clear        ] = std::make_pair("Clear", S);
 110       key_map[ EA::KEY_Return       ] = std::make_pair("Enter", S);
 111       key_map[ EA::KEY_Pause        ] = std::make_pair("Pause", S);
 112       key_map[ EA::KEY_Scroll_Lock  ] = std::make_pair("ScrollLock", S);
 113       key_map[ EA::KEY_Sys_Req      ] = std::make_pair("SystemRequest", S);
 114       key_map[ EA::KEY_Escape       ] = std::make_pair("Escape", S);
 115       key_map[ EA::KEY_Delete       ] = std::make_pair("Delete", S);
 116
 117       key_map[ EA::KEY_Home         ] = std::make_pair("Home", S);
 118       key_map[ EA::KEY_Left         ] = std::make_pair("Left", S);
 119       key_map[ EA::KEY_Up           ] = std::make_pair("Up", S);
 120       key_map[ EA::KEY_Right        ] = std::make_pair("Right", S);
 121       key_map[ EA::KEY_Down         ] = std::make_pair("Down", S);
 122       key_map[ EA::KEY_Page_Up      ] = std::make_pair("PageUp", S);
 123       key_map[ EA::KEY_Page_Down    ] = std::make_pair("PageDown", S);
 124       key_map[ EA::KEY_End          ] = std::make_pair("End", S);
 125       key_map[ EA::KEY_Begin        ] = std::make_pair("Begin", S);
 126
 127       key_map[ EA::KEY_Select       ] = std::make_pair("Select", S);
 128       key_map[ EA::KEY_Print        ] = std::make_pair("PrintScreen", S);
 129       key_map[ EA::KEY_Execute      ] = std::make_pair("Execute", S);
 130       key_map[ EA::KEY_Insert       ] = std::make_pair("Insert", S);
 131       key_map[ EA::KEY_Undo         ] = std::make_pair("Undo", S);
 132       key_map[ EA::KEY_Redo         ] = std::make_pair("Redo", S);
 133       key_map[ EA::KEY_Menu         ] = std::make_pair("ContextMenu", S);
 134       key_map[ EA::KEY_Find         ] = std::make_pair("Find", S);
 135       key_map[ EA::KEY_Cancel       ] = std::make_pair("Cancel", S);
 136       key_map[ EA::KEY_Help         ] = std::make_pair("Help", S);
 137       key_map[ EA::KEY_Break        ] = std::make_pair("Break", S);
 138       key_map[ EA::KEY_Mode_switch  ] = std::make_pair("ModeChange", S);
 139       key_map[ EA::KEY_Num_Lock     ] = std::make_pair("NumLock", S);
 140
 141       key_map[ EA::KEY_KP_Space     ] = std::make_pair(" ", N);
 142       key_map[ EA::KEY_KP_Tab       ] = std::make_pair("Tab", N);
 143       key_map[ EA::KEY_KP_Enter     ] = std::make_pair("Enter", N);
 144       key_map[ EA::KEY_KP_F1        ] = std::make_pair("F1", N);
 145       key_map[ EA::KEY_KP_F2        ] = std::make_pair("F2", N);
 146       key_map[ EA::KEY_KP_F3        ] = std::make_pair("F3", N);
 147       key_map[ EA::KEY_KP_F4        ] = std::make_pair("F4", N);
 148       key_map[ EA::KEY_KP_Home      ] = std::make_pair("Home", N);
 149       key_map[ EA::KEY_KP_Left      ] = std::make_pair("Left", N);
 150       key_map[ EA::KEY_KP_Up        ] = std::make_pair("Up", N);
 151       key_map[ EA::KEY_KP_Right     ] = std::make_pair("Right", N);
 152       key_map[ EA::KEY_KP_Down      ] = std::make_pair("Down", N);
 153       key_map[ EA::KEY_KP_Page_Up   ] = std::make_pair("PageUp", N);
 154       key_map[ EA::KEY_KP_Page_Down ] = std::make_pair("PageDown", N);
 155       key_map[ EA::KEY_KP_End       ] = std::make_pair("End", N);
 156       key_map[ EA::KEY_KP_Begin     ] = std::make_pair("Begin", N);
 157       key_map[ EA::KEY_KP_Insert    ] = std::make_pair("Insert", N);
 158       key_map[ EA::KEY_KP_Delete    ] = std::make_pair("Delete", N);
 159       key_map[ EA::KEY_KP_Equal     ] = std::make_pair("=", N);
 160       key_map[ EA::KEY_KP_Multiply  ] = std::make_pair("*", N);
 161       key_map[ EA::KEY_KP_Add       ] = std::make_pair("+", N);
 162       key_map[ EA::KEY_KP_Separator ] = std::make_pair("", N);
 163       key_map[ EA::KEY_KP_Subtract  ] = std::make_pair("-", N);
 164       key_map[ EA::KEY_KP_Decimal   ] = std::make_pair("", N);
 165       key_map[ EA::KEY_KP_Divide    ] = std::make_pair("/", N);
 166
 167       key_map[ EA::KEY_KP_0 ] = std::make_pair("0", N);
 168       key_map[ EA::KEY_KP_1 ] = std::make_pair("1", N);
 169       key_map[ EA::KEY_KP_2 ] = std::make_pair("2", N);
 170       key_map[ EA::KEY_KP_3 ] = std::make_pair("3", N);
 171       key_map[ EA::KEY_KP_4 ] = std::make_pair("4", N);
 172       key_map[ EA::KEY_KP_5 ] = std::make_pair("5", N);
 173       key_map[ EA::KEY_KP_6 ] = std::make_pair("6", N);
 174       key_map[ EA::KEY_KP_7 ] = std::make_pair("7", N);
 175       key_map[ EA::KEY_KP_8 ] = std::make_pair("8", N);
 176       key_map[ EA::KEY_KP_9 ] = std::make_pair("9", N);
 177
 178       key_map[ EA::KEY_F1   ] = std::make_pair("F1", S);
 179       key_map[ EA::KEY_F2   ] = std::make_pair("F2", S);
 180       key_map[ EA::KEY_F3   ] = std::make_pair("F3", S);
 181       key_map[ EA::KEY_F4   ] = std::make_pair("F4", S);
 182       key_map[ EA::KEY_F5   ] = std::make_pair("F5", S);
 183       key_map[ EA::KEY_F6   ] = std::make_pair("F6", S);
 184       key_map[ EA::KEY_F7   ] = std::make_pair("F7", S);
 185       key_map[ EA::KEY_F8   ] = std::make_pair("F8", S);
 186       key_map[ EA::KEY_F9   ] = std::make_pair("F9", S);
 187       key_map[ EA::KEY_F10  ] = std::make_pair("F10", S);
 188       key_map[ EA::KEY_F11  ] = std::make_pair("F11", S);
 189       key_map[ EA::KEY_F12  ] = std::make_pair("F12", S);
 190       key_map[ EA::KEY_F13  ] = std::make_pair("F13", S);
 191       key_map[ EA::KEY_F14  ] = std::make_pair("F14", S);
 192       key_map[ EA::KEY_F15  ] = std::make_pair("F15", S);
 193       key_map[ EA::KEY_F16  ] = std::make_pair("F16", S);
 194       key_map[ EA::KEY_F17  ] = std::make_pair("F17", S);
 195       key_map[ EA::KEY_F18  ] = std::make_pair("F18", S);
 196       key_map[ EA::KEY_F19  ] = std::make_pair("F19", S);
 197       key_map[ EA::KEY_F20  ] = std::make_pair("F20", S);
 198       key_map[ EA::KEY_F21  ] = std::make_pair("F21", S);
 199       key_map[ EA::KEY_F22  ] = std::make_pair("F22", S);
 200       key_map[ EA::KEY_F23  ] = std::make_pair("F23", S);
 201       key_map[ EA::KEY_F24  ] = std::make_pair("F24", S);
 202       key_map[ EA::KEY_F25  ] = std::make_pair("F25", S);
 203       key_map[ EA::KEY_F26  ] = std::make_pair("F26", S);
 204       key_map[ EA::KEY_F27  ] = std::make_pair("F27", S);
 205       key_map[ EA::KEY_F28  ] = std::make_pair("F28", S);
 206       key_map[ EA::KEY_F29  ] = std::make_pair("F29", S);
 207       key_map[ EA::KEY_F30  ] = std::make_pair("F30", S);
 208       key_map[ EA::KEY_F31  ] = std::make_pair("F31", S);
 209       key_map[ EA::KEY_F32  ] = std::make_pair("F32", S);
 210       key_map[ EA::KEY_F33  ] = std::make_pair("F33", S);
 211       key_map[ EA::KEY_F34  ] = std::make_pair("F34", S);
 212       key_map[ EA::KEY_F35  ] = std::make_pair("F35", S);
 213
 214       key_map[ KEY_AltGraph       ] = std::make_pair("AltGraph", S);
 215       key_map[ EA::KEY_Shift_L    ] = std::make_pair("Shift", L);
 216       key_map[ EA::KEY_Shift_R    ] = std::make_pair("Shift", R);
 217       key_map[ EA::KEY_Control_L  ] = std::make_pair("Control", L);
 218       key_map[ EA::KEY_Control_R  ] = std::make_pair("Control", R);
 219       key_map[ EA::KEY_Caps_Lock  ] = std::make_pair("CapsLock", S);
 220       key_map[ EA::KEY_Shift_Lock ] = std::make_pair("ShiftLock", S);
 221       key_map[ EA::KEY_Meta_L     ] = std::make_pair("Meta", L);
 222       key_map[ EA::KEY_Meta_R     ] = std::make_pair("Meta", R);
 223       key_map[ EA::KEY_Alt_L      ] = std::make_pair("Alt", L);
 224       key_map[ EA::KEY_Alt_R      ] = std::make_pair("Alt", R);
 225       key_map[ EA::KEY_Super_L    ] = std::make_pair("Super", L);
 226       key_map[ EA::KEY_Super_R    ] = std::make_pair("Super", R);
 227       key_map[ EA::KEY_Hyper_L    ] = std::make_pair("Hyper", L);
 228       key_map[ EA::KEY_Hyper_R    ] = std::make_pair("Hyper", R);
 229
 230       num_pad_keys.insert(EA::KEY_KP_Home     );
 231       num_pad_keys.insert(EA::KEY_KP_Left     );
 232       num_pad_keys.insert(EA::KEY_KP_Up       );
 233       num_pad_keys.insert(EA::KEY_KP_Right    );
 234       num_pad_keys.insert(EA::KEY_KP_Down     );
 235       num_pad_keys.insert(EA::KEY_KP_Page_Up  );
 236       num_pad_keys.insert(EA::KEY_KP_Page_Down);
 237       num_pad_keys.insert(EA::KEY_KP_End      );
 238       num_pad_keys.insert(EA::KEY_KP_Begin    );
 239       num_pad_keys.insert(EA::KEY_KP_Insert   );
 240       num_pad_keys.insert(EA::KEY_KP_Delete   );
 241     }
 242
 243     _location = DOM_KEY_LOCATION_STANDARD;
 244
 245     InternalKeyMap::const_iterator it = key_map.find(_key);
 246     if( it != key_map.end())
 247     {
 248       _name = it->second.first;
 249       _location = it->second.second;
 250     }
 251
 252     // Empty or no mapping -> convert UTF-32 key value to UTF-8
 253     if( _name.empty() )
 254       _name = boost::locale::conv::utf_to_utf<char>(&_key, &_key + 1);
 255
 256     // Keys on the numpad with NumLock enabled are reported just like their
 257     // equivalent keys in the standard key block. Using the unmodified key value
 258     // we can detect such keys and set the location accordingly.
 259     if( num_pad_keys.find(_unmodified_key) != num_pad_keys.end() )
 260       _location = DOM_KEY_LOCATION_NUMPAD;
 261
 262     return _name;
 263   }
 264
 265   //----------------------------------------------------------------------------
 266   KeyboardEvent::DOMKeyLocation KeyboardEvent::location() const
 267   {
 268     key(); // ensure location is up-to-date
 269     return static_cast<DOMKeyLocation>(_location);
 270   }
 271
 272   //----------------------------------------------------------------------------
 273   bool KeyboardEvent::isModifier() const
 274   {
 275     return (  _key >= EA::KEY_Shift_L
 276            && _key <= EA::KEY_Hyper_R
 277            )
 278         || _key == KEY_AltGraph;
 279   }
 280
 281 } // namespace canvas
 282 } // namespace simgear