bool QQnxBpsEventFilter::handleNavigatorEvent(bps_event_t *event)
{
switch (bps_event_get_code(event)) {
case NAVIGATOR_ORIENTATION_CHECK: {
const int angle = navigator_event_get_orientation_angle(event);
qBpsEventFilterDebug() << Q_FUNC_INFO << "ORIENTATION CHECK event. angle=" << angle;
const bool result = m_navigatorEventHandler->handleOrientationCheck(angle);
qBpsEventFilterDebug() << Q_FUNC_INFO << "ORIENTATION CHECK event. result=" << result;
// reply to navigator whether orientation is acceptable
navigator_orientation_check_response(event, result);
break;
}
case NAVIGATOR_ORIENTATION: {
const int angle = navigator_event_get_orientation_angle(event);
qBpsEventFilterDebug() << Q_FUNC_INFO << "ORIENTATION event. angle=" << angle;
m_navigatorEventHandler->handleOrientationChange(angle);
navigator_done_orientation(event);
break;
}
case NAVIGATOR_SWIPE_DOWN:
qBpsEventFilterDebug() << Q_FUNC_INFO << "SWIPE DOWN event";
m_navigatorEventHandler->handleSwipeDown();
break;
case NAVIGATOR_EXIT:
qBpsEventFilterDebug() << Q_FUNC_INFO << "EXIT event";
m_navigatorEventHandler->handleExit();
break;
case NAVIGATOR_WINDOW_ACTIVE: {
qBpsEventFilterDebug() << Q_FUNC_INFO << "WINDOW ACTIVE event";
const QByteArray id(navigator_event_get_groupid(event));
m_navigatorEventHandler->handleWindowGroupActivated(id);
break;
}
case NAVIGATOR_WINDOW_INACTIVE: {
qBpsEventFilterDebug() << Q_FUNC_INFO << "WINDOW INACTIVE event";
const QByteArray id(navigator_event_get_groupid(event));
m_navigatorEventHandler->handleWindowGroupDeactivated(id);
break;
}
default:
qBpsEventFilterDebug() << Q_FUNC_INFO << "Unhandled navigator event. code=" << bps_event_get_code(event);
return false;
}
return true;
}
static int resize(bps_event_t *event) {
//Query width and height of the window surface created by utility code
EGLint surface_width, surface_height;
if (event) {
int angle = navigator_event_get_orientation_angle(event);
//Let bbutil rotate current screen surface to this angle
if (EXIT_FAILURE == bbutil_rotate_screen_surface(angle)) {
fprintf(stderr, "Unable to handle orientation change\n");
return EXIT_FAILURE;
}
}
eglQuerySurface(egl_disp, egl_surf, EGL_WIDTH, &surface_width);
eglQuerySurface(egl_disp, egl_surf, EGL_HEIGHT, &surface_height);
EGLint err = eglGetError();
if (err != 0x3000) {
fprintf(stderr, "Unable to query EGL surface dimensions\n");
return EXIT_FAILURE;
}
width = (float) surface_width;
height = (float) surface_height;
if (event) {
render();
navigator_done_orientation(event);
}
return EXIT_SUCCESS;
}
bool BbGuiHelper::nativeEventFilter(const QByteArray &eventType, void *message, long *result)
{
Q_UNUSED(result);
Q_UNUSED(eventType);
bps_event_t * const event = static_cast<bps_event_t *>(message);
if (event && bps_event_get_domain(event) == navigator_get_domain()) {
const int code = bps_event_get_code(event);
if (code == NAVIGATOR_ORIENTATION) {
const int newOrientation = navigator_event_get_orientation_angle(event);
if (newOrientation != m_currentOrientation) {
m_currentOrientation = newOrientation;
emit orientationChanged();
}
} else if (code == NAVIGATOR_WINDOW_STATE) {
const bool appActive =
(navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_FULLSCREEN);
if (m_applicationActive != appActive) {
m_applicationActive = appActive;
emit applicationActiveChanged();
}
}
}
return false;
}
int resize(bps_event_t *event) {
//Query width and height of the window surface created by utility code
EGLint surface_width, surface_height;
if (event) {
int angle = navigator_event_get_orientation_angle(event);
//Let bbutil rotate current screen surface to this angle
if (EXIT_FAILURE == bbutil_rotate_screen_surface(angle)) {
fprintf(stderr, "Unable to handle orientation change\n");
return EXIT_FAILURE;
}
navigator_set_orientation(angle, NULL);
navigator_done_orientation(event);
}
eglQuerySurface(egl_disp, egl_surf, EGL_WIDTH, &surface_width);
eglQuerySurface(egl_disp, egl_surf, EGL_HEIGHT, &surface_height);
EGLint err = eglGetError();
if (err != 0x3000) {
fprintf(stderr, "Unable to query egl surface dimensions\n");
return EXIT_FAILURE;
}
width = (float) surface_width;
height = (float) surface_height;
if (width > height) {
shadow_pos_x = 365.0f;
shadow_pos_y = 0.0f;
cube_pos_x = 2.9f;
cube_pos_y = 0.3f;
cube_pos_z = -20.0f;
} else {
shadow_pos_x = 70.0f;
shadow_pos_y = 10.0f;
cube_pos_x = 0.5f;
cube_pos_y = -4.1f;
cube_pos_z = -30.0f;
}
shadow_vertices[0] = shadow_pos_x;
shadow_vertices[1] = shadow_pos_y;
shadow_vertices[2] = shadow_pos_x + shadow_size_x;
shadow_vertices[3] = shadow_pos_y;
shadow_vertices[4] = shadow_pos_x;
shadow_vertices[5] = shadow_pos_y + shadow_size_y;
shadow_vertices[6] = shadow_pos_x + shadow_size_x;
shadow_vertices[7] = shadow_pos_y + shadow_size_y;
update();
return EXIT_SUCCESS;
}
int resize(bps_event_t *event) {
//Query width and height of the window surface created by utility code
EGLint surface_width, surface_height;
if (event) {
int angle = navigator_event_get_orientation_angle(event);
//Let bbutil rotate current screen surface to this angle
if (EXIT_FAILURE == bbutil_rotate_screen_surface(angle)) {
fprintf(stderr, "Unable to handle orientation change\n");
return EXIT_FAILURE;
}
}
eglQuerySurface(egl_disp, egl_surf, EGL_WIDTH, &surface_width);
eglQuerySurface(egl_disp, egl_surf, EGL_HEIGHT, &surface_height);
EGLint err = eglGetError();
if (err != 0x3000) {
fprintf(stderr, "Unable to query EGL surface dimensions\n");
return EXIT_FAILURE;
}
width = (float) surface_width;
height = (float) surface_height;
if (width > height) {
cube_pos_x = 2.9f;
cube_pos_y = 0.3f;
cube_pos_z = -20.0f;
background = background_landscape;
background_vertices = background_landscape_vertices;
background_tex_coord = background_landscape_tex_coord;
} else {
cube_pos_x = 0.5f;
cube_pos_y = -4.1f;
cube_pos_z = -30.0f;
background = background_portrait;
background_vertices = background_portrait_vertices;
background_tex_coord = background_portrait_tex_coord;
}
update();
if (event) {
render();
navigator_done_orientation(event);
}
return EXIT_SUCCESS;
}
int resize(bps_event_t *event)
{
int angle = navigator_event_get_orientation_angle(event);
fprintf(stderr,"angle: %i\n",angle);
//Let bbutil rotate current screen surface to this angle
if (EXIT_FAILURE == bbutil_rotate_screen_surface(angle))
{
fprintf(stderr, "Unable to handle orientation change\n");
return EXIT_FAILURE;
}
//Query width and height of the window surface created by utility code
EGLint surface_width, surface_height;
eglQuerySurface(egl_disp, egl_surf, EGL_WIDTH, &surface_width);
eglQuerySurface(egl_disp, egl_surf, EGL_HEIGHT, &surface_height);
EGLint err = eglGetError();
if (err != 0x3000) {
fprintf(stderr, "Unable to query EGL surface dimensions\n");
return EXIT_FAILURE;
}
// width and height from Render.h
width = (float) surface_width;
height = (float) surface_height;
fprintf(stderr, "angle %i\n",angle);
switch (angle)
{
case 0:
oriention_side_up = 0;
break;
case 90:
oriention_side_up = 1;
break;
case 270:
oriention_side_up = 2;
break;
case 180:
oriention_side_up = -1;
break;
default:
oriention_side_up = 0;
break;
}
render();
navigator_done_orientation(event);
return EXIT_SUCCESS;
}
void OSBB10::_resize(bps_event_t* event) {
int angle = navigator_event_get_orientation_angle(event);
bbutil_rotate_screen_surface(angle);
EGLint surface_width, surface_height;
eglQuerySurface(egl_disp, egl_surf, EGL_WIDTH, &surface_width);
eglQuerySurface(egl_disp, egl_surf, EGL_HEIGHT, &surface_height);
VideoMode mode;
mode.width = surface_width;
mode.height = surface_height;
mode.fullscreen = true;
mode.resizable = false;
set_video_mode(mode);
};
void BbGuiHelper::handleBpsEvent(bps_event_t *event)
{
if (event && bps_event_get_domain(event) == navigator_get_domain()) {
const int code = bps_event_get_code(event);
if (code == NAVIGATOR_ORIENTATION) {
const int newOrientation = navigator_event_get_orientation_angle(event);
if (newOrientation != m_currentOrientation) {
m_currentOrientation = newOrientation;
emit orientationChanged();
}
} else if (code == NAVIGATOR_WINDOW_STATE) {
const bool appActive =
(navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_FULLSCREEN);
if (m_applicationActive != appActive) {
m_applicationActive = appActive;
emit applicationActiveChanged();
}
}
}
}
void BlackberryMain::runMain() {
bool running = true;
while (running && !g_quitRequested) {
input_state.mouse_valid = false;
input_state.accelerometer_valid = false;
while (true) {
// Handle Blackberry events
bps_event_t *event = NULL;
bps_get_event(&event, 0);
if (event == NULL)
break; // Ran out of events
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleInput(screen_event_get_event(event));
} else if (domain == navigator_get_domain()) {
switch(bps_event_get_code(event))
{
case NAVIGATOR_INVOKE_TARGET:
{
const navigator_invoke_invocation_t *invoke = navigator_invoke_event_get_invocation(event);
if(invoke) {
boot_filename = navigator_invoke_invocation_get_uri(invoke)+7; // Remove file://
}
}
break;
case NAVIGATOR_ORIENTATION:
sensor_remap_coordinates(navigator_event_get_orientation_angle(event));
break;
case NAVIGATOR_BACK:
case NAVIGATOR_SWIPE_DOWN:
NativeKey(KeyInput(DEVICE_ID_KEYBOARD, NKCODE_ESCAPE, KEY_DOWN));
break;
case NAVIGATOR_EXIT:
return;
}
} else if (domain == sensor_get_domain()) {
if (SENSOR_ACCELEROMETER_READING == bps_event_get_code(event)) {
sensor_event_get_xyz(event, &(input_state.acc.y), &(input_state.acc.x), &(input_state.acc.z));
AxisInput axis;
axis.deviceId = DEVICE_ID_ACCELEROMETER;
axis.flags = 0;
axis.axisId = JOYSTICK_AXIS_ACCELEROMETER_X;
axis.value = input_state.acc.x;
NativeAxis(axis);
axis.axisId = JOYSTICK_AXIS_ACCELEROMETER_Y;
axis.value = input_state.acc.y;
NativeAxis(axis);
axis.axisId = JOYSTICK_AXIS_ACCELEROMETER_Z;
axis.value = input_state.acc.z;
NativeAxis(axis);
}
}
}
UpdateInputState(&input_state);
NativeUpdate(input_state);
// Work in Progress
// Currently: Render to HDMI port (eg. 1080p) when in game. Render to device when in menu.
// Idea: Render to all displays. Controls go to internal, game goes to external(s).
if (GetUIState() == UISTATE_INGAME && !emulating) {
emulating = true;
switchDisplay(screen_emu);
if (g_Config.iShowFPSCounter == 4) {
int options = SCREEN_DEBUG_STATISTICS;
screen_set_window_property_iv(screen_win[0], SCREEN_PROPERTY_DEBUG, &options);
}
} else if (GetUIState() != UISTATE_INGAME && emulating) {
emulating = false;
switchDisplay(screen_ui);
}
NativeRender();
EndInputState(&input_state);
time_update();
// This handles VSync
if (emulating)
eglSwapBuffers(egl_disp[screen_emu], egl_surf[screen_emu]);
else
eglSwapBuffers(egl_disp[screen_ui], egl_surf[screen_ui]);
}
}
bool QQnxBpsEventFilter::handleNavigatorEvent(bps_event_t *event)
{
switch (bps_event_get_code(event)) {
case NAVIGATOR_ORIENTATION_CHECK: {
const int angle = navigator_event_get_orientation_angle(event);
qBpsEventFilterDebug() << "ORIENTATION CHECK event. angle=" << angle;
const bool result = m_navigatorEventHandler->handleOrientationCheck(angle);
qBpsEventFilterDebug() << "ORIENTATION CHECK event. result=" << result;
// reply to navigator whether orientation is acceptable
navigator_orientation_check_response(event, result);
break;
}
case NAVIGATOR_ORIENTATION: {
const int angle = navigator_event_get_orientation_angle(event);
qBpsEventFilterDebug() << "ORIENTATION event. angle=" << angle;
m_navigatorEventHandler->handleOrientationChange(angle);
navigator_done_orientation(event);
break;
}
case NAVIGATOR_SWIPE_DOWN:
qBpsEventFilterDebug("SWIPE DOWN event");
m_navigatorEventHandler->handleSwipeDown();
break;
case NAVIGATOR_EXIT:
qBpsEventFilterDebug("EXIT event");
m_navigatorEventHandler->handleExit();
break;
case NAVIGATOR_WINDOW_STATE: {
qBpsEventFilterDebug("WINDOW STATE event");
const navigator_window_state_t state = navigator_event_get_window_state(event);
const QByteArray id(navigator_event_get_groupid(event));
switch (state) {
case NAVIGATOR_WINDOW_FULLSCREEN:
m_navigatorEventHandler->handleWindowGroupStateChanged(id, Qt::WindowFullScreen);
break;
case NAVIGATOR_WINDOW_THUMBNAIL:
m_navigatorEventHandler->handleWindowGroupStateChanged(id, Qt::WindowMinimized);
break;
case NAVIGATOR_WINDOW_INVISIBLE:
break;
}
break;
}
case NAVIGATOR_WINDOW_ACTIVE: {
qBpsEventFilterDebug("WINDOW ACTIVE event");
const QByteArray id(navigator_event_get_groupid(event));
m_navigatorEventHandler->handleWindowGroupActivated(id);
break;
}
case NAVIGATOR_WINDOW_INACTIVE: {
qBpsEventFilterDebug("WINDOW INACTIVE event");
const QByteArray id(navigator_event_get_groupid(event));
m_navigatorEventHandler->handleWindowGroupDeactivated(id);
break;
}
case NAVIGATOR_LOW_MEMORY:
qWarning() << "QGuiApplication based process" << QCoreApplication::applicationPid()
<< "received \"NAVIGATOR_LOW_MEMORY\" event";
return false;
default:
qBpsEventFilterDebug() << "Unhandled navigator event. code=" << bps_event_get_code(event);
return false;
}
return true;
}
void fgPlatformProcessSingleEvent ( void )
{
if(fgStructure.CurrentWindow == NULL) {
//XXX Is this right? Would this just cause a whole lot of busy looping while we wait for events?
LOGW("fgPlatformProcessSingleEvent: Missing current window. Skipping event processing");
return;
}
if(fgDisplay.pDisplay.event == NULL)
/* Nothing to do */
return;
int domain;
do
{
SFG_Window* window = fgStructure.CurrentWindow;
#ifdef __PLAYBOOK__
/* Get the keyboard height before doing anything since we otherwise don't get it until it changes */
if(window->State.pWState.keyboardHeight == 0) {
virtualkeyboard_get_height(&window->State.pWState.keyboardHeight);
}
#endif
domain = bps_event_get_domain(fgDisplay.pDisplay.event);
if (domain == screen_get_domain()) {
int eventType;
int mod;
screen_event_t screenEvent = screen_event_get_event(fgDisplay.pDisplay.event);
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_TYPE, &eventType);
switch (eventType) {
//Mostly from fg_main_android
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_RELEASE:
case SCREEN_EVENT_MTOUCH_MOVE:
{
mtouch_event_t touchEvent;
screen_get_mtouch_event(screenEvent, &touchEvent, 0);
#ifndef __PLAYBOOK__
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_MODIFIERS, &mod);
#else
mod = 0;
#endif
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));
/* Remember the current modifiers state so user can query it from their callback */
fgState.Modifiers = fgPlatformGetModifiers(mod);
if(touchEvent.contact_id == 0) {
int size[2];
screen_get_window_property_iv(window->Window.Handle, SCREEN_PROPERTY_BUFFER_SIZE, size);
handle_left_mouse(touchEvent.x, touchEvent.y, size[1], eventType, window);
}
//Now handle mutlitouch (adapted from fg_main_windows)
if (eventType == SCREEN_EVENT_MTOUCH_TOUCH) {
INVOKE_WCB( *window, MultiEntry, ( touchEvent.contact_id, GLUT_ENTERED ) );
INVOKE_WCB( *window, MultiButton, ( touchEvent.contact_id, touchEvent.x, touchEvent.y, 0, GLUT_DOWN ) );
} else if (eventType == SCREEN_EVENT_MTOUCH_MOVE) {
INVOKE_WCB( *window, MultiMotion, ( touchEvent.contact_id, touchEvent.x, touchEvent.y ) );
//XXX No motion is performed without contact, thus MultiPassive is never used
} else if (eventType == SCREEN_EVENT_MTOUCH_RELEASE) {
INVOKE_WCB( *window, MultiButton, ( touchEvent.contact_id, touchEvent.x, touchEvent.y, 0, GLUT_UP ) );
INVOKE_WCB( *window, MultiEntry, ( touchEvent.contact_id, GLUT_LEFT ) );
}
fgState.Modifiers = INVALID_MODIFIERS;
break;
}
case SCREEN_EVENT_POINTER:
{
//Based off/part taken from GamePlay3d PlatformBlackBerry
static int mouse_pressed = 0;
int buttons;
int position[2];
int wheel;
// A move event will be fired unless a button state changed.
bool move = true;
bool left_move = false;
// This is a mouse move event, it is applicable to a device with a usb mouse or simulator.
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_BUTTONS, &buttons);
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_SOURCE_POSITION, position);
#ifndef __PLAYBOOK__
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_MOUSE_WHEEL, &wheel);
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_MODIFIERS, &mod);
#else
wheel = mod = 0;
#endif
int size[2];
screen_get_window_property_iv(window->Window.Handle, SCREEN_PROPERTY_BUFFER_SIZE, size);
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));
//XXX Is multitouch be handled in a good way?
/* Remember the current modifiers state so user can query it from their callback */
fgState.Modifiers = fgPlatformGetModifiers(mod);
// Handle left mouse. Interpret as touch if the left mouse event is not consumed.
if (buttons & SCREEN_LEFT_MOUSE_BUTTON) {
if (mouse_pressed & SCREEN_LEFT_MOUSE_BUTTON) {
left_move = true;
} else {
move = false;
mouse_pressed |= SCREEN_LEFT_MOUSE_BUTTON;
handle_left_mouse(position[0], position[1], size[1], SCREEN_EVENT_MTOUCH_TOUCH, window);
}
} else if (mouse_pressed & SCREEN_LEFT_MOUSE_BUTTON) {
move = false;
mouse_pressed &= ~SCREEN_LEFT_MOUSE_BUTTON;
handle_left_mouse(position[0], position[1], size[1], SCREEN_EVENT_MTOUCH_RELEASE, window);
}
// Handle right mouse.
if (buttons & SCREEN_RIGHT_MOUSE_BUTTON) {
if ((mouse_pressed & SCREEN_RIGHT_MOUSE_BUTTON) == 0) {
move = false;
mouse_pressed |= SCREEN_RIGHT_MOUSE_BUTTON;
INVOKE_WCB(*window, Mouse, (GLUT_RIGHT_BUTTON, GLUT_DOWN, position[0], position[1]));
}
} else if (mouse_pressed & SCREEN_RIGHT_MOUSE_BUTTON) {
move = false;
mouse_pressed &= ~SCREEN_RIGHT_MOUSE_BUTTON;
INVOKE_WCB(*window, Mouse, (GLUT_RIGHT_BUTTON, GLUT_UP, position[0], position[1]));
}
// Handle middle mouse.
if (buttons & SCREEN_MIDDLE_MOUSE_BUTTON) {
if ((mouse_pressed & SCREEN_MIDDLE_MOUSE_BUTTON) == 0) {
move = false;
mouse_pressed |= SCREEN_MIDDLE_MOUSE_BUTTON;
INVOKE_WCB(*window, Mouse, (GLUT_MIDDLE_BUTTON, GLUT_DOWN, position[0], position[1]));
}
} else if (mouse_pressed & SCREEN_MIDDLE_MOUSE_BUTTON) {
move = false;
mouse_pressed &= ~SCREEN_MIDDLE_MOUSE_BUTTON;
INVOKE_WCB(*window, Mouse, (GLUT_MIDDLE_BUTTON, GLUT_UP, position[0], position[1]));
}
// Fire a move event if none of the buttons changed.
if (left_move || move) {
handle_left_mouse(position[0], position[1], size[1], SCREEN_EVENT_MTOUCH_MOVE, window);
}
if (wheel) {
/* Very slightly modified from fg_main_mswin.
* Because we don't want MouseWheel to be called every. single. time.
* That the action occurs, we mimic the Windows version with "wheel deltas"
* XXX Do we even want this?
* XXX If we want this, it's possible to get horizontal scroll as well.
* XXX -Vertical scroll=wheel 0, horizontal=wheel 1? */
fgState.MouseWheelTicks -= wheel;
if (abs(fgState.MouseWheelTicks) >= WHEEL_DELTA)
{
int wheel_number = 0;
int direction = (fgState.MouseWheelTicks > 0) ? -1 : 1;
if (!FETCH_WCB(*window, MouseWheel) && !FETCH_WCB(*window, Mouse))
break;
//XXX fgSetWindow(window);
while(abs(fgState.MouseWheelTicks) >= WHEEL_DELTA)
{
if (FETCH_WCB(*window, MouseWheel))
INVOKE_WCB(*window, MouseWheel, (wheel_number, direction, window->State.MouseX, window->State.MouseY));
else /* No mouse wheel, call the mouse button callback twice */
{
/*
* Map wheel zero to button 3 and 4; +1 to 3, -1 to 4
* " " one +1 to 5, -1 to 6, ...
*
* XXX The below assumes that you have no more than 3 mouse
* XXX buttons. Sorry.
*/
int button = wheel_number * 2 + 3;
if (direction < 0)
++button;
INVOKE_WCB(*window, Mouse, (button, GLUT_DOWN, window->State.MouseX, window->State.MouseY));
INVOKE_WCB(*window, Mouse, (button, GLUT_UP, window->State.MouseX, window->State.MouseY));
}
fgState.MouseWheelTicks -= WHEEL_DELTA * direction;
}
}
}
fgState.Modifiers = INVALID_MODIFIERS;
break;
}
//Based off fg_main_android
case SCREEN_EVENT_KEYBOARD:
{
int flags;
int value;
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_FLAGS, &flags);
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_SYM, &value);
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_KEY_MODIFIERS, &mod);
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));
/* Suppress key repeats if desired. Based off fg_main_mswin */
if ((flags & KEY_REPEAT) == 0 || (fgState.KeyRepeat == GLUT_KEY_REPEAT_OFF && fgStructure.CurrentWindow->State.IgnoreKeyRepeat == GL_TRUE)) {
unsigned int keypress = 0;
unsigned char ascii = 0;
/* Remember the current modifiers state so user can query it from their callback */
fgState.Modifiers = fgPlatformGetModifiers(mod);
/* Process keys */
if ((keypress = key_special(value))) {
if(flags & KEY_DOWN) {
INVOKE_WCB(*window, Special, (keypress, window->State.MouseX, window->State.MouseY));
} else {
INVOKE_WCB(*window, SpecialUp, (keypress, window->State.MouseX, window->State.MouseY));
}
} else if((flags & KEY_SYM_VALID) && (ascii = key_ascii(value))) {
if(flags & KEY_DOWN) {
INVOKE_WCB(*window, Keyboard, (ascii, window->State.MouseX, window->State.MouseY));
} else {
INVOKE_WCB(*window, KeyboardUp, (ascii, window->State.MouseX, window->State.MouseY));
}
} else {
LOGW("fgPlatformProcessSingleEvent: SCREEN_EVENT_KEYBOARD. Unhandled key event");
}
fgState.Modifiers = INVALID_MODIFIERS;
}
break;
}
case SCREEN_EVENT_PROPERTY:
case SCREEN_EVENT_IDLE:
break;
default:
LOGW("fgPlatformProcessSingleEvent: unknown screen event: 0x%X", SLOG2_FA_SIGNED(eventType));
break;
}
} else if (domain == navigator_get_domain()) {
unsigned int eventType = bps_event_get_code(fgDisplay.pDisplay.event);
switch (eventType) {
case NAVIGATOR_WINDOW_STATE:
{
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE");
/* Covered only happens due to keyboard. When the app is minimized, the keyboard is closed.
When the keyboard is open, and the app is fullscreened, the keyboard is also closed.
If a window is covered and the app is minimized, the state will be set and the keyboard event
will adjust the screen size and change window status. */
navigator_window_state_t state = navigator_event_get_window_state(fgDisplay.pDisplay.event);
if(window->State.pWState.windowCovered == GL_FALSE)
{
switch (state)
{
case NAVIGATOR_WINDOW_FULLSCREEN:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE-NAVIGATOR_WINDOW_FULLSCREEN");
window->State.Visible = GL_TRUE;
INVOKE_WCB(*window, WindowStatus, (GLUT_FULLY_RETAINED));
break;
case NAVIGATOR_WINDOW_THUMBNAIL:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE-NAVIGATOR_WINDOW_THUMBNAIL");
window->State.Visible = GL_TRUE;
INVOKE_WCB(*window, WindowStatus, (GLUT_PARTIALLY_RETAINED));
break;
case NAVIGATOR_WINDOW_INVISIBLE:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE-NAVIGATOR_WINDOW_INVISIBLE");
window->State.Visible = GL_FALSE;
INVOKE_WCB(*window, WindowStatus, (GLUT_HIDDEN));
break;
default:
LOGW("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_STATE unknown: 0x%X", SLOG2_FA_SIGNED(state));
break;
}
}
window->State.pWState.windowState = state;
break;
}
case NAVIGATOR_EXIT:
{
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_EXIT");
fgPlatformMainLoopPostWork();
/* User closed the application for good, let's kill the window */
SFG_Window* window = fgStructure.CurrentWindow;
if (window != NULL) {
fgDestroyWindow(window);
} else {
LOGW("NAVIGATOR_EXIT: No current window");
}
//XXX Should this be a bit more "forceful" so that it doesn't continue to loop through events?
break;
}
case NAVIGATOR_SWIPE_DOWN:
/* XXX Open app menu */
break;
/* Orientation is a bunch of handshakes.
- First the app get's asked if it wants to rotate (NAVIGATOR_ORIENTATION_CHECK)
- If the app wants to rotate, then it will be told what size it will be after rotate (NAVIGATOR_ORIENTATION_SIZE).
- Once the OS confirms that it's ready to rotate, it tells the app to handle rotation (NAVIGATOR_ORIENTATION).
- Once rotation is complete, the OS tells the app it's done (NAVIGATOR_ORIENTATION_DONE) */
case NAVIGATOR_ORIENTATION_CHECK:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_ORIENTATION_CHECK");
/* Reset sizes */
window->State.pWState.newWidth = 0;
window->State.pWState.newHeight = 0;
#ifdef __PLAYBOOK__
/* On rotation, the keyboard is closed. This prevents two resize calls */
window->State.pWState.keyboardOpen = GL_FALSE;
#endif
/* Notify that we want to rotate */
navigator_orientation_check_response(fgDisplay.pDisplay.event, true);
break;
case NAVIGATOR_ORIENTATION:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_ORIENTATION");
/* NAVIGATOR_ORIENTATION occurs before NAVIGATOR_KEYBOARD_POSITION */
/* Rotate and resize the window */
fgPlatformRotateWindow(window, navigator_event_get_orientation_angle(fgDisplay.pDisplay.event));
fgPlatformFlushCommands();
#ifdef __PLAYBOOK__
/* PlayBook doesn't indicate what the new size will be, so we need to retrieve it from the window itself */
window->State.pWState.newWidth = glutGet(GLUT_WINDOW_WIDTH);
window->State.pWState.newHeight = glutGet(GLUT_WINDOW_HEIGHT);
#endif
fghOnReshapeNotify(window, window->State.pWState.newWidth, window->State.pWState.newHeight, GL_FALSE);
/* Reset sizes */
window->State.pWState.newWidth = 0;
window->State.pWState.newHeight = 0;
/* Done rotating */
navigator_done_orientation(fgDisplay.pDisplay.event);
break;
case NAVIGATOR_BACK:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_BACK");
INVOKE_WCB(*window, Keyboard, (ESCAPE_BUTTON_KEY, window->State.MouseX, window->State.MouseY));
INVOKE_WCB(*window, KeyboardUp, (ESCAPE_BUTTON_KEY, window->State.MouseX, window->State.MouseY));
break;
case NAVIGATOR_WINDOW_ACTIVE:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_ACTIVE");
INVOKE_WCB(*window, AppStatus, (GLUT_APPSTATUS_RESUME));
break;
case NAVIGATOR_WINDOW_INACTIVE:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_WINDOW_INACTIVE");
INVOKE_WCB(*window, AppStatus, (GLUT_APPSTATUS_PAUSE));
break;
case NAVIGATOR_ORIENTATION_DONE:
case NAVIGATOR_ORIENTATION_RESULT:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_ORIENTATION_DONE/NAVIGATOR_ORIENTATION_RESULT");
break;
#ifndef __PLAYBOOK__
case NAVIGATOR_KEYBOARD_STATE:
{
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_KEYBOARD_STATE");
navigator_keyboard_state_t state = navigator_event_get_keyboard_state(fgDisplay.pDisplay.event);
switch (state)
{
case NAVIGATOR_KEYBOARD_CLOSED:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_KEYBOARD_STATE-NAVIGATOR_KEYBOARD_CLOSED");
/* NAVIGATOR_KEYBOARD_POSITION only occurs on open, so on keyboard close we need to reset the keyboard height */
fgPlatformHandleKeyboardHeight(window, 0);
break;
case NAVIGATOR_KEYBOARD_OPENING:
case NAVIGATOR_KEYBOARD_OPENED:
case NAVIGATOR_KEYBOARD_CLOSING:
break;
case NAVIGATOR_KEYBOARD_UNRECOGNIZED:
LOGW("fgPlatformProcessSingleEvent: NAVIGATOR_KEYBOARD_STATE-NAVIGATOR_KEYBOARD_UNRECOGNIZED");
break;
default:
LOGW("fgPlatformProcessSingleEvent: NAVIGATOR_KEYBOARD_STATE unknown: 0x%X", SLOG2_FA_SIGNED(state));
break;
}
break;
}
case NAVIGATOR_KEYBOARD_POSITION:
{
/* Occurs only when keyboard has opened or resizes */
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_KEYBOARD_POSITION");
int keyboardOffset = navigator_event_get_keyboard_position(fgDisplay.pDisplay.event);
if(keyboardOffset == BPS_FAILURE) {
LOGW("fgPlatformProcessSingleEvent: NAVIGATOR_KEYBOARD_POSITION: getting keyboard offset failed");
} else {
/* keyboardOffset is the offset from the top of the screen to the top of the keyboard, AKA the size of the uncovered screen
We want the height of the keyboard. So instead of determining the orientation, getting the right display size, and subtracting;
we just get the keyboard height which may be slower but easier to understand and work with */
virtualkeyboard_get_height(&keyboardOffset);
fgPlatformHandleKeyboardHeight(window, keyboardOffset);
}
break;
}
case NAVIGATOR_DEVICE_LOCK_STATE:
break;
case NAVIGATOR_WINDOW_COVER:
case NAVIGATOR_WINDOW_COVER_ENTER:
case NAVIGATOR_WINDOW_COVER_EXIT:
/* BlackBerry specific. Let app status and window status take care of everything */
break;
case NAVIGATOR_APP_STATE:
/* Can do the same as NAVIGATOR_WINDOW_ACTIVE/NAVIGATOR_WINDOW_INACTIVE but
seems like it doesn't work when the app comes to the foreground. Might be a bug */
break;
case NAVIGATOR_ORIENTATION_SIZE:
LOGI("fgPlatformProcessSingleEvent: NAVIGATOR_ORIENTATION_SIZE");
/* Get new window size */
window->State.pWState.newWidth = navigator_event_get_orientation_size_width(fgDisplay.pDisplay.event);
window->State.pWState.newHeight = navigator_event_get_orientation_size_height(fgDisplay.pDisplay.event);
break;
#endif
case 0: //Doesn't exist in header, but shows up when keyboard shows and resizes
break;
default:
LOGW("fgPlatformProcessSingleEvent: unknown navigator event: 0x%X", SLOG2_FA_SIGNED(eventType));
break;
}
}
#ifdef __PLAYBOOK__
/* While this could be used for non-PlayBook, BlackBerry 10 will still get navigator events, so use those. They are a bit more exact. */
else if(domain == virtualkeyboard_get_domain()) {
unsigned int eventType = bps_event_get_code(fgDisplay.pDisplay.event);
switch (eventType) {
case VIRTUALKEYBOARD_EVENT_VISIBLE:
LOGI("fgPlatformProcessSingleEvent: VIRTUALKEYBOARD_EVENT_VISIBLE");
if(window->State.pWState.keyboardOpen != GL_TRUE) {
window->State.pWState.keyboardOpen = GL_TRUE;
fgPlatformHandleKeyboardHeight(window, window->State.pWState.keyboardHeight);
}
break;
case VIRTUALKEYBOARD_EVENT_HIDDEN:
LOGI("fgPlatformProcessSingleEvent: VIRTUALKEYBOARD_EVENT_HIDDEN");
if(window->State.pWState.keyboardOpen != GL_FALSE) {
window->State.pWState.keyboardOpen = GL_FALSE;
fgPlatformHandleKeyboardHeight(window, 0);
}
break;
case VIRTUALKEYBOARD_EVENT_INFO:
LOGI("fgPlatformProcessSingleEvent: VIRTUALKEYBOARD_EVENT_INFO");
window->State.pWState.keyboardHeight = virtualkeyboard_event_get_height(fgDisplay.pDisplay.event);
if(window->State.pWState.keyboardOpen == GL_TRUE) {
fgPlatformHandleKeyboardHeight(window, window->State.pWState.keyboardHeight);
}
break;
default:
LOGW("fgPlatformProcessSingleEvent: unknown virtualkeyboard event: 0x%X", eventType);
break;
}
}
#endif
} while(bps_get_event(&fgDisplay.pDisplay.event, 1) == BPS_SUCCESS && fgDisplay.pDisplay.event != NULL);
/* Reset event to reduce chances of triggering something */
fgDisplay.pDisplay.event = NULL;
}
