src/SDLInput/SDLInput.cpp

   1 // Copyright 2008 Brian Caine
   2
   3 // This file is part of Potpourri.
   4
   5 // Potpourri is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9
  10 // Potpourri is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTIBILITY of FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with Potpourri. If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // NOTES:
  20 // The sauce to the afforementioned SDLInput class
  21
  22 #include "SDLInput.h"
  23 #include "../SDL/SDLManager.h"
  24
  25 #include <stdexcept>
  26 #include <iostream>
  27
  28 #include <SDL/SDL.h>
  29
  30 using namespace fragrant;
  31
  32 SDLInput::SDLInput()
  33 {
  34   pipeline = 0;
  35
  36   SDLManager manager;
  37   manager.increment(SS_Video);
  38 }
  39
  40 SDLInput::~SDLInput()
  41 {
  42   SDLManager manager;
  43   manager.decrement(SS_Video);
  44 }
  45
  46 void SDLInput::init(EventPipeline* pipeline)
  47 {
  48   SDL_EnableKeyRepeat(10, 30);
  49   this->pipeline = pipeline;
  50 }
  51
  52 void SDLInput::close()
  53 {
  54   delete this;
  55 }
  56
  57 void SDLInput::appendEvent(Event nevent)
  58 {
  59   events.push_back(nevent);
  60   return;
  61 }
  62
  63 void SDLInput::pump()
  64 {
  65   SDL_Event event;
  66   Event result;
  67
  68   while (SDL_PollEvent(&event))
  69     {
  70       switch (event.type)
  71         {
  72           case (SDL_ACTIVEEVENT):
  73             {
  74               result.name = EventStringArray[ET_WMEvent];
  75
  76               Variant* gain = new Variant();
  77               *gain = static_cast<int>(event.active.gain);
  78
  79               int nstate;
  80               int oldstate = event.active.state;
  81
  82               nstate = (oldstate & SDL_APPMOUSEFOCUS) |
  83                        (oldstate & SDL_APPINPUTFOCUS) |
  84                        (oldstate & SDL_APPACTIVE);
  85
  86               Variant* state = new Variant();
  87               *state = static_cast<int>(nstate);
  88
  89               result.data["gain"] = gain;
  90               result.data["state"] = state;
  91
  92               break;
  93             }
  94
  95           case (SDL_KEYDOWN):
  96           case (SDL_KEYUP):
  97             {
  98               result.name = EventStringArray[ET_Key];
  99
 100               Variant* pressed = new Variant();
 101               *pressed = (event.key.state == SDL_PRESSED);
 102
 103               Variant* dchar = new Variant();
 104               *dchar = static_cast<char>(event.key.keysym.unicode);
 105
 106               Variant* key = new Variant();
 107               *key = getKey(event.key.keysym.sym);
 108
 109               result.data["pressed"] = pressed;
 110               result.data["char"] = dchar;
 111               result.data["key"] = key;
 112
 113               break;
 114             }
 115
 116           case (SDL_MOUSEMOTION):
 117             {
 118               result.name = EventStringArray[ET_MouseMotion];
 119
 120               int ostate = event.motion.state;
 121
 122               Variant* state = new Variant();
 123               *state = static_cast<int>(
 124                 ((SDL_BUTTON(1) & ostate) ? MB_LEFT : 0) |
 125                 ((SDL_BUTTON(2) & ostate) ? MB_MIDDLE : 0) |
 126                 ((SDL_BUTTON(3) & ostate) ? MB_RIGHT : 0));
 127
 128               Variant* x = new Variant();
 129               *x = static_cast<int>(event.motion.x);
 130
 131               Variant* y = new Variant();
 132               *y = static_cast<int>(event.motion.y);
 133
 134               Variant* xrel = new Variant();
 135               *xrel = static_cast<int>(event.motion.xrel);
 136
 137               Variant* yrel = new Variant();
 138               *yrel = static_cast<int>(event.motion.yrel);
 139
 140               result.data["state"] = state;
 141
 142               result.data["x"] = x;
 143               result.data["y"] = y;
 144
 145               result.data["xrel"] = xrel;
 146               result.data["yrel"] = yrel;
 147
 148               break;
 149             }
 150
 151           case (SDL_MOUSEBUTTONDOWN):
 152           case (SDL_MOUSEBUTTONUP):
 153             {
 154               result.name = EventStringArray[ET_MouseButton];
 155
 156               Variant* button = new Variant();
 157               switch (event.button.button)
 158                 {
 159                   case(SDL_BUTTON_LEFT):
 160                     {
 161                       *button = MB_LEFT;
 162                       break;
 163                     }
 164
 165                   case(SDL_BUTTON_MIDDLE):
 166                     {
 167                       *button = MB_MIDDLE;
 168                       break;
 169                     }
 170                   case(SDL_BUTTON_RIGHT):
 171                     {
 172                       *button = MB_RIGHT;
 173                       break;
 174                     }
 175                   case(SDL_BUTTON_WHEELUP):
 176                     {
 177                       *button = MB_WHEEL_UP;
 178                       break;
 179                     }
 180                   case(SDL_BUTTON_WHEELDOWN):
 181                     {
 182                       *button = MB_WHEEL_DOWN;
 183                       break;
 184                     }
 185                 }
 186
 187               Variant* pressed = new Variant();
 188               *pressed = event.button.state == SDL_PRESSED;
 189
 190               Variant* x = new Variant();
 191               *x = static_cast<int>(event.button.x);
 192
 193               Variant* y = new Variant();
 194               *y = static_cast<int>(event.button.y);
 195
 196               result.data["button"] = button;
 197               result.data["pressed"] = pressed;
 198
 199               result.data["x"] = x;
 200               result.data["y"] = y;
 201
 202               break;
 203             }
 204
 205           case (SDL_JOYAXISMOTION):
 206           case (SDL_JOYBALLMOTION):
 207           case (SDL_JOYHATMOTION):
 208           case (SDL_JOYBUTTONDOWN):
 209           case (SDL_JOYBUTTONUP):
 210             {
 211               std::cout << "SDLInput::pump(): Joystick events not supported"
 212                         << std::endl;
 213               break;
 214             }
 215
 216           case (SDL_QUIT):
 217             {
 218               result.name = EventStringArray[ET_Quit];
 219               break;
 220             }
 221         }
 222
 223       pipeline->raiseEvent(result);
 224       result = Event();
 225     }
 226
 227   int cur;
 228   for (cur = 0; cur < events.size(); cur++)
 229     pipeline->raiseEvent(events.at(cur));
 230
 231   events.clear();
 232
 233   return;
 234 }
 235
 236 Key SDLInput::getKey(SDLKey key)
 237 {
 238   switch (key)
 239     {
 240       case(SDLK_FIRST): return K_FIRST;
 241       case(SDLK_BACKSPACE): return K_BACKSPACE;
 242       case(SDLK_TAB): return K_TAB;
 243       case(SDLK_CLEAR): return K_CLEAR;
 244       case(SDLK_RETURN): return K_RETURN;
 245       case(SDLK_PAUSE): return K_PAUSE;
 246       case(SDLK_ESCAPE): return K_ESCAPE;
 247       case(SDLK_SPACE): return K_SPACE;
 248       case(SDLK_EXCLAIM): return K_EXCLAIM;
 249       case(SDLK_QUOTEDBL): return K_QUOTEDBL;
 250       case(SDLK_HASH): return K_HASH;
 251       case(SDLK_DOLLAR): return K_DOLLAR;
 252       case(SDLK_AMPERSAND): return K_AMPERSAND;
 253       case(SDLK_QUOTE): return K_QUOTE;
 254       case(SDLK_LEFTPAREN): return K_LEFTPAREN;
 255       case(SDLK_RIGHTPAREN): return K_RIGHTPAREN;
 256       case(SDLK_ASTERISK): return K_ASTERISK;
 257       case(SDLK_PLUS): return K_PLUS;
 258       case(SDLK_COMMA): return K_COMMA;
 259       case(SDLK_MINUS): return K_MINUS;
 260       case(SDLK_PERIOD): return K_PERIOD;
 261       case(SDLK_SLASH): return K_SLASH;
 262       case(SDLK_0): return K_0;
 263       case(SDLK_1): return K_1;
 264       case(SDLK_2): return K_2;
 265       case(SDLK_3): return K_3;
 266       case(SDLK_4): return K_4;
 267       case(SDLK_5): return K_5;
 268       case(SDLK_6): return K_6;
 269       case(SDLK_7): return K_7;
 270       case(SDLK_8): return K_8;
 271       case(SDLK_9): return K_9;
 272       case(SDLK_COLON): return K_COLON;
 273       case(SDLK_SEMICOLON): return K_SEMICOLON;
 274       case(SDLK_LESS): return K_LESS;
 275       case(SDLK_EQUALS): return K_EQUALS;
 276       case(SDLK_GREATER): return K_GREATER;
 277       case(SDLK_QUESTION): return K_QUESTION;
 278       case(SDLK_AT): return K_AT;
 279       case(SDLK_LEFTBRACKET): return K_LEFTBRACKET;
 280       case(SDLK_BACKSLASH): return K_BACKSLASH;
 281       case(SDLK_RIGHTBRACKET): return K_RIGHTBRACKET;
 282       case(SDLK_CARET): return K_CARET;
 283       case(SDLK_UNDERSCORE): return K_UNDERSCORE;
 284       case(SDLK_BACKQUOTE): return K_BACKQUOTE;
 285       case(SDLK_a): return K_a;
 286       case(SDLK_b): return K_b;
 287       case(SDLK_c): return K_c;
 288       case(SDLK_d): return K_d;
 289       case(SDLK_e): return K_e;
 290       case(SDLK_f): return K_f;
 291       case(SDLK_g): return K_g;
 292       case(SDLK_h): return K_h;
 293       case(SDLK_i): return K_i;
 294       case(SDLK_j): return K_j;
 295       case(SDLK_k): return K_k;
 296       case(SDLK_l): return K_l;
 297       case(SDLK_m): return K_m;
 298       case(SDLK_n): return K_n;
 299       case(SDLK_o): return K_o;
 300       case(SDLK_p): return K_p;
 301       case(SDLK_q): return K_q;
 302       case(SDLK_r): return K_r;
 303       case(SDLK_s): return K_s;
 304       case(SDLK_t): return K_t;
 305       case(SDLK_u): return K_u;
 306       case(SDLK_v): return K_v;
 307       case(SDLK_w): return K_w;
 308       case(SDLK_x): return K_x;
 309       case(SDLK_y): return K_y;
 310       case(SDLK_z): return K_z;
 311       case(SDLK_DELETE): return K_DELETE;
 312       case(SDLK_WORLD_0): return K_WORLD_0;
 313       case(SDLK_WORLD_1): return K_WORLD_1;
 314       case(SDLK_WORLD_2): return K_WORLD_2;
 315       case(SDLK_WORLD_3): return K_WORLD_3;
 316       case(SDLK_WORLD_4): return K_WORLD_4;
 317       case(SDLK_WORLD_5): return K_WORLD_5;
 318       case(SDLK_WORLD_6): return K_WORLD_6;
 319       case(SDLK_WORLD_7): return K_WORLD_7;
 320       case(SDLK_WORLD_8): return K_WORLD_8;
 321       case(SDLK_WORLD_9): return K_WORLD_9;
 322       case(SDLK_WORLD_10): return K_WORLD_10;
 323       case(SDLK_WORLD_11): return K_WORLD_11;
 324       case(SDLK_WORLD_12): return K_WORLD_12;
 325       case(SDLK_WORLD_13): return K_WORLD_13;
 326       case(SDLK_WORLD_14): return K_WORLD_14;
 327       case(SDLK_WORLD_15): return K_WORLD_15;
 328       case(SDLK_WORLD_16): return K_WORLD_16;
 329       case(SDLK_WORLD_17): return K_WORLD_17;
 330       case(SDLK_WORLD_18): return K_WORLD_18;
 331       case(SDLK_WORLD_19): return K_WORLD_19;
 332       case(SDLK_WORLD_20): return K_WORLD_20;
 333       case(SDLK_WORLD_21): return K_WORLD_21;
 334       case(SDLK_WORLD_22): return K_WORLD_22;
 335       case(SDLK_WORLD_23): return K_WORLD_23;
 336       case(SDLK_WORLD_24): return K_WORLD_24;
 337       case(SDLK_WORLD_25): return K_WORLD_25;
 338       case(SDLK_WORLD_26): return K_WORLD_26;
 339       case(SDLK_WORLD_27): return K_WORLD_27;
 340       case(SDLK_WORLD_28): return K_WORLD_28;
 341       case(SDLK_WORLD_29): return K_WORLD_29;
 342       case(SDLK_WORLD_30): return K_WORLD_30;
 343       case(SDLK_WORLD_31): return K_WORLD_31;
 344       case(SDLK_WORLD_32): return K_WORLD_32;
 345       case(SDLK_WORLD_33): return K_WORLD_33;
 346       case(SDLK_WORLD_34): return K_WORLD_34;
 347       case(SDLK_WORLD_35): return K_WORLD_35;
 348       case(SDLK_WORLD_36): return K_WORLD_36;
 349       case(SDLK_WORLD_37): return K_WORLD_37;
 350       case(SDLK_WORLD_38): return K_WORLD_38;
 351       case(SDLK_WORLD_39): return K_WORLD_39;
 352       case(SDLK_WORLD_40): return K_WORLD_40;
 353       case(SDLK_WORLD_41): return K_WORLD_41;
 354       case(SDLK_WORLD_42): return K_WORLD_42;
 355       case(SDLK_WORLD_43): return K_WORLD_43;
 356       case(SDLK_WORLD_44): return K_WORLD_44;
 357       case(SDLK_WORLD_45): return K_WORLD_45;
 358       case(SDLK_WORLD_46): return K_WORLD_46;
 359       case(SDLK_WORLD_47): return K_WORLD_47;
 360       case(SDLK_WORLD_48): return K_WORLD_48;
 361       case(SDLK_WORLD_49): return K_WORLD_49;
 362       case(SDLK_WORLD_50): return K_WORLD_50;
 363       case(SDLK_WORLD_51): return K_WORLD_51;
 364       case(SDLK_WORLD_52): return K_WORLD_52;
 365       case(SDLK_WORLD_53): return K_WORLD_53;
 366       case(SDLK_WORLD_54): return K_WORLD_54;
 367       case(SDLK_WORLD_55): return K_WORLD_55;
 368       case(SDLK_WORLD_56): return K_WORLD_56;
 369       case(SDLK_WORLD_57): return K_WORLD_57;
 370       case(SDLK_WORLD_58): return K_WORLD_58;
 371       case(SDLK_WORLD_59): return K_WORLD_59;
 372       case(SDLK_WORLD_60): return K_WORLD_60;
 373       case(SDLK_WORLD_61): return K_WORLD_61;
 374       case(SDLK_WORLD_62): return K_WORLD_62;
 375       case(SDLK_WORLD_63): return K_WORLD_63;
 376       case(SDLK_WORLD_64): return K_WORLD_64;
 377       case(SDLK_WORLD_65): return K_WORLD_65;
 378       case(SDLK_WORLD_66): return K_WORLD_66;
 379       case(SDLK_WORLD_67): return K_WORLD_67;
 380       case(SDLK_WORLD_68): return K_WORLD_68;
 381       case(SDLK_WORLD_69): return K_WORLD_69;
 382       case(SDLK_WORLD_70): return K_WORLD_70;
 383       case(SDLK_WORLD_71): return K_WORLD_71;
 384       case(SDLK_WORLD_72): return K_WORLD_72;
 385       case(SDLK_WORLD_73): return K_WORLD_73;
 386       case(SDLK_WORLD_74): return K_WORLD_74;
 387       case(SDLK_WORLD_75): return K_WORLD_75;
 388       case(SDLK_WORLD_76): return K_WORLD_76;
 389       case(SDLK_WORLD_77): return K_WORLD_77;
 390       case(SDLK_WORLD_78): return K_WORLD_78;
 391       case(SDLK_WORLD_79): return K_WORLD_79;
 392       case(SDLK_WORLD_80): return K_WORLD_80;
 393       case(SDLK_WORLD_81): return K_WORLD_81;
 394       case(SDLK_WORLD_82): return K_WORLD_82;
 395       case(SDLK_WORLD_83): return K_WORLD_83;
 396       case(SDLK_WORLD_84): return K_WORLD_84;
 397       case(SDLK_WORLD_85): return K_WORLD_85;
 398       case(SDLK_WORLD_86): return K_WORLD_86;
 399       case(SDLK_WORLD_87): return K_WORLD_87;
 400       case(SDLK_WORLD_88): return K_WORLD_88;
 401       case(SDLK_WORLD_89): return K_WORLD_89;
 402       case(SDLK_WORLD_90): return K_WORLD_90;
 403       case(SDLK_WORLD_91): return K_WORLD_91;
 404       case(SDLK_WORLD_92): return K_WORLD_92;
 405       case(SDLK_WORLD_93): return K_WORLD_93;
 406       case(SDLK_WORLD_94): return K_WORLD_94;
 407       case(SDLK_WORLD_95): return K_WORLD_95;
 408       case(SDLK_KP0): return K_KP0;
 409       case(SDLK_KP1): return K_KP1;
 410       case(SDLK_KP2): return K_KP2;
 411       case(SDLK_KP3): return K_KP3;
 412       case(SDLK_KP4): return K_KP4;
 413       case(SDLK_KP5): return K_KP5;
 414       case(SDLK_KP6): return K_KP6;
 415       case(SDLK_KP7): return K_KP7;
 416       case(SDLK_KP8): return K_KP8;
 417       case(SDLK_KP9): return K_KP9;
 418       case(SDLK_KP_PERIOD): return K_KP_PERIOD;
 419       case(SDLK_KP_DIVIDE): return K_KP_DIVIDE;
 420       case(SDLK_KP_MULTIPLY): return K_KP_MULTIPLY;
 421       case(SDLK_KP_MINUS): return K_KP_MINUS;
 422       case(SDLK_KP_PLUS): return K_KP_PLUS;
 423       case(SDLK_KP_ENTER): return K_KP_ENTER;
 424       case(SDLK_KP_EQUALS): return K_KP_EQUALS;
 425       case(SDLK_UP): return K_UP;
 426       case(SDLK_DOWN): return K_DOWN;
 427       case(SDLK_RIGHT): return K_RIGHT;
 428       case(SDLK_LEFT): return K_LEFT;
 429       case(SDLK_INSERT): return K_INSERT;
 430       case(SDLK_HOME): return K_HOME;
 431       case(SDLK_END): return K_END;
 432       case(SDLK_PAGEUP): return K_PAGEUP;
 433       case(SDLK_PAGEDOWN): return K_PAGEDOWN;
 434       case(SDLK_F1): return K_F1;
 435       case(SDLK_F2): return K_F2;
 436       case(SDLK_F3): return K_F3;
 437       case(SDLK_F4): return K_F4;
 438       case(SDLK_F5): return K_F5;
 439       case(SDLK_F6): return K_F6;
 440       case(SDLK_F7): return K_F7;
 441       case(SDLK_F8): return K_F8;
 442       case(SDLK_F9): return K_F9;
 443       case(SDLK_F10): return K_F10;
 444       case(SDLK_F11): return K_F11;
 445       case(SDLK_F12): return K_F12;
 446       case(SDLK_F13): return K_F13;
 447       case(SDLK_F14): return K_F14;
 448       case(SDLK_F15): return K_F15;
 449       case(SDLK_NUMLOCK): return K_NUMLOCK;
 450       case(SDLK_CAPSLOCK): return K_CAPSLOCK;
 451       case(SDLK_SCROLLOCK): return K_SCROLLOCK;
 452       case(SDLK_RSHIFT): return K_RSHIFT;
 453       case(SDLK_LSHIFT): return K_LSHIFT;
 454       case(SDLK_RCTRL): return K_RCTRL;
 455       case(SDLK_LCTRL): return K_LCTRL;
 456       case(SDLK_RALT): return K_RALT;
 457       case(SDLK_LALT): return K_LALT;
 458       case(SDLK_RMETA): return K_RMETA;
 459       case(SDLK_LMETA): return K_LMETA;
 460       case(SDLK_LSUPER): return K_LSUPER;
 461       case(SDLK_RSUPER): return K_RSUPER;
 462       case(SDLK_MODE): return K_MODE;
 463       case(SDLK_COMPOSE): return K_COMPOSE;
 464       case(SDLK_HELP): return K_HELP;
 465       case(SDLK_PRINT): return K_PRINT;
 466       case(SDLK_SYSREQ): return K_SYSREQ;
 467       case(SDLK_BREAK): return K_BREAK;
 468       case(SDLK_MENU): return K_MENU;
 469       case(SDLK_POWER): return K_POWER;
 470       case(SDLK_EURO): return K_EURO;
 471       case(SDLK_UNDO): return K_UNDO;
 472     }
 473 }