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;
}
}
void QBBScreenEventThread::run()
{
screen_event_t event;
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result)
qFatal("QBB: failed to create screen event, errno=%d", errno);
#if defined(QBBSCREENEVENTTHREAD_DEBUG)
qDebug() << "QBB: screen event thread started";
#endif
// loop indefinitely
while (!mQuit) {
// block until screen event is available
errno = 0;
result = screen_get_event(mContext, event, -1);
if (result)
qFatal("QBB: failed to get screen event, errno=%d", errno);
// process received event
errno = 0;
int qnxType;
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &qnxType);
if (result)
qFatal("QBB: failed to query screen event type, errno=%d", errno);
if (qnxType == SCREEN_EVENT_USER) {
// treat all screen user events as shutdown requests
#if defined(QBBSCREENEVENTTHREAD_DEBUG)
qDebug() << "QBB: QNX screen user event";
#endif
mQuit = true;
} else {
mEventHandler->handleEvent(event, qnxType);
}
}
#if defined(QBBSCREENEVENTTHREAD_DEBUG)
qDebug() << "QBB: screen event thread stopped";
#endif
// cleanup
screen_destroy_event(event);
}
void QBBEventThread::run()
{
screen_event_t event;
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result) {
qFatal("QBB: failed to create event, errno=%d", errno);
}
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop started";
#endif
// loop indefinitely
while (!mQuit) {
// block until screen event is available
errno = 0;
result = screen_get_event(mContext, event, -1);
if (result) {
qFatal("QBB: failed to get event, errno=%d", errno);
}
// process received event
dispatchEvent(event);
}
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop stopped";
#endif
// cleanup
screen_destroy_event(event);
}
static void HandleEvents(void)
{
int t = 0;
int rc = 0;
int freeze = 0;
int prop;
int size[2];
int x, y, val, tid, key, keyflags;
mtouch_event_t mtouch_event;
static int retainMovX = 0, retainMovY = 0;
static int lookX = 0, lookY = 0;
static camThrottle = 0;
static int moveTouchId = -1;
static int lookTouchId = -1;
static qboolean touchIds[3] = { false, false, false };
qboolean dowarp = qfalse;
int jmping = 0;
#if 0
while(1) {
while (!screen_get_event(screen_ctx, screen_ev, freeze ? ~0 : 0)) {
rc = screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_TYPE, &val);
if (rc || val == SCREEN_EVENT_NONE) {
break;
}
switch (val) {
case SCREEN_EVENT_PROPERTY:
screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_NAME, &prop);
if (prop == SCREEN_PROPERTY_VISIBLE) {
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_VISIBLE, &prop);
if (prop) {
freeze = 0;
} else {
freeze = 1;
}
}
}
}
if (!freeze) {
break;
}
}
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_SIZE, size);
if ((size[0] <= 374) && (size[1] <= 219)) {
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_SOURCE_SIZE, size);
if ((size[0] != 374) && (size[1] != 219)) {
glConfig.vidWidth = 374;
glConfig.vidHeight = 219 * 600 / 768;
min = 1;
}
} else {
screen_get_window_property_iv(screen_win, SCREEN_PROPERTY_SOURCE_SIZE, size);
if ((size[0] != bz[0]) && (size[1] != bz[1])) {
glConfig.vidWidth = bz[0];
glConfig.vidHeight = bz[1];
max = 1;
}
}
#else
t = Sys_Milliseconds();
if (jmping)
{
Sys_QueEvent( t, SE_KEY, K_SPACE, qfalse, 0, NULL );
}
while (!screen_get_event(screen_ctx, screen_ev, 1))
{
rc = screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_TYPE, &val);
if (rc || val == SCREEN_EVENT_NONE)
break;
switch (val)
{
case SCREEN_EVENT_CLOSE:
Com_Printf("SCREEN CLOSE EVENT!\n");
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
screen_get_mtouch_event(screen_ev, &mtouch_event, 0);
tid = mtouch_event.contact_id;
if (touchIds[tid]) {
if (moveTouchId == tid) {
moveTouchId = -1;
touchIds[tid] = false;
movX = movY = 0;
retainMovX = retainMovY = 0;
} else if (lookTouchId == tid) {
lookTouchId = -1;
touchIds[tid] = false;
lookX = lookY = 0;
}
}
Sys_QueEvent(t, SE_KEY, K_MOUSE1, qfalse, 0, NULL);
Sys_QueEvent( t, SE_KEY, K_SPACE, qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 's', qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 'w', qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 'd', qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 'a', qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 'n', qfalse, 0, NULL );
break;
case SCREEN_EVENT_POINTER:
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
screen_get_mtouch_event(screen_ev, &mtouch_event, 0);
if (mouse_active && tid < 3)
{
if (cls.state == CA_ACTIVE && !uis.activemenu)
{
x = mtouch_event.x;
y = mtouch_event.y;
tid = mtouch_event.contact_id;
if (val == SCREEN_EVENT_MTOUCH_TOUCH)
{
// check for new input type
if (moveTouchId == -1 && (((movBoundX - x) * (movBoundX - x) + (movBoundY - y)*(movBoundY - y)) < r1square ))
{
// move
moveTouchId = tid;
touchIds[tid] = true;
}
else
{
// look
lookTouchId = tid;
touchIds[tid] = true;
lookX = x;
lookY = y;
// allow looking while firing/jumping
if (((fireBoundX - x) * (fireBoundX - x) + (fireBoundY - y)*(fireBoundY - y)) < r2square)
{
// fire
Sys_QueEvent(t, SE_KEY, K_MOUSE1, qtrue, 0, NULL);
}
else if (((jmpBoundX - x) * (jmpBoundX - x) + (jmpBoundY - y)*(jmpBoundY - y)) < r2square )
{
// jump
Sys_QueEvent( t, SE_KEY, K_SPACE, qtrue, 0, NULL );
}
else if (((weaponNextX - x) * (weaponNextX - x) + (weaponNextY - y)*(weaponNextY - y)) < r2square )
{
// weapon prev
Sys_QueEvent( t, SE_KEY, 'n', qtrue, 0, NULL );
}
}
}
if (moveTouchId == tid)
{
// process moving
x = (x - movBoundX);
y = (y - movBoundY);
retainMovX = x;
retainMovY = y;
movX = x * 640 / 786;
movY = y;
if (x * x + y * y > r1square)
{
movX = movY = -1; // hide
}
}
else if (lookTouchId == tid)
{
// process looking
Sys_QueEvent(t, SE_MOUSE, (x - lookX) * 2, (y - lookY) * 2, 0, NULL);
lookX = x;
lookY = y;
}
}
else if (cls.state == CA_CINEMATIC)
{
x = mtouch_event.x;
y = mtouch_event.y;
if (val == SCREEN_EVENT_MTOUCH_TOUCH)
{
Sys_QueEvent(t, SE_KEY, K_MOUSE1, qtrue, 0, NULL);
}
else if (val == SCREEN_EVENT_MTOUCH_RELEASE)
{
Sys_QueEvent(t, SE_KEY, K_MOUSE1, qfalse, 0, NULL);
}
}
else if ((cls.state == CA_ACTIVE && uis.activemenu) ||
(cls.state != CA_ACTIVE && cls.state != CA_CINEMATIC))
{
x = (mtouch_event.x * 640) / 1024;
y = (mtouch_event.y * 480 ) / 768;
if (x == glConfig.vidWidth/2 &&
y == glConfig.vidHeight/2)
{
x = y = 0;
break;
}
dowarp = qtrue;
x = x - prevX;
y = y - prevY;
Sys_QueEvent(t, SE_MOUSE, x, y, 0, NULL);
prevX = (mtouch_event.x * 640) / 1024;
prevY = (mtouch_event.y * 480 ) / 768;
if (val == SCREEN_EVENT_MTOUCH_TOUCH)
{
Sys_QueEvent(t, SE_KEY, K_MOUSE1, qtrue, 0, NULL);
}
else if (val == SCREEN_EVENT_MTOUCH_RELEASE)
{
Sys_QueEvent(t, SE_KEY, K_MOUSE1, qfalse, 0, NULL);
}
}
}
if (retainMovX > movBoundRad / 2)
{
Sys_QueEvent( t, SE_KEY, 'd', qtrue, 0, NULL );
}
else if (retainMovX < -movBoundRad / 2 )
{
Sys_QueEvent( t, SE_KEY, 'a', qtrue, 0, NULL );
}
else
{
Sys_QueEvent( t, SE_KEY, 'd', qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 'a', qfalse, 0, NULL );
}
if (retainMovY > movBoundRad / 2)
{
Sys_QueEvent( t, SE_KEY, 's', qtrue, 0, NULL );
}
else if (retainMovY < -movBoundRad / 2)
{
Sys_QueEvent( t, SE_KEY, 'w', qtrue, 0, NULL );
}
else
{
Sys_QueEvent( t, SE_KEY, 's', qfalse, 0, NULL );
Sys_QueEvent( t, SE_KEY, 'w', qfalse, 0, NULL );
}
break;
case SCREEN_EVENT_KEYBOARD:
screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_KEY_SYM, &key);
screen_get_event_property_iv(screen_ev, SCREEN_PROPERTY_KEY_FLAGS, &keyflags);
if (keyflags & KEY_DOWN)
{
if (key >= ' ' && key < '~')
{
Sys_QueEvent( t, SE_CHAR, key, qfalse, 0, NULL );
}
else
{
key = key - 0xf000;
switch (key)
{
case 8: // backspace
Sys_QueEvent( t, SE_CHAR, '\b', qfalse, 0, NULL );
return;
default:
break;
}
Sys_QueEvent( t, SE_KEY, key, qtrue, 0, NULL );
Sys_QueEvent( t, SE_KEY, key, qfalse, 0, NULL );
}
}
break;
}
}
#endif
}
gceSTATUS
gcoOS_GetEvent(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
OUT halEvent * Event
)
{
screen_event_t screen_evt;
int rc;
gceSTATUS status = gcvSTATUS_NOT_FOUND;
rc = screen_create_event(&screen_evt);
while (screen_get_event(screen_ctx, screen_evt, 0L) == 0)
{
int type;
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_TYPE, &type);
if (type == SCREEN_EVENT_CLOSE)
{
Event->type = HAL_CLOSE;
status = gcvSTATUS_OK;
break;
}
else if (type == SCREEN_EVENT_POINTER)
{
static int last_buttons;
int buttons;
int pointer[2];
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_BUTTONS, &buttons);
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_POSITION, pointer);
if (buttons != last_buttons)
{
Event->type = HAL_BUTTON;
Event->data.button.left = (buttons & 0x0001);
/* TODO
Event->data.button.middle = (buttons & 0x????);
Event->data.button.right = (buttons & 0x????);
*/
Event->data.button.x = pointer[0];
Event->data.button.y = pointer[1];
last_buttons = buttons;
}
else
{
Event->type = HAL_POINTER;
Event->data.pointer.x = pointer[0];
Event->data.pointer.y = pointer[1];
}
status = gcvSTATUS_OK;
break;
}
else if (type == SCREEN_EVENT_KEYBOARD)
{
int buffer;
int scancode;
static int prefix;
screen_get_event_property_iv(screen_evt, SCREEN_PROPERTY_KEY_SCAN, &buffer);
if ((buffer == 0xE0) || (buffer == 0xE1))
{
prefix = buffer;
continue;
}
if (prefix)
{
scancode = keys[buffer & 0x7F].extended;
prefix = 0;
}
else
{
scancode = keys[buffer & 0x7F].normal;
}
if (scancode == HAL_UNKNOWN)
{
continue;
}
Event->type = HAL_KEYBOARD;
Event->data.keyboard.scancode = scancode;
Event->data.keyboard.pressed = buffer < 0x80;
Event->data.keyboard.key = ( (scancode < HAL_SPACE)
|| (scancode >= HAL_F1)
)
? 0
: (char) scancode;
status = gcvSTATUS_OK;
break;
}
else if (type == SCREEN_EVENT_NONE)
{
break;
}
else
{
break;
}
}
screen_destroy_event(screen_evt);
return status;
}
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;
}
