lib/driver/rcsdl.cpp

   1 #include <lib/driver/rcsdl.h>
   2 //#include <lib/actions/action.h>
   3 #include <lib/base/init.h>
   4 #include <lib/base/init_num.h>
   5 #include <lib/driver/input_fake.h>
   6
   7 /*
   8  * eSDLInputDevice
   9  */
  10
  11 eSDLInputDevice::eSDLInputDevice(eRCDriver *driver) : eRCDevice("SDL", driver), m_escape(false), m_unicode(0)
  12 {
  13 }
  14
  15 eSDLInputDevice::~eSDLInputDevice()
  16 {
  17 }
  18
  19 void eSDLInputDevice::handleCode(long arg)
  20 {
  21         const SDL_KeyboardEvent *event = (const SDL_KeyboardEvent *)arg;
  22         const SDL_keysym *key = &event->keysym;
  23         int km = input->getKeyboardMode();
  24         int code, flags;
  25
  26         if (event->type == SDL_KEYDOWN) {
  27                 m_unicode = key->unicode;
  28                 flags = eRCKey::flagMake;
  29         } else {
  30                 flags = eRCKey::flagBreak;
  31         }
  32
  33         if (km == eRCInput::kmNone) {
  34                 code = translateKey(key->sym);
  35         } else {
  36                 // ASCII keys should only generate key press events
  37                 if (flags == eRCKey::flagBreak)
  38                         return;
  39
  40                 eDebug("unicode=%04x scancode=%02x", m_unicode, key->scancode);
  41                 if (m_unicode & 0xff80) {
  42                         eDebug("SDL: skipping unicode character");
  43                         return;
  44                 }
  45                 code = m_unicode & ~0xff80;
  46                 // unicode not set...!? use key symbol
  47                 if (code == 0) {
  48                         // keysym is ascii
  49                         if (key->sym >= 128) {
  50                                 eDebug("SDL: cannot emulate ASCII");
  51                                 return;
  52                         }
  53                         eDebug("SDL: emulate ASCII");
  54                         code = key->sym;
  55                 }
  56                 if (km == eRCInput::kmAscii) {
  57                         // skip ESC c or ESC '[' c
  58                         if (m_escape) {
  59                                 if (code != '[')
  60                                         m_escape = false;
  61                                 return;
  62                         }
  63
  64                         if (code == SDLK_ESCAPE)
  65                                 m_escape = true;
  66
  67                         if ((code < SDLK_SPACE) ||
  68                             (code == 0x7e) ||   // really?
  69                             (code == SDLK_DELETE))
  70                                 return;
  71                 }
  72                 flags |= eRCKey::flagAscii;
  73         }
  74
  75         eDebug("SDL code=%d flags=%d", code, flags);
  76         input->keyPressed(eRCKey(this, code, flags));
  77 }
  78
  79 const char *eSDLInputDevice::getDescription() const
  80 {
  81         return "SDL";
  82 }
  83
  84 int eSDLInputDevice::translateKey(SDLKey key)
  85 {
  86         #define P(a)    case SDLK_##a: return KEY_##a
  87         #define P2(a,b) case SDLK_##a: return KEY_##b
  88
  89         switch (key) {
  90         P(BACKSPACE);
  91         P(TAB);
  92         P(CLEAR);
  93         P2(RETURN,ENTER);
  94         P(PAUSE);
  95         P2(ESCAPE,ESC);
  96         P(SPACE);
  97 #if 0
  98         P(EXCLAIM);
  99         P(QUOTEDBL);
 100         P(HASH);
 101 #endif
 102         P(DOLLAR);
 103 #if 0
 104         P(AMPERSAND);
 105 #endif
 106         P2(QUOTE,APOSTROPHE);
 107 #if 0
 108         P(LEFTPAREN);
 109         P(RIGHTPAREN);
 110         P(ASTERISK);
 111         P(PLUS);
 112 #endif
 113         P(COMMA);
 114         P(MINUS);
 115         P2(PERIOD,DOT);
 116         P(SLASH);
 117         P(0);
 118         P(1);
 119         P(2);
 120         P(3);
 121         P(4);
 122         P(5);
 123         P(6);
 124         P(7);
 125         P(8);
 126         P(9);
 127 #if 0
 128         P(COLON);
 129 #endif
 130         P(SEMICOLON);
 131 #if 0
 132         P(LESS);
 133 #endif
 134         P2(EQUALS,EQUAL);
 135 #if 0
 136         P(GREATER);
 137 #endif
 138         P(QUESTION);
 139 #if 0
 140         P(AT);
 141 #endif
 142         P2(LEFTBRACKET,LEFTBRACE);
 143         P(BACKSLASH);
 144         P2(RIGHTBRACKET,RIGHTBRACE);
 145         P2(CARET,GRAVE);
 146 #if 0
 147         P(UNDERSCORE);
 148         P(BACKQUOTE);
 149 #endif
 150         P2(a,A);
 151         P2(b,B);
 152         P2(c,C);
 153         P2(d,D);
 154         P2(e,E);
 155         P2(f,F);
 156         P2(g,G);
 157         P2(h,H);
 158         P2(i,I);
 159         P2(j,J);
 160         P2(k,K);
 161         P2(l,L);
 162         P2(m,M);
 163         P2(n,N);
 164         P2(o,O);
 165         P2(p,P);
 166         P2(q,Q);
 167         P2(r,R);
 168         P2(s,S);
 169         P2(t,T);
 170         P2(u,U);
 171         P2(v,V);
 172         P2(w,W);
 173         P2(x,X);
 174         P2(y,Y);
 175         P2(z,Z);
 176         P(DELETE);
 177 #if 0
 178         P(WORLD_0);
 179         P(WORLD_1);
 180         P(WORLD_2);
 181         P(WORLD_3);
 182         P(WORLD_4);
 183         P(WORLD_5);
 184         P(WORLD_6);
 185         P(WORLD_7);
 186         P(WORLD_8);
 187         P(WORLD_9);
 188         P(WORLD_10);
 189         P(WORLD_11);
 190         P(WORLD_12);
 191         P(WORLD_13);
 192         P(WORLD_14);
 193         P(WORLD_15);
 194         P(WORLD_16);
 195         P(WORLD_17);
 196         P(WORLD_18);
 197         P(WORLD_19);
 198         P(WORLD_20);
 199         P(WORLD_21);
 200         P(WORLD_22);
 201         P(WORLD_23);
 202         P(WORLD_24);
 203         P(WORLD_25);
 204         P(WORLD_26);
 205         P(WORLD_27);
 206         P(WORLD_28);
 207         P(WORLD_29);
 208         P(WORLD_30);
 209         P(WORLD_31);
 210         P(WORLD_32);
 211         P(WORLD_33);
 212         P(WORLD_34);
 213         P(WORLD_35);
 214         P(WORLD_36);
 215         P(WORLD_37);
 216         P(WORLD_38);
 217         P(WORLD_39);
 218         P(WORLD_40);
 219         P(WORLD_41);
 220         P(WORLD_42);
 221         P(WORLD_43);
 222         P(WORLD_44);
 223         P(WORLD_45);
 224         P(WORLD_46);
 225         P(WORLD_47);
 226         P(WORLD_48);
 227         P(WORLD_49);
 228         P(WORLD_50);
 229         P(WORLD_51);
 230         P(WORLD_52);
 231         P(WORLD_53);
 232         P(WORLD_54);
 233         P(WORLD_55);
 234         P(WORLD_56);
 235         P(WORLD_57);
 236         P(WORLD_58);
 237         P(WORLD_59);
 238         P(WORLD_60);
 239         P(WORLD_61);
 240         P(WORLD_62);
 241         P(WORLD_63);
 242         P(WORLD_64);
 243         P(WORLD_65);
 244         P(WORLD_66);
 245         P(WORLD_67);
 246         P(WORLD_68);
 247         P(WORLD_69);
 248         P(WORLD_70);
 249         P(WORLD_71);
 250         P(WORLD_72);
 251         P(WORLD_73);
 252         P(WORLD_74);
 253         P(WORLD_75);
 254         P(WORLD_76);
 255         P(WORLD_77);
 256         P(WORLD_78);
 257         P(WORLD_79);
 258         P(WORLD_80);
 259         P(WORLD_81);
 260         P(WORLD_82);
 261         P(WORLD_83);
 262         P(WORLD_84);
 263         P(WORLD_85);
 264         P(WORLD_86);
 265         P(WORLD_87);
 266         P(WORLD_88);
 267         P(WORLD_89);
 268         P(WORLD_90);
 269         P(WORLD_91);
 270         P(WORLD_92);
 271         P(WORLD_93);
 272         P(WORLD_94);
 273         P(WORLD_95);
 274 #endif
 275         P(KP0);
 276         P(KP1);
 277         P(KP2);
 278         P(KP3);
 279         P(KP4);
 280         P(KP5);
 281         P(KP6);
 282         P(KP7);
 283         P(KP8);
 284         P(KP9);
 285         P2(KP_PERIOD,KPDOT);
 286         P2(KP_DIVIDE,KPSLASH);
 287         P2(KP_MULTIPLY,KPASTERISK);
 288         P2(KP_MINUS,KPMINUS);
 289         P2(KP_PLUS,KPPLUS);
 290         P2(KP_ENTER,KPENTER);
 291         P2(KP_EQUALS,KPEQUAL);
 292         P(UP);
 293         P(DOWN);
 294         P(RIGHT);
 295         P(LEFT);
 296         P(INSERT);
 297         P(HOME);
 298         P(END);
 299         P(PAGEUP);
 300         P(PAGEDOWN);
 301         P(F1);
 302         P(F2);
 303         P(F3);
 304         P(F4);
 305         P(F5);
 306         P(F6);
 307         P(F7);
 308         P(F8);
 309         P(F9);
 310         P(F10);
 311         P(F11);
 312         P(F12);
 313         P(F13);
 314         P(F14);
 315         P(F15);
 316         P(NUMLOCK);
 317         P(CAPSLOCK);
 318         P2(SCROLLOCK,SCROLLLOCK);
 319         P2(RSHIFT,RIGHTSHIFT);
 320         P2(LSHIFT,LEFTSHIFT);
 321         P2(RCTRL,RIGHTCTRL);
 322         P2(LCTRL,LEFTCTRL);
 323         P2(RALT,RIGHTALT);
 324         P2(LALT,LEFTALT);
 325         P2(RMETA,RIGHTMETA);
 326         P2(LMETA,LEFTMETA);
 327 #if 0
 328         P(LSUPER);
 329         P(RSUPER);
 330 #endif
 331         P(MODE);
 332         P(COMPOSE);
 333         P(HELP);
 334         P(PRINT);
 335         P2(SYSREQ,SYSRQ);
 336         P(BREAK);
 337         P(MENU);
 338         P(POWER);
 339         P(EURO);
 340         P(UNDO);
 341         default:
 342                 eDebug("unhandled SDL keycode: %d", key);
 343                 return KEY_RESERVED;
 344         }
 345
 346         #undef P2
 347         #undef P
 348 }
 349
 350 /*
 351  * eSDLInputDriver
 352  */
 353
 354 eSDLInputDriver *eSDLInputDriver::instance;
 355
 356 eSDLInputDriver::eSDLInputDriver() : eRCDriver(eRCInput::getInstance())
 357 {
 358         ASSERT(instance == 0);
 359         instance = this;
 360 }
 361
 362 eSDLInputDriver::~eSDLInputDriver()
 363 {
 364         instance = 0;
 365 }
 366
 367 void eSDLInputDriver::keyPressed(const SDL_KeyboardEvent *key)
 368 {
 369         eDebug("km=%d enabled=%d locked=%d",
 370                 input->getKeyboardMode(), enabled, input->islocked());
 371
 372         if (!enabled || input->islocked())
 373                 return;
 374
 375         std::list<eRCDevice*>::iterator i(listeners.begin());
 376         while (i != listeners.end()) {
 377                 (*i)->handleCode((long)key);
 378                 ++i;
 379         }
 380 }
 381
 382 class eRCSDLInit
 383 {
 384 private:
 385         eSDLInputDriver driver;
 386         eSDLInputDevice device;
 387
 388 public:
 389         eRCSDLInit(): driver(), device(&driver)
 390         {
 391         }
 392 };
 393
 394 eAutoInitP0<eRCSDLInit> init_rcSDL(eAutoInitNumbers::rc+1, "SDL RC Driver");