void handleEvent() {
//Request and process BPS next available event
int rc, domain;
for (;;) {
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if(domain == navigator_get_domain()) {
handleNavigatorEvent(event);
} else if (domain == dialog_get_domain()) {
handle_dialog_response(event);
}
} else {
break;
}
}
}
bool QQnxBpsEventFilter::nativeEventFilter(const QByteArray &eventType, void *message, long *result)
{
Q_UNUSED(eventType);
Q_UNUSED(result);
bps_event_t *event = static_cast<bps_event_t *>(message);
const int eventDomain = bps_event_get_domain(event);
qBpsEventFilterDebug() << Q_FUNC_INFO << "event=" << event << "domain=" << eventDomain;
if (eventDomain == screen_get_domain()) {
if (!m_screenEventHandler) {
qWarning("QQNX: registered for screen events, but no handler provided.");
return false;
}
screen_event_t screenEvent = screen_event_get_event(event);
return m_screenEventHandler->handleEvent(screenEvent);
}
if (eventDomain == dialog_get_domain()) {
dialog_instance_t nativeDialog = dialog_event_get_dialog_instance(event);
QQnxFileDialogHelper *dialog = m_dialogMapper.value(nativeDialog, 0);
if (dialog)
return dialog->handleEvent(event);
}
if (eventDomain == navigator_get_domain())
return handleNavigatorEvent(event);
if (m_virtualKeyboard->handleEvent(event))
return true;
return false;
}
static void qnx_input_poll(void *data)
{
global_t *global = global_get_ptr();
qnx_input_t *qnx = (qnx_input_t*)data;
global->lifecycle_state &= ~(1ULL << RARCH_MENU_TOGGLE);
/* Request and process all available BPS events. */
while(true)
{
bps_event_t *event = NULL;
int rc = bps_get_event(&event, 0);
if(rc == BPS_SUCCESS)
{
int domain;
if (!event)
break;
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
qnx_handle_navigator_event(qnx, event);
else if (domain == screen_get_domain())
qnx_handle_screen_event(qnx, event);
}
}
}
static void handleEvents()
{
int domain;
// Get the first event in the queue.
bps_event_t *event = NULL;
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event() failed\n");
return;
}
// Handle all events in the queue.
// If we don't do this in a loop, we'll only handle one event per frame.
// If many events are triggered quickly, e.g. by spinning the analog sticks,
// the queue will grow and the user will see the analog sticks lag.
while (event) {
if (event) {
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain()) {
handleNavigatorEvent(event);
} else if (domain == screen_get_domain()) {
handleScreenEvent(event);
}
}
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event() failed\n");
return;
}
}
}
static void handle_events() {
int screen_domain = screen_get_domain();
int navigator_domain = navigator_get_domain();
int sensor_domain = sensor_get_domain();
int rc;
//Request and process available BPS events
for(;;) {
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_domain) {
handleScreenEvent(event);
} else if (domain == navigator_domain) {
handleNavigatorEvent(event);
} else if (domain == sensor_domain) {
handleSensorEvent(event);
}
} else {
//No more events in the queue
break;
}
}
}
static void qnx_input_poll(void *data)
{
qnx_input_t *qnx = (qnx_input_t*)data;
/* Request and process all available BPS events. */
while(true)
{
bps_event_t *event = NULL;
int rc = bps_get_event(&event, 0);
if(rc == BPS_SUCCESS)
{
int domain;
if (!event)
break;
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
qnx_handle_navigator_event(qnx, event);
else if (domain == screen_get_domain())
qnx_handle_screen_event(qnx, event);
}
}
}
static void qnx_input_poll(void *data)
{
(void)data;
//Request and process all available BPS events
int rc, domain;
g_extern.lifecycle_state &= ~(1ULL << RARCH_MENU_TOGGLE);
while(true)
{
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
if(rc == BPS_SUCCESS)
{
if (event)
{
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
handle_navigator_event(event);
else if (domain == screen_get_domain())
handle_screen_event(event);
}
else
break;
}
}
}
bool ScreenWindow::pollEvent(WinEvent *event)
{
bps_event_t *bpsEvent;
bps_get_event(&bpsEvent, 0);
if (bpsEvent) {
int domain = bps_event_get_domain(bpsEvent);
if (domain == navigator_get_domain()) {
if (bps_event_get_code(bpsEvent) == NAVIGATOR_EXIT) {
event->type = QUIT;
return true;
}
} else if (domain == screen_get_domain()) {
screen_event_t se = screen_event_get_event(bpsEvent);
int type;
screen_get_event_property_iv(se, SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_EVENT_CLOSE) {
event->type = QUIT;
return true;
} else if (type == SCREEN_EVENT_MTOUCH_TOUCH) {
event->type = MOUSEBUTTONDOWN;
return true;
}
}
}
return false;
}
static void
handle_event()
{
int rc, domain;
bps_event_t *event = NULL;
rc = bps_get_event(&event, -1);
assert(rc == BPS_SUCCESS);
if (event) {
domain = bps_event_get_domain(event);
if (domain == navigator_get_domain()) {
handle_navigator_event(event);
} else if (domain == screen_get_domain()) {
handle_screen_event(event);
}
}
}
static void gfx_ctx_check_window(bool *quit,
bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
{
(void)frame_count;
//Request and process all available BPS events
bps_event_t *event = NULL;
bps_get_event(&event, 0);
*quit = false;
unsigned new_width, new_height;
gfx_ctx_get_video_size(&new_width, &new_height);
if (new_width != *width || new_height != *height)
{
*width = new_width;
*height = new_height;
*resize = true;
}
if (event)
{
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain())
{
screen_event_t screen_event = screen_event_get_event(event);
int screen_val;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
switch (screen_val) {
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
case SCREEN_EVENT_MTOUCH_RELEASE:
break;
}
}
else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event)))
g_extern.lifecycle_state |= (1ULL << RARCH_QUIT_KEY);
}
// Check if we are exiting.
if (g_extern.lifecycle_state & (1ULL << RARCH_QUIT_KEY))
*quit = true;
}
static bool s_eventFilter(void *message)
{
bps_event_t * const event = static_cast<bps_event_t *>(message);
if (event &&
(bps_event_get_domain(event) == mmrenderer_get_domain() ||
bps_event_get_domain(event) == screen_get_domain() )) {
const int id = mmrenderer_event_get_userdata(event);
BbMediaPlayerControl * const control = s_idToPlayerMap.value(id);
if (control)
control->bpsEventHandler(event);
}
if (s_previousEventFilter)
return s_previousEventFilter(message);
else
return false;
}
static void event(bps_event_t *event, int domain, int code, void *data)
{
if(domain == screen_get_domain())
{
screen_event_t screenEvent = screen_event_get_event(event);
int eventType;
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_TYPE, &eventType);
if(eventType == SCREEN_EVENT_MTOUCH_TOUCH/* || eventType == SCREEN_EVENT_MTOUCH_MOVE*/)
{
int pair[2];
screen_get_event_property_iv(screenEvent, SCREEN_PROPERTY_SOURCE_POSITION, pair);
Game::OnScreenTouch(pair[0], pair[1]);
}
}
}
static void handle_events() {
//Request and process available BPS events
for(;;) {
bps_event_t *event = NULL;
if (BPS_SUCCESS != bps_get_event(&event, 0)) {
fprintf(stderr, "bps_get_event failed\n");
break;
}
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if (domain == navigator_get_domain()) {
handleNavigatorEvent(event);
}
} else {
break;
}
}
}
void BbVideoWindowControl::bpsEventHandler(bps_event_t *event)
{
if (event && bps_event_get_domain(event) == screen_get_domain()) {
const screen_event_t screen_event = screen_event_get_event(event);
int eventType;
if (screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType) != 0) {
perror("BbVideoWindowControl: Failed to query screen event type");
return;
}
if (eventType != SCREEN_EVENT_CREATE)
return;
screen_window_t window = 0;
if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0) {
perror("BbVideoWindowControl: Failed to query window property");
return;
}
const int maxIdStrLength = 128;
char idString[maxIdStrLength];
if (screen_get_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, maxIdStrLength, idString) != 0) {
perror("BbVideoWindowControl: Failed to query window ID string");
return;
}
if (m_windowName == idString) {
m_window = window;
updateVideoPosition();
const int visibleFlag = 1;
if (screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &visibleFlag) != 0) {
perror("BbVideoWindowControl: Failed to make window visible");
return;
}
}
}
}
bool WindowGrabber::nativeEventFilter(const QByteArray&, void *message, long*)
{
bps_event_t * const event = static_cast<bps_event_t *>(message);
if (event && bps_event_get_domain(event) == screen_get_domain()) {
const screen_event_t screen_event = screen_event_get_event(event);
int eventType;
if (screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType) != 0) {
qWarning() << "WindowGrabber: Failed to query screen event type";
return false;
}
if (eventType != SCREEN_EVENT_CREATE)
return false;
screen_window_t window = 0;
if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0) {
qWarning() << "WindowGrabber: Failed to query window property";
return false;
}
const int maxIdStrLength = 128;
char idString[maxIdStrLength];
if (screen_get_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, maxIdStrLength, idString) != 0) {
qWarning() << "WindowGrabber: Failed to query window ID string";
return false;
}
if (m_windowId == idString) {
m_window = window;
start();
}
}
return false;
}
void ConfigWindow::runEventLoop(TCOContext *emuContext)
{
screen_buffer_t buffer = draw(emuContext);
bool showingWindow = true;
bps_initialize();
screen_request_events(m_context);
bps_event_t *event; /* FIXME: How do we verify they ran bps_initialize? */
screen_event_t se;
int eventType;
int contactId;
bool touching = false;
bool releasedThisRound = false;
int startPos[2] = {0,0};
int endPos[2] = {0,0};
bool scaling = false;
while (showingWindow)
{
const int dirtyRects[4] = {0, 0, m_size[0], m_size[1]};
releasedThisRound = false;
bps_get_event(&event, 0);
while (showingWindow && event)
{
int domain = bps_event_get_domain(event);
if (domain == navigator_get_domain())
{
if (bps_event_get_code(event) == NAVIGATOR_SWIPE_DOWN)
showingWindow = false;
else if (bps_event_get_code(event) == NAVIGATOR_EXIT) {
showingWindow = false;
}
} else if (domain == screen_get_domain()) {
se = screen_event_get_event(event);
screen_get_event_property_iv(se, SCREEN_PROPERTY_TYPE, &eventType);
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
switch (eventType)
{
case SCREEN_EVENT_MTOUCH_TOUCH:
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
if (contactId == 0 && !touching && !releasedThisRound) {
touching = true;
screen_get_event_property_iv(se, SCREEN_PROPERTY_SOURCE_POSITION, startPos);
endPos[0] = startPos[0];
endPos[1] = startPos[1];
}
break;
case SCREEN_EVENT_MTOUCH_MOVE:
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
if (contactId == 0 && touching) {
screen_get_event_property_iv(se, SCREEN_PROPERTY_SOURCE_POSITION, endPos);
}
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
screen_get_event_property_iv(se, SCREEN_PROPERTY_TOUCH_ID, &contactId);
if (contactId == 0 && touching) {
touching = false;
releasedThisRound = true;
screen_get_event_property_iv(se, SCREEN_PROPERTY_SOURCE_POSITION, endPos);
}
break;
case SCREEN_EVENT_PROPERTY:
break;
default:
#ifdef _DEBUG
fprintf(stderr, "Unknown screen event: %d\n", eventType);
#endif
break;
}
}
bps_get_event(&event, 0);
}
if (releasedThisRound) {
m_selected = 0;
} else if (touching) {
if (!m_selected)
m_selected = emuContext->controlAt(startPos);
if (m_selected && (endPos[0] != startPos[0] || endPos[1] != startPos[1])) {
m_selected->move(endPos[0] - startPos[0], endPos[1] - startPos[1], (unsigned*)m_size);
buffer = draw(emuContext);
startPos[0] = endPos[0];
startPos[1] = endPos[1];
}
}
if (buffer)
post(buffer);
}
}
void zaAppBase::dispatchevent(bps_event_t *event)
{
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain())
{
int screen_val;
int pair[2];
int id;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE,
&screen_val);
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_SOURCE_POSITION, pair);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TOUCH_ID,
&id);
if (screen_val >= SCREEN_EVENT_MTOUCH_TOUCH
&& screen_val <= SCREEN_EVENT_MTOUCH_RELEASE
&& (id == 0 || m_multitouch))
{
e.m_id = id;
e.m_type = screen_val;
e.m_x = pair[0];
e.m_y = m_height - pair[1];
// e.m_obj
m_active->processEvent(&e);
}
else if (screen_val == SCREEN_EVENT_KEYBOARD)
{
int key_status;
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_KEY_FLAGS, &key_status);
if (key_status & KEY_DOWN)
{
int key_code;
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_KEY_SYM, &key_code);
e.m_type = screen_val;
e.m_keycode = key_code;
m_active->processEvent(&e);
}
}
else if (screen_val == SCREEN_EVENT_POINTER)
{
int buttons;
static int mouse_pressed = false;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS,
&buttons);
e.m_event = 0;
e.m_x = pair[0];
e.m_y = m_height - pair[1];
e.m_id = id;
if (buttons == SCREEN_LEFT_MOUSE_BUTTON && mouse_pressed == false)
{
mouse_pressed = true;
e.m_type = 100; //down
}
else if (mouse_pressed && buttons == SCREEN_LEFT_MOUSE_BUTTON)
{
e.m_type = 101; //move
}
else if (mouse_pressed)
{
fprintf(stderr,"2222222 btn %d, x %d ,y %d \n", buttons,e.m_x ,e.m_y );
mouse_pressed = false;
e.m_type = 102; //up
}
if (e.m_type >= 100 && e.m_type <= 102)
m_active->processEvent(&e);
}
}
else if (domain == navigator_get_domain())
{
int cod = bps_event_get_code(event);
if (NAVIGATOR_WINDOW_INACTIVE == cod)
{
onInactive();
// ZaScreenFlash * l_flash = (ZaScreenFlash *)ZaResLib::getInstance()->getScreen("ZaScreenFlash");
// ZaScreenBase * l_src = (ZaScreenBase *)ZaResLib::getInstance()->getScreen("ZaScreenStart");
// string p= "";
// l_flash->changeScreen(l_src,l_src,l_src,p.c_str(),ZaScreenFlash::NONE);
}
}
}
int main(int argc, char *argv[]) {
int rc;
int exit_application = 0;
static screen_context_t screen_cxt;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt, 0);
//Initialize BPS library
bps_initialize();
//Use utility code to initialize EGL in landscape orientation
if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt, GL_ES_1, LANDSCAPE)) {
fprintf(stderr, "bbutil_init_egl failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize application logic
if (EXIT_SUCCESS != initialize()) {
fprintf(stderr, "initialize failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator and screen events will be requested
if (BPS_SUCCESS != screen_request_events(screen_cxt)) {
fprintf(stderr, "screen_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "navigator_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator orientation is not to be locked
if (BPS_SUCCESS != navigator_rotation_lock(false)) {
fprintf(stderr, "navigator_rotation_lock failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
while (!exit_application) {
//Request and process BPS next available event
bps_event_t *event = NULL;
rc = bps_get_event(&event, 0);
assert(rc == BPS_SUCCESS);
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if ((domain == navigator_get_domain())
&& (NAVIGATOR_EXIT == bps_event_get_code(event))) {
exit_application = 1;
}
}
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
int main(int argc, char *argv[])
{
int exit_application = 0;
screen_context_t screen_cxt;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt,0);
//Use utility code to initialize EGL for 2D rendering with GL ES 1.1
if (EXIT_SUCCESS != bbutil_init(screen_cxt, GL_ES_1)) {
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize app data
initialize();
//Initialize BPS library
bps_initialize();
//Signal BPS library that navigator, screen, and keyboard events will be requested
screen_request_events(screen_cxt);
navigator_request_events(0);
virtualkeyboard_request_events(0);
virtualkeyboard_show();
for (;;) {
//Request and process BPS next available event
bps_event_t *event = NULL;
if (bps_get_event(&event, 0) != BPS_SUCCESS)
return EXIT_FAILURE;
if (event) {
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain()) {
handleScreenEvent(event);
} else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event))) {
exit_application = 1;
}
}
if (exit_application) {
break;
}
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
int ButtonMap::mapNextButtonPressed()
{
bps_event_t *event = NULL;
int sym;
//use in frontend run loop, get key pressed back, and map
int z = 10;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &z) != 0)
{
return -1;
}
screen_post_window(screen_win, screen_buf, 1, screen_resolution, 0);
while(1)
{
if (BPS_SUCCESS != bps_get_event(&event, -1))
{
fprintf(stderr, "bps_get_event failed\n");
break;
}
if (event)
{
int domain = bps_event_get_domain(event);
int events = bps_event_get_code(event);
if (events == NAVIGATOR_SWIPE_DOWN)
{
if(overlayDisplay)
{
*g_settings.input.overlay = '\1';
}
else
{
*g_settings.input.overlay = '\1';
}
overlayDisplay = !overlayDisplay;
}
if (domain == screen_get_domain())
{
screen_event_t screen_event = screen_event_get_event(event);
int screen_val;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
//TODO: Should we only let the buttons through that we are trying to map?
if(screen_val == SCREEN_EVENT_MTOUCH_TOUCH)
{
//This is touch screen event
sym = NO_BTN;
break;
}
else if(screen_val == SCREEN_EVENT_KEYBOARD)
{
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SYM, &sym);
sym &= 0xFF;
break;
}
else if( (screen_val == SCREEN_EVENT_GAMEPAD) || (screen_val == SCREEN_EVENT_JOYSTICK) )
{
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS, &sym);
break;
}
}
}
}
z = -10;
if (screen_set_window_property_iv(screen_win, SCREEN_PROPERTY_ZORDER, &z) != 0)
{
return -1;
}
screen_post_window(screen_win, screen_buf, 1, screen_resolution, 0);
return (g_settings.input.binds[player][button].joykey = sym);
}
int main(int argc, char *argv[])
{
int exit_application = 0;
int rc;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt, 0);
initGestures();
//Initialize BPS library
bps_initialize();
//Use utility code to initialize EGL for 2D rendering with GL ES 1.1
if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt, GL_ES_1, AUTO))
{
fprintf(stderr, "bbutil_init_egl failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize application logic
if (EXIT_SUCCESS != initialize())
{
fprintf(stderr, "initialize failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator and screen events will be requested
if (BPS_SUCCESS != screen_request_events(screen_cxt))
{
fprintf(stderr, "screen_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
if (BPS_SUCCESS != navigator_request_events(0))
{
fprintf(stderr, "navigator_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator orientation is not to be locked
if (BPS_SUCCESS != navigator_rotation_lock(false))
{
fprintf(stderr, "navigator_rotation_lock failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
// set up our box2D tests
fprintf(stderr, "Box2D Version %d.%d.%d\n", b2_version.major, b2_version.minor, b2_version.revision);
testCount = 0;
while (g_testEntries[testCount].createFcn != NULL)
{
++testCount;
}
testIndex = b2Clamp(testIndex, 0, testCount-1);
testSelection = testIndex;
entry = g_testEntries + testIndex;
test = entry->createFcn();
test->m_debugDraw.SetFont(font);
test->m_debugDraw.SetScreenSize(width, height);
struct timespec time_struct;
clock_gettime(CLOCK_REALTIME, &time_struct);
long update_time = time2millis(&time_struct);
long current_time, last_time;
#ifdef FPS
int frames = 0;
last_time = update_time;
#endif
for (;;)
{
//Request and process BPS next available event
bps_event_t *event = NULL;
rc = bps_get_event(&event, 1);
assert(rc == BPS_SUCCESS);
if (event)
{
int domain = bps_event_get_domain(event);
if (domain == screen_get_domain())
{
handleScreenEvent(event);
}
else if ((domain == navigator_get_domain()) && (NAVIGATOR_EXIT == bps_event_get_code(event)))
{
exit_application = 1;
}
}
clock_gettime(CLOCK_REALTIME, &time_struct);
current_time = time2millis(&time_struct);
if ((current_time - update_time) > framePeriod)
{
update_time = current_time;
render();
#ifdef FPS
frames++;
#endif
}
else
{
sleep(0);
}
#ifdef FPS
if (current_time - last_time > 1000)
{
fprintf(stderr, "fps: %d\n", frames);
frames = 0;
last_time = current_time;
}
#endif
if (exit_application)
break;
}
// clean up gestures
gesturesCleanup();
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Destroy the font
bbutil_destroy_font(font);
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
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]);
}
}
int main(int argc, char *argv[])
{
int rc;
int exit_application = 0;
bps_initialize();
// Create and set up the app window.
if (EXIT_FAILURE == setup_screen())
return EXIT_FAILURE;
bbads_set_log_verbosity(2);
// Display Banner on screen
load_ad(screen_window, WINDOW_GROUP_NAME);
screen_request_events(screen_context);
navigator_request_events(0);
/**
* Handle keyboard events and stop playback upon user request.
*/
for (;;) {
bps_event_t *event = 0;
if (BPS_SUCCESS != bps_get_event(&event, -1)) {
fprintf(stderr, "ERROR: Could not get BPS event!\n");
return EXIT_FAILURE;
}
if (event) {
if (navigator_get_domain() == bps_event_get_domain(event)) {
int code = bps_event_get_code(event);
if (NAVIGATOR_EXIT == code) {
if (BBADS_EOK != bbads_banner_destroy(ad_banner))
{
fprintf(stderr, "cannot destroy banner");
}
else
{
fprintf(stderr, "banner destroy");
}
exit_application = 1;
}
}
else if (bbads_get_domain() == bps_event_get_domain(event)) {
bbads_banner_t* event_banner;
bbads_event_get_banner(event, &event_banner);
bbads_banner_event_type_t event_type = (bbads_banner_event_type_t)bps_event_get_code(event);
banner_event_handler(event_banner, event_type);
}
else if (screen_get_domain() == bps_event_get_domain(event)) {
int screen_val;
char buf[1024];
int pos[2];
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
screen_get_event_property_cv(screen_event, SCREEN_PROPERTY_ID_STRING, sizeof(buf), buf);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_POSITION, pos);
switch (screen_val) {
case SCREEN_EVENT_CREATE:
fprintf(stderr, "create\n");
if (BBADS_EOK != bbads_banner_is_visible(ad_banner, &ad_is_visible))
{
fprintf(stderr, "cannot get banner visibility");
}
if (!ad_is_visible)
{
if (BBADS_EOK != bbads_banner_set_window_visible(ad_banner))
fprintf(stderr, "bbads_banner_set_window_visible has errors\n");
if (BBADS_EOK != bbads_banner_display(ad_banner, screen_context, event))
fprintf(stderr, "create cannot display banner\n");
}
break;
}
if (exit_application)
break;
}
}
}
screen_stop_events(screen_context);
bps_shutdown();
if (screen_destroy_window(screen_window) != 0)
return EXIT_FAILURE;
if (screen_destroy_context(screen_context) != 0)
return EXIT_FAILURE;
screen_context = 0;
screen_window = 0;
return EXIT_SUCCESS;
}
// Entry Point
int main(int argc, char *argv[]) {
static screen_context_t screen_cxt;
// Receive events from window manager
screen_create_context(&screen_cxt, 0);
//Initialise Blackberry Platform Services
bps_initialize();
net::Init();
init_GLES2(screen_cxt);
#ifdef BLACKBERRY10
// Dev Alpha: 1280x768, 4.2", 356DPI, 0.6f scale
int dpi;
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_DPI, &dpi);
#else
// Playbook: 1024x600, 7", 170DPI, 1.25f scale
int screen_phys_size[2];
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_PHYSICAL_SIZE, screen_phys_size);
int screen_resolution[2];
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, screen_resolution);
double diagonal_pixels = sqrt(screen_resolution[0] * screen_resolution[0] + screen_resolution[1] * screen_resolution[1]);
double diagonal_inches = 0.0393700787 * sqrt(screen_phys_size[0] * screen_phys_size[0] + screen_phys_size[1] * screen_phys_size[1]);
int dpi = (int)(diagonal_pixels / diagonal_inches + 0.5);
#endif
float dpi_scale = 213.6f / dpi;
dp_xres = (int)(pixel_xres * dpi_scale); dp_yres = (int)(pixel_yres * dpi_scale);
NativeInit(argc, (const char **)argv, "data/", "/accounts/1000/shared", "BADCOFFEE");
NativeInitGraphics();
screen_request_events(screen_cxt);
navigator_request_events(0);
dialog_request_events(0);
#ifdef BLACKBERRY10
vibration_request_events(0);
#endif
BlackberryAudio* audio = new BlackberryAudio();
InputState input_state;
bool running = true;
while (running) {
input_state.mouse_valid = false;
input_state.accelerometer_valid = false;
SimulateGamepad(&input_state);
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()) {
int screen_val, buttons, pointerId;
int pair[2];
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_SOURCE_POSITION, pair);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TOUCH_ID, &pointerId);
input_state.mouse_valid = true;
switch(screen_val)
{
// Touchscreen
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_RELEASE: // Up, down
input_state.pointer_down[pointerId] = (screen_val == SCREEN_EVENT_MTOUCH_TOUCH);
case SCREEN_EVENT_MTOUCH_MOVE:
input_state.pointer_x[pointerId] = pair[0] * dpi_scale;
input_state.pointer_y[pointerId] = pair[1] * dpi_scale;
break;
// Mouse, Simulator
case SCREEN_EVENT_POINTER:
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS,
&buttons);
if (buttons == SCREEN_LEFT_MOUSE_BUTTON) { // Down
input_state.pointer_x[pointerId] = pair[0] * dpi_scale;
input_state.pointer_y[pointerId] = pair[1] * dpi_scale;
input_state.pointer_down[pointerId] = true;
} else if (input_state.pointer_down[pointerId]) { // Up
input_state.pointer_x[pointerId] = pair[0] * dpi_scale;
input_state.pointer_y[pointerId] = pair[1] * dpi_scale;
input_state.pointer_down[pointerId] = false;
}
break;
// Keyboard
case SCREEN_EVENT_KEYBOARD:
int flags, value;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_FLAGS, &flags);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SYM, &value);
if (flags & (KEY_DOWN | KEY_SYM_VALID)) {
for (int b = 0; b < 14; b++) {
if (value == buttonMappings[b])
input_state.pad_buttons |= (1<<b);
}
}
break;
}
} else if (domain == navigator_get_domain()) {
switch(bps_event_get_code(event))
{
case NAVIGATOR_BACK:
case NAVIGATOR_SWIPE_DOWN:
input_state.pad_buttons |= PAD_BUTTON_MENU;
break;
case NAVIGATOR_EXIT:
running = false;
break;
}
}
}
UpdateInputState(&input_state);
NativeUpdate(input_state);
EndInputState(&input_state);
NativeRender();
// On Blackberry, this handles VSync for us
eglSwapBuffers(egl_disp, egl_surf);
}
screen_stop_events(screen_cxt);
bps_shutdown();
NativeShutdownGraphics();
delete audio;
NativeShutdown();
kill_GLES2();
net::Shutdown();
screen_destroy_context(screen_cxt);
exit(0);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
int rc;
// Renderer variables
mmr_connection_t* mmr_connection = 0;
mmr_context_t* mmr_context = 0;
strm_dict_t* dict = NULL;
// I/O variables
int video_device_output_id = -1;
int audio_device_output_id = -1;
// Position of the play and stop button.
static int ctrl_x = 0;
static int ctrl_y = 0;
EGLint surface_width;
EGLint surface_height;
srand(time(0));
app_id = rand();
// I/O devices
static char *audio_device_url = "audio:default";
static char video_device_url[PATH_MAX];
rc = snprintf(video_device_url, PATH_MAX, "screen:?winid=videosamplewindowgroup_%d&wingrp=videosamplewindowgroup_%d", app_id, app_id);
if (rc >= PATH_MAX) {
fprintf(stderr, "URL too long\n");
}
// Name of video context...with a random number appended.
static char video_context_name[PATH_MAX];
rc = snprintf(video_context_name, PATH_MAX, "samplevideocontextname_%d", app_id);
if (rc >= PATH_MAX) {
fprintf(stderr, "Video context name too long\n");
}
// Window group name...with the same random number appended.
static char window_group_name[PATH_MAX];
rc = snprintf(window_group_name, PATH_MAX, "videosamplewindowgroup_%d", app_id);
if (rc >= PATH_MAX) {
fprintf(stderr, "Video context name too long\n");
}
// Video file bundled with our app
static const char *video_file_relative_path = "app/native/pb_sample.mp4";
bps_initialize();
// Create the Screen Context.
if (screen_create_context(&g_screen_ctx, SCREEN_APPLICATION_CONTEXT) != 0) {
fprintf(stderr, "screen_create_context failed\n");
return EXIT_FAILURE;
}
// Create the window and initialize EGL for GL_ES_1 rendering
rc = initialize_egl_window(g_screen_ctx, window_group_name);
if (rc != EXIT_SUCCESS) {
fprintf(stderr, "initialize_egl_window failed\n");
return EXIT_FAILURE;
}
// Query width and height of the window surface created by utility code
eglQuerySurface(g_egl_disp, g_egl_surf, EGL_WIDTH, &surface_width);
eglQuerySurface(g_egl_disp, g_egl_surf, EGL_HEIGHT, &surface_height);
EGLint err = eglGetError();
if (err != EGL_SUCCESS) {
fprintf(stderr, "Unable to query EGL surface dimensions\n");
return EXIT_FAILURE;
}
// Initialize GL for 2D rendering
glViewport(0, 0, (int)surface_width, (int) surface_height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrthof(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Set world coordinates to coincide with screen pixels
glScalef(1.0f / (float)surface_width, 1.0f / (float)surface_height, 1.0f);
// We can calculate location and verticies of the controls
ctrl_x = (float)surface_width / 2 - ctrl_w / 2;
ctrl_y = (float)surface_height / 2 - ctrl_h / 2;
g_triangle_vertices[0] = ctrl_x;
g_triangle_vertices[1] = ctrl_y;
g_triangle_vertices[2] = ctrl_x;
g_triangle_vertices[3] = ctrl_y + ctrl_h;
g_triangle_vertices[4] = ctrl_x + ctrl_w;
g_triangle_vertices[5] = ctrl_y + ctrl_h / 2;
g_square_vertices[0] = ctrl_x;
g_square_vertices[1] = ctrl_y;
g_square_vertices[2] = ctrl_x;
g_square_vertices[3] = ctrl_y + ctrl_h;
g_square_vertices[4] = ctrl_x + ctrl_w;
g_square_vertices[5] = ctrl_y + ctrl_h;
g_square_vertices[6] = ctrl_x + ctrl_w;
g_square_vertices[7] = ctrl_y;
g_square_vertices[8] = ctrl_x;
g_square_vertices[9] = ctrl_y;
// Configure mm-renderer.
mmr_connection = mmr_connect(NULL);
if (mmr_connection == NULL) {
fprintf(stderr, "mmr_connect failed\n");
return EXIT_FAILURE;
}
mmr_context = mmr_context_create(mmr_connection, video_context_name, 0, S_IRWXU|S_IRWXG|S_IRWXO);
if (mmr_context == NULL) {
fprintf(stderr, "mmr_context_create failed\n");
return EXIT_FAILURE;
}
// Configure video and audio output.
video_device_output_id = mmr_output_attach(mmr_context, video_device_url, "video");
if (video_device_output_id == -1) {
fprintf(stderr, "mmr_output_attach(video) failed\n");
return EXIT_FAILURE;
}
audio_device_output_id = mmr_output_attach(mmr_context, audio_device_url, "audio");
if (audio_device_output_id == -1) {
fprintf(stderr, "mmr_output_attach(audio) failed\n");
return EXIT_FAILURE;
}
// render 'paused'
render(true);
// Build up the path where our bundled resource is.
char cwd[PATH_MAX];
char media_file[PATH_MAX];
getcwd(cwd,PATH_MAX);
rc = snprintf(media_file, PATH_MAX, "file://%s/%s", cwd, video_file_relative_path);
if ((rc == -1) || (rc >= PATH_MAX)) {
fprintf(stderr, "snprintf(media_file) failed\n");
return EXIT_FAILURE;
}
// Attach the input media.
if (mmr_input_attach(mmr_context, media_file, "track") != 0) {
fprintf(stderr, "mmr_input_attach(track) failed\n");
return EXIT_FAILURE;
}
int video_speed = 0;
// Set the speed to 0 to pause the video initially
if (mmr_speed_set(mmr_context, video_speed) != 0) {
fprintf(stderr, "mmr_set_speed(0) failed\n");
return EXIT_FAILURE;
}
// Change to the play state, although speed is zero
if (mmr_play(mmr_context) != 0) {
fprintf(stderr, "mmr_play failed\n");
return EXIT_FAILURE;
}
/* Do some work to make the aspect ratio correct.
*/
dict = calculate_rect(surface_width, surface_height);
if (NULL == dict) {
fprintf(stderr, "calculate_rect failed\n");
return EXIT_FAILURE;
}
if (mmr_output_parameters(mmr_context, video_device_output_id, dict) != 0) {
fprintf(stderr, "mmr_output_parameters failed\n");
return EXIT_FAILURE;
}
/* Note that we allocated memory for the dictionary, but the call to
* mmr_output_parameters() deallocates that memory even on failure.
*/
dict = NULL;
screen_request_events(g_screen_ctx);
navigator_request_events(0);
screen_window_t video_window = (screen_window_t)0;
bool app_window_above = true;
int screen_val;
int exit_value = EXIT_SUCCESS;
// Handle keyboard events and stop playback upon user request.
for (;;) {
bps_event_t *event = NULL;
if (bps_get_event(&event, 0) != BPS_SUCCESS) {
return EXIT_FAILURE;
}
if (event) {
if (bps_event_get_domain(event) == navigator_get_domain()) {
if (bps_event_get_code(event) == NAVIGATOR_EXIT) {
break;
} else if(NAVIGATOR_SWIPE_DOWN == bps_event_get_code(event)) {
if ((screen_window_t)0 != video_window) {
app_window_above = !app_window_above;
if (app_window_above) {
screen_val = 1;
} else {
screen_val = -1;
}
if (screen_set_window_property_iv(video_window, SCREEN_PROPERTY_ZORDER, &screen_val) != 0) {
fprintf(stderr, "screen_set_window_property(ZORDER) failed\n");
exit_value = EXIT_FAILURE;
break;
}
screen_val = 1;
if (screen_set_window_property_iv(video_window, SCREEN_PROPERTY_VISIBLE, &screen_val) != 0) {
fprintf(stderr, "screen_set_window_property(VISIBLE) failed\n");
exit_value = EXIT_FAILURE;
break;
}
rc = screen_flush_context(g_screen_ctx, SCREEN_WAIT_IDLE);
if (rc != 0) {
fprintf (stderr, "Warning: Failed to flush\n");
}
}
}
} else if (bps_event_get_domain(event) == screen_get_domain()) {
screen_event_t screen_event = screen_event_get_event(event);
int event_type;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &event_type);
if (event_type == SCREEN_EVENT_CREATE && (video_window == (screen_window_t)0)) {
char id[256];
rc = screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&video_window);
if (rc != 0) {
fprintf(stderr, "screen_get_event_property(WINDOW) failed\n");
exit_value = EXIT_FAILURE;
break;
}
fprintf(stderr, "video_window%d\n",(int)video_window);
rc = screen_get_window_property_cv(video_window, SCREEN_PROPERTY_ID_STRING, 256, id);
if (rc != 0) {
fprintf(stderr, "screen_get_window_property(ID) failed\n");
exit_value = EXIT_FAILURE;
break;
}
fprintf(stderr, "window ID is %s\n", id);
if (strncmp(id, window_group_name, strlen(window_group_name)) != 0) {
fprintf(stderr, "window ID mismatch\n");
exit_value = EXIT_FAILURE;
break;
}
} else if(event_type == SCREEN_EVENT_MTOUCH_TOUCH) {
if (video_speed == 0) {
video_speed = 1000;
render(false);
} else {
video_speed = 0;
render(true);
}
if (mmr_speed_set(mmr_context, video_speed) != 0) {
fprintf(stderr, "mmr_speed_set(%d) failed\n", video_speed);
exit_value = EXIT_FAILURE;
break;
}
}
}
}
}
screen_stop_events(g_screen_ctx);
if (mmr_stop(mmr_context) != 0) {
fprintf(stderr, "mmr_stop failed\n");
exit_value = EXIT_FAILURE;
}
if (mmr_output_detach(mmr_context, audio_device_output_id) != 0) {
fprintf(stderr, "mmr_output_detach(audio) failed\n");
exit_value = EXIT_FAILURE;
}
if (mmr_output_detach(mmr_context, video_device_output_id) != 0) {
fprintf(stderr, "mmr_output_detach(video) failed\n");
exit_value = EXIT_FAILURE;
}
if (mmr_context_destroy(mmr_context) != 0) {
fprintf(stderr, "mmr_context_destroy failed\n");
exit_value = EXIT_FAILURE;
}
mmr_context = 0;
video_device_output_id = -1;
audio_device_output_id = -1;
mmr_disconnect(mmr_connection);
mmr_connection = 0;
bps_shutdown();
if (screen_destroy_window(g_screen_win) != 0) {
fprintf(stderr, "screen_destroy_window failed\n");
exit_value = EXIT_FAILURE;
}
if (screen_destroy_context(g_screen_ctx) != 0) {
fprintf(stderr, "screen_destroy_context failed\n");
exit_value = EXIT_FAILURE;
}
g_screen_ctx = 0;
g_screen_win = 0;
return exit_value;
}
static void
event(bps_event_t *event, int domain, int code, void *p)
{
if (virtualkeyboard_get_domain() == domain) {
switch (code) {
case VIRTUALKEYBOARD_EVENT_VISIBLE:
keyboard_visible = true;
break;
case VIRTUALKEYBOARD_EVENT_HIDDEN:
keyboard_visible = false;
break;
}
} else if (screen_get_domain() == domain) {
screen_event_t screen_event = screen_event_get_event(event);
int screen_val;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &screen_val);
switch (screen_val) {
case SCREEN_EVENT_MTOUCH_TOUCH:
if (!keyboard_visible) {
virtualkeyboard_show();
}
break;
case SCREEN_EVENT_KEYBOARD:
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_FLAGS, &screen_val);
if (screen_val & KEY_DOWN) {
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_KEY_SYM,&screen_val);
fprintf(stderr, "The '%c' key was pressed\n", (char)screen_val);
switch (screen_val) {
case KEYCODE_I:
// Display the email layout with "Send" enter key
virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_EMAIL, VIRTUALKEYBOARD_ENTER_SEND);
break;
case KEYCODE_O:
// Display the phone layout with "Connect" enter key
virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_PHONE, VIRTUALKEYBOARD_ENTER_CONNECT);
break;
case KEYCODE_P:
// Display the default layout with default enter key
virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_DEFAULT, VIRTUALKEYBOARD_ENTER_DEFAULT);
break;
case KEYCODE_H:
// Hide the keyboard
virtualkeyboard_hide();
break;
case KEYCODE_A:
// Increment rotation angle
angle = fmod(angle + ANGLE_INCREMENT, CIRCLE_DEGREES );
break;
case KEYCODE_Z:
// Decrement rotation angle
angle = fmod(angle - ANGLE_INCREMENT, CIRCLE_DEGREES );
break;
default:
break;
}
}
break;
}
}
}
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;
}
}
}
}
