FUNCTIONS

1. GGI_PumpEvents
2. GGI_InitOSKeymap
3. GGI_TranslateKey

   1 /*
   2         SDL - Simple DirectMedia Layer
   3         Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
   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
  17         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 
  19         Sam Lantinga
  20         slouken@devolution.com
  21 */
  23 #ifdef SAVE_RCSID
  24 static char rcsid =
  25  "@(#) $Id: SDL_ggievents.c,v 1.2.2.2 2001/02/10 07:20:06 hercules Exp $";
  26 #endif
  28 /* Handle the event stream, converting GGI events into SDL events */
  30 #include <sys/types.h>
  31 #include <sys/time.h>
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <termios.h>
  38 #include <ggi/keyboard.h>
  40 #include "SDL_ggikeys.h"
  42 #include "SDL.h"
  43 #include "SDL_sysevents.h"
  44 #include "SDL_sysvideo.h"
  45 #include "SDL_events_c.h"
  46 #include "SDL_ggivideo.h"
  47 #include "SDL_ggievents_c.h"
  49 /* The translation tables from a GGI keycode to a SDL keysym */
  50 static SDLKey keymap[128];
  51 static SDL_keysym *GGI_TranslateKey(ggi_event *ev, SDL_keysym *keysym);
  53 static int posted = 0;
  55 void GGI_PumpEvents(_THIS)
     /* [<][>][^][v][top][bottom][index][help] */
  56 {
  57         struct timeval *tvp, tv = { 0, 0 };
  58         ggi_event ev;
  60         tvp = &tv;
  62 /*      ggiFlush(VIS); */
  64         while (ggiEventPoll(VIS, emAll, tvp))
  65 /*      while (ggiEventPoll(VIS, (emKeyboard | emPointer | emCommand), tvp)) */
  66         {
  67                 int queueevent_mouse = 0, queueevent_kbd = 0;
  68                 static int buttons = 0;
  69                 static int mouse_x = 0, mouse_y = 0, mouse_z = 0;
  70                 int x = 0, y = 0, z = 0, rx = 0, ry = 0, rz = 0;
  71                 uint32 sym;
  72                 int pressed_mouse, pressed_kbd;
  73                 SDL_keysym keysym;
  75                 posted = 0;
  77                 /* FIXME: We do not actually want all events, only
  78                  * mouse and keyboard events.  Having to handle all
  79                  * events will slow things down.  */
  81                 ggiEventRead(VIS, &ev, emAll);
  82 /*              ggiEventRead(VIS, &ev, (emKeyboard | emPointer | emCommand)); */
  84                 switch (ev.any.type)
  85                 {
  86                         case evPtrRelative:
  87                         x = ev.pmove.x;
  88                         y = ev.pmove.y;
  89                         z = ev.pmove.wheel;
  90                         posted += SDL_PrivateMouseMotion(0, 1, x, y);
  91                         break;
  92                         case evPtrAbsolute:
  93                         if (mouse_x != ev.pmove.x || mouse_y != ev.pmove.y || mouse_z != ev.pmove.wheel)
  94                         {
  95                                 x = ev.pmove.x - mouse_x;
  96                                 y = ev.pmove.y - mouse_y;
  97                                 z = ev.pmove.wheel - mouse_z;
  98                                 mouse_x = ev.pmove.x;
  99                                 mouse_y = ev.pmove.y;
 100                                 mouse_z = ev.pmove.wheel;
 101                                 posted += SDL_PrivateMouseMotion(0, 1, x, y);
 102                         } 
 103                         break;
 104                         case evPtrButtonPress:
 105                         posted += SDL_PrivateMouseButton(SDL_PRESSED, ev.pbutton.button, 0, 0);
 106                         break;
 107                         case evPtrButtonRelease:
 108                         posted += SDL_PrivateMouseButton(SDL_RELEASED, ev.pbutton.button, 0, 0);
 109                         break;
 110                         case evKeyPress:
 111                         case evKeyRepeat:
 112                         posted += SDL_PrivateKeyboard(SDL_PRESSED, GGI_TranslateKey(&ev, &keysym));
 113                         break;
 114                         case evKeyRelease:
 115                         posted += SDL_PrivateKeyboard(SDL_RELEASED, GGI_TranslateKey(&ev, &keysym));
 116                         break;
 117                         case evCommand:
 118                         fprintf(stderr, "Command event %x recieved\n", ev.cmd.code);
 119                         break;
 120                         default:
 121                         fprintf(stderr, "Unhandled event type %d\n", ev.any.type);
 122                         break;
 123                 }
 124         }
 126 }
 128 void GGI_InitOSKeymap(_THIS)
     /* [<][>][^][v][top][bottom][index][help] */
 129 {
 130         int i;
 132         /* Initialize the GGI key translation table */
 133         for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
 134                 keymap[i] = SDLK_UNKNOWN;
 136         keymap[SCANCODE_ESCAPE] = SDLK_ESCAPE;
 137         keymap[SCANCODE_1] = SDLK_1;
 138         keymap[SCANCODE_2] = SDLK_2;
 139         keymap[SCANCODE_3] = SDLK_3;
 140         keymap[SCANCODE_4] = SDLK_4;
 141         keymap[SCANCODE_5] = SDLK_5;
 142         keymap[SCANCODE_6] = SDLK_6;
 143         keymap[SCANCODE_7] = SDLK_7;
 144         keymap[SCANCODE_8] = SDLK_8;
 145         keymap[SCANCODE_9] = SDLK_9;
 146         keymap[SCANCODE_0] = SDLK_0;
 147         keymap[SCANCODE_MINUS] = SDLK_MINUS;
 148         keymap[SCANCODE_EQUAL] = SDLK_EQUALS;
 149         keymap[SCANCODE_BACKSPACE] = SDLK_BACKSPACE;
 150         keymap[SCANCODE_TAB] = SDLK_TAB;
 151         keymap[SCANCODE_Q] = SDLK_q;
 152         keymap[SCANCODE_W] = SDLK_w;
 153         keymap[SCANCODE_E] = SDLK_e;
 154         keymap[SCANCODE_R] = SDLK_r;
 155         keymap[SCANCODE_T] = SDLK_t;
 156         keymap[SCANCODE_Y] = SDLK_y;
 157         keymap[SCANCODE_U] = SDLK_u;
 158         keymap[SCANCODE_I] = SDLK_i;
 159         keymap[SCANCODE_O] = SDLK_o;
 160         keymap[SCANCODE_P] = SDLK_p;
 161         keymap[SCANCODE_BRACKET_LEFT] = SDLK_LEFTBRACKET;
 162         keymap[SCANCODE_BRACKET_RIGHT] = SDLK_RIGHTBRACKET;
 163         keymap[SCANCODE_ENTER] = SDLK_RETURN;
 164         keymap[SCANCODE_LEFTCONTROL] = SDLK_LCTRL;
 165         keymap[SCANCODE_A] = SDLK_a;
 166         keymap[SCANCODE_S] = SDLK_s;
 167         keymap[SCANCODE_D] = SDLK_d;
 168         keymap[SCANCODE_F] = SDLK_f;
 169         keymap[SCANCODE_G] = SDLK_g;
 170         keymap[SCANCODE_H] = SDLK_h;
 171         keymap[SCANCODE_J] = SDLK_j;
 172         keymap[SCANCODE_K] = SDLK_k;
 173         keymap[SCANCODE_L] = SDLK_l;
 174         keymap[SCANCODE_SEMICOLON] = SDLK_SEMICOLON;
 175         keymap[SCANCODE_APOSTROPHE] = SDLK_QUOTE;
 176         keymap[SCANCODE_GRAVE] = SDLK_BACKQUOTE;
 177         keymap[SCANCODE_LEFTSHIFT] = SDLK_LSHIFT;
 178         keymap[SCANCODE_BACKSLASH] = SDLK_BACKSLASH;
 179         keymap[SCANCODE_Z] = SDLK_z;
 180         keymap[SCANCODE_X] = SDLK_x;
 181         keymap[SCANCODE_C] = SDLK_c;
 182         keymap[SCANCODE_V] = SDLK_v;
 183         keymap[SCANCODE_B] = SDLK_b;
 184         keymap[SCANCODE_N] = SDLK_n;
 185         keymap[SCANCODE_M] = SDLK_m;
 186         keymap[SCANCODE_COMMA] = SDLK_COMMA;
 187         keymap[SCANCODE_PERIOD] = SDLK_PERIOD;
 188         keymap[SCANCODE_SLASH] = SDLK_SLASH;
 189         keymap[SCANCODE_RIGHTSHIFT] = SDLK_RSHIFT;
 190         keymap[SCANCODE_KEYPADMULTIPLY] = SDLK_KP_MULTIPLY;
 191         keymap[SCANCODE_LEFTALT] = SDLK_LALT;
 192         keymap[SCANCODE_SPACE] = SDLK_SPACE;
 193         keymap[SCANCODE_CAPSLOCK] = SDLK_CAPSLOCK;
 194         keymap[SCANCODE_F1] = SDLK_F1;
 195         keymap[SCANCODE_F2] = SDLK_F2;
 196         keymap[SCANCODE_F3] = SDLK_F3;
 197         keymap[SCANCODE_F4] = SDLK_F4;
 198         keymap[SCANCODE_F5] = SDLK_F5;
 199         keymap[SCANCODE_F6] = SDLK_F6;
 200         keymap[SCANCODE_F7] = SDLK_F7;
 201         keymap[SCANCODE_F8] = SDLK_F8;
 202         keymap[SCANCODE_F9] = SDLK_F9;
 203         keymap[SCANCODE_F10] = SDLK_F10;
 204         keymap[SCANCODE_NUMLOCK] = SDLK_NUMLOCK;
 205         keymap[SCANCODE_SCROLLLOCK] = SDLK_SCROLLOCK;
 206         keymap[SCANCODE_KEYPAD7] = SDLK_KP7;
 207         keymap[SCANCODE_CURSORUPLEFT] = SDLK_KP7;
 208         keymap[SCANCODE_KEYPAD8] = SDLK_KP8;
 209         keymap[SCANCODE_CURSORUP] = SDLK_KP8;
 210         keymap[SCANCODE_KEYPAD9] = SDLK_KP9;
 211         keymap[SCANCODE_CURSORUPRIGHT] = SDLK_KP9;
 212         keymap[SCANCODE_KEYPADMINUS] = SDLK_KP_MINUS;
 213         keymap[SCANCODE_KEYPAD4] = SDLK_KP4;
 214         keymap[SCANCODE_CURSORLEFT] = SDLK_KP4;
 215         keymap[SCANCODE_KEYPAD5] = SDLK_KP5;
 216         keymap[SCANCODE_KEYPAD6] = SDLK_KP6;
 217         keymap[SCANCODE_CURSORRIGHT] = SDLK_KP6;
 218         keymap[SCANCODE_KEYPADPLUS] = SDLK_KP_PLUS;
 219         keymap[SCANCODE_KEYPAD1] = SDLK_KP1;
 220         keymap[SCANCODE_CURSORDOWNLEFT] = SDLK_KP1;
 221         keymap[SCANCODE_KEYPAD2] = SDLK_KP2;
 222         keymap[SCANCODE_CURSORDOWN] = SDLK_KP2;
 223         keymap[SCANCODE_KEYPAD3] = SDLK_KP3;
 224         keymap[SCANCODE_CURSORDOWNRIGHT] = SDLK_KP3;
 225         keymap[SCANCODE_KEYPAD0] = SDLK_KP0;
 226         keymap[SCANCODE_KEYPADPERIOD] = SDLK_KP_PERIOD;
 227         keymap[SCANCODE_LESS] = SDLK_LESS;
 228         keymap[SCANCODE_F11] = SDLK_F11;
 229         keymap[SCANCODE_F12] = SDLK_F12;
 230         keymap[SCANCODE_KEYPADENTER] = SDLK_KP_ENTER;
 231         keymap[SCANCODE_RIGHTCONTROL] = SDLK_RCTRL;
 232         keymap[SCANCODE_CONTROL] = SDLK_RCTRL;
 233         keymap[SCANCODE_KEYPADDIVIDE] = SDLK_KP_DIVIDE;
 234         keymap[SCANCODE_PRINTSCREEN] = SDLK_PRINT;
 235         keymap[SCANCODE_RIGHTALT] = SDLK_RALT;
 236         keymap[SCANCODE_BREAK] = SDLK_BREAK;
 237         keymap[SCANCODE_BREAK_ALTERNATIVE] = SDLK_UNKNOWN;
 238         keymap[SCANCODE_HOME] = SDLK_HOME;
 239         keymap[SCANCODE_CURSORBLOCKUP] = SDLK_UP;
 240         keymap[SCANCODE_PAGEUP] = SDLK_PAGEUP;
 241         keymap[SCANCODE_CURSORBLOCKLEFT] = SDLK_LEFT;
 242         keymap[SCANCODE_CURSORBLOCKRIGHT] = SDLK_RIGHT;
 243         keymap[SCANCODE_END] = SDLK_END;
 244         keymap[SCANCODE_CURSORBLOCKDOWN] = SDLK_DOWN;
 245         keymap[SCANCODE_PAGEDOWN] = SDLK_PAGEDOWN;
 246         keymap[SCANCODE_INSERT] = SDLK_INSERT;
 247         keymap[SCANCODE_REMOVE] = SDLK_DELETE;
 248         keymap[119] = SDLK_PAUSE;
 249         keymap[SCANCODE_RIGHTWIN] = SDLK_RSUPER;
 250         keymap[SCANCODE_LEFTWIN] = SDLK_LSUPER;
 251         keymap[127] = SDLK_MENU;
 252 }
 256 static SDL_keysym *GGI_TranslateKey(gii_event *ev, SDL_keysym *keysym)
     /* [<][>][^][v][top][bottom][index][help] */
 257 {
 258         /* Set the keysym information */
 259         keysym->scancode = ev->key.button;
 260         keysym->sym = keymap[ev->key.button];
 261         keysym->mod = KMOD_NONE;
 263         /* If UNICODE is on, get the UNICODE value for the key */
 264         keysym->unicode = 0;
 265         if (SDL_TranslateUNICODE) 
 266         {
 267                 keysym->unicode = GII_UNICODE(ev->key.sym);
 268         }
 270         return keysym;
 271 }