bool WindowGrabber::handleScreenEvent(screen_event_t screen_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;
}
static void process_gamepad_event(screen_event_t screen_event, int type)
{
screen_device_t device;
screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_DEVICE, (void**)&device);
input_device_t* controller = NULL;
int i;
for (i = 0; i < MAX_PADS; ++i)
{
if (device == devices[i].handle)
{
controller = &devices[i];
break;
}
}
if (!controller)
return;
// Store the controller's new state.
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS, &controller->buttons);
if (controller->analogCount > 0)
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ANALOG0, controller->analog0);
if (controller->analogCount == 2)
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ANALOG1, controller->analog1);
//Only player 1
//TODO: Am I missing something? Is there a better way?
if((controller->port == 0) && (controller->buttons & g_settings.input.binds[0][RARCH_MENU_TOGGLE].joykey))
g_extern.lifecycle_state ^= (1ULL << RARCH_MENU_TOGGLE);
}
void QQnxScreenEventHandler::handleCreateEvent(screen_event_t event)
{
screen_window_t window = 0;
if (screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0)
qFatal("QQnx: failed to query window property, errno=%d", errno);
Q_EMIT newWindowCreated(window);
}
static void process_keyboard_event(screen_event_t event, int type)
{
input_device_t* controller = NULL;
int i = 0;
//Get Keyboard state
int sym = 0;
screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SYM, &sym);
int modifiers = 0;
screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_MODIFIERS, &modifiers);
int flags = 0;
screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_FLAGS, &flags);
int scan = 0;
screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SCAN, &scan);
int cap = 0;
screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_CAP, &cap);
#ifdef HAVE_BB10
//Find device that pressed the key
screen_device_t device;
screen_get_event_property_pv(event, SCREEN_PROPERTY_DEVICE, (void**)&device);
for (i = 0; i < MAX_PADS; ++i)
{
if (device == devices[i].handle)
{
controller = &devices[i];
break;
}
}
if (!controller)
return;
#else
controller = &devices[0];
#endif
if(controller->port == -1)
return;
int b;
for (b = 0; b < RARCH_FIRST_CUSTOM_BIND; ++b)
{
if ((unsigned int)g_settings.input.binds[controller->port][b].joykey == (unsigned int)(sym&0xFF))
{
if (flags & KEY_DOWN)
controller->buttons |= 1 << b;
else
controller->buttons &= ~(1<<b);
}
}
//TODO: Am I missing something? Is there a better way?
if((controller->port == 0) && ((unsigned int)g_settings.input.binds[0][RARCH_MENU_TOGGLE].joykey == (unsigned int)(sym&0xFF)))
if (flags & KEY_DOWN)
g_extern.lifecycle_state ^= (1ULL << RARCH_MENU_TOGGLE);
}
void
PLAYBOOK_PumpEvents(_THIS)
{
while (1)
{
int rc = screen_get_event(this->hidden->screenContext, this->hidden->screenEvent, 0 /*timeout*/);
if (rc)
break;
int type;
rc = screen_get_event_property_iv(this->hidden->screenEvent, SCREEN_PROPERTY_TYPE, &type);
if (rc || type == SCREEN_EVENT_NONE)
break;
screen_window_t window;
screen_get_event_property_pv(this->hidden->screenEvent, SCREEN_PROPERTY_WINDOW, (void **)&window);
if (!window && type != SCREEN_EVENT_KEYBOARD)
break;
switch (type)
{
case SCREEN_EVENT_CLOSE:
SDL_PrivateQuit(); // We can't stop it from closing anyway
break;
case SCREEN_EVENT_PROPERTY:
{
int val;
screen_get_event_property_iv(this->hidden->screenEvent, SCREEN_PROPERTY_NAME, &val);
//fprintf(stderr, "Property change (property val=%d)\n", val);
}
break;
case SCREEN_EVENT_POINTER:
handlePointerEvent(this->hidden->screenEvent, window);
break;
case SCREEN_EVENT_KEYBOARD:
handleKeyboardEvent(this->hidden->screenEvent);
break;
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
case SCREEN_EVENT_MTOUCH_RELEASE:
handleMtouchEvent(this->hidden->screenEvent, window, type);
break;
}
}
#ifdef TOUCHPAD_SIMULATE
if (state.pending[0] || state.pending[1]) {
SDL_PrivateMouseMotion(state.mask, 1, state.pending[0], state.pending[1]);
state.pending[0] = 0;
state.pending[1] = 0;
}
#endif
if (moveEvent.pending) {
SDL_PrivateMouseMotion((moveEvent.touching?SDL_BUTTON_LEFT:0), 0, moveEvent.pos[0], moveEvent.pos[1]);
moveEvent.pending = 0;
}
}
static void qnx_process_gamepad_event(
qnx_input_t *qnx,
screen_event_t screen_event, int type)
{
int i;
screen_device_t device;
qnx_input_device_t* controller = NULL;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
uint64_t *state_cur = NULL;
(void)type;
screen_get_event_property_pv(screen_event,
SCREEN_PROPERTY_DEVICE, (void**)&device);
for (i = 0; i < MAX_PADS; ++i)
{
if (device == qnx->devices[i].handle)
{
controller = (qnx_input_device_t*)&qnx->devices[i];
break;
}
}
if (!controller)
return;
/* Store the controller's new state. */
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_BUTTONS, &controller->buttons);
state_cur = (uint64_t*)&qnx->pad_state[controller->port];
*state_cur = 0;
for (i = 0; i < 20; i++)
*state_cur |= (controller->buttons & (1 << i) ? (1 << i) : 0);
if (controller->analogCount > 0)
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ANALOG0, controller->analog0);
if (controller->analogCount == 2)
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ANALOG1, controller->analog1);
/* Only user 1
* TODO: Am I missing something? Is there a better way? */
if((controller->port == 0) &&
(controller->buttons &
settings->input.binds[0][RARCH_MENU_TOGGLE].joykey))
global->lifecycle_state ^= (1ULL << RARCH_MENU_TOGGLE);
}
static void
handle_screen_event(bps_event_t *event)
{
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);
switch (screen_val) {
case SCREEN_EVENT_MTOUCH_TOUCH:
fprintf(stderr,"Touch event\n");
touch = true;
break;
case SCREEN_EVENT_MTOUCH_MOVE:
fprintf(stderr,"Move event\n");
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
fprintf(stderr,"Release event\n");
break;
case SCREEN_EVENT_CREATE:
// in a more involved application, it may be wise to actually check the window name to ensure
// that we are processing the viewfinder window here, and not some other window
if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void **)&vf_win) == -1) {
perror("screen_get_event_property_pv(SCREEN_PROPERTY_WINDOW)");
} else {
fprintf(stderr,"viewfinder window found!\n");
// mirror viewfinder if this is the front-facing camera
int i = (shouldmirror?1:0);
screen_set_window_property_iv(vf_win, SCREEN_PROPERTY_MIRROR, &i);
// place viewfinder in front of the black application background window.
// note that a child window's ZORDER is relative to it's parent.
// if we wanted to draw a UI on the application window, we could place the
// viewfinder behind it and rely on transparency. or alternately, another
// child window could be overlaid on top of the viewfinder.
i = +1;
screen_set_window_property_iv(vf_win, SCREEN_PROPERTY_ZORDER, &i);
// make viewfinder window visible
i = 1;
screen_set_window_property_iv(vf_win, SCREEN_PROPERTY_VISIBLE, &i);
screen_flush_context(screen_ctx, 0);
// we should now have a visible viewfinder
// other things we could do here include rotating the viewfinder window (screen rotation),
// or adjusting the size & position of the window.
// some properties are immutable for security reasons since the window was actually created
// in another process. anything related to presentation should be modifiable.
touch = false;
state = STATE_VIEWFINDER;
}
break;
default:
break;
}
}
void QQnxScreenEventHandler::handleCloseEvent(screen_event_t event)
{
screen_window_t window = 0;
if (screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0)
qFatal("QQnx: failed to query window property, errno=%d", errno);
Q_EMIT windowClosed(window);
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(window);
if (w != 0) {
QWindowSystemInterface::handleCloseEvent(w);
}
}
void QBBEventThread::handleCloseEvent(screen_event_t event)
{
// Query the window that was closed
void *qnxWindow;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &qnxWindow);
if (result != 0) {
qFatal("QBB: failed to query event window, errno=%d", errno);
}
// map window to top-level widget
QWidget* w = QWidget::find( (WId)qnxWindow );
if (w != NULL) {
QWindowSystemInterface::handleCloseEvent(w);
}
}
static void qnx_process_gamepad_event(
qnx_input_t *qnx,
screen_event_t screen_event, int type)
{
int i;
screen_device_t device;
qnx_input_device_t* controller = NULL;
uint64_t *state_cur = NULL;
(void)type;
screen_get_event_property_pv(screen_event,
SCREEN_PROPERTY_DEVICE, (void**)&device);
for (i = 0; i < MAX_PADS; ++i)
{
if (device == qnx->devices[i].handle)
{
controller = (qnx_input_device_t*)&qnx->devices[i];
break;
}
}
if (!controller)
return;
/* Store the controller's new state. */
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_BUTTONS, &controller->buttons);
if (controller->analogCount > 0)
{
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ANALOG0, controller->analog0);
controller->analog0[0] *= 256;
controller->analog0[1] *= 256;
if (controller->analogCount == 2)
{
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ANALOG1, controller->analog1);
controller->analog1[0] *= 256;
controller->analog1[1] *= 256;
}
}
}
int NativeWindow::screenDisplayAttached(bps_event_t *event, int *size)
{
screen_display_t eventDisplay;
int type;
int attached = -1;
screen_event_t screen_event = screen_event_get_event(event);
//Query type of screen event and its location on the screen
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE,
&type);
_displaysMutex.lock();
if (_screenDisplays) {
free (_screenDisplays);
}
// try this first as it will fail if an HDMI display is not attached
screen_get_context_property_iv(_screenContext, SCREEN_PROPERTY_DISPLAY_COUNT, &_numberDisplays);
_screenDisplays = (screen_display_t *)calloc(_numberDisplays, sizeof(screen_display_t));
screen_get_context_property_pv(_screenContext, SCREEN_PROPERTY_DISPLAYS, (void **)_screenDisplays);
switch (type) {
case SCREEN_EVENT_DISPLAY:
screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_DISPLAY, (void **)&eventDisplay);
for (int index = 0; index < _numberDisplays; index++) {
if (eventDisplay == _screenDisplays[index]) {
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ATTACHED, &attached);
if (attached) {
screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_SIZE, size);
if (size[0] == 0 || size[1] == 0) {
attached = 0;
}
}
}
}
break;
}
_displaysMutex.unlock();
return attached;
}
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 QQnxScreenEventHandler::handleDisplayEvent(screen_event_t event)
{
screen_display_t nativeDisplay = 0;
if (screen_get_event_property_pv(event, SCREEN_PROPERTY_DISPLAY, (void **)&nativeDisplay) != 0) {
qWarning("QQnx: failed to query display property, errno=%d", errno);
return;
}
int isAttached = 0;
if (screen_get_event_property_iv(event, SCREEN_PROPERTY_ATTACHED, &isAttached) != 0) {
qWarning("QQnx: failed to query display attached property, errno=%d", errno);
return;
}
qScreenEventDebug() << Q_FUNC_INFO << "display attachment is now:" << isAttached;
QQnxScreen *screen = m_qnxIntegration->screenForNative(nativeDisplay);
if (!screen) {
if (isAttached) {
qScreenEventDebug() << "creating new QQnxScreen for newly attached display";
m_qnxIntegration->createDisplay(nativeDisplay, false /* not primary, we assume */);
}
} else if (!isAttached) {
// We never remove the primary display, the qpa plugin doesn't support that and it crashes.
// To support it, this would be needed:
// - Adjust all qnx qpa code which uses screens
// - Make QWidgetBackingStore not dereference a null paint device
// - Create platform resources ( QQnxWindow ) for all QWindow because they would be deleted
// when you delete the screen
if (!screen->isPrimaryScreen()) {
// libscreen display is deactivated, let's remove the QQnxScreen / QScreen
qScreenEventDebug() << "removing display";
m_qnxIntegration->removeDisplay(screen);
}
}
}
static void qnx_process_keyboard_event(
qnx_input_t *qnx,
screen_event_t event, int type)
{
unsigned b;
qnx_input_device_t* controller = NULL;
settings_t *settings = config_get_ptr();
int i = 0;
int sym = 0;
int modifiers = 0;
int flags = 0;
int scan = 0;
int cap = 0;
uint64_t *state_cur = NULL;
/* Get Keyboard state. */
screen_get_event_property_iv(event,
SCREEN_PROPERTY_KEY_SYM, &sym);
screen_get_event_property_iv(event,
SCREEN_PROPERTY_KEY_MODIFIERS, &modifiers);
screen_get_event_property_iv(event,
SCREEN_PROPERTY_KEY_FLAGS, &flags);
screen_get_event_property_iv(event,
SCREEN_PROPERTY_KEY_SCAN, &scan);
screen_get_event_property_iv(event,
SCREEN_PROPERTY_KEY_CAP, &cap);
#ifdef HAVE_BB10
/* Find device that pressed the key. */
screen_device_t device;
screen_get_event_property_pv(event,
SCREEN_PROPERTY_DEVICE, (void**)&device);
for (i = 0; i < MAX_PADS; ++i)
{
if (device == qnx->devices[i].handle)
{
controller = (qnx_input_device_t*)&qnx->devices[i];
break;
}
}
if (!controller)
return;
#else
controller = (qnx_input_device_t*)&qnx->devices[0];
#endif
if(controller->port == -1)
return;
state_cur = &qnx->pad_state[controller->port];
*state_cur = 0;
for (b = 0; b < RARCH_FIRST_CUSTOM_BIND; ++b)
{
if ((unsigned int)
settings->input.binds[controller->port][b].joykey
== (unsigned int)(sym & 0xFF))
{
if (flags & KEY_DOWN)
{
controller->buttons |= 1 << b;
*state_cur |= 1 << b;
}
else
controller->buttons &= ~(1<<b);
}
}
/* TODO: Am I missing something? Is there a better way? */
if((controller->port == 0) && ((unsigned int)
settings->input.binds[0][RARCH_MENU_TOGGLE].joykey
== (unsigned int)(sym&0xFF)))
{
if (flags & KEY_DOWN)
qnx->lifecycle_state ^= (UINT64_C(1) << RARCH_MENU_TOGGLE);
}
}
int main(int argc, char **argv)
{
int pos[2] = {0, 0};
int size[2];
int vis = 1;
int type;
screen_create_context(&screen_ctx, SCREEN_APPLICATION_CONTEXT);
int count = 0;
screen_get_context_property_iv(screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &count);
screen_display_t *screen_disps = calloc(count, sizeof(screen_display_t));
screen_get_context_property_pv(screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)screen_disps);
screen_display_t screen_disp = screen_disps[0];
free(screen_disps);
int dims[2] = { 0, 0 };
screen_get_display_property_iv(screen_disp, SCREEN_PROPERTY_SIZE, dims);
char str[16];
snprintf(str, sizeof(str), "%d", getpid());
screen_bg_win = create_bg_window(str, dims);
screen_bar_win = create_bar_window(str, bar_id_string, dims);
screen_hg_win = create_hg_window(str, hg_id_string, dims);
if ( create_gles_window(str, gles_id_string, dims) != EXIT_SUCCESS){
fprintf(stderr, "Could not initialize OpenGL window. Exiting...\n");
screen_destroy_context(screen_ctx);
return EXIT_FAILURE;
}
screen_event_t screen_ev;
screen_create_event(&screen_ev);
// Now draw our OpenGL stuff, it does not change so we need to do it only once
GLfloat vVertices[] = {0.0f, 0.5f, 0.0f, -0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f};
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
glDrawArrays(GL_TRIANGLES, 0, 3);
int rc = eglSwapBuffers(egl_disp, egl_surf);
if (rc != EGL_TRUE) {
egl_perror("eglSwapBuffers");
}
while (1) {
do {
screen_get_event(screen_ctx, screen_ev, vis ? 0 : ~0);
screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_EVENT_CLOSE) {
screen_window_t screen_win;
screen_get_event_property_pv(screen_ev, SCREEN_PROPERTY_WINDOW, (void **)&screen_win);
if (screen_win == screen_bar_win) {
screen_bar_win = NULL;
} else if (screen_win == screen_hg_win) {
screen_hg_win = NULL;
} else if (screen_win == screen_gles_win) {
screen_gles_win = NULL;
}
screen_destroy_window(screen_win);
if (!screen_bar_win || !screen_hg_win || !screen_gles_win) {
vis = 0;
}
}
if (vis) {
if (++pos[0] > dims[0] - barwidth) {
pos[0] = 0;
}
screen_set_window_property_iv(screen_bar_win, SCREEN_PROPERTY_POSITION, pos);
screen_flush_context(screen_ctx, SCREEN_WAIT_IDLE);
}
} while (type != SCREEN_EVENT_NONE);
}
screen_destroy_event(screen_ev);
screen_destroy_context(screen_ctx);
return EXIT_SUCCESS;
}
static void handle_screen_event(bps_event_t *event)
{
int type;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &type);
switch(type)
{
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_RELEASE:
case SCREEN_EVENT_MTOUCH_MOVE:
process_touch_event(screen_event, type);
break;
case SCREEN_EVENT_KEYBOARD:
process_keyboard_event(screen_event, type);
break;
#ifdef HAVE_BB10
case SCREEN_EVENT_GAMEPAD:
case SCREEN_EVENT_JOYSTICK:
process_gamepad_event(screen_event, type);
break;
case SCREEN_EVENT_DEVICE:
{
// A device was attached or removed.
screen_device_t device;
int attached;
int type;
screen_get_event_property_pv(screen_event,
SCREEN_PROPERTY_DEVICE, (void**)&device);
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ATTACHED, &attached);
if (attached)
screen_get_device_property_iv(device,
SCREEN_PROPERTY_TYPE, &type);
int i;
if (attached && (type == SCREEN_EVENT_GAMEPAD || type == SCREEN_EVENT_JOYSTICK || type == SCREEN_EVENT_KEYBOARD))
{
for (i = 0; i < MAX_PADS; ++i)
{
if (!devices[i].handle)
{
devices[i].handle = device;
loadController(&devices[i]);
break;
}
}
}
else
{
for (i = 0; i < MAX_PADS; ++i)
{
if (device == devices[i].handle)
{
RARCH_LOG("Device %s: Disconnected.\n", devices[i].id);
initController(&devices[i]);
break;
}
}
}
}
break;
#endif
default:
break;
}
}
static void qnx_handle_screen_event(qnx_input_t *qnx, bps_event_t *event)
{
int type;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &type);
switch(type)
{
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_RELEASE:
case SCREEN_EVENT_MTOUCH_MOVE:
qnx_process_touch_event(qnx, screen_event, type);
break;
case SCREEN_EVENT_KEYBOARD:
qnx_process_keyboard_event(qnx, screen_event, type);
break;
#ifdef HAVE_BB10
case SCREEN_EVENT_GAMEPAD:
qnx_process_gamepad_event(qnx, screen_event, type);
break;
case SCREEN_EVENT_JOYSTICK:
qnx_process_joystick_event(qnx, screen_event, type);
break;
case SCREEN_EVENT_DEVICE:
{
/* A device was attached or removed. */
screen_device_t device;
int attached, type, i;
screen_get_event_property_pv(screen_event,
SCREEN_PROPERTY_DEVICE, (void**)&device);
screen_get_event_property_iv(screen_event,
SCREEN_PROPERTY_ATTACHED, &attached);
if (attached)
screen_get_device_property_iv(device,
SCREEN_PROPERTY_TYPE, &type);
if (attached &&
(
type == SCREEN_EVENT_GAMEPAD ||
type == SCREEN_EVENT_JOYSTICK ||
type == SCREEN_EVENT_KEYBOARD)
)
{
for (i = 0; i < MAX_PADS; ++i)
{
if (!qnx->devices[i].handle)
{
qnx->devices[i].handle = device;
qnx_handle_device(qnx, &qnx->devices[i]);
break;
}
}
}
else
{
for (i = 0; i < MAX_PADS; ++i)
{
if (device == qnx->devices[i].handle)
{
RARCH_LOG("Device %s: Disconnected.\n",
qnx->devices[i].id);
qnx_init_controller(qnx, &qnx->devices[i]);
break;
}
}
}
}
break;
#endif
default:
break;
}
}
void QBBEventThread::handleTouchEvent(screen_event_t event, int qnxType)
{
// get display coordinates of touch
errno = 0;
int pos[2];
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QBB: failed to query event position, errno=%d", errno);
}
// get window coordinates of touch
errno = 0;
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QBB: failed to query event window position, errno=%d", errno);
}
// determine which finger touched
errno = 0;
int touchId;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TOUCH_ID, &touchId);
if (result) {
qFatal("QBB: failed to query event touch id, errno=%d", errno);
}
// determine which window was touched
errno = 0;
void *qnxWindow;
result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &qnxWindow);
if (result) {
qFatal("QBB: failed to query event window, errno=%d", errno);
}
// check if finger is valid
if (touchId < MAX_TOUCH_POINTS) {
// map window to top-level widget
QWidget* w = QWidget::find( (WId)qnxWindow );
// Generate enter and leave events as needed.
if (qnxWindow != mLastMouseWindow) {
QWidget* wOld = QWidget::find( (WId)mLastMouseWindow );
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt leave, w=" << wOld;
#endif
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt enter, w=" << w;
#endif
}
}
if (w) {
// convert primary touch to mouse event
if (touchId == 0) {
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// map touch state to button state
Qt::MouseButtons buttons = (qnxType == SCREEN_EVENT_MTOUCH_RELEASE) ? Qt::NoButton : Qt::LeftButton;
// inject event into Qt
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << buttons;
#endif
}
// get size of screen which contains window
QPlatformScreen* platformScreen = QPlatformScreen::platformScreenForWidget(w);
QSize screenSize = platformScreen->physicalSize();
// update cached position of current touch point
mTouchPoints[touchId].normalPosition = QPointF( ((qreal)pos[0]) / screenSize.width(), ((qreal)pos[1]) / screenSize.height() );
mTouchPoints[touchId].area = QRectF( pos[0], pos[1], 0.0, 0.0 );
// determine event type and update state of current touch point
QEvent::Type type = QEvent::None;
switch (qnxType) {
case SCREEN_EVENT_MTOUCH_TOUCH:
mTouchPoints[touchId].state = Qt::TouchPointPressed;
type = QEvent::TouchBegin;
break;
case SCREEN_EVENT_MTOUCH_MOVE:
mTouchPoints[touchId].state = Qt::TouchPointMoved;
type = QEvent::TouchUpdate;
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
mTouchPoints[touchId].state = Qt::TouchPointReleased;
type = QEvent::TouchEnd;
break;
}
// build list of active touch points
QList<QWindowSystemInterface::TouchPoint> pointList;
for (int i = 0; i < MAX_TOUCH_POINTS; i++) {
if (i == touchId) {
// current touch point is always active
pointList.append(mTouchPoints[i]);
} else if (mTouchPoints[i].state != Qt::TouchPointReleased) {
// finger is down but did not move
mTouchPoints[i].state = Qt::TouchPointStationary;
pointList.append(mTouchPoints[i]);
}
}
// inject event into Qt
QWindowSystemInterface::handleTouchEvent(w, type, QTouchEvent::TouchScreen, pointList);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt touch, w=" << w << ", p=(" << pos[0] << "," << pos[1] << "), t=" << type;
#endif
}
}
}
void QBBEventThread::handlePointerEvent(screen_event_t event)
{
errno = 0;
// Query the window that was clicked
void *qnxWindow;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &qnxWindow);
if (result) {
qFatal("QBB: failed to query event window, errno=%d", errno);
}
// Query the button states
int buttonState = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_BUTTONS, &buttonState);
if (result) {
qFatal("QBB: failed to query event button state, errno=%d", errno);
}
// Query the window position
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QBB: failed to query event window position, errno=%d", errno);
}
// Query the screen position
int pos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QBB: failed to query event position, errno=%d", errno);
}
// Query the wheel delta
int wheelDelta = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_MOUSE_WHEEL, &wheelDelta);
if (result) {
qFatal("QBB: failed to query event wheel delta, errno=%d", errno);
}
// map window to top-level widget
QWidget* w = QWidget::find( (WId)qnxWindow );
// Generate enter and leave events as needed.
if (qnxWindow != mLastMouseWindow) {
QWidget* wOld = QWidget::find( (WId)mLastMouseWindow );
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt leave, w=" << wOld;
#endif
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt enter, w=" << w;
#endif
}
}
// Apply scaling to wheel delta and invert value for Qt. We'll probably want to scale
// this via a system preference at some point. But for now this is a sane value and makes
// the wheel usable.
wheelDelta *= -10;
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// Convert buttons.
Qt::MouseButtons buttons = Qt::NoButton;
if (buttonState & 1)
buttons |= Qt::LeftButton;
if (buttonState & 2)
buttons |= Qt::MidButton;
if (buttonState & 4)
buttons |= Qt::RightButton;
if (w) {
// Inject mouse event into Qt only if something has changed.
if (mLastGlobalMousePoint != globalPoint ||
mLastLocalMousePoint != localPoint ||
mLastButtonState != buttons) {
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << (int)buttons;
#endif
}
if (wheelDelta) {
// Screen only supports a single wheel, so we will assume Vertical orientation for
// now since that is pretty much standard.
QWindowSystemInterface::handleWheelEvent(w, localPoint, globalPoint, wheelDelta, Qt::Vertical);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: Qt wheel, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), d=" << (int)wheelDelta;
#endif
}
}
mLastGlobalMousePoint = globalPoint;
mLastLocalMousePoint = localPoint;
mLastButtonState = buttons;
}
static void handleScreenEvent(bps_event_t *event)
{
int eventType;
screen_event_t screen_event = screen_event_get_event(event);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType);
switch (eventType) {
case SCREEN_EVENT_GAMEPAD:
case SCREEN_EVENT_JOYSTICK:
{
if (!_polling) {
// Determine which controller this is.
screen_device_t device;
SCREEN_API(screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_DEVICE, (void**)&device), "SCREEN_PROPERTY_DEVICE");
GameController* controller = NULL;
int i;
for (i = 0; i < MAX_CONTROLLERS; ++i) {
if (device == _controllers[i].handle) {
controller = &_controllers[i];
break;
}
}
if (!controller) {
break;
}
// Store the controller's new state.
SCREEN_API(screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS, &controller->buttons), "SCREEN_PROPERTY_BUTTONS");
SCREEN_API(screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ANALOG0, controller->analog0), "SCREEN_PROPERTY_ANALOG0");
if (controller->type == SCREEN_EVENT_GAMEPAD) {
SCREEN_API(screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ANALOG1, controller->analog1), "SCREEN_PROPERTY_ANALOG1");
}
}
break;
}
case SCREEN_EVENT_DEVICE:
{
// A device was attached or removed.
screen_device_t device;
int attached;
int type;
SCREEN_API(screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_DEVICE, (void**)&device), "SCREEN_PROPERTY_DEVICE");
SCREEN_API(screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ATTACHED, &attached), "SCREEN_PROPERTY_ATTACHED");
if (attached) {
SCREEN_API(screen_get_device_property_iv(device, SCREEN_PROPERTY_TYPE, &type), "SCREEN_PROPERTY_TYPE");
}
int i;
if (attached && (type == SCREEN_EVENT_GAMEPAD || type == SCREEN_EVENT_JOYSTICK)) {
for (i = 0; i < MAX_CONTROLLERS; ++i) {
if (!_controllers[i].handle) {
_controllers[i].handle = device;
loadController(&_controllers[i]);
break;
}
}
} else {
for (i = 0; i < MAX_CONTROLLERS; ++i) {
if (device == _controllers[i].handle) {
initController(&_controllers[i], i);
break;
}
}
}
break;
}
case SCREEN_EVENT_MTOUCH_RELEASE:
{
int pos[2];
SCREEN_API(screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_SOURCE_POSITION, pos), "SCREEN_PROPERTY_SOURCE_POSITION");
int x = pos[0];
int y = _surfaceHeight - pos[1];
int i;
for (i = 0; i < MAX_CONTROLLERS; ++i) {
bool buttonTapped = false;
int j;
for (j = 0; j < MAX_BUTTONS; ++j) {
Button* button = &_buttons[i][j];
Quad* quad = button->quad;
// Detect that a button was tapped.
if (x > quad->x && x < quad->x + quad->width &&
y > quad->y && y < quad->y + quad->height) {
_activeButton[i] = button;
buttonTapped = true;
break;
}
}
if (_activeButton[i] && !buttonTapped) {
// Cancel the button's active state.
_activeButton[i] = NULL;
}
}
// The polling button is used to switch between handling all device events and polling devices once per frame.
Quad* quad = _pollingButton.quad;
if (x > quad->x && x < quad->x + quad->width &&
y > quad->y && y < quad->y + quad->height) {
_polling = !_polling;
// The polling button lights up when polling is enabled.
if (_polling) {
quad->uvs = _triggerDownUVs;
} else {
quad->uvs = _triggerUpUVs;
}
}
break;
}
}
}
void BlackberryMain::handleInput(screen_event_t screen_event)
{
TouchInput input;
KeyInput key;
int val, buttons, pointerId;
int pair[2];
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &val);
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_SOURCE_POSITION, pair);
input_state.mouse_valid = true;
switch(val)
{
// Touchscreen
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_RELEASE: // Up, down
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TOUCH_ID, &pointerId);
input_state.pointer_down[pointerId] = (val == SCREEN_EVENT_MTOUCH_TOUCH);
input_state.pointer_x[pointerId] = pair[0] * g_dpi_scale;
input_state.pointer_y[pointerId] = pair[1] * g_dpi_scale;
input.x = pair[0] * g_dpi_scale;
input.y = pair[1] * g_dpi_scale;
input.flags = (val == SCREEN_EVENT_MTOUCH_TOUCH) ? TOUCH_DOWN : TOUCH_UP;
input.id = pointerId;
NativeTouch(input);
break;
case SCREEN_EVENT_MTOUCH_MOVE:
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TOUCH_ID, &pointerId);
input_state.pointer_x[pointerId] = pair[0] * g_dpi_scale;
input_state.pointer_y[pointerId] = pair[1] * g_dpi_scale;
input.x = pair[0] * g_dpi_scale;
input.y = pair[1] * g_dpi_scale;
input.flags = TOUCH_MOVE;
input.id = pointerId;
NativeTouch(input);
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[0] = pair[0] * g_dpi_scale;
input_state.pointer_y[0] = pair[1] * g_dpi_scale;
input_state.pointer_down[0] = true;
input.x = pair[0] * g_dpi_scale;
input.y = pair[1] * g_dpi_scale;
input.flags = TOUCH_DOWN;
input.id = 0;
NativeTouch(input);
} else if (input_state.pointer_down[0]) { // Up
input_state.pointer_x[0] = pair[0] * g_dpi_scale;
input_state.pointer_y[0] = pair[1] * g_dpi_scale;
input_state.pointer_down[0] = false;
input.x = pair[0] * g_dpi_scale;
input.y = pair[1] * g_dpi_scale;
input.flags = TOUCH_UP;
input.id = 0;
NativeTouch(input);
}
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);
NativeKey(KeyInput(DEVICE_ID_KEYBOARD, KeyMapRawBlackberrytoNative.find(value)->second, (flags & KEY_DOWN) ? KEY_DOWN : KEY_UP));
break;
// Gamepad
case SCREEN_EVENT_GAMEPAD:
case SCREEN_EVENT_JOYSTICK:
int analog0[3];
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_BUTTONS, &buttons);
for (int i = 0; i < 32; i++) {
int mask = 1 << i;
if ((old_buttons & mask) != (buttons & mask))
NativeKey(KeyInput(DEVICE_ID_PAD_0, KeyMapPadBlackberrytoNative.find(mask)->second, (buttons & mask) ? KEY_DOWN : KEY_UP));
}
if (!screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ANALOG0, analog0)) {
for (int i = 0; i < 2; i++) {
AxisInput axis;
axis.axisId = JOYSTICK_AXIS_X + i;
// 1.2 to try to approximate the PSP's clamped rectangular range.
axis.value = 1.2 * analog0[i] / 128.0f;
if (axis.value > 1.0f) axis.value = 1.0f;
if (axis.value < -1.0f) axis.value = -1.0f;
axis.deviceId = DEVICE_ID_PAD_0;
axis.flags = 0;
NativeAxis(axis);
}
}
old_buttons = buttons;
break;
case SCREEN_EVENT_DISPLAY:
screen_display_t new_dpy = NULL;
screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_DISPLAY, (void **)&new_dpy);
for (int i = 0; i < ndisplays; i++) {
if (new_dpy != screen_dpy[i])
continue;
int active = 0;
screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_ATTACHED, &active);
if (active) {
int size[2];
screen_get_display_property_iv(screen_dpy[i], SCREEN_PROPERTY_SIZE, size);
if (size[0] == 0 || size[1] == 0)
active = 0;
}
if (active && !displays[i].attached)
realiseDisplay(i);
else if (!active && displays[i].attached && displays[i].realised)
unrealiseDisplay(i);
displays[i].attached = active;
}
break;
}
}
void QQnxScreenEventHandler::handleTouchEvent(screen_event_t event, int qnxType)
{
// get display coordinates of touch
errno = 0;
int pos[2];
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QQNX: failed to query event position, errno=%d", errno);
}
// get window coordinates of touch
errno = 0;
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QQNX: failed to query event window position, errno=%d", errno);
}
// determine which finger touched
errno = 0;
int touchId;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TOUCH_ID, &touchId);
if (result) {
qFatal("QQNX: failed to query event touch id, errno=%d", errno);
}
// determine which window was touched
errno = 0;
void *handle;
result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
screen_window_t qnxWindow = static_cast<screen_window_t>(handle);
// check if finger is valid
if (touchId < MaximumTouchPoints) {
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
// Generate enter and leave events as needed.
if (qnxWindow != m_lastMouseWindow) {
QWindow *wOld = QQnxIntegration::window(m_lastMouseWindow);
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
qScreenEventDebug() << Q_FUNC_INFO << "Qt leave, w=" << wOld;
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
qScreenEventDebug() << Q_FUNC_INFO << "Qt enter, w=" << w;
}
}
m_lastMouseWindow = qnxWindow;
if (w) {
// get size of screen which contains window
QPlatformScreen *platformScreen = QPlatformScreen::platformScreenForWindow(w);
QSizeF screenSize = platformScreen->physicalSize();
// update cached position of current touch point
m_touchPoints[touchId].normalPosition = QPointF( static_cast<qreal>(pos[0]) / screenSize.width(), static_cast<qreal>(pos[1]) / screenSize.height() );
m_touchPoints[touchId].area = QRectF( pos[0], pos[1], 0.0, 0.0 );
// determine event type and update state of current touch point
QEvent::Type type = QEvent::None;
switch (qnxType) {
case SCREEN_EVENT_MTOUCH_TOUCH:
m_touchPoints[touchId].state = Qt::TouchPointPressed;
type = QEvent::TouchBegin;
break;
case SCREEN_EVENT_MTOUCH_MOVE:
m_touchPoints[touchId].state = Qt::TouchPointMoved;
type = QEvent::TouchUpdate;
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
m_touchPoints[touchId].state = Qt::TouchPointReleased;
type = QEvent::TouchEnd;
break;
}
// build list of active touch points
QList<QWindowSystemInterface::TouchPoint> pointList;
for (int i = 0; i < MaximumTouchPoints; i++) {
if (i == touchId) {
// current touch point is always active
pointList.append(m_touchPoints[i]);
} else if (m_touchPoints[i].state != Qt::TouchPointReleased) {
// finger is down but did not move
m_touchPoints[i].state = Qt::TouchPointStationary;
pointList.append(m_touchPoints[i]);
}
}
// inject event into Qt
QWindowSystemInterface::handleTouchEvent(w, m_touchDevice, pointList);
qScreenEventDebug() << Q_FUNC_INFO << "Qt touch, w =" << w
<< ", p=(" << pos[0] << "," << pos[1]
<< "), t=" << type;
}
}
}
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;
}
void QQnxScreenEventHandler::handlePointerEvent(screen_event_t event)
{
errno = 0;
// Query the window that was clicked
screen_window_t qnxWindow;
void *handle;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
qnxWindow = static_cast<screen_window_t>(handle);
// Query the button states
int buttonState = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_BUTTONS, &buttonState);
if (result) {
qFatal("QQNX: failed to query event button state, errno=%d", errno);
}
// Query the window position
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QQNX: failed to query event window position, errno=%d", errno);
}
// Query the screen position
int pos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QQNX: failed to query event position, errno=%d", errno);
}
// Query the wheel delta
int wheelDelta = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_MOUSE_WHEEL, &wheelDelta);
if (result) {
qFatal("QQNX: failed to query event wheel delta, errno=%d", errno);
}
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
// Generate enter and leave events as needed.
if (qnxWindow != m_lastMouseWindow) {
QWindow *wOld = QQnxIntegration::window(m_lastMouseWindow);
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
qScreenEventDebug() << Q_FUNC_INFO << "Qt leave, w=" << wOld;
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
qScreenEventDebug() << Q_FUNC_INFO << "Qt enter, w=" << w;
}
}
// If we don't have a navigator, we don't get activation events.
if (buttonState && w && w != QGuiApplication::focusWindow() && !m_qnxIntegration->supportsNavigatorEvents())
QWindowSystemInterface::handleWindowActivated(w);
m_lastMouseWindow = qnxWindow;
// Apply scaling to wheel delta and invert value for Qt. We'll probably want to scale
// this via a system preference at some point. But for now this is a sane value and makes
// the wheel usable.
wheelDelta *= -10;
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// Convert buttons.
// Some QNX header files invert 'Right Button versus "Left Button' ('Right' == 0x01). But they also offer a 'Button Swap' bit,
// so we may receive events as shown. (If this is wrong, the fix is easy.)
// QNX Button mask is 8 buttons wide, with a maximum value of x080.
Qt::MouseButtons buttons = Qt::NoButton;
if (buttonState & 0x01)
buttons |= Qt::LeftButton;
if (buttonState & 0x02)
buttons |= Qt::MidButton;
if (buttonState & 0x04)
buttons |= Qt::RightButton;
if (buttonState & 0x08)
buttons |= Qt::ExtraButton1; // AKA 'Qt::BackButton'
if (buttonState & 0x10)
buttons |= Qt::ExtraButton2; // AKA 'Qt::ForwardButton'
if (buttonState & 0x20)
buttons |= Qt::ExtraButton3;
if (buttonState & 0x40)
buttons |= Qt::ExtraButton4;
if (buttonState & 0x80)
buttons |= Qt::ExtraButton5;
if (w) {
// Inject mouse event into Qt only if something has changed.
if (m_lastGlobalMousePoint != globalPoint ||
m_lastLocalMousePoint != localPoint ||
m_lastButtonState != buttons) {
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
qScreenEventDebug() << Q_FUNC_INFO << "Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << static_cast<int>(buttons);
}
if (wheelDelta) {
// Screen only supports a single wheel, so we will assume Vertical orientation for
// now since that is pretty much standard.
QWindowSystemInterface::handleWheelEvent(w, localPoint, globalPoint, wheelDelta, Qt::Vertical);
qScreenEventDebug() << Q_FUNC_INFO << "Qt wheel, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), d=" << static_cast<int>(wheelDelta);
}
}
m_lastGlobalMousePoint = globalPoint;
m_lastLocalMousePoint = localPoint;
m_lastButtonState = buttons;
}
