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; } } } }