static void qnx_handle_navigator_event(
qnx_input_t *qnx, bps_event_t *event)
{
int rc;
navigator_window_state_t state;
bps_event_t *event_pause = NULL;
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)rc;
switch (bps_event_get_code(event))
{
case NAVIGATOR_SWIPE_DOWN:
qnx->lifecycle_state ^= (UINT64_C(1) << RARCH_MENU_TOGGLE);
break;
case NAVIGATOR_EXIT:
/* Catch this in thumbnail loop. */
break;
case NAVIGATOR_WINDOW_STATE:
state = navigator_event_get_window_state(event);
switch(state)
{
case NAVIGATOR_WINDOW_THUMBNAIL:
for(;;)
{
/* Block until we get a resume or exit event. */
rc = bps_get_event(&event_pause, -1);
if(bps_event_get_code(event_pause) == NAVIGATOR_WINDOW_STATE)
{
state = navigator_event_get_window_state(event_pause);
if(state == NAVIGATOR_WINDOW_FULLSCREEN)
break;
}
else if (bps_event_get_code(event_pause) == NAVIGATOR_EXIT)
{
system->shutdown = true;
break;
}
}
break;
case NAVIGATOR_WINDOW_FULLSCREEN:
break;
case NAVIGATOR_WINDOW_INVISIBLE:
break;
}
break;
default:
break;
}
}
static void handle_navigator_event(void *data, bps_event_t *event)
{
navigator_window_state_t state;
bps_event_t *event_pause = NULL;
int rc;
(void)data;
(void)rc;
switch (bps_event_get_code(event))
{
case NAVIGATOR_SWIPE_DOWN:
g_extern.lifecycle_state ^= (1ULL << RARCH_MENU_TOGGLE);
break;
case NAVIGATOR_EXIT:
/* Catch this in thumbnail loop. */
break;
case NAVIGATOR_WINDOW_STATE:
state = navigator_event_get_window_state(event);
switch(state)
{
case NAVIGATOR_WINDOW_THUMBNAIL:
for(;;)
{
/* Block until we get a resume or exit event. */
rc = bps_get_event(&event_pause, -1);
if(bps_event_get_code(event_pause) == NAVIGATOR_WINDOW_STATE)
{
state = navigator_event_get_window_state(event_pause);
if(state == NAVIGATOR_WINDOW_FULLSCREEN)
break;
}
else if (bps_event_get_code(event_pause) == NAVIGATOR_EXIT)
{
g_extern.system.shutdown = true;
break;
}
}
break;
case NAVIGATOR_WINDOW_FULLSCREEN:
break;
case NAVIGATOR_WINDOW_INVISIBLE:
break;
}
break;
default:
break;
}
}
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;
}
//! runs the device. Returns false if device wants to be deleted
bool CIrrDeviceBB10::run()
{
os::Timer::tick();
//TODO: translate native event
SEvent irrevent;
bps_event_t *event = NULL;
while ( !Close &&(bps_get_event(&event, 0) ==BPS_SUCCESS))
{
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_EXIT == bps_event_get_code(event)))
{
Close =true;
break;
}
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_WINDOW_INACTIVE == bps_event_get_code(event)))
{
WindowHasFocus =false;
break;
}
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_WINDOW_ACTIVE == bps_event_get_code(event)))
{
WindowHasFocus =true;
break;
}
if ((event) && (bps_event_get_domain(event) == navigator_get_domain())
&& (NAVIGATOR_WINDOW_STATE == bps_event_get_code(event)))
{
if(navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_INVISIBLE)
WindowHasFocus =false;
else
WindowHasFocus =true;
break;
}
//TODO: transfer bps event to irr event
//postEventFromUser(irrevent);
break;
} // end while
return !Close;
}
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 OSBB10::process_events() {
handle_accelerometer();
bps_event_t *event = NULL;
do {
int rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (!event) break;
#ifdef BB10_SCORELOOP_ENABLED
ScoreloopBB10* sc = Globals::get_singleton()->get_singleton_object("Scoreloop")->cast_to<ScoreloopBB10>();
if (sc->handle_event(event))
continue;
#endif
#ifdef PAYMENT_SERVICE_ENABLED
if (payment_service->handle_event(event))
continue;
#endif
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handle_screen_event(event);
} else if (domain == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
if (main_loop)
main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
bps_event_destroy(event);
exit(0);
return;
/*
} else if (bps_event_get_code(event) == NAVIGATOR_ORIENTATION_CHECK) {
int angle = navigator_event_get_orientation_angle(event);
navigator_orientation_check_response(event, false);
} else if (bps_event_get_code(event) == NAVIGATOR_ORIENTATION) {
_resize(event);
*/
} else if (bps_event_get_code(event) == NAVIGATOR_WINDOW_STATE) {
int state = navigator_event_get_window_state(event);
bool was_fullscreen = fullscreen;
minimized = state == NAVIGATOR_WINDOW_INVISIBLE;
fullscreen = state == NAVIGATOR_WINDOW_FULLSCREEN;
set_low_processor_usage_mode(!fullscreen);
if (fullscreen != was_fullscreen) {
if (fullscreen) {
audio_server->set_fx_global_volume_scale(fullscreen_mixer_volume);
audio_server->set_stream_global_volume_scale(fullscreen_stream_volume);
} else {
fullscreen_mixer_volume = audio_server->get_fx_global_volume_scale();
fullscreen_stream_volume = audio_server->get_stream_global_volume_scale();
audio_server->set_fx_global_volume_scale(0);
audio_server->set_stream_global_volume_scale(0);
};
};
};
} else if (domain == audiodevice_get_domain()) {
const char * audiodevice_path = audiodevice_event_get_path(event);
printf("************* got audiodevice event, path %s\n", audiodevice_path);
audio_driver->finish();
audio_driver->init(audiodevice_path);
audio_driver->start();
};
//bps_event_destroy(event);
} while (event);
};
bool CCEGLView::handleEvents()
{
bps_event_t* event = NULL;
mtouch_event_t mtouch_event;
int touch_id = 0;
int val = 0;
int rc = 0;
int domain = 0;
char buf[4] = {0};
for (;;)
{
rc = bps_get_event(&event, 1);
assert(rc == BPS_SUCCESS);
// break if no more events
if (event == NULL)
break;
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
{
switch (bps_event_get_code(event))
{
case NAVIGATOR_SWIPE_DOWN:
CCDirector::sharedDirector()->getKeypadDispatcher()->dispatchKeypadMSG(kTypeMenuClicked);
break;
case NAVIGATOR_EXIT:
// exit the application
// release();
end();
break;
case NAVIGATOR_WINDOW_INACTIVE:
if (m_isWindowActive)
{
CCApplication::sharedApplication()->applicationDidEnterBackground();
m_isWindowActive = false;
}
break;
case NAVIGATOR_WINDOW_ACTIVE:
if (!m_isWindowActive)
{
CCApplication::sharedApplication()->applicationWillEnterForeground();
m_isWindowActive = true;
}
break;
case NAVIGATOR_WINDOW_STATE:
{
switch(navigator_event_get_window_state(event))
{
case NAVIGATOR_WINDOW_FULLSCREEN:
if (!m_isWindowActive)
{
CCApplication::sharedApplication()->applicationWillEnterForeground();
m_isWindowActive = true;
}
break;
case NAVIGATOR_WINDOW_THUMBNAIL:
if (m_isWindowActive)
{
CCApplication::sharedApplication()->applicationDidEnterBackground();
m_isWindowActive = false;
}
break;
}
break;
}
default:
break;
}
}
else if (domain == screen_get_domain())
{
m_screenEvent = screen_event_get_event(event);
rc = screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_TYPE, &val);
if (rc || val == SCREEN_EVENT_NONE)
break;
float x, y;
switch (val)
{
case SCREEN_EVENT_CLOSE:
fprintf(stderr, "SCREEN CLOSE EVENT!\n");
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
screen_get_mtouch_event(m_screenEvent, &mtouch_event, 0);
touch_id = mtouch_event.contact_id;
x = mtouch_event.x;
y = mtouch_event.y;
handleTouchesEnd(1, &touch_id, &x, &y);
break;
case SCREEN_EVENT_MTOUCH_TOUCH:
screen_get_mtouch_event(m_screenEvent, &mtouch_event, 0);
touch_id = mtouch_event.contact_id;
x = mtouch_event.x;
y = mtouch_event.y;
handleTouchesBegin(1, &touch_id, &x, &y);
break;
case SCREEN_EVENT_MTOUCH_MOVE:
screen_get_mtouch_event(m_screenEvent, &mtouch_event, 0);
touch_id = mtouch_event.contact_id;
x = mtouch_event.x;
y = mtouch_event.y;
handleTouchesMove(1, &touch_id, &x, &y);
break;
case SCREEN_EVENT_POINTER:
{
int buttons = 0;
int pair_[2] = {0};
float pair[2] = {0.0f};
static bool mouse_pressed = false;
// this is a mouse move event, it is applicable to a device with a usb mouse or simulator
screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_BUTTONS, &buttons);
screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_SOURCE_POSITION, pair_);
pair[0] = (float)pair_[0];
pair[1] = (float)pair_[1];
if (buttons & SCREEN_LEFT_MOUSE_BUTTON)
{
if (mouse_pressed)
{
handleTouchesMove(1, &touch_id, &pair[0], &pair[1]);
}
else
{
// Left mouse button is pressed
mouse_pressed = true;
handleTouchesBegin(1, &touch_id, &pair[0], &pair[1]);
}
}
else
{
if (mouse_pressed)
{
mouse_pressed = false;
handleTouchesEnd(1, &touch_id, &pair[0], &pair[1]);
}
}
}
break;
case SCREEN_EVENT_KEYBOARD:
screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_KEY_FLAGS, &val);
if (val & KEY_DOWN)
{
screen_get_event_property_iv(m_screenEvent, SCREEN_PROPERTY_KEY_SYM, &val);
if (val >= ' ' && val < '~')
{
buf[0] = val;
buf[1]= '\0';
CCIMEDispatcher::sharedDispatcher()->dispatchInsertText(buf, 1);
}
else
{
val = val - 0xf000;
buf[0] = val;
buf[1]= '\0';
switch (val)
{
case 8: // backspace
// CCKeypadDispatcher::sharedDispatcher()->dispatchKeypadMSG(kTypeBackClicked);
CCIMEDispatcher::sharedDispatcher()->dispatchDeleteBackward();
break;
default:
CCIMEDispatcher::sharedDispatcher()->dispatchInsertText(buf, 1);
break;
}
}
}
break;
default:
break;
}
}
else if (domain == sensor_get_domain())
{
if (bps_event_get_code(event) == SENSOR_ACCELEROMETER_READING)
{
struct timespec time_struct;
long current_time;
float x, y, z;
clock_gettime(CLOCK_REALTIME, &time_struct);
current_time = time2millis(&time_struct);
sensor_event_get_xyz(event, &x, &y, &z);
CCDirector::sharedDirector()->getAccelerometer()->update(current_time, -x, -y, z);
}
}
}
return true;
}
void PB_HandleEvents(void (*keyHandleFunction)(screen_event_t*)){
bps_event_t *event = NULL;
while(1){
bps_get_event(&event, 0);
if(event == NULL){
break;
}
if (bps_event_get_domain(event) == screen_get_domain()) {
int screen_val;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE,
&screen_val);
//Here we should handle menu related functions such as rom switch, etc.
//Then pass off to input plugin.
switch(screen_val){
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
case SCREEN_EVENT_MTOUCH_RELEASE:
(*keyHandleFunction)((void*)&screen_event);
break;
}
} else if (bps_event_get_domain(event) == navigator_get_domain()) {
int rc;
navigator_window_state_t state;
bps_event_t *activation_event = NULL;
//int videoPlugin, disableSound;
switch (bps_event_get_code(event)) {
case NAVIGATOR_ORIENTATION_CHECK:
//Signal navigator that we intend to resize
//navigator_orientation_check_response(event, true);
break;
case NAVIGATOR_ORIENTATION:
//if (EXIT_FAILURE == resize(event)) {
// shutdown = true;
//}
break;
case NAVIGATOR_SWIPE_DOWN:
//Rom picker
rc = dialog_select_game(romName, "shared/misc/n64/roms/", &videoPlugin, &disableSound);
if (rc == 0) {
(*keyHandleFunction)(0);
}
break;
case NAVIGATOR_EXIT:
break;
case NAVIGATOR_WINDOW_STATE:
state = navigator_event_get_window_state(event);
switch(state){
case NAVIGATOR_WINDOW_THUMBNAIL:
for(;;){
rc = bps_get_event(&activation_event, -1);
assert(rc==BPS_SUCCESS);
if(bps_event_get_code(activation_event) == NAVIGATOR_WINDOW_STATE){
state = navigator_event_get_window_state(activation_event);
if(state == NAVIGATOR_WINDOW_FULLSCREEN){
break;
}
}
}
break;
}
break;
}
}
}
}
/**
* A sample application demonstrates the BlackBerry Native APIs for accelerometer.
* The sample initializes and reads the accelerometer periodically until a
* NAVIGATOR_EXIT event is received.
* The application also listens for window state changes from the navigator so that
* it can stop reading the accelerometer when the application is no longer visible.
*/
int
main(int argc, char *argv[])
{
if (setup_screen() != EXIT_SUCCESS) {
printf("Unable to set up the screen. Exiting.");
return 0;
}
/*
* The accelerometer forces
*/
double force_x, force_y, force_z;
/*
* Before we can listen for events from the BlackBerry Tablet OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
/*
* Once the BPS infrastructure has been initialized we can register for
* events from the various BlackBerry Tablet OS platform services. The
* Navigator service manages and delivers application life cycle and
* visibility events.
* For this sample, we request Navigator events so we can track when
* the system is terminating the application (NAVIGATOR_EXIT event). This allows
* us to clean up application resources.
*/
navigator_request_events(0);
/*
* Before initializing the accelerometer service we must ensure the device
* supports it
*/
if (!accelerometer_is_supported()) {
/*
* If the device does not support accelerometer then notify the user,
* clean up and exit
*/
printf("Accelerometer not supported by device!");
bps_shutdown();
return EXIT_FAILURE;
}
/*
* Initialize the accelerometer by setting the rates at which the
* accelerometer values will be updated from hardware
*/
accelerometer_set_update_frequency(FREQ_40_HZ);
/*
* Process Navigator events and take accelerometer readings periodically
* until we receive a NAVIGATOR_EXIT event.
*/
int exit_application = 0;
int paused = 0;
while (!exit_application) {
/*
* By setting the bps_get_event timeout to ACCELEROMETER_MAX_POLL_INTERVAL,
* we assign the maximum time (in millis) that we will wait before
* unblocking so we can take an accelerometer reading.
*/
bps_event_t *event = NULL;
bps_get_event(&event, ACCELEROMETER_MAX_POLL_INTERVAL);
if (event) {
if (bps_event_get_domain(event) == navigator_get_domain()) {
/*
* If it is a NAVIGATOR_EXIT event then set the
* exit_application flag so the application will stop
* processing events, clean up and exit.
*
* If it is a NAVIGATOR_WINDOW_STATE event, and the window
* state is NAVIGATOR_WINDOW_INVISIBLE, set paused to true so
* that we stop collecting accelerometer data. Otherwise, if
* we're currently paused, then set paused back to false to
* resume collecting accelerometer data.
*/
unsigned int event_code = bps_event_get_code(event);
if (NAVIGATOR_EXIT == event_code) {
exit_application = 1;
} else if (NAVIGATOR_WINDOW_STATE == event_code) {
if (navigator_event_get_window_state(event) == NAVIGATOR_WINDOW_FULLSCREEN) {
/*
* The application is now full screen.
* Resume reading the accelerometer.
*/
paused = 0;
printf("Resuming accelerometer reads.\n");
} else if (!paused){
/*
* The application has become thumbnailed or invisible.
* If it is not already paused, then pause it.
* Otherwise, ignore the window state change.
*/
paused = 1;
printf("Resuming accelerometer reads.\n");
}
}
}
/*
* Remember to destroy any delivered events as we need to trigger
* the release of any event resources when we are done processing
* it.
*/
bps_event_destroy(event);
} else {
/*
* We've woken up. See if we are in the paused state. If not,
* take an accelerometer reading
*/
if (!paused) {
accelerometer_read_forces(&force_x, &force_y, &force_z);
display_accelerometer_reading(
ACCELEROMETER_CALCULATE_PITCH(force_x, force_y, force_z),
ACCELEROMETER_CALCULATE_ROLL(force_x, force_y, force_z));
}
}
}
/*
* Clean up screen resources
*/
screen_destroy_window(screen_win);
screen_destroy_context(screen_ctx);
/*
* Clean up the BPS infrastructure and exit
*/
bps_shutdown();
return 0;
}
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;
}
int Platform::enterMessagePump()
{
GP_ASSERT(_game);
int rc;
int eventType;
int flags;
int value;
int position[2];
int domain;
mtouch_event_t touchEvent;
bool suspended = false;
// Get the initial time.
clock_gettime(CLOCK_REALTIME, &__timespec);
__timeStart = timespec2millis(&__timespec);
__timeAbsolute = 0L;
_game->run();
// Message loop.
while (true)
{
bps_event_t* event = NULL;
while (true)
{
rc = bps_get_event(&event, 1);
GP_ASSERT(rc == BPS_SUCCESS);
if (event == NULL)
break;
domain = bps_event_get_domain(event);
if (domain == screen_get_domain())
{
__screenEvent = screen_event_get_event(event);
screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_TYPE, &eventType);
switch (eventType)
{
case SCREEN_EVENT_MTOUCH_TOUCH:
{
screen_get_mtouch_event(__screenEvent, &touchEvent, 0);
if (__gestureEventsProcessed.any())
rc = gestures_set_process_event(__gestureSet, &touchEvent, NULL);
if ( !rc && (__multiTouch || touchEvent.contact_id == 0) )
{
gameplay::Platform::touchEventInternal(Touch::TOUCH_PRESS, touchEvent.x, touchEvent.y, touchEvent.contact_id);
}
break;
}
case SCREEN_EVENT_MTOUCH_RELEASE:
{
screen_get_mtouch_event(__screenEvent, &touchEvent, 0);
if (__gestureEventsProcessed.any())
rc = gestures_set_process_event(__gestureSet, &touchEvent, NULL);
if ( !rc && (__multiTouch || touchEvent.contact_id == 0) )
{
gameplay::Platform::touchEventInternal(Touch::TOUCH_RELEASE, touchEvent.x, touchEvent.y, touchEvent.contact_id);
}
if (__gestureSwipeRecognized)
{
__gestureSwipeRecognized = false;
}
break;
}
case SCREEN_EVENT_MTOUCH_MOVE:
{
screen_get_mtouch_event(__screenEvent, &touchEvent, 0);
if (__gestureEventsProcessed.any())
rc = gestures_set_process_event(__gestureSet, &touchEvent, NULL);
if ( !rc && (__multiTouch || touchEvent.contact_id == 0) )
{
gameplay::Platform::touchEventInternal(Touch::TOUCH_MOVE, touchEvent.x, touchEvent.y, touchEvent.contact_id);
}
break;
}
case SCREEN_EVENT_POINTER:
{
static int mouse_pressed = 0;
int buttons;
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);
screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_MOUSE_WHEEL, &wheel);
// 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;
mouseOrTouchEvent(Mouse::MOUSE_PRESS_LEFT_BUTTON, Touch::TOUCH_PRESS, position[0], position[1]);
}
}
else if (mouse_pressed & SCREEN_LEFT_MOUSE_BUTTON)
{
move = false;
mouse_pressed &= ~SCREEN_LEFT_MOUSE_BUTTON;
mouseOrTouchEvent(Mouse::MOUSE_RELEASE_LEFT_BUTTON, Touch::TOUCH_RELEASE, position[0], position[1]);
}
// 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;
gameplay::Platform::mouseEventInternal(Mouse::MOUSE_PRESS_RIGHT_BUTTON, position[0], position[1], 0);
}
}
else if (mouse_pressed & SCREEN_RIGHT_MOUSE_BUTTON)
{
move = false;
mouse_pressed &= ~SCREEN_RIGHT_MOUSE_BUTTON;
gameplay::Platform::mouseEventInternal(Mouse::MOUSE_RELEASE_RIGHT_BUTTON, position[0], position[1], 0);
}
// 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;
gameplay::Platform::mouseEventInternal(Mouse::MOUSE_PRESS_MIDDLE_BUTTON, position[0], position[1], 0);
}
}
else if (mouse_pressed & SCREEN_MIDDLE_MOUSE_BUTTON)
{
move = false;
mouse_pressed &= ~SCREEN_MIDDLE_MOUSE_BUTTON;
gameplay::Platform::mouseEventInternal(Mouse::MOUSE_RELEASE_MIDDLE_BUTTON, position[0], position[1], 0);
}
// Fire a move event if none of the buttons changed.
if (left_move)
{
mouseOrTouchEvent(Mouse::MOUSE_MOVE, Touch::TOUCH_MOVE, position[0], position[1]);
}
else if (move)
{
gameplay::Platform::mouseEventInternal(Mouse::MOUSE_MOVE, position[0], position[1], 0);
}
// Handle mouse wheel events.
if (wheel)
{
gameplay::Platform::mouseEventInternal(Mouse::MOUSE_WHEEL, position[0], position[1], -wheel);
}
break;
}
case SCREEN_EVENT_KEYBOARD:
{
screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_KEY_FLAGS, &flags);
screen_get_event_property_iv(__screenEvent, SCREEN_PROPERTY_KEY_SYM, &value);
gameplay::Keyboard::KeyEvent evt = (flags & KEY_DOWN) ? gameplay::Keyboard::KEY_PRESS : gameplay::Keyboard::KEY_RELEASE;
// Suppress key repeats.
if ((flags & KEY_REPEAT) == 0)
{
keyEventInternal(evt, getKey(value));
if (evt == gameplay::Keyboard::KEY_PRESS && (flags & KEY_SYM_VALID))
{
int unicode = getUnicode(value);
if (unicode)
keyEventInternal(gameplay::Keyboard::KEY_CHAR, unicode);
}
}
break;
}
}
}
else if (domain == navigator_get_domain())
{
switch (bps_event_get_code(event))
{
case NAVIGATOR_SWIPE_DOWN:
_game->menuEvent();
break;
case NAVIGATOR_WINDOW_STATE:
{
navigator_window_state_t state = navigator_event_get_window_state(event);
switch (state)
{
case NAVIGATOR_WINDOW_FULLSCREEN:
_game->resume();
suspended = false;
break;
case NAVIGATOR_WINDOW_THUMBNAIL:
case NAVIGATOR_WINDOW_INVISIBLE:
if (!suspended)
_game->pause();
suspended = true;
break;
}
break;
}
case NAVIGATOR_EXIT:
_game->exit();
break;
}
}
else if (domain == sensor_get_domain())
{
if (bps_event_get_code(event) == SENSOR_AZIMUTH_PITCH_ROLL_READING)
{
float azimuth;
sensor_event_get_apr(event, &azimuth, &__pitch, &__roll);
}
}
}
// If we are done, then exit.
if (_game->getState() == Game::UNINITIALIZED)
break;
if (!suspended)
{
_game->frame();
// Post the new frame to the display.
// Note that there are a couple cases where eglSwapBuffers could fail
// with an error code that requires a certain level of re-initialization:
//
// 1) EGL_BAD_NATIVE_WINDOW - Called when the surface we're currently using
// is invalidated. This would require us to destroy our EGL surface,
// close our OpenKODE window, and start again.
//
// 2) EGL_CONTEXT_LOST - Power management event that led to our EGL context
// being lost. Requires us to re-create and re-initalize our EGL context
// and all OpenGL ES state.
//
// For now, if we get these, we'll simply exit.
rc = eglSwapBuffers(__eglDisplay, __eglSurface);
if (rc != EGL_TRUE)
{
_game->exit();
perror("eglSwapBuffers");
break;
}
}
}
screen_stop_events(__screenContext);
bps_shutdown();
screen_destroy_context(__screenContext);
return 0;
}
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;
}
static void qnx_handle_navigator_event(
qnx_input_t *qnx, bps_event_t *event)
{
navigator_window_state_t state;
bps_event_t *event_pause = NULL;
switch (bps_event_get_code(event))
{
case NAVIGATOR_SYSKEY_PRESS:
switch(navigator_event_get_syskey_key(event))
{
case NAVIGATOR_SYSKEY_BACK:
input_keyboard_event(true, RETROK_BACKSPACE, 0, 0, RETRO_DEVICE_KEYBOARD);
input_keyboard_event(false, RETROK_BACKSPACE, 0, 0, RETRO_DEVICE_KEYBOARD);
break;
case NAVIGATOR_SYSKEY_SEND:
case NAVIGATOR_SYSKEY_END:
break;
default:
break;
}
break;
case NAVIGATOR_SWIPE_DOWN:
command_event(CMD_EVENT_MENU_TOGGLE, NULL);
break;
case NAVIGATOR_WINDOW_STATE:
switch(navigator_event_get_window_state(event))
{
case NAVIGATOR_WINDOW_THUMBNAIL:
case NAVIGATOR_WINDOW_INVISIBLE:
while(true)
{
unsigned event_code;
/* Block until we get a resume or exit event. */
bps_get_event(&event_pause, -1);
event_code = bps_event_get_code(event_pause);
if(event_code == NAVIGATOR_WINDOW_STATE)
{
if(navigator_event_get_window_state(event_pause) == NAVIGATOR_WINDOW_FULLSCREEN)
break;
}
else if(event_code == NAVIGATOR_EXIT)
goto shutdown;
}
break;
case NAVIGATOR_WINDOW_FULLSCREEN:
break;
}
break;
case NAVIGATOR_EXIT:
goto shutdown;
default:
break;
}
return;
togglemenu:
command_event(CMD_EVENT_MENU_TOGGLE, NULL);
return;
shutdown:
rarch_ctl(RARCH_CTL_SET_SHUTDOWN, NULL);
return;
}
