void CCEGLView::release()
{
screen_stop_events(m_screenContext);
bps_shutdown();
if (m_eglDisplay != EGL_NO_DISPLAY)
{
eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
if (m_eglSurface != EGL_NO_SURFACE)
{
eglDestroySurface(m_eglDisplay, m_eglSurface);
m_eglSurface = EGL_NO_SURFACE;
}
if (m_eglContext != EGL_NO_CONTEXT)
{
eglDestroyContext(m_eglDisplay, m_eglContext);
m_eglContext = EGL_NO_CONTEXT;
}
if (m_eglDisplay != EGL_NO_DISPLAY)
{
eglTerminate(m_eglDisplay);
m_eglDisplay = EGL_NO_DISPLAY;
}
if (m_screenWindow)
{
screen_destroy_window(m_screenWindow);
m_screenWindow = NULL;
}
if (m_screenEvent)
{
screen_destroy_event(m_screenEvent);
m_screenEvent = NULL;
}
if (m_screenContext)
{
screen_destroy_context(m_screenContext);
m_screenContext = NULL;
}
eglReleaseThread();
m_isGLInitialized = false;
exit(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);
}
Platform::~Platform()
{
if (__eglDisplay != EGL_NO_DISPLAY)
{
eglMakeCurrent(__eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
if (__eglSurface != EGL_NO_SURFACE)
{
eglDestroySurface(__eglDisplay, __eglSurface);
__eglSurface = EGL_NO_SURFACE;
}
if (__eglContext != EGL_NO_CONTEXT)
{
eglDestroyContext(__eglDisplay, __eglContext);
__eglContext = EGL_NO_CONTEXT;
}
if (__eglDisplay != EGL_NO_DISPLAY)
{
eglTerminate(__eglDisplay);
__eglDisplay = EGL_NO_DISPLAY;
}
if (__screenWindow)
{
screen_destroy_window(__screenWindow);
__screenWindow = NULL;
}
if (__screenEvent)
{
screen_destroy_event(__screenEvent);
__screenEvent = NULL;
}
if (__screenContext)
{
screen_destroy_context(__screenContext);
__screenContext = NULL;
}
}
void QBBEventThread::shutdown()
{
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);
}
// set the event type as user
errno = 0;
int type = SCREEN_EVENT_USER;
result = screen_set_event_property_iv(event, SCREEN_PROPERTY_TYPE, &type);
if (result) {
qFatal("QBB: failed to set event type, errno=%d", errno);
}
// NOTE: ignore SCREEN_PROPERTY_USER_DATA; treat all user events as shutdown events
// post event to event loop so it will wake up and die
errno = 0;
result = screen_send_event(mContext, event, getpid());
if (result) {
qFatal("QBB: failed to set event type, errno=%d", errno);
}
// cleanup
screen_destroy_event(event);
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop shutdown begin";
#endif
// block until thread terminates
wait();
#if defined(QBBEVENTTHREAD_DEBUG)
qDebug() << "QBB: event loop shutdown end";
#endif
}
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);
}
void GLimp_Shutdown( void ) {
if (!eglContext || !eglDisplay) return;
IN_DeactivateMouse();
// bk001206 - replaced with H2/Fakk2 solution
// XAutoRepeatOn(dpy);
// autorepeaton = qfalse; // bk001130 - from cvs1.17 (mkv)
screen_destroy_event(screen_ev);
eglMakeCurrent(eglDisplay, NULL, NULL, NULL);
eglDestroySurface(eglDisplay, eglSurface);
screen_destroy_window(screen_win);
screen_destroy_context(screen_ctx);
eglDestroyContext(eglDisplay, eglContext);
eglTerminate(eglDisplay);
eglReleaseThread();
eglDisplay = NULL;
eglContext = NULL;
eglSurface = NULL;
memset( &glConfig, 0, sizeof( glConfig ) );
memset( &glState, 0, sizeof( glState ) );
}
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;
}
