sdl-ios-xcode: src/video/x11/SDL_x11events.c comparison

comparison src/video/x11/SDL_x11events.c @ 1668:4da1ee79c9af SDL-1.3

more tweaking indent options

author	Sam Lantinga <slouken@libsdl.org>
date	Mon, 29 May 2006 04:04:35 +0000
parents	782fd950bd46
children

comparison

equal deleted inserted replaced

-:1fddae038bc8
+:4da1ee79c9af
 /*#define DEBUG_XEVENTS*/
 /* The translation tables from an X11 keysym to a SDL keysym */
 static SDLKey ODD_keymap[256];
 static SDLKey MISC_keymap[256];
-SDLKey X11_TranslateKeycode (Display * display, KeyCode kc);
+SDLKey X11_TranslateKeycode(Display * display, KeyCode kc);
 #ifdef X_HAVE_UTF8_STRING
 Uint32
-Utf8ToUcs4 (const Uint8 * utf8)
+Utf8ToUcs4(const Uint8 * utf8)
 {
 Uint32 c;
 int i = 1;
 int noOctets = 0;
 int firstOctetMask = 0;
 /* Check to see if this is a repeated key.
 (idea shamelessly lifted from GII -- thanks guys! :)
 */
 static int
-X11_KeyRepeat (Display * display, XEvent * event)
+X11_KeyRepeat(Display * display, XEvent * event)
 {
 XEvent peekevent;
 int repeated;
 repeated = 0;
-if (XPending (display)) {
+if (XPending(display)) {
-XPeekEvent (display, &peekevent);
+XPeekEvent(display, &peekevent);
 if ((peekevent.type == KeyPress) &&
 (peekevent.xkey.keycode == event->xkey.keycode) &&
 ((peekevent.xkey.time - event->xkey.time) < 2)) {
 repeated = 1;
-XNextEvent (display, &peekevent);
+XNextEvent(display, &peekevent);
 }
 }
 return (repeated);
 }
 warping the pointer when it reaches the edge, and then wait for it.
 */
 #define MOUSE_FUDGE_FACTOR	8
 static __inline__ int
-X11_WarpedMotion (_THIS, XEvent * xevent)
+X11_WarpedMotion(_THIS, XEvent * xevent)
 {
 int w, h, i;
 int deltax, deltay;
 int posted;
 w = SDL_VideoSurface->w;
 h = SDL_VideoSurface->h;
 deltax = xevent->xmotion.x - mouse_last.x;
 deltay = xevent->xmotion.y - mouse_last.y;
 #ifdef DEBUG_MOTION
-printf ("Warped mouse motion: %d,%d\n", deltax, deltay);
+printf("Warped mouse motion: %d,%d\n", deltax, deltay);
 #endif
 mouse_last.x = xevent->xmotion.x;
 mouse_last.y = xevent->xmotion.y;
-posted = SDL_PrivateMouseMotion (0, 1, deltax, deltay);
+posted = SDL_PrivateMouseMotion(0, 1, deltax, deltay);
 if ((xevent->xmotion.x < MOUSE_FUDGE_FACTOR) ||
 (xevent->xmotion.x > (w - MOUSE_FUDGE_FACTOR)) ||
 (xevent->xmotion.y < MOUSE_FUDGE_FACTOR) ||
 (xevent->xmotion.y > (h - MOUSE_FUDGE_FACTOR))) {
 /* Get the events that have accumulated */
-while (XCheckTypedEvent (SDL_Display, MotionNotify, xevent)) {
+while (XCheckTypedEvent(SDL_Display, MotionNotify, xevent)) {
 deltax = xevent->xmotion.x - mouse_last.x;
 deltay = xevent->xmotion.y - mouse_last.y;
 #ifdef DEBUG_MOTION
-printf ("Extra mouse motion: %d,%d\n", deltax, deltay);
+printf("Extra mouse motion: %d,%d\n", deltax, deltay);
 #endif
 mouse_last.x = xevent->xmotion.x;
 mouse_last.y = xevent->xmotion.y;
-posted += SDL_PrivateMouseMotion (0, 1, deltax, deltay);
+posted += SDL_PrivateMouseMotion(0, 1, deltax, deltay);
 }
 mouse_last.x = w / 2;
 mouse_last.y = h / 2;
-XWarpPointer (SDL_Display, None, SDL_Window, 0, 0, 0, 0,
+XWarpPointer(SDL_Display, None, SDL_Window, 0, 0, 0, 0,
 mouse_last.x, mouse_last.y);
 for (i = 0; i < 10; ++i) {
-XMaskEvent (SDL_Display, PointerMotionMask, xevent);
+XMaskEvent(SDL_Display, PointerMotionMask, xevent);
 if ((xevent->xmotion.x >
 (mouse_last.x - MOUSE_FUDGE_FACTOR)) &&
 (xevent->xmotion.x <
 (mouse_last.x + MOUSE_FUDGE_FACTOR)) &&
 (xevent->xmotion.y >
 (mouse_last.y - MOUSE_FUDGE_FACTOR)) &&
 (xevent->xmotion.y < (mouse_last.y + MOUSE_FUDGE_FACTOR))) {
 break;
 }
 #ifdef DEBUG_XEVENTS
-printf ("Lost mouse motion: %d,%d\n", xevent->xmotion.x,
+printf("Lost mouse motion: %d,%d\n", xevent->xmotion.x,
 xevent->xmotion.y);
 #endif
 }
 #ifdef DEBUG_XEVENTS
 if (i == 10) {
-printf ("Warning: didn't detect mouse warp motion\n");
+printf("Warning: didn't detect mouse warp motion\n");
 }
 #endif
 }
 return (posted);
 }
 static int
-X11_DispatchEvent (_THIS)
+X11_DispatchEvent(_THIS)
 {
 int posted;
 XEvent xevent;
-SDL_memset (&xevent, '\0', sizeof (XEvent));        /* valgrind fix. --ryan. */
+SDL_memset(&xevent, '\0', sizeof(XEvent));  /* valgrind fix. --ryan. */
-XNextEvent (SDL_Display, &xevent);
+XNextEvent(SDL_Display, &xevent);
 posted = 0;
 switch (xevent.type) {
 /* Gaining mouse coverage? */
 case EnterNotify:
 {
 #ifdef DEBUG_XEVENTS
-printf ("EnterNotify! (%d,%d)\n", xevent.xcrossing.x,
+printf("EnterNotify! (%d,%d)\n", xevent.xcrossing.x,
 xevent.xcrossing.y);
 if (xevent.xcrossing.mode == NotifyGrab)
-printf ("Mode: NotifyGrab\n");
+printf("Mode: NotifyGrab\n");
 if (xevent.xcrossing.mode == NotifyUngrab)
-printf ("Mode: NotifyUngrab\n");
+printf("Mode: NotifyUngrab\n");
 #endif
 if ((xevent.xcrossing.mode != NotifyGrab) &&
 (xevent.xcrossing.mode != NotifyUngrab)) {
 if (SDL_CurrentWindow.input_grab == SDL_GRAB_OFF) {
-posted = SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS);
+posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
 }
-posted = SDL_PrivateMouseMotion (0, 0,
+posted = SDL_PrivateMouseMotion(0, 0,
 xevent.xcrossing.x,
 xevent.xcrossing.y);
 }
 }
 break;
 /* Losing mouse coverage? */
 case LeaveNotify:
 {
 #ifdef DEBUG_XEVENTS
-printf ("LeaveNotify! (%d,%d)\n", xevent.xcrossing.x,
+printf("LeaveNotify! (%d,%d)\n", xevent.xcrossing.x,
 xevent.xcrossing.y);
 if (xevent.xcrossing.mode == NotifyGrab)
-printf ("Mode: NotifyGrab\n");
+printf("Mode: NotifyGrab\n");
 if (xevent.xcrossing.mode == NotifyUngrab)
-printf ("Mode: NotifyUngrab\n");
+printf("Mode: NotifyUngrab\n");
 #endif
 if ((xevent.xcrossing.mode != NotifyGrab) &&
 (xevent.xcrossing.mode != NotifyUngrab) &&
 (xevent.xcrossing.detail != NotifyInferior)) {
 if (SDL_CurrentWindow.input_grab == SDL_GRAB_OFF) {
-posted = SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS);
+posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
 } else {
-posted = SDL_PrivateMouseMotion (0, 0,
+posted = SDL_PrivateMouseMotion(0, 0,
 xevent.xcrossing.x,
 xevent.xcrossing.y);
 }
 }
 }
 break;
 /* Gaining input focus? */
 case FocusIn:
 {
 #ifdef DEBUG_XEVENTS
-printf ("FocusIn!\n");
+printf("FocusIn!\n");
 #endif
-posted = SDL_PrivateAppActive (1, SDL_APPINPUTFOCUS);
+posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
 #ifdef X_HAVE_UTF8_STRING
 if (SDL_IC != NULL) {
-XSetICFocus (SDL_IC);
+XSetICFocus(SDL_IC);
 }
 #endif
 /* Queue entry into fullscreen mode */
 switch_waiting = 0x01 | SDL_FULLSCREEN;
-switch_time = SDL_GetTicks () + 1500;
+switch_time = SDL_GetTicks() + 1500;
 }
 break;
 /* Losing input focus? */
 case FocusOut:
 {
 #ifdef DEBUG_XEVENTS
-printf ("FocusOut!\n");
+printf("FocusOut!\n");
 #endif
-posted = SDL_PrivateAppActive (0, SDL_APPINPUTFOCUS);
+posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
 #ifdef X_HAVE_UTF8_STRING
 if (SDL_IC != NULL) {
-XUnsetICFocus (SDL_IC);
+XUnsetICFocus(SDL_IC);
 }
 #endif
 /* Queue leaving fullscreen mode */
 switch_waiting = 0x01;
-switch_time = SDL_GetTicks () + 200;
+switch_time = SDL_GetTicks() + 200;
 }
 break;
 /* Generated upon EnterWindow and FocusIn */
 case KeymapNotify:
 {
 #ifdef DEBUG_XEVENTS
-printf ("KeymapNotify!\n");
+printf("KeymapNotify!\n");
 #endif
-X11_SetKeyboardState (SDL_Display, xevent.xkeymap.key_vector);
+X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);
 }
 break;
 /* Mouse motion? */
 case MotionNotify:
 {
 if (SDL_VideoSurface) {
 if (mouse_relative) {
 if (using_dga & DGA_MOUSE) {
 #ifdef DEBUG_MOTION
-printf ("DGA motion: %d,%d\n",
+printf("DGA motion: %d,%d\n",
 xevent.xmotion.x_root, xevent.xmotion.y_root);
 #endif
-posted = SDL_PrivateMouseMotion (0, 1,
+posted = SDL_PrivateMouseMotion(0, 1,
 xevent.
 xmotion.
 x_root,
 xevent.
 xmotion.y_root);
 } else {
-posted = X11_WarpedMotion (_this, &xevent);
+posted = X11_WarpedMotion(_this, &xevent);
 }
 } else {
 #ifdef DEBUG_MOTION
-printf ("X11 motion: %d,%d\n", xevent.xmotion.x,
+printf("X11 motion: %d,%d\n", xevent.xmotion.x,
 xevent.xmotion.y);
 #endif
-posted = SDL_PrivateMouseMotion (0, 0,
+posted = SDL_PrivateMouseMotion(0, 0,
 xevent.xmotion.x,
 xevent.xmotion.y);
 }
 }
 }
 break;
 /* Mouse button press? */
 case ButtonPress:
 {
-posted = SDL_PrivateMouseButton (SDL_PRESSED,
+posted = SDL_PrivateMouseButton(SDL_PRESSED,
 xevent.xbutton.button, 0, 0);
 }
 break;
 /* Mouse button release? */
 case ButtonRelease:
 {
-posted = SDL_PrivateMouseButton (SDL_RELEASED,
+posted = SDL_PrivateMouseButton(SDL_RELEASED,
 xevent.xbutton.button, 0, 0);
 }
 break;
 /* Key press? */
 case KeyPress:
 static SDL_keysym saved_keysym;
 SDL_keysym keysym;
 KeyCode keycode = xevent.xkey.keycode;
 #ifdef DEBUG_XEVENTS
-printf ("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
+printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
 #endif
 /* Get the translated SDL virtual keysym */
 if (keycode) {
 keysym.scancode = keycode;
-keysym.sym = X11_TranslateKeycode (SDL_Display, keycode);
+keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
 keysym.mod = KMOD_NONE;
 keysym.unicode = 0;
 } else {
 keysym = saved_keysym;
 }
 /* If we're not doing translation, we're done! */
 if (!SDL_TranslateUNICODE) {
-posted = SDL_PrivateKeyboard (SDL_PRESSED, &keysym);
+posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
 break;
 }
-if (XFilterEvent (&xevent, None)) {
+if (XFilterEvent(&xevent, None)) {
 if (xevent.xkey.keycode) {
-posted = SDL_PrivateKeyboard (SDL_PRESSED, &keysym);
+posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
 } else {
 /* Save event to be associated with IM text
 In 1.3 we'll have a text event instead.. */
 saved_keysym = keysym;
 }
 #ifdef X_HAVE_UTF8_STRING
 if (SDL_IC != NULL) {
 static Status state;
 /* A UTF-8 character can be at most 6 bytes */
 char keybuf[6];
-if (Xutf8LookupString (SDL_IC, &xevent.xkey,
+if (Xutf8LookupString(SDL_IC, &xevent.xkey,
-keybuf, sizeof (keybuf),
+keybuf, sizeof(keybuf), NULL, &state)) {
-NULL, &state)) {
+keysym.unicode = Utf8ToUcs4((Uint8 *) keybuf);
-keysym.unicode = Utf8ToUcs4 ((Uint8 *) keybuf);
 }
 } else
 #endif
 {
 static XComposeStatus state;
 char keybuf[32];
-if (XLookupString (&xevent.xkey,
+if (XLookupString(&xevent.xkey,
-keybuf, sizeof (keybuf), NULL, &state)) {
+keybuf, sizeof(keybuf), NULL, &state)) {
 /*
 * FIXME: XLookupString() may yield more than one
 * character, so we need a mechanism to allow for
 * this (perhaps null keypress events with a
 * unicode value)
 */
 keysym.unicode = (Uint8) keybuf[0];
 }
 }
-posted = SDL_PrivateKeyboard (SDL_PRESSED, &keysym);
+posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
 }
 break;
 /* Key release? */
 case KeyRelease:
 {
 SDL_keysym keysym;
 KeyCode keycode = xevent.xkey.keycode;
 #ifdef DEBUG_XEVENTS
-printf ("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
+printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
 #endif
 /* Check to see if this is a repeated key */
-if (X11_KeyRepeat (SDL_Display, &xevent)) {
+if (X11_KeyRepeat(SDL_Display, &xevent)) {
 break;
 }
 /* Get the translated SDL virtual keysym */
 keysym.scancode = keycode;
-keysym.sym = X11_TranslateKeycode (SDL_Display, keycode);
+keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
 keysym.mod = KMOD_NONE;
 keysym.unicode = 0;
-posted = SDL_PrivateKeyboard (SDL_RELEASED, &keysym);
+posted = SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
 }
 break;
 /* Have we been iconified? */
 case UnmapNotify:
 {
 #ifdef DEBUG_XEVENTS
-printf ("UnmapNotify!\n");
+printf("UnmapNotify!\n");
 #endif
 /* If we're active, make ourselves inactive */
-if (SDL_GetAppState () & SDL_APPACTIVE) {
+if (SDL_GetAppState() & SDL_APPACTIVE) {
 /* Swap out the gamma before we go inactive */
-X11_SwapVidModeGamma (_this);
+X11_SwapVidModeGamma(_this);
 /* Send an internal deactivate event */
-posted = SDL_PrivateAppActive (0,
+posted = SDL_PrivateAppActive(0,
 SDL_APPACTIVE |
 SDL_APPINPUTFOCUS);
 }
 }
 break;
 /* Have we been restored? */
 case MapNotify:
 {
 #ifdef DEBUG_XEVENTS
-printf ("MapNotify!\n");
+printf("MapNotify!\n");
 #endif
 /* If we're not active, make ourselves active */
-if (!(SDL_GetAppState () & SDL_APPACTIVE)) {
+if (!(SDL_GetAppState() & SDL_APPACTIVE)) {
 /* Send an internal activate event */
-posted = SDL_PrivateAppActive (1, SDL_APPACTIVE);
+posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);
 /* Now that we're active, swap the gamma back */
-X11_SwapVidModeGamma (_this);
+X11_SwapVidModeGamma(_this);
 }
 if (SDL_VideoSurface &&
 (SDL_VideoSurface->flags & SDL_FULLSCREEN)) {
-X11_EnterFullScreen (_this);
+X11_EnterFullScreen(_this);
 } else {
-X11_GrabInputNoLock (_this, SDL_CurrentWindow.input_grab);
+X11_GrabInputNoLock(_this, SDL_CurrentWindow.input_grab);
 }
-X11_CheckMouseModeNoLock (_this);
+X11_CheckMouseModeNoLock(_this);
 if (SDL_VideoSurface) {
-X11_RefreshDisplay (_this);
+X11_RefreshDisplay(_this);
 }
 }
 break;
 /* Have we been resized or moved? */
 case ConfigureNotify:
 {
 #ifdef DEBUG_XEVENTS
-printf ("ConfigureNotify! (resize: %dx%d)\n",
+printf("ConfigureNotify! (resize: %dx%d)\n",
 xevent.xconfigure.width, xevent.xconfigure.height);
 #endif
 if (SDL_VideoSurface) {
 if ((xevent.xconfigure.width != SDL_VideoSurface->w) ||
 (xevent.xconfigure.height != SDL_VideoSurface->h)) {
 /* FIXME: Find a better fix for the bug with KDE 1.2 */
 if (!((xevent.xconfigure.width == 32) &&
 (xevent.xconfigure.height == 32))) {
-SDL_PrivateResize (xevent.xconfigure.width,
+SDL_PrivateResize(xevent.xconfigure.width,
 xevent.xconfigure.height);
 }
 } else {
 /* OpenGL windows need to know about the change */
 if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) {
-SDL_PrivateExpose ();
+SDL_PrivateExpose();
 }
 }
 }
 }
 break;
 /* Have we been requested to quit (or another client message?) */
 case ClientMessage:
 {
 if ((xevent.xclient.format == 32) &&
 (xevent.xclient.data.l[0] == WM_DELETE_WINDOW)) {
-posted = SDL_PrivateQuit ();
+posted = SDL_PrivateQuit();
 } else if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
 SDL_SysWMmsg wmmsg;
-SDL_VERSION (&wmmsg.version);
+SDL_VERSION(&wmmsg.version);
 wmmsg.subsystem = SDL_SYSWM_X11;
 wmmsg.event.xevent = xevent;
-posted = SDL_PrivateSysWMEvent (&wmmsg);
+posted = SDL_PrivateSysWMEvent(&wmmsg);
 }
 }
 break;
 /* Do we need to refresh ourselves? */
 case Expose:
 {
 #ifdef DEBUG_XEVENTS
-printf ("Expose (count = %d)\n", xevent.xexpose.count);
+printf("Expose (count = %d)\n", xevent.xexpose.count);
 #endif
 if (SDL_VideoSurface && (xevent.xexpose.count == 0)) {
-X11_RefreshDisplay (_this);
+X11_RefreshDisplay(_this);
 }
 }
 break;
 default:
 {
 #ifdef DEBUG_XEVENTS
-printf ("Unhandled event %d\n", xevent.type);
+printf("Unhandled event %d\n", xevent.type);
 #endif
 /* Only post the event if we're watching for it */
 if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
 SDL_SysWMmsg wmmsg;
-SDL_VERSION (&wmmsg.version);
+SDL_VERSION(&wmmsg.version);
 wmmsg.subsystem = SDL_SYSWM_X11;
 wmmsg.event.xevent = xevent;
-posted = SDL_PrivateSysWMEvent (&wmmsg);
+posted = SDL_PrivateSysWMEvent(&wmmsg);
 }
 }
 break;
 }
 return (posted);
 }
 /* Ack!  XPending() actually performs a blocking read if no events available */
 int
-X11_Pending (Display * display)
+X11_Pending(Display * display)
 {
 /* Flush the display connection and look to see if events are queued */
-XFlush (display);
+XFlush(display);
-if (XEventsQueued (display, QueuedAlready)) {
+if (XEventsQueued(display, QueuedAlready)) {
 return (1);
 }
 /* More drastic measures are required -- see if X is ready to talk */
 {
 static struct timeval zero_time;        /* static == 0 */
 int x11_fd;
 fd_set fdset;
-x11_fd = ConnectionNumber (display);
+x11_fd = ConnectionNumber(display);
-FD_ZERO (&fdset);
+FD_ZERO(&fdset);
-FD_SET (x11_fd, &fdset);
+FD_SET(x11_fd, &fdset);
-if (select (x11_fd + 1, &fdset, NULL, NULL, &zero_time) == 1) {
+if (select(x11_fd + 1, &fdset, NULL, NULL, &zero_time) == 1) {
-return (XPending (display));
+return (XPending(display));
 }
 }
 /* Oh well, nothing is ready .. */
 return (0);
 }
 void
-X11_PumpEvents (_THIS)
+X11_PumpEvents(_THIS)
 {
 int pending;
 /* Keep processing pending events */
 pending = 0;
-while (X11_Pending (SDL_Display)) {
+while (X11_Pending(SDL_Display)) {
-X11_DispatchEvent (_this);
+X11_DispatchEvent(_this);
 ++pending;
 }
 if (switch_waiting) {
 Uint32 now;
-now = SDL_GetTicks ();
+now = SDL_GetTicks();
 if (pending || !SDL_VideoSurface) {
 /* Try again later... */
 if (switch_waiting & SDL_FULLSCREEN) {
 switch_time = now + 1500;
 } else {
 go_fullscreen = switch_waiting & SDL_FULLSCREEN;
 switch_waiting = 0;
 if (SDL_VideoSurface->flags & SDL_FULLSCREEN) {
 if (go_fullscreen) {
-X11_EnterFullScreen (_this);
+X11_EnterFullScreen(_this);
 } else {
-X11_LeaveFullScreen (_this);
+X11_LeaveFullScreen(_this);
 }
 }
 /* Handle focus in/out when grabbed */
 if (go_fullscreen) {
-X11_GrabInputNoLock (_this, SDL_CurrentWindow.input_grab);
+X11_GrabInputNoLock(_this, SDL_CurrentWindow.input_grab);
 } else {
-X11_GrabInputNoLock (_this, SDL_GRAB_OFF);
+X11_GrabInputNoLock(_this, SDL_GRAB_OFF);
 }
-X11_CheckMouseModeNoLock (_this);
+X11_CheckMouseModeNoLock(_this);
 }
 }
 }
 void
-X11_InitKeymap (void)
+X11_InitKeymap(void)
 {
 int i;
 /* Odd keys used in international keyboards */
-for (i = 0; i < SDL_arraysize (ODD_keymap); ++i)
+for (i = 0; i < SDL_arraysize(ODD_keymap); ++i)
 ODD_keymap[i] = SDLK_UNKNOWN;
 /* Some of these might be mappable to an existing SDLK_ code */
 ODD_keymap[XK_dead_grave & 0xFF] = SDLK_COMPOSE;
 ODD_keymap[XK_dead_acute & 0xFF] = SDLK_COMPOSE;
 #ifdef XK_ISO_Level3_Shift
 ODD_keymap[XK_ISO_Level3_Shift & 0xFF] = SDLK_MODE; /* "Alt Gr" key */
 #endif
 /* Map the miscellaneous keys */
-for (i = 0; i < SDL_arraysize (MISC_keymap); ++i)
+for (i = 0; i < SDL_arraysize(MISC_keymap); ++i)
 MISC_keymap[i] = SDLK_UNKNOWN;
 /* These X keysyms have 0xFF as the high byte */
 MISC_keymap[XK_BackSpace & 0xFF] = SDLK_BACKSPACE;
 MISC_keymap[XK_Tab & 0xFF] = SDLK_TAB;
 MISC_keymap[XK_Hyper_R & 0xFF] = SDLK_MENU; /* Windows "Menu" key */
 }
 /* Get the translated SDL virtual keysym */
 SDLKey
-X11_TranslateKeycode (Display * display, KeyCode kc)
+X11_TranslateKeycode(Display * display, KeyCode kc)
 {
 KeySym xsym;
 SDLKey key;
-xsym = XKeycodeToKeysym (display, kc, 0);
+xsym = XKeycodeToKeysym(display, kc, 0);
 #ifdef DEBUG_KEYS
-fprintf (stderr, "Translating key code %d -> 0x%.4x\n", kc, xsym);
+fprintf(stderr, "Translating key code %d -> 0x%.4x\n", kc, xsym);
 #endif
 key = SDLK_UNKNOWN;
 if (xsym) {
 switch (xsym >> 8) {
 case 0x1005FF:
 /* X11 modifier masks for various keys */
 static unsigned meta_l_mask, meta_r_mask, alt_l_mask, alt_r_mask;
 static unsigned num_mask, mode_switch_mask;
 static void
-get_modifier_masks (Display * display)
+get_modifier_masks(Display * display)
 {
 static unsigned got_masks;
 int i, j;
 XModifierKeymap *xmods;
 unsigned n;
 if (got_masks)
 return;
-xmods = XGetModifierMapping (display);
+xmods = XGetModifierMapping(display);
 n = xmods->max_keypermod;
 for (i = 3; i < 8; i++) {
 for (j = 0; j < n; j++) {
 KeyCode kc = xmods->modifiermap[i * n + j];
-KeySym ks = XKeycodeToKeysym (display, kc, 0);
+KeySym ks = XKeycodeToKeysym(display, kc, 0);
 unsigned mask = 1 << i;
 switch (ks) {
 case XK_Num_Lock:
 num_mask = mask;
 break;
 mode_switch_mask = mask;
 break;
 }
 }
 }
-XFreeModifiermap (xmods);
+XFreeModifiermap(xmods);
 got_masks = 1;
 }
 /*
 * Note that it isn't completely accurate either; in particular, multi-key
 * sequences (dead accents, compose key sequences) will not work since the
 * state has been irrevocably lost.
 */
 Uint16
-X11_KeyToUnicode (SDLKey keysym, SDLMod modifiers)
+X11_KeyToUnicode(SDLKey keysym, SDLMod modifiers)
 {
-SDL_VideoDevice *_this = SDL_GetVideoDevice ();
+SDL_VideoDevice *_this = SDL_GetVideoDevice();
 char keybuf[32];
 int i;
 KeySym xsym = 0;
 XKeyEvent xkey;
 Uint16 unicode;
 if (!_this || !SDL_Display) {
 return 0;
 }
-SDL_memset (&xkey, 0, sizeof (xkey));
+SDL_memset(&xkey, 0, sizeof(xkey));
 xkey.display = SDL_Display;
 xsym = keysym;              /* last resort if not found */
 for (i = 0; i < 256; ++i) {
 if (MISC_keymap[i] == keysym) {
 xsym = 0xFE00 | i;
 break;
 }
 }
-xkey.keycode = XKeysymToKeycode (xkey.display, xsym);
+xkey.keycode = XKeysymToKeycode(xkey.display, xsym);
-get_modifier_masks (SDL_Display);
+get_modifier_masks(SDL_Display);
 if (modifiers & KMOD_SHIFT)
 xkey.state |= ShiftMask;
 if (modifiers & KMOD_CAPS)
 xkey.state |= LockMask;
 if (modifiers & KMOD_CTRL)
 xkey.state |= meta_r_mask;
 if (modifiers & KMOD_NUM)
 xkey.state |= num_mask;
 unicode = 0;
-if (XLookupString (&xkey, keybuf, sizeof (keybuf), NULL, NULL))
+if (XLookupString(&xkey, keybuf, sizeof(keybuf), NULL, NULL))
 unicode = (unsigned char) keybuf[0];
 return (unicode);
 }
 * Called when focus is regained, to read the keyboard state and generate
 * synthetic keypress/release events.
 * key_vec is a bit vector of keycodes (256 bits)
 */
 void
-X11_SetKeyboardState (Display * display, const char *key_vec)
+X11_SetKeyboardState(Display * display, const char *key_vec)
 {
 char keys_return[32];
 int i;
-Uint8 *kstate = SDL_GetKeyState (NULL);
+Uint8 *kstate = SDL_GetKeyState(NULL);
 SDLMod modstate;
 Window junk_window;
 int x, y;
 unsigned int mask;
 /* The first time the window is mapped, we initialize key state */
 if (!key_vec) {
-XQueryKeymap (display, keys_return);
+XQueryKeymap(display, keys_return);
 key_vec = keys_return;
 }
 /* Get the keyboard modifier state */
 modstate = 0;
-get_modifier_masks (display);
+get_modifier_masks(display);
-if (XQueryPointer (display, DefaultRootWindow (display),
+if (XQueryPointer(display, DefaultRootWindow(display),
 &junk_window, &junk_window, &x, &y, &x, &y, &mask)) {
 if (mask & LockMask) {
 modstate |= KMOD_CAPS;
 }
 if (mask & mode_switch_mask) {
 modstate |= KMOD_MODE;
 modstate |= KMOD_NUM;
 }
 }
 /* Zero the new keyboard state and generate it */
-SDL_memset (kstate, 0, SDLK_LAST);
+SDL_memset(kstate, 0, SDLK_LAST);
 /*
 * An obvious optimisation is to check entire longwords at a time in
 * both loops, but we can't be sure the arrays are aligned so it's not
 * worth the extra complexity
 */
 continue;
 for (j = 0; j < 8; j++) {
 if (key_vec[i] & (1 << j)) {
 SDLKey key;
 KeyCode kc = (i << 3 | j);
-key = X11_TranslateKeycode (display, kc);
+key = X11_TranslateKeycode(display, kc);
 if (key == SDLK_UNKNOWN) {
 continue;
 }
 kstate[key] = SDL_PRESSED;
 switch (key) {
 } else {
 kstate[SDLK_NUMLOCK] = SDL_RELEASED;
 }
 /* Set the final modifier state */
-SDL_SetModState (modstate);
+SDL_SetModState(modstate);
 }
 void
-X11_InitOSKeymap (_THIS)
+X11_InitOSKeymap(_THIS)
 {
-X11_InitKeymap ();
+X11_InitKeymap();
 }
 void
-X11_SaveScreenSaver (Display * display, int *saved_timeout, BOOL * dpms)
+X11_SaveScreenSaver(Display * display, int *saved_timeout, BOOL * dpms)
 {
 int timeout, interval, prefer_blank, allow_exp;
-XGetScreenSaver (display, &timeout, &interval, &prefer_blank, &allow_exp);
+XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
 *saved_timeout = timeout;
 #if SDL_VIDEO_DRIVER_X11_DPMS
 if (SDL_X11_HAVE_DPMS) {
 int dummy;
-if (DPMSQueryExtension (display, &dummy, &dummy)) {
+if (DPMSQueryExtension(display, &dummy, &dummy)) {
 CARD16 state;
-DPMSInfo (display, &state, dpms);
+DPMSInfo(display, &state, dpms);
 }
 }
 #else
 *dpms = 0;
 #endif /* SDL_VIDEO_DRIVER_X11_DPMS */
 }
 void
-X11_DisableScreenSaver (Display * display)
+X11_DisableScreenSaver(Display * display)
 {
 int timeout, interval, prefer_blank, allow_exp;
-XGetScreenSaver (display, &timeout, &interval, &prefer_blank, &allow_exp);
+XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
 timeout = 0;
-XSetScreenSaver (display, timeout, interval, prefer_blank, allow_exp);
+XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp);
 #if SDL_VIDEO_DRIVER_X11_DPMS
 if (SDL_X11_HAVE_DPMS) {
 int dummy;
-if (DPMSQueryExtension (display, &dummy, &dummy)) {
+if (DPMSQueryExtension(display, &dummy, &dummy)) {
-DPMSDisable (display);
+DPMSDisable(display);
 }
 }
 #endif /* SDL_VIDEO_DRIVER_X11_DPMS */
 }
 void
-X11_RestoreScreenSaver (Display * display, int saved_timeout, BOOL dpms)
+X11_RestoreScreenSaver(Display * display, int saved_timeout, BOOL dpms)
 {
 int timeout, interval, prefer_blank, allow_exp;
-XGetScreenSaver (display, &timeout, &interval, &prefer_blank, &allow_exp);
+XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
 timeout = saved_timeout;
-XSetScreenSaver (display, timeout, interval, prefer_blank, allow_exp);
+XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp);
 #if SDL_VIDEO_DRIVER_X11_DPMS
 if (SDL_X11_HAVE_DPMS) {
 int dummy;
-if (DPMSQueryExtension (display, &dummy, &dummy)) {
+if (DPMSQueryExtension(display, &dummy, &dummy)) {
 if (dpms) {
-DPMSEnable (display);
+DPMSEnable(display);
 }
 }
 }
 #endif /* SDL_VIDEO_DRIVER_X11_DPMS */
 }

Mercurial > sdl-ios-xcode

comparison src/video/x11/SDL_x11events.c @ 1668:4da1ee79c9af SDL-1.3