git.mutantstargoat.com Git - freeglut/blob - src/blackberry/fg_main_blackberry.c

   1 /*
   2  * fg_main_blackberry.c
   3  *
   4  * The BlackBerry-specific windows message processing methods.
   5  *
   6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
   7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
   8  * Copied for Platform code by Evan Felix <karcaw at gmail.com>
   9  * Copyright (C) 2012  Sylvain Beucler
  10  * Copyright (C) 2013  Vincent Simonetti
  11  *
  12  * Permission is hereby granted, free of charge, to any person obtaining a
  13  * copy of this software and associated documentation files (the "Software"),
  14  * to deal in the Software without restriction, including without limitation
  15  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  16  * and/or sell copies of the Software, and to permit persons to whom the
  17  * Software is furnished to do so, subject to the following conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be included
  20  * in all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  25  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  26  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  */
  29
  30 #include <GL/freeglut.h>
  31 #include "fg_internal.h"
  32 #include "egl/fg_window_egl.h"
  33
  34 #include <slog2.h>
  35 #define LOGI(...) ((void)slog2fa(NULL, 1337, SLOG2_INFO, __VA_ARGS__, SLOG2_FA_END))
  36 #define LOGW(...) ((void)slog2fa(NULL, 1337, SLOG2_WARNING, __VA_ARGS__, SLOG2_FA_END))
  37 #include <sys/keycodes.h>
  38 #include <input/screen_helpers.h>
  39 #include <bps/bps.h>
  40 #include <bps/event.h>
  41 #include <bps/screen.h>
  42 #include <bps/navigator.h>
  43
  44 extern void fghOnReshapeNotify(SFG_Window *window, int width, int height, GLboolean forceNotify);
  45 extern void fghOnPositionNotify(SFG_Window *window, int x, int y, GLboolean forceNotify);
  46 extern void fgPlatformFullScreenToggle( SFG_Window *win );
  47 extern void fgPlatformPositionWindow( SFG_Window *window, int x, int y );
  48 extern void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height );
  49 extern void fgPlatformPushWindow( SFG_Window *window );
  50 extern void fgPlatformPopWindow( SFG_Window *window );
  51 extern void fgPlatformHideWindow( SFG_Window *window );
  52 extern void fgPlatformIconifyWindow( SFG_Window *window );
  53 extern void fgPlatformShowWindow( SFG_Window *window );
  54 extern void fgPlatformMainLoopPostWork ( void );
  55
  56 static struct touchscreen touchscreen;
  57
  58 unsigned int key_special(int qnxKeycode)
  59 {
  60     switch(qnxKeycode) {
  61     case KEYCODE_F1:
  62         return GLUT_KEY_F1;
  63     case KEYCODE_F2:
  64         return GLUT_KEY_F2;
  65     case KEYCODE_F3:
  66         return GLUT_KEY_F3;
  67     case KEYCODE_F4:
  68         return GLUT_KEY_F4;
  69     case KEYCODE_F5:
  70         return GLUT_KEY_F5;
  71     case KEYCODE_F6:
  72         return GLUT_KEY_F6;
  73     case KEYCODE_F7:
  74         return GLUT_KEY_F7;
  75     case KEYCODE_F8:
  76         return GLUT_KEY_F8;
  77     case KEYCODE_F9:
  78         return GLUT_KEY_F9;
  79     case KEYCODE_F10:
  80         return GLUT_KEY_F10;
  81     case KEYCODE_F11:
  82         return GLUT_KEY_F11;
  83     case KEYCODE_F12:
  84         return GLUT_KEY_F12;
  85     case KEYCODE_PG_UP:
  86         return GLUT_KEY_PAGE_UP;
  87     case KEYCODE_PG_DOWN:
  88         return GLUT_KEY_PAGE_DOWN;
  89     case KEYCODE_HOME:
  90         return GLUT_KEY_HOME;
  91     case KEYCODE_END:
  92         return GLUT_KEY_END;
  93     case KEYCODE_INSERT:
  94         return GLUT_KEY_INSERT;
  95     case KEYCODE_UP:
  96     //case KEYCODE_KP_UP:
  97         return GLUT_KEY_UP;
  98     case KEYCODE_DOWN:
  99     //case KEYCODE_KP_DOWN:
 100         return GLUT_KEY_DOWN;
 101     case KEYCODE_LEFT:
 102     //case KEYCODE_KP_LEFT:
 103         return GLUT_KEY_LEFT;
 104     case KEYCODE_RIGHT:
 105     //case KEYCODE_KP_RIGHT:
 106         return GLUT_KEY_RIGHT;
 107     case KEYCODE_NUM_LOCK:
 108         return GLUT_KEY_NUM_LOCK;
 109     case KEYCODE_LEFT_ALT:
 110         return GLUT_KEY_ALT_L;
 111     case KEYCODE_RIGHT_ALT:
 112         return GLUT_KEY_ALT_R;
 113     case KEYCODE_LEFT_SHIFT:
 114         return GLUT_KEY_SHIFT_L;
 115     case KEYCODE_RIGHT_SHIFT:
 116         return GLUT_KEY_SHIFT_R;
 117     case KEYCODE_LEFT_CTRL:
 118         return GLUT_KEY_CTRL_L;
 119     case KEYCODE_RIGHT_CTRL:
 120         return GLUT_KEY_CTRL_R;
 121     }
 122     return 0;
 123 }
 124
 125 unsigned char key_ascii(int qnxKeycode)
 126 {
 127     if (qnxKeycode >= KEYCODE_PC_KEYS && qnxKeycode <= UNICODE_PRIVATE_USE_AREA_LAST) {
 128         switch (qnxKeycode) {
 129         case KEYCODE_BACKSPACE:
 130             return 0x0008;
 131         case KEYCODE_TAB:
 132             return 0x0009;
 133         case KEYCODE_KP_ENTER:
 134         case KEYCODE_RETURN:
 135             return 0x000A;
 136         case KEYCODE_ESCAPE:
 137             return 0x001B;
 138         }
 139     }
 140     return qnxKeycode;
 141 }
 142
 143 //From fg_main_x11
 144 fg_time_t fgPlatformSystemTime ( void )
 145 {
 146 #ifdef CLOCK_MONOTONIC
 147     struct timespec now;
 148     clock_gettime(CLOCK_MONOTONIC, &now);
 149     return now.tv_nsec/1000000 + now.tv_sec*1000;
 150 #elif defined(HAVE_GETTIMEOFDAY)
 151     struct timeval now;
 152     gettimeofday( &now, NULL );
 153     return now.tv_usec/1000 + now.tv_sec*1000;
 154 #endif
 155 }
 156
 157 /*
 158  * Does the magic required to relinquish the CPU until something interesting
 159  * happens.
 160  */
 161 void fgPlatformSleepForEvents( fg_time_t msec )
 162 {
 163     //XXX: Is this right? Is there a more direct way to access the context?
 164     if(fgStructure.CurrentWindow && fgDisplay.pDisplay.event == NULL && bps_get_event(&fgDisplay.pDisplay.event, (int)msec) != BPS_SUCCESS) {
 165         LOGW("BPS couldn't get event");
 166     }
 167 }
 168
 169 void handle_left_mouse(int x, int y, int height, int eventType, SFG_Window* window)
 170 {
 171     bool handled = false;
 172     /* Virtual arrows PAD */
 173     /* Don't interfere with existing mouse move event */
 174     if (!touchscreen.in_mmotion) {
 175         struct vpad_state prev_vpad = touchscreen.vpad;
 176         touchscreen.vpad.left = touchscreen.vpad.right = touchscreen.vpad.up = touchscreen.vpad.down = false;
 177
 178         if (eventType == SCREEN_EVENT_MTOUCH_TOUCH || eventType == SCREEN_EVENT_MTOUCH_MOVE) {
 179             if ((x > 0 && x < 100) && (y > (height - 100) && y < height))
 180             {
 181                 touchscreen.vpad.left = true;
 182             }
 183             if ((x > 200 && x < 300) && (y > (height - 100) && y < height))
 184             {
 185                 touchscreen.vpad.right = true;
 186             }
 187             if ((x > 100 && x < 200) && (y > (height - 100) && y < height))
 188             {
 189                 touchscreen.vpad.down = true;
 190             }
 191             if ((x > 100 && x < 200) && (y > (height - 200) && y < (height - 100)))
 192             {
 193                 touchscreen.vpad.up = true;
 194             }
 195         }
 196
 197         if (eventType == SCREEN_EVENT_MTOUCH_TOUCH &&
 198                 (touchscreen.vpad.left || touchscreen.vpad.right || touchscreen.vpad.down || touchscreen.vpad.up)) {
 199             touchscreen.vpad.on = true;
 200         }
 201         if (eventType == SCREEN_EVENT_MTOUCH_RELEASE) {
 202             touchscreen.vpad.on = false;
 203         }
 204
 205         if (prev_vpad.left != touchscreen.vpad.left
 206                 || prev_vpad.right != touchscreen.vpad.right
 207                 || prev_vpad.up != touchscreen.vpad.up
 208                 || prev_vpad.down != touchscreen.vpad.down
 209                 || prev_vpad.on != touchscreen.vpad.on) {
 210             if (FETCH_WCB(*window, Special)) {
 211                 if (prev_vpad.left == false && touchscreen.vpad.left == true) {
 212                     INVOKE_WCB(*window, Special, (GLUT_KEY_LEFT, x, y));
 213                 }
 214                 else if (prev_vpad.right == false && touchscreen.vpad.right == true) {
 215                     INVOKE_WCB(*window, Special, (GLUT_KEY_RIGHT, x, y));
 216                 }
 217                 else if (prev_vpad.up == false && touchscreen.vpad.up == true) {
 218                     INVOKE_WCB(*window, Special, (GLUT_KEY_UP, x, y));
 219                 }
 220                 else if (prev_vpad.down == false && touchscreen.vpad.down == true) {
 221                     INVOKE_WCB(*window, Special, (GLUT_KEY_DOWN, x, y));
 222                 }
 223             }
 224             if (FETCH_WCB(*window, SpecialUp)) {
 225                 if (prev_vpad.left == true && touchscreen.vpad.left == false) {
 226                     INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_LEFT, x, y));
 227                 }
 228                 if (prev_vpad.right == true && touchscreen.vpad.right == false) {
 229                     INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_RIGHT, x, y));
 230                 }
 231                 if (prev_vpad.up == true && touchscreen.vpad.up == false) {
 232                     INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_UP, x, y));
 233                 }
 234                 if (prev_vpad.down == true && touchscreen.vpad.down == false) {
 235                     INVOKE_WCB(*window, SpecialUp, (GLUT_KEY_DOWN, x, y));
 236                 }
 237             }
 238             handled = true;
 239         }
 240     }
 241
 242     /* Normal mouse events */
 243     if (!handled && !touchscreen.vpad.on) {
 244         window->State.MouseX = x;
 245         window->State.MouseY = y;
 246
 247         if(eventType == SCREEN_EVENT_MTOUCH_MOVE) {
 248             INVOKE_WCB(*window, Motion, (x, y));
 249         } else if(FETCH_WCB(*window, Mouse)) {
 250             touchscreen.in_mmotion = eventType == SCREEN_EVENT_MTOUCH_TOUCH;
 251             int glutTouchType = eventType == SCREEN_EVENT_MTOUCH_TOUCH ? GLUT_DOWN : GLUT_UP;
 252             INVOKE_WCB(*window, Mouse, (GLUT_LEFT_BUTTON, glutTouchType, x, y));
 253         }
 254     }
 255 }
 256
 257 /*
 258  * Determine a GLUT modifier mask based on BlackBerry modifier info.
 259  */
 260 int fgPlatformGetModifiers (int mod)
 261 {
 262     return (((mod & KEYMOD_SHIFT) ? GLUT_ACTIVE_SHIFT : 0) |
 263             ((mod & KEYMOD_CTRL) ? GLUT_ACTIVE_CTRL : 0) |
 264             ((mod & KEYMOD_ALT) ? GLUT_ACTIVE_ALT : 0));
 265 }
 266
 267 void fgPlatformProcessSingleEvent ( void )
 268 {
 269     if(fgStructure.CurrentWindow == NULL) {
 270         //XXX Is this right? Would this just cause a whole lot of busy looping while we wait for events?
 271         LOGW("fgPlatformProcessSingleEvent: Missing current window. Skipping event processing");
 272         return;
 273     }
 274
 275     int domain;
 276     do
 277     {
 278         if(fgDisplay.pDisplay.event != NULL) {
 279             SFG_Window* window = fgStructure.CurrentWindow;
 280             if (window->Window.Handle != NULL) {
 281                 int size[2];
 282                 screen_get_window_property_iv(window->Window.Handle, SCREEN_PROPERTY_BUFFER_SIZE, size);
 283                 fghOnReshapeNotify(window,size[0],size[1],GL_FALSE);
 284             }
 285
 286             domain = bps_event_get_domain(fgDisplay.pDisplay.event);
 287             if (domain == screen_get_domain()) {
 288                 int eventType;
 289                 int mod;
 290                 screen_event_t screenEvent = screen_event_get_event(fgDisplay.pDisplay.event);
 291                 screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_TYPE, &eventType);
 292                 switch (eventType) {
 293
 294                 //Mostly from fg_main_android
 295                 case SCREEN_EVENT_MTOUCH_TOUCH:
 296                 case SCREEN_EVENT_MTOUCH_RELEASE:
 297                 case SCREEN_EVENT_MTOUCH_MOVE:
 298                 {
 299                     mtouch_event_t touchEvent;
 300                     screen_get_mtouch_event(screenEvent, &touchEvent, 0);
 301                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_MODIFIERS, &mod);
 302
 303                     LOGI("fgPlatformProcessSingleEvent: SCREEN_EVENT_MTOUCH_*: Type: 0x%X, X: %d, Y: %d, Contact Id: %d, Mod: 0x%X", SLOG2_FA_SIGNED(eventType), SLOG2_FA_SIGNED(touchEvent.x), SLOG2_FA_SIGNED(touchEvent.y), SLOG2_FA_SIGNED(touchEvent.contact_id), SLOG2_FA_SIGNED(mod));
 304
 305                     /* Remember the current modifiers state so user can query it from their callback */
 306                     fgState.Modifiers = fgPlatformGetModifiers(mod);
 307
 308                     if(touchEvent.contact_id == 0) {
 309                         int size[2];
 310                         screen_get_window_property_iv(window->Window.Handle, SCREEN_PROPERTY_BUFFER_SIZE, size);
 311                         handle_left_mouse(touchEvent.x, touchEvent.y, size[1], eventType, window);
 312                     }
 313
 314                     //Now handle mutlitouch (adapted from fg_main_windows)
 315                     if (eventType == SCREEN_EVENT_MTOUCH_TOUCH) {
 316                         INVOKE_WCB( *window, MultiEntry,  ( touchEvent.contact_id, GLUT_ENTERED ) );
 317                         INVOKE_WCB( *window, MultiButton, ( touchEvent.contact_id, touchEvent.x, touchEvent.y, 0, GLUT_DOWN ) );
 318                     } else if (eventType == SCREEN_EVENT_MTOUCH_MOVE) {
 319                         INVOKE_WCB( *window, MultiMotion, ( touchEvent.contact_id, touchEvent.x, touchEvent.y ) );
 320                         //XXX No motion is performed without contact, thus MultiPassive is never used
 321                     } else if (eventType == SCREEN_EVENT_MTOUCH_RELEASE) {
 322                         INVOKE_WCB( *window, MultiButton, ( touchEvent.contact_id, touchEvent.x, touchEvent.y, 0, GLUT_UP ) );
 323                         INVOKE_WCB( *window, MultiEntry,  ( touchEvent.contact_id, GLUT_LEFT ) );
 324                     }
 325
 326                     fgState.Modifiers = INVALID_MODIFIERS;
 327                     break;
 328                 }
 329
 330                 case SCREEN_EVENT_POINTER:
 331                 {
 332                     //Based off/part taken from GamePlay3d PlatformBlackBerry
 333                     static int mouse_pressed = 0;
 334                     int buttons;
 335                     int position[2];
 336                     int wheel;
 337                     // A move event will be fired unless a button state changed.
 338                     bool move = true;
 339                     bool left_move = false;
 340                     // This is a mouse move event, it is applicable to a device with a usb mouse or simulator.
 341                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_BUTTONS, &buttons);
 342                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_SOURCE_POSITION, position);
 343                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_MOUSE_WHEEL, &wheel);
 344                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_MODIFIERS, &mod);
 345                     int size[2];
 346                     screen_get_window_property_iv(window->Window.Handle, SCREEN_PROPERTY_BUFFER_SIZE, size);
 347
 348                     LOGI("fgPlatformProcessSingleEvent: SCREEN_EVENT_POINTER: Buttons: 0x%X, X: %d, Y: %d, Wheel: %d, Mod: 0x%X", SLOG2_FA_SIGNED(buttons), SLOG2_FA_SIGNED(position[0]), SLOG2_FA_SIGNED(position[1]), SLOG2_FA_SIGNED(wheel), SLOG2_FA_SIGNED(mod));
 349
 350                     //XXX Should multitouch be handled?
 351
 352                     /* Remember the current modifiers state so user can query it from their callback */
 353                     fgState.Modifiers = fgPlatformGetModifiers(mod);
 354
 355                     // Handle left mouse. Interpret as touch if the left mouse event is not consumed.
 356                     if (buttons & SCREEN_LEFT_MOUSE_BUTTON) {
 357                         if (mouse_pressed & SCREEN_LEFT_MOUSE_BUTTON) {
 358                             left_move = true;
 359                         } else {
 360                             move = false;
 361                             mouse_pressed |= SCREEN_LEFT_MOUSE_BUTTON;
 362                             handle_left_mouse(position[0], position[1], size[1], SCREEN_EVENT_MTOUCH_TOUCH, window);
 363                         }
 364                     } else if (mouse_pressed & SCREEN_LEFT_MOUSE_BUTTON) {
 365                         move = false;
 366                         mouse_pressed &= ~SCREEN_LEFT_MOUSE_BUTTON;
 367                         handle_left_mouse(position[0], position[1], size[1], SCREEN_EVENT_MTOUCH_RELEASE, window);
 368                     }
 369
 370                     // Handle right mouse.
 371                     if (buttons & SCREEN_RIGHT_MOUSE_BUTTON) {
 372                         if ((mouse_pressed & SCREEN_RIGHT_MOUSE_BUTTON) == 0) {
 373                             move = false;
 374                             mouse_pressed |= SCREEN_RIGHT_MOUSE_BUTTON;
 375                             INVOKE_WCB(*window, Mouse, (GLUT_RIGHT_BUTTON, GLUT_DOWN, position[0], position[1]));
 376                         }
 377                     } else if (mouse_pressed & SCREEN_RIGHT_MOUSE_BUTTON) {
 378                         move = false;
 379                         mouse_pressed &= ~SCREEN_RIGHT_MOUSE_BUTTON;
 380                         INVOKE_WCB(*window, Mouse, (GLUT_RIGHT_BUTTON, GLUT_UP, position[0], position[1]));
 381                     }
 382
 383                     // Handle middle mouse.
 384                     if (buttons & SCREEN_MIDDLE_MOUSE_BUTTON) {
 385                         if ((mouse_pressed & SCREEN_MIDDLE_MOUSE_BUTTON) == 0) {
 386                             move = false;
 387                             mouse_pressed |= SCREEN_MIDDLE_MOUSE_BUTTON;
 388                             INVOKE_WCB(*window, Mouse, (GLUT_MIDDLE_BUTTON, GLUT_DOWN, position[0], position[1]));
 389                         }
 390                     } else if (mouse_pressed & SCREEN_MIDDLE_MOUSE_BUTTON) {
 391                         move = false;
 392                         mouse_pressed &= ~SCREEN_MIDDLE_MOUSE_BUTTON;
 393                         INVOKE_WCB(*window, Mouse, (GLUT_MIDDLE_BUTTON, GLUT_UP, position[0], position[1]));
 394                     }
 395
 396                     // Fire a move event if none of the buttons changed.
 397                     if (left_move || move) {
 398                         handle_left_mouse(position[0], position[1], size[1], SCREEN_EVENT_MTOUCH_MOVE, window);
 399                     }
 400
 401                     if (wheel) {
 402                         /* Very slightly modified from fg_main_mswin.
 403                          * Because we don't want MouseWheel to be called every. single. time.
 404                          * That the action occurs, we mimic the Windows version with "wheel deltas"
 405                          * XXX Do we even want this?
 406                          * XXX If we want this, it's possible to get horizontal scroll as well.
 407                          * XXX -Vertical scroll=wheel 0, horizontal=wheel 1? */
 408                         fgState.MouseWheelTicks -= wheel;
 409                         if (abs(fgState.MouseWheelTicks) >= WHEEL_DELTA)
 410                         {
 411                             int wheel_number = 0;
 412                             int direction = (fgState.MouseWheelTicks > 0) ? -1 : 1;
 413
 414                             if (!FETCH_WCB(*window, MouseWheel) && !FETCH_WCB(*window, Mouse))
 415                                 break;
 416
 417                             //XXX fgSetWindow(window);
 418
 419                             while(abs(fgState.MouseWheelTicks) >= WHEEL_DELTA)
 420                             {
 421                                 if (FETCH_WCB(*window, MouseWheel))
 422                                     INVOKE_WCB(*window, MouseWheel, (wheel_number, direction, window->State.MouseX, window->State.MouseY));
 423                                 else /* No mouse wheel, call the mouse button callback twice */
 424                                 {
 425                                     /*
 426                                      * Map wheel zero to button 3 and 4; +1 to 3, -1 to 4
 427                                      *  "    "   one                     +1 to 5, -1 to 6, ...
 428                                      *
 429                                      * XXX The below assumes that you have no more than 3 mouse
 430                                      * XXX buttons.  Sorry.
 431                                      */
 432                                     int button = wheel_number * 2 + 3;
 433                                     if (direction < 0)
 434                                         ++button;
 435                                     INVOKE_WCB(*window, Mouse, (button, GLUT_DOWN, window->State.MouseX, window->State.MouseY));
 436                                     INVOKE_WCB(*window, Mouse, (button, GLUT_UP, window->State.MouseX, window->State.MouseY));
 437                                 }
 438
 439                                 fgState.MouseWheelTicks -= WHEEL_DELTA * direction;
 440                             }
 441                         }
 442                     }
 443
 444                     fgState.Modifiers = INVALID_MODIFIERS;
 445                     break;
 446                 }
 447
 448                 //Based off fg_main_android
 449                 case SCREEN_EVENT_KEYBOARD:
 450                 {
 451                     int flags;
 452                     int value;
 453                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_FLAGS, &flags);
 454                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_SYM, &value);
 455                     screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_MODIFIERS, &mod);
 456
 457                     LOGI("fgPlatformProcessSingleEvent: SCREEN_EVENT_KEYBOARD. Flags: 0x%X, Sym: 0x%X, Mod: 0x%X", SLOG2_FA_SIGNED(flags), SLOG2_FA_SIGNED(value), SLOG2_FA_SIGNED(mod));
 458
 459                     /* Suppress key repeats if desired. Based off fg_main_mswin */
 460                     if ((flags & KEY_REPEAT) == 0 || (fgState.KeyRepeat == GLUT_KEY_REPEAT_OFF && fgStructure.CurrentWindow->State.IgnoreKeyRepeat == GL_TRUE)) {
 461                         unsigned int keypress = 0;
 462                         unsigned char ascii = 0;
 463
 464                         /* Remember the current modifiers state so user can query it from their callback */
 465                         fgState.Modifiers = fgPlatformGetModifiers(mod);
 466
 467                         /* Process keys */
 468                         if ((keypress = key_special(value))) {
 469                             if(flags & KEY_DOWN) {
 470                                 INVOKE_WCB(*window, Special, (keypress, window->State.MouseX, window->State.MouseY));
 471                             } else {
 472                                 INVOKE_WCB(*window, SpecialUp, (keypress, window->State.MouseX, window->State.MouseY));
 473                             }
 474                         } else if((flags & KEY_SYM_VALID) && (ascii = key_ascii(value))) {
 475                             if(flags & KEY_DOWN) {
 476                                 INVOKE_WCB(*window, Keyboard, (ascii, window->State.MouseX, window->State.MouseY));
 477                             } else {
 478                                 INVOKE_WCB(*window, KeyboardUp, (ascii, window->State.MouseX, window->State.MouseY));
 479                             }
 480                         } else {
 481                             LOGW("fgPlatformProcessSingleEvent: SCREEN_EVENT_KEYBOARD. Unhandled key event");
 482                         }
 483
 484                         fgState.Modifiers = INVALID_MODIFIERS;
 485                     }
 486                     break;
 487                 }
 488
 489                 case SCREEN_EVENT_PROPERTY:
 490                 case SCREEN_EVENT_IDLE:
 491                     break;
 492
 493                 default:
 494                     LOGW("fgPlatformProcessSingleEvent: unknown screen event: 0x%X", SLOG2_FA_SIGNED(eventType));
 495                     break;
 496                 }
 497             } else if (domain == navigator_get_domain()) {
 498                 int eventType = bps_event_get_code(fgDisplay.pDisplay.event);
 499                 switch (eventType) {
 500
 501                 case NAVIGATOR_WINDOW_STATE:
 502                 {
 503                     LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE");
 504                     navigator_window_state_t state = navigator_event_get_window_state(fgDisplay.pDisplay.event);
 505                     switch (state)
 506                     {
 507                     case NAVIGATOR_WINDOW_FULLSCREEN:
 508                         LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE-NAVIGATOR_WINDOW_FULLSCREEN");
 509                         INVOKE_WCB(*window, AppStatus, (GLUT_APPSTATUS_RESUME));
 510                         break;
 511                     case NAVIGATOR_WINDOW_THUMBNAIL:
 512                     case NAVIGATOR_WINDOW_INVISIBLE:
 513                         LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE-NAVIGATOR_WINDOW_THUMBNAIL/NAVIGATOR_WINDOW_INVISIBLE");
 514                         INVOKE_WCB(*window, AppStatus, (GLUT_APPSTATUS_PAUSE));
 515                         break;
 516                     default:
 517                         LOGW("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE unknown: 0x%X", SLOG2_FA_SIGNED(state));
 518                         break;
 519                     }
 520                     break;
 521                 }
 522
 523                 case NAVIGATOR_EXIT:
 524                 {
 525                     LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_EXIT");
 526
 527                     fgPlatformMainLoopPostWork();
 528
 529                     /* User closed the application for good, let's kill the window */
 530                     SFG_Window* window = fgStructure.CurrentWindow;
 531                     if (window != NULL) {
 532                         fgDestroyWindow(window);
 533                     } else {
 534                         LOGW("NAVIGATOR_EXIT: No current window");
 535                     }
 536                     break;
 537                 }
 538
 539                 case NAVIGATOR_SWIPE_DOWN:
 540                 case NAVIGATOR_BACK:
 541                 case NAVIGATOR_WINDOW_ACTIVE:
 542                 case NAVIGATOR_WINDOW_INACTIVE:
 543                 case NAVIGATOR_KEYBOARD_STATE:
 544                 case NAVIGATOR_KEYBOARD_POSITION:
 545                 case NAVIGATOR_DEVICE_LOCK_STATE:
 546                 case NAVIGATOR_WINDOW_COVER:
 547                 case NAVIGATOR_WINDOW_COVER_ENTER:
 548                 case NAVIGATOR_WINDOW_COVER_EXIT:
 549                 case NAVIGATOR_APP_STATE:
 550                     //XXX Should probably do something with these
 551                     break;
 552
 553                 default:
 554                     LOGW("fgPlatformProcessSingleEvent: unknown navigator event: 0x%X", SLOG2_FA_SIGNED(eventType));
 555                     break;
 556                 }
 557             }
 558         }
 559     } while(bps_get_event(&fgDisplay.pDisplay.event, 1) == BPS_SUCCESS && fgDisplay.pDisplay.event != NULL);
 560
 561     /* Reset event to reduce chances of triggering something */
 562     fgDisplay.pDisplay.event = NULL;
 563 }
 564
 565 void fgPlatformMainLoopPreliminaryWork ( void )
 566 {
 567     LOGI("fgPlatformMainLoopPreliminaryWork");
 568
 569     /* Request navigator events */
 570     navigator_request_events(0);
 571     //XXX rotation lock? navigator_rotation_lock(true);
 572
 573     /* Request window events */
 574     screen_request_events(fgDisplay.pDisplay.screenContext);
 575 }
 576
 577 void fgPlatformMainLoopPostWork ( void )
 578 {
 579     LOGI("fgPlatformMainLoopPostWork");
 580
 581     screen_stop_events(fgDisplay.pDisplay.screenContext);
 582
 583     navigator_stop_events(0);
 584 }
 585
 586 /* deal with work list items */
 587 void fgPlatformInitWork(SFG_Window* window)
 588 {
 589     /* notify windowStatus/visibility */
 590     INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) );
 591
 592     /* Position callback, always at 0,0 */
 593     fghOnPositionNotify(window, 0, 0, GL_TRUE);
 594
 595     /* Size gets notified on window creation with size detection in mainloop above
 596      * XXX CHECK: does this messages happen too early like on windows,
 597      * so client code cannot have registered a callback yet and the message
 598      * is thus never received by client?
 599      */
 600 }
 601
 602 void fgPlatformPosResZordWork(SFG_Window* window, unsigned int workMask)
 603 {
 604     if (workMask & GLUT_FULL_SCREEN_WORK)
 605         fgPlatformFullScreenToggle( window );
 606     if (workMask & GLUT_POSITION_WORK)
 607         fgPlatformPositionWindow( window, window->State.DesiredXpos, window->State.DesiredYpos );
 608     if (workMask & GLUT_SIZE_WORK)
 609         fgPlatformReshapeWindow ( window, window->State.DesiredWidth, window->State.DesiredHeight );
 610     if (workMask & GLUT_ZORDER_WORK)
 611     {
 612         if (window->State.DesiredZOrder < 0)
 613             fgPlatformPushWindow( window );
 614         else
 615             fgPlatformPopWindow( window );
 616     }
 617 }
 618
 619 void fgPlatformVisibilityWork(SFG_Window* window)
 620 {
 621     /* Visibility status of window should get updated in the window message handlers
 622      * For now, none of these functions called below do anything, so don't worry
 623      * about it
 624      */
 625     SFG_Window *win = window;
 626     switch (window->State.DesiredVisibility)
 627     {
 628     case DesireHiddenState:
 629         fgPlatformHideWindow( window );
 630         break;
 631     case DesireIconicState:
 632         /* Call on top-level window */
 633         while (win->Parent)
 634             win = win->Parent;
 635         fgPlatformIconifyWindow( win );
 636         break;
 637     case DesireNormalState:
 638         fgPlatformShowWindow( window );
 639         break;
 640     }
 641 }