sdl-ios-xcode: src/video/photon/SDL

comparison src/video/photon/SDL_photon.c @ 3139:7f684f249ec9

indent

author	Sam Lantinga <slouken@libsdl.org>
date	Sat, 23 May 2009 22:41:08 +0000
parents	1102a3305928
children	44d5474c2c8a

comparison

equal deleted inserted replaced

-:d71d8ceda8b3
+:7f684f249ec9
 /* Pixel format conversion routines */
 #include "SDL_photon_pixelfmt.h"
 /* Use GF's pixel format functions for OpenGL ES context creation */
 #if defined(SDL_VIDEO_OPENGL_ES)
 #include "../qnxgf/SDL_gf_pixelfmt.h"
 /* If GF driver is not compiled in, include some of usefull functions */
 #if !defined(SDL_VIDEO_DRIVER_QNXGF)
 #include "../qnxgf/SDL_gf_pixelfmt.c"
 #endif /* SDL_VIDEO_DRIVER_QNXGF */
 #endif /* SDL_VIDEO_OPENGL_ES */
 /* Use GF's OpenGL ES 1.1 functions emulation */
 #if defined(SDL_VIDEO_OPENGL_ES)
 #include "../qnxgf/SDL_gf_opengles.h"
 /* If GF driver is not compiled in, include some of usefull functions */
 #if !defined(SDL_VIDEO_DRIVER_QNXGF)
 #include "../qnxgf/SDL_gf_opengles.c"
 #endif /* SDL_VIDEO_DRIVER_QNXGF */
 #endif /* SDL_VIDEO_OPENGL_ES */
 /* Low level device graphics driver names, which they are reporting */
-Photon_DeviceCaps photon_devicename[]=
+Photon_DeviceCaps photon_devicename[] = {
-{
+/* ATI Rage 128 graphics driver (devg-ati_rage128)      */
-/* ATI Rage 128 graphics driver (devg-ati_rage128)      */
+{"ati_rage128", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"ati_rage128", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
 /* Fujitsu Carmine graphics driver (devg-carmine.so)    */
-{"carmine",     SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D},
+{"carmine", SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D}
-/* C&T graphics driver (devg-chips.so)                  */
+,
-{"chips",       SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* C&T graphics driver (devg-chips.so)                  */
-/* Fujitsu Coral graphics driver (devg-coral.so)        */
+{"chips", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"coral",       SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D},
+,
-/* Intel integrated graphics driver (devg-extreme2.so)  */
+/* Fujitsu Coral graphics driver (devg-coral.so)        */
-{"extreme2",    SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D},
+{"coral", SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D}
-/* Unaccelerated FB driver (devg-flat.so)               */
+,
-{"flat",        SDL_PHOTON_UNACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* Intel integrated graphics driver (devg-extreme2.so)  */
-/* NS Geode graphics driver (devg-geode.so)             */
+{"extreme2", SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D}
-{"geode",       SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* Geode LX graphics driver (devg-geodelx.so)           */
+/* Unaccelerated FB driver (devg-flat.so)               */
-{"geodelx",     SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+{"flat", SDL_PHOTON_UNACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-/* Intel integrated graphics driver (devg-gma9xx.so)    */
+,
-{"gma",         SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D},
+/* NS Geode graphics driver (devg-geode.so)             */
-/* Intel integrated graphics driver (devg-i810.so)      */
+{"geode", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"i810",        SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* Intel integrated graphics driver (devg-i830.so)      */
+/* Geode LX graphics driver (devg-geodelx.so)           */
-{"i830",        SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+{"geodelx", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-/* Geode LX graphics driver (devg-lx800.so)             */
+,
-{"lx800",       SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* Intel integrated graphics driver (devg-gma9xx.so)    */
-/* Matrox Gxx graphics driver (devg-matroxg.so)         */
+{"gma", SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D}
-{"matroxg",     SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* Intel Poulsbo graphics driver (devg-poulsbo.so)      */
+/* Intel integrated graphics driver (devg-i810.so)      */
-{"poulsbo",     SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D},
+{"i810", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-/* ATI Radeon driver (devg-radeon.so)                   */
+,
-{"radeon",      SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* Intel integrated graphics driver (devg-i830.so)      */
-/* ATI Rage driver (devg-rage.so)                       */
+{"i830", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"rage",        SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* S3 Savage graphics driver (devg-s3_savage.so)        */
+/* Geode LX graphics driver (devg-lx800.so)             */
-{"s3_savage",   SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+{"lx800", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-/* SiS630 integrated graphics driver (devg-sis630.so)   */
+,
-{"sis630",      SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* Matrox Gxx graphics driver (devg-matroxg.so)         */
-/* PowerVR SGX 535 graphics driver (devg-poulsbo.so)    */
+{"matroxg", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"sgx",         SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D},
+,
-/* SM Voyager GX graphics driver (devg-smi5xx.so)       */
+/* Intel Poulsbo graphics driver (devg-poulsbo.so)      */
-{"smi5xx",      SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+{"poulsbo", SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D}
-/* Silicon Motion graphics driver (devg-smi7xx.so)      */
+,
-{"smi7xx",      SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* ATI Radeon driver (devg-radeon.so)                   */
-/* SVGA unaccelerated gfx driver (devg-svga.so)         */
+{"radeon", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"svga",        SDL_PHOTON_UNACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* nVidia TNT graphics driver (devg-tnt.so)             */
+/* ATI Rage driver (devg-rage.so)                       */
-{"tnt",         SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+{"rage", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-/* VIA integrated graphics driver (devg-tvia.so)        */
+,
-{"tvia",        SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* S3 Savage graphics driver (devg-s3_savage.so)        */
-/* VIA UniChrome graphics driver (devg-unichrome.so)    */
+{"s3_savage", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-{"unichrome",   SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* VESA unaccelerated gfx driver (devg-vesa.so)         */
+/* SiS630 integrated graphics driver (devg-sis630.so)   */
-{"vesa",        SDL_PHOTON_UNACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+{"sis630", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
-/* VmWare graphics driver (devg-volari.so)              */
+,
-{"vmware",      SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+/* PowerVR SGX 535 graphics driver (devg-poulsbo.so)    */
-/* XGI XP10 graphics driver (devg-volari.so), OpenGL 1.5*/
+{"sgx", SDL_PHOTON_ACCELERATED | SDL_PHOTON_ACCELERATED_3D}
-{"volari",      SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D},
+,
-/* End of list */
+/* SM Voyager GX graphics driver (devg-smi5xx.so)       */
-{NULL,          0x00000000}
+{"smi5xx", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* Silicon Motion graphics driver (devg-smi7xx.so)      */
+{"smi7xx", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* SVGA unaccelerated gfx driver (devg-svga.so)         */
+{"svga", SDL_PHOTON_UNACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* nVidia TNT graphics driver (devg-tnt.so)             */
+{"tnt", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* VIA integrated graphics driver (devg-tvia.so)        */
+{"tvia", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* VIA UniChrome graphics driver (devg-unichrome.so)    */
+{"unichrome", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* VESA unaccelerated gfx driver (devg-vesa.so)         */
+{"vesa", SDL_PHOTON_UNACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* VmWare graphics driver (devg-volari.so)              */
+{"vmware", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* XGI XP10 graphics driver (devg-volari.so), OpenGL 1.5 */
+{"volari", SDL_PHOTON_ACCELERATED | SDL_PHOTON_UNACCELERATED_3D}
+,
+/* End of list */
+{NULL, 0x00000000}
 };
-static SDL_bool photon_initialized=SDL_FALSE;
+static SDL_bool photon_initialized = SDL_FALSE;
-static int photon_available(void)
+static int
-{
+photon_available(void)
-int status;
+{
+int status;
-/* Check if Photon was initialized before */
-if (photon_initialized==SDL_FALSE)
+/* Check if Photon was initialized before */
-{
+if (photon_initialized == SDL_FALSE) {
 /* Initialize Photon widget library and open channel to Photon */
-status=PtInit(NULL);
+status = PtInit(NULL);
-if (status==0)
+if (status == 0) {
-{
+photon_initialized = SDL_TRUE;
-photon_initialized=SDL_TRUE;
+return 1;
-return 1;
+} else {
-}
+photon_initialized = SDL_FALSE;
-else
+return 0;
-{
+}
-photon_initialized=SDL_FALSE;
+}
-return 0;
-}
+return 1;
 }
-return 1;
+static void
-}
+photon_destroy(SDL_VideoDevice * device)
+{
-static void photon_destroy(SDL_VideoDevice* device)
+SDL_VideoData *phdata = (SDL_VideoData *) device->driverdata;
-{
-SDL_VideoData* phdata=(SDL_VideoData*) device->driverdata;
+#if defined(SDL_VIDEO_OPENGL_ES)
+if (phdata->gfinitialized != SDL_FALSE) {
-#if defined(SDL_VIDEO_OPENGL_ES)
+gf_dev_detach(phdata->gfdev);
-if (phdata->gfinitialized!=SDL_FALSE)
+}
-{
+#endif /* SDL_VIDEO_OPENGL_ES */
-gf_dev_detach(phdata->gfdev);
-}
+if (device->driverdata != NULL) {
-#endif /* SDL_VIDEO_OPENGL_ES */
+device->driverdata = NULL;
+}
-if (device->driverdata!=NULL)
+}
-{
-device->driverdata=NULL;
+static SDL_VideoDevice *
-}
+photon_create(int devindex)
-}
+{
+SDL_VideoDevice *device;
-static SDL_VideoDevice* photon_create(int devindex)
+SDL_VideoData *phdata;
-{
+int status;
-SDL_VideoDevice*  device;
-SDL_VideoData*    phdata;
+/* Check if photon could be initialized */
-int               status;
+status = photon_available();
+if (status == 0) {
-/* Check if photon could be initialized */
+/* Photon could not be used */
-status=photon_available();
+return NULL;
-if (status==0)
+}
-{
-/* Photon could not be used */
+/* Photon agregates all video devices to one with multiple heads */
-return NULL;
+if (devindex != 0) {
-}
+/* devindex could be zero only in Photon SDL driver */
+return NULL;
-/* Photon agregates all video devices to one with multiple heads */
+}
-if (devindex!=0)
-{
+/* Initialize SDL_VideoDevice structure */
-/* devindex could be zero only in Photon SDL driver */
+device = (SDL_VideoDevice *) SDL_calloc(1, sizeof(SDL_VideoDevice));
-return NULL;
+if (device == NULL) {
-}
+SDL_OutOfMemory();
+return NULL;
-/* Initialize SDL_VideoDevice structure */
+}
-device=(SDL_VideoDevice*)SDL_calloc(1, sizeof(SDL_VideoDevice));
-if (device==NULL)
+/* Initialize internal photon specific data */
-{
+phdata = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
-SDL_OutOfMemory();
+if (phdata == NULL) {
-return NULL;
+SDL_OutOfMemory();
-}
+SDL_free(device);
+return NULL;
-/* Initialize internal photon specific data */
+}
-phdata=(SDL_VideoData*)SDL_calloc(1, sizeof(SDL_VideoData));
+device->driverdata = phdata;
-if (phdata==NULL)
-{
+/* Get all photon display devices */
-SDL_OutOfMemory();
+phdata->avail_rids =
-SDL_free(device);
+PdGetDevices(&phdata->rid[0], SDL_VIDEO_PHOTON_MAX_RIDS);
-return NULL;
+if (phdata->avail_rids > SDL_VIDEO_PHOTON_MAX_RIDS) {
-}
+phdata->avail_rids = SDL_VIDEO_PHOTON_MAX_RIDS;
-device->driverdata=phdata;
+}
+#if defined(SDL_VIDEO_OPENGL_ES)
-/* Get all photon display devices */
+/* TODO: add real device detection versus multiple heads */
-phdata->avail_rids=PdGetDevices(&phdata->rid[0], SDL_VIDEO_PHOTON_MAX_RIDS);
+status =
-if (phdata->avail_rids>SDL_VIDEO_PHOTON_MAX_RIDS)
+gf_dev_attach(&phdata->gfdev, GF_DEVICE_INDEX(0),
-{
+&phdata->gfdev_info);
-phdata->avail_rids=SDL_VIDEO_PHOTON_MAX_RIDS;
+if (status != GF_ERR_OK) {
-}
+/* Do not fail right now, if GF can't be attached */
+phdata->gfinitialized = SDL_FALSE;
-#if defined(SDL_VIDEO_OPENGL_ES)
+} else {
-/* TODO: add real device detection versus multiple heads */
+phdata->gfinitialized = SDL_TRUE;
-status=gf_dev_attach(&phdata->gfdev, GF_DEVICE_INDEX(0), &phdata->gfdev_info);
+}
-if (status!=GF_ERR_OK)
+#endif /* SDL_VIDEO_OPENGL_ES */
-{
-/* Do not fail right now, if GF can't be attached */
+/* Set default target device */
-phdata->gfinitialized=SDL_FALSE;
+status = PdSetTargetDevice(NULL, phdata->rid[0]);
-}
+if (status == -1) {
-else
+SDL_SetError("Photon: Can't set default target device");
-{
+#if defined(SDL_VIDEO_OPENGL_ES)
-phdata->gfinitialized=SDL_TRUE;
+gf_dev_detach(phdata->gfdev);
-}
+#endif /* SDL_VIDEO_OPENGL_ES */
-#endif /* SDL_VIDEO_OPENGL_ES */
+SDL_free(phdata);
+SDL_free(device);
-/* Set default target device */
+return NULL;
-status=PdSetTargetDevice(NULL, phdata->rid[0]);
+}
-if (status==-1)
+phdata->current_device_id = 0;
-{
-SDL_SetError("Photon: Can't set default target device");
+/* Setup amount of available displays and current display */
-#if defined(SDL_VIDEO_OPENGL_ES)
+device->num_displays = 0;
-gf_dev_detach(phdata->gfdev);
+device->current_display = 0;
-#endif /* SDL_VIDEO_OPENGL_ES */
-SDL_free(phdata);
+/* Set device free function */
-SDL_free(device);
+device->free = photon_destroy;
-return NULL;
-}
+/* Setup all functions which we can handle */
-phdata->current_device_id=0;
+device->VideoInit = photon_videoinit;
+device->VideoQuit = photon_videoquit;
-/* Setup amount of available displays and current display */
+device->GetDisplayModes = photon_getdisplaymodes;
-device->num_displays=0;
+device->SetDisplayMode = photon_setdisplaymode;
-device->current_display=0;
+device->SetDisplayPalette = photon_setdisplaypalette;
+device->GetDisplayPalette = photon_getdisplaypalette;
-/* Set device free function */
+device->SetDisplayGammaRamp = photon_setdisplaygammaramp;
-device->free=photon_destroy;
+device->GetDisplayGammaRamp = photon_getdisplaygammaramp;
+device->CreateWindow = photon_createwindow;
-/* Setup all functions which we can handle */
+device->CreateWindowFrom = photon_createwindowfrom;
-device->VideoInit=photon_videoinit;
+device->SetWindowTitle = photon_setwindowtitle;
-device->VideoQuit=photon_videoquit;
+device->SetWindowIcon = photon_setwindowicon;
-device->GetDisplayModes=photon_getdisplaymodes;
+device->SetWindowPosition = photon_setwindowposition;
-device->SetDisplayMode=photon_setdisplaymode;
+device->SetWindowSize = photon_setwindowsize;
-device->SetDisplayPalette=photon_setdisplaypalette;
+device->ShowWindow = photon_showwindow;
-device->GetDisplayPalette=photon_getdisplaypalette;
+device->HideWindow = photon_hidewindow;
-device->SetDisplayGammaRamp=photon_setdisplaygammaramp;
+device->RaiseWindow = photon_raisewindow;
-device->GetDisplayGammaRamp=photon_getdisplaygammaramp;
+device->MaximizeWindow = photon_maximizewindow;
-device->CreateWindow=photon_createwindow;
+device->MinimizeWindow = photon_minimizewindow;
-device->CreateWindowFrom=photon_createwindowfrom;
+device->RestoreWindow = photon_restorewindow;
-device->SetWindowTitle=photon_setwindowtitle;
+device->SetWindowGrab = photon_setwindowgrab;
-device->SetWindowIcon=photon_setwindowicon;
+device->DestroyWindow = photon_destroywindow;
-device->SetWindowPosition=photon_setwindowposition;
+device->GetWindowWMInfo = photon_getwindowwminfo;
-device->SetWindowSize=photon_setwindowsize;
+device->GL_LoadLibrary = photon_gl_loadlibrary;
-device->ShowWindow=photon_showwindow;
+device->GL_GetProcAddress = photon_gl_getprocaddres;
-device->HideWindow=photon_hidewindow;
+device->GL_UnloadLibrary = photon_gl_unloadlibrary;
-device->RaiseWindow=photon_raisewindow;
+device->GL_CreateContext = photon_gl_createcontext;
-device->MaximizeWindow=photon_maximizewindow;
+device->GL_MakeCurrent = photon_gl_makecurrent;
-device->MinimizeWindow=photon_minimizewindow;
+device->GL_SetSwapInterval = photon_gl_setswapinterval;
-device->RestoreWindow=photon_restorewindow;
+device->GL_GetSwapInterval = photon_gl_getswapinterval;
-device->SetWindowGrab=photon_setwindowgrab;
+device->GL_SwapWindow = photon_gl_swapwindow;
-device->DestroyWindow=photon_destroywindow;
+device->GL_DeleteContext = photon_gl_deletecontext;
-device->GetWindowWMInfo=photon_getwindowwminfo;
+device->PumpEvents = photon_pumpevents;
-device->GL_LoadLibrary=photon_gl_loadlibrary;
+device->SuspendScreenSaver = photon_suspendscreensaver;
-device->GL_GetProcAddress=photon_gl_getprocaddres;
-device->GL_UnloadLibrary=photon_gl_unloadlibrary;
+return device;
-device->GL_CreateContext=photon_gl_createcontext;
+}
-device->GL_MakeCurrent=photon_gl_makecurrent;
-device->GL_SetSwapInterval=photon_gl_setswapinterval;
+VideoBootStrap photon_bootstrap = {
-device->GL_GetSwapInterval=photon_gl_getswapinterval;
+"photon",
-device->GL_SwapWindow=photon_gl_swapwindow;
+"SDL QNX Photon video driver",
-device->GL_DeleteContext=photon_gl_deletecontext;
+photon_available,
-device->PumpEvents=photon_pumpevents;
+photon_create
-device->SuspendScreenSaver=photon_suspendscreensaver;
-return device;
-}
-VideoBootStrap photon_bootstrap=
-{
-"photon",
-"SDL QNX Photon video driver",
-photon_available,
-photon_create
 };
 /*****************************************************************************/
 /* SDL Video and Display initialization/handling functions                   */
 /*****************************************************************************/
-int photon_videoinit(_THIS)
+int
-{
+photon_videoinit(_THIS)
-SDL_VideoData*    phdata=(SDL_VideoData*)_this->driverdata;
+{
-PgHWCaps_t        hwcaps;
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-PgVideoModeInfo_t modeinfo;
+PgHWCaps_t hwcaps;
-int32_t           status;
+PgVideoModeInfo_t modeinfo;
-SDL_VideoDisplay  display;
+int32_t status;
-SDL_DisplayMode   current_mode;
+SDL_VideoDisplay display;
-SDL_DisplayData*  didata;
+SDL_DisplayMode current_mode;
-uint32_t          it;
+SDL_DisplayData *didata;
-uint32_t          jt;
+uint32_t it;
-char*             override;
+uint32_t jt;
+char *override;
-/* By default Photon do not uses swap on VSYNC */
-phdata->swapinterval=0;
+/* By default Photon do not uses swap on VSYNC */
+phdata->swapinterval = 0;
-for (it=0; it<phdata->avail_rids; it++)
-{
+for (it = 0; it < phdata->avail_rids; it++) {
-didata=(SDL_DisplayData*)SDL_calloc(1, sizeof(SDL_DisplayData));
+didata = (SDL_DisplayData *) SDL_calloc(1, sizeof(SDL_DisplayData));
-if (didata==NULL)
+if (didata == NULL) {
-{
+/* memory allocation error */
-/* memory allocation error */
+SDL_OutOfMemory();
-SDL_OutOfMemory();
+return -1;
-return -1;
+}
-}
+/* Allocate two cursors with SDL_VIDEO_PHOTON_MAX_CURSOR_SIZE size */
-/* Allocate two cursors with SDL_VIDEO_PHOTON_MAX_CURSOR_SIZE size */
+/* and 128 bytes of spare place                                    */
-/* and 128 bytes of spare place                                    */
+didata->cursor_size =
-didata->cursor_size=((SDL_VIDEO_PHOTON_MAX_CURSOR_SIZE*4)>>3)+128;
+((SDL_VIDEO_PHOTON_MAX_CURSOR_SIZE * 4) >> 3) + 128;
-didata->cursor=(PhCursorDef_t*)SDL_calloc(1, didata->cursor_size);
+didata->cursor = (PhCursorDef_t *) SDL_calloc(1, didata->cursor_size);
-if (didata->cursor==NULL)
+if (didata->cursor == NULL) {
-{
+/* memory allocation error */
-/* memory allocation error */
+SDL_OutOfMemory();
-SDL_OutOfMemory();
+SDL_free(didata);
-SDL_free(didata);
+return -1;
-return -1;
+}
-}
+/* Initialize GF in case of OpenGL ES support is compiled in */
-/* Initialize GF in case of OpenGL ES support is compiled in */
+#if defined(SDL_VIDEO_OPENGL_ES)
-#if defined(SDL_VIDEO_OPENGL_ES)
+/* TODO: add real device detection versus multiple heads */
-/* TODO: add real device detection versus multiple heads */
+if (phdata->gfinitialized == SDL_TRUE) {
-if (phdata->gfinitialized==SDL_TRUE)
+status =
-{
+gf_display_attach(&didata->display, phdata->gfdev, it,
-status=gf_display_attach(&didata->display, phdata->gfdev, it, &didata->display_info);
+&didata->display_info);
-if (status!=GF_ERR_OK)
+if (status != GF_ERR_OK) {
-{
+/* Just shutdown GF, do not fail */
-/* Just shutdown GF, do not fail */
+gf_dev_detach(phdata->gfdev);
-gf_dev_detach(phdata->gfdev);
+phdata->gfinitialized = SDL_FALSE;
-phdata->gfinitialized=SDL_FALSE;
 }
 }
 #endif /* SDL_VIDEO_OPENGL_ES */
 /* Check if current device is not the same as target */
-if (phdata->current_device_id!=it)
+if (phdata->current_device_id != it) {
-{
+/* Set target device as default for Pd and Pg functions */
-/* Set target device as default for Pd and Pg functions */
+status = PdSetTargetDevice(NULL, phdata->rid[it]);
-status=PdSetTargetDevice(NULL, phdata->rid[it]);
+if (status != 0) {
-if (status!=0)
+SDL_SetError("Photon: Can't set default target device\n");
-{
+SDL_free(didata->cursor);
-SDL_SetError("Photon: Can't set default target device\n");
+SDL_free(didata);
+return -1;
+}
+phdata->current_device_id = it;
+}
+/* Store device id */
+didata->device_id = it;
+/* Query photon about graphics hardware caps and current video mode */
+status = PgGetGraphicsHWCaps(&hwcaps);
+if (status != 0) {
+SDL_SetError("Photon: Can't get graphics capabilities");
 SDL_free(didata->cursor);
 SDL_free(didata);
 return -1;
 }
-phdata->current_device_id=it;
-}
+/* Get current video mode details */
+status = PgGetVideoModeInfo(hwcaps.current_video_mode, &modeinfo);
-/* Store device id */
+if (status != 0) {
-didata->device_id=it;
+SDL_SetError("Photon: Can't get current video mode information");
+SDL_free(didata->cursor);
-/* Query photon about graphics hardware caps and current video mode */
+SDL_free(didata);
-status=PgGetGraphicsHWCaps(&hwcaps);
+return -1;
-if (status!=0)
+}
-{
-SDL_SetError("Photon: Can't get graphics capabilities");
+/* Setup current desktop mode for SDL */
-SDL_free(didata->cursor);
+SDL_zero(current_mode);
-SDL_free(didata);
+current_mode.w = modeinfo.width;
-return -1;
+current_mode.h = modeinfo.height;
-}
+current_mode.refresh_rate = hwcaps.current_rrate;
+current_mode.format = photon_image_to_sdl_pixelformat(modeinfo.type);
-/* Get current video mode details */
+current_mode.driverdata = NULL;
-status=PgGetVideoModeInfo(hwcaps.current_video_mode, &modeinfo);
-if (status!=0)
+/* Copy device name */
-{
+SDL_strlcpy(didata->description, hwcaps.chip_name,
-SDL_SetError("Photon: Can't get current video mode information");
+SDL_VIDEO_PHOTON_DEVICENAME_MAX - 1);
-SDL_free(didata->cursor);
-SDL_free(didata);
+/* Search device capabilities and possible workarounds */
-return -1;
+jt = 0;
-}
+do {
+if (photon_devicename[jt].name == NULL) {
-/* Setup current desktop mode for SDL */
+break;
-SDL_zero(current_mode);
+}
-current_mode.w=modeinfo.width;
+if (SDL_strncmp
-current_mode.h=modeinfo.height;
+(photon_devicename[jt].name, didata->description,
-current_mode.refresh_rate=hwcaps.current_rrate;
+SDL_strlen(photon_devicename[jt].name)) == 0) {
-current_mode.format=photon_image_to_sdl_pixelformat(modeinfo.type);
+didata->caps = photon_devicename[jt].caps;
-current_mode.driverdata=NULL;
+}
+jt++;
-/* Copy device name */
+} while (1);
-SDL_strlcpy(didata->description, hwcaps.chip_name, SDL_VIDEO_PHOTON_DEVICENAME_MAX-1);
+/* Initialize display structure */
-/* Search device capabilities and possible workarounds */
+SDL_zero(display);
-jt=0;
+display.desktop_mode = current_mode;
-do {
+display.current_mode = current_mode;
-if (photon_devicename[jt].name==NULL)
+display.driverdata = didata;
-{
+didata->current_mode = current_mode;
-break;
+SDL_AddVideoDisplay(&display);
-}
-if (SDL_strncmp(photon_devicename[jt].name, didata->description, SDL_strlen(photon_devicename[jt].name))==0)
+/* Check for environment variables which could override some SDL settings */
-{
+didata->custom_refresh = 0;
-didata->caps=photon_devicename[jt].caps;
+override = SDL_getenv("SDL_VIDEO_PHOTON_REFRESH_RATE");
-}
+if (override != NULL) {
-jt++;
+if (SDL_sscanf(override, "%u", &didata->custom_refresh) != 1) {
-} while(1);
+didata->custom_refresh = 0;
+}
-/* Initialize display structure */
+}
-SDL_zero(display);
+}
-display.desktop_mode=current_mode;
-display.current_mode=current_mode;
+/* Add photon input devices */
-display.driverdata=didata;
+status = photon_addinputdevices(_this);
-didata->current_mode=current_mode;
+if (status != 0) {
-SDL_AddVideoDisplay(&display);
+/* SDL error is set by photon_addinputdevices() function */
+return -1;
-/* Check for environment variables which could override some SDL settings */
+}
-didata->custom_refresh=0;
-override=SDL_getenv("SDL_VIDEO_PHOTON_REFRESH_RATE");
+/* Add photon renderer to SDL */
-if (override!=NULL)
+photon_addrenderdriver(_this);
-{
-if (SDL_sscanf(override, "%u", &didata->custom_refresh)!=1)
+/* video has been initialized successfully */
-{
+return 1;
-didata->custom_refresh=0;
+}
-}
-}
+void
-}
+photon_videoquit(_THIS)
+{
-/* Add photon input devices */
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-status=photon_addinputdevices(_this);
+SDL_DisplayData *didata;
-if (status!=0)
+uint32_t it;
-{
-/* SDL error is set by photon_addinputdevices() function */
+/* SDL will restore our desktop mode on exit */
-return -1;
+for (it = 0; it < _this->num_displays; it++) {
-}
+didata = _this->displays[it].driverdata;
-/* Add photon renderer to SDL */
+if (didata->cursor != NULL) {
-photon_addrenderdriver(_this);
+SDL_free(didata->cursor);
+}
-/* video has been initialized successfully */
+#if defined(SDL_VIDEO_OPENGL_ES)
-return 1;
+if (phdata->gfinitialized == SDL_TRUE) {
-}
-void photon_videoquit(_THIS)
-{
-SDL_VideoData*   phdata=(SDL_VideoData*)_this->driverdata;
-SDL_DisplayData* didata;
-uint32_t it;
-/* SDL will restore our desktop mode on exit */
-for(it=0; it<_this->num_displays; it++)
-{
-didata=_this->displays[it].driverdata;
-if (didata->cursor!=NULL)
-{
-SDL_free(didata->cursor);
-}
-#if defined(SDL_VIDEO_OPENGL_ES)
-if (phdata->gfinitialized==SDL_TRUE)
-{
 /* Detach GF display */
 gf_display_detach(didata->display);
 }
 #endif /* SDL_VIDEO_OPENGL_ES */
 }
 }
-void photon_getdisplaymodes(_THIS)
+void
-{
+photon_getdisplaymodes(_THIS)
-SDL_VideoData*    phdata=(SDL_VideoData*)_this->driverdata;
+{
-SDL_DisplayData*  didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-SDL_DisplayMode   mode;
+SDL_DisplayData *didata =
-PgVideoModes_t    modes;
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
-PgVideoModeInfo_t modeinfo;
+SDL_DisplayMode mode;
-int32_t           status;
+PgVideoModes_t modes;
-uint32_t          it;
+PgVideoModeInfo_t modeinfo;
-uint32_t          jt;
+int32_t status;
+uint32_t it;
-/* Check if current device is not the same as target */
+uint32_t jt;
-if (phdata->current_device_id!=didata->device_id)
-{
+/* Check if current device is not the same as target */
-/* Set target device as default for Pd and Pg functions */
+if (phdata->current_device_id != didata->device_id) {
-status=PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
+/* Set target device as default for Pd and Pg functions */
-if (status!=0)
+status = PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
-{
+if (status != 0) {
 SDL_SetError("Photon: Can't set default target device\n");
 return;
 }
-phdata->current_device_id=didata->device_id;
+phdata->current_device_id = didata->device_id;
 }
 /* Get array of available video modes */
-status=PgGetVideoModeList(&modes);
+status = PgGetVideoModeList(&modes);
-if (status!=0)
+if (status != 0) {
-{
+SDL_SetError("Photon: Can't get video mode list");
-SDL_SetError("Photon: Can't get video mode list");
+return;
-return;
+}
-}
+for (it = 0; it < modes.num_modes; it++) {
-for (it=0; it<modes.num_modes; it++)
+status = PgGetVideoModeInfo(modes.modes[it], &modeinfo);
-{
+if (status != 0) {
-status=PgGetVideoModeInfo(modes.modes[it], &modeinfo);
+/* Maybe something wrong with this particular mode, skip it */
-if (status!=0)
+continue;
-{
+}
-/* Maybe something wrong with this particular mode, skip it */
-continue;
+jt = 0;
-}
+do {
+if (modeinfo.refresh_rates[jt] != 0) {
-jt=0;
+mode.w = modeinfo.width;
-do {
+mode.h = modeinfo.height;
-if (modeinfo.refresh_rates[jt]!=0)
+mode.refresh_rate = modeinfo.refresh_rates[jt];
-{
+mode.format = photon_image_to_sdl_pixelformat(modeinfo.type);
-mode.w=modeinfo.width;
+mode.driverdata = NULL;
-mode.h=modeinfo.height;
+SDL_AddDisplayMode(_this->current_display, &mode);
-mode.refresh_rate=modeinfo.refresh_rates[jt];
+jt++;
-mode.format=photon_image_to_sdl_pixelformat(modeinfo.type);
+} else {
-mode.driverdata=NULL;
+break;
-SDL_AddDisplayMode(_this->current_display, &mode);
+}
-jt++;
+} while (1);
 }
-else
+}
-{
-break;
+int
-}
+photon_setdisplaymode(_THIS, SDL_DisplayMode * mode)
-} while(1);
+{
-}
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-}
+SDL_DisplayData *didata =
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
-int photon_setdisplaymode(_THIS, SDL_DisplayMode* mode)
+PgVideoModes_t modes;
-{
+PgVideoModeInfo_t modeinfo;
-SDL_VideoData*      phdata=(SDL_VideoData*)_this->driverdata;
+PgDisplaySettings_t modesettings;
-SDL_DisplayData*    didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+uint32_t refresh_rate = 0;
-PgVideoModes_t      modes;
+int32_t status;
-PgVideoModeInfo_t   modeinfo;
+uint32_t it;
-PgDisplaySettings_t modesettings;
-uint32_t refresh_rate=0;
+/* Check if current device is not the same as target */
-int32_t  status;
+if (phdata->current_device_id != didata->device_id) {
-uint32_t it;
+/* Set target device as default for Pd and Pg functions */
+status = PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
-/* Check if current device is not the same as target */
+if (status != 0) {
-if (phdata->current_device_id!=didata->device_id)
+SDL_SetError("Photon: Can't set default target device\n");
-{
+return;
-/* Set target device as default for Pd and Pg functions */
+}
-status=PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
+phdata->current_device_id = didata->device_id;
-if (status!=0)
+}
-{
-SDL_SetError("Photon: Can't set default target device\n");
+/* Get array of available video modes */
-return;
+status = PgGetVideoModeList(&modes);
-}
+if (status != 0) {
-phdata->current_device_id=didata->device_id;
+SDL_SetError("Photon: Can't get video mode list");
-}
+return;
+}
-/* Get array of available video modes */
-status=PgGetVideoModeList(&modes);
+/* Current display dimension and bpp are no more valid */
-if (status!=0)
+didata->current_mode.format = SDL_PIXELFORMAT_UNKNOWN;
-{
+didata->current_mode.w = 0;
-SDL_SetError("Photon: Can't get video mode list");
+didata->current_mode.h = 0;
-return;
-}
+/* Check if custom refresh rate requested */
+if (didata->custom_refresh != 0) {
-/* Current display dimension and bpp are no more valid */
+refresh_rate = didata->custom_refresh;
-didata->current_mode.format=SDL_PIXELFORMAT_UNKNOWN;
+} else {
-didata->current_mode.w=0;
+refresh_rate = mode->refresh_rate;
-didata->current_mode.h=0;
+}
-/* Check if custom refresh rate requested */
+/* Check if SDL GF driver needs to find appropriate refresh rate itself */
-if (didata->custom_refresh!=0)
+if (refresh_rate == 0) {
-{
+SDL_DisplayMode tempmode;
-refresh_rate=didata->custom_refresh;
-}
+/* Clear display mode structure */
-else
+SDL_memset(&tempmode, 0x00, sizeof(SDL_DisplayMode));
-{
+tempmode.refresh_rate = 0x0000FFFF;
-refresh_rate=mode->refresh_rate;
-}
+/* Check if window width and height matches one of our modes */
+for (it = 0; it < SDL_CurrentDisplay.num_display_modes; it++) {
-/* Check if SDL GF driver needs to find appropriate refresh rate itself */
+if ((SDL_CurrentDisplay.display_modes[it].w == mode->w) &&
-if (refresh_rate==0)
+(SDL_CurrentDisplay.display_modes[it].h == mode->h) &&
-{
+(SDL_CurrentDisplay.display_modes[it].format == mode->format))
-SDL_DisplayMode tempmode;
-/* Clear display mode structure */
-SDL_memset(&tempmode, 0x00, sizeof(SDL_DisplayMode));
-tempmode.refresh_rate=0x0000FFFF;
-/* Check if window width and height matches one of our modes */
-for (it=0; it<SDL_CurrentDisplay.num_display_modes; it++)
-{
-if ((SDL_CurrentDisplay.display_modes[it].w==mode->w) &&
-(SDL_CurrentDisplay.display_modes[it].h==mode->h) &&
-(SDL_CurrentDisplay.display_modes[it].format==mode->format))
-{
-/* Find the lowest refresh rate available */
-if (tempmode.refresh_rate>SDL_CurrentDisplay.display_modes[it].refresh_rate)
 {
-tempmode=SDL_CurrentDisplay.display_modes[it];
+/* Find the lowest refresh rate available */
+if (tempmode.refresh_rate >
+SDL_CurrentDisplay.display_modes[it].refresh_rate) {
+tempmode = SDL_CurrentDisplay.display_modes[it];
+}
 }
 }
-}
+if (tempmode.refresh_rate != 0x0000FFFF) {
-if (tempmode.refresh_rate!=0x0000FFFF)
+refresh_rate = tempmode.refresh_rate;
-{
+} else {
-refresh_rate=tempmode.refresh_rate;
+/* Let video driver decide what to do with this */
-}
+refresh_rate = 0;
-else
+}
-{
+}
-/* Let video driver decide what to do with this */
-refresh_rate=0;
+/* Check if SDL GF driver needs to check custom refresh rate */
-}
+if (didata->custom_refresh != 0) {
-}
+SDL_DisplayMode tempmode;
-/* Check if SDL GF driver needs to check custom refresh rate */
+/* Clear display mode structure */
-if (didata->custom_refresh!=0)
+SDL_memset(&tempmode, 0x00, sizeof(SDL_DisplayMode));
-{
+tempmode.refresh_rate = 0x0000FFFF;
-SDL_DisplayMode tempmode;
+/* Check if window width and height matches one of our modes */
-/* Clear display mode structure */
+for (it = 0; it < SDL_CurrentDisplay.num_display_modes; it++) {
-SDL_memset(&tempmode, 0x00, sizeof(SDL_DisplayMode));
+if ((SDL_CurrentDisplay.display_modes[it].w == mode->w) &&
-tempmode.refresh_rate=0x0000FFFF;
+(SDL_CurrentDisplay.display_modes[it].h == mode->h) &&
+(SDL_CurrentDisplay.display_modes[it].format == mode->format))
-/* Check if window width and height matches one of our modes */
-for (it=0; it<SDL_CurrentDisplay.num_display_modes; it++)
-{
-if ((SDL_CurrentDisplay.display_modes[it].w==mode->w) &&
-(SDL_CurrentDisplay.display_modes[it].h==mode->h) &&
-(SDL_CurrentDisplay.display_modes[it].format==mode->format))
-{
-/* Find the lowest refresh rate available */
-if (tempmode.refresh_rate>SDL_CurrentDisplay.display_modes[it].refresh_rate)
 {
-tempmode=SDL_CurrentDisplay.display_modes[it];
+/* Find the lowest refresh rate available */
+if (tempmode.refresh_rate >
+SDL_CurrentDisplay.display_modes[it].refresh_rate) {
+tempmode = SDL_CurrentDisplay.display_modes[it];
+}
+/* Check if requested refresh rate found */
+if (refresh_rate ==
+SDL_CurrentDisplay.display_modes[it].refresh_rate) {
+tempmode = SDL_CurrentDisplay.display_modes[it];
+break;
+}
 }
+}
-/* Check if requested refresh rate found */
+if (tempmode.refresh_rate != 0x0000FFFF) {
-if (refresh_rate==SDL_CurrentDisplay.display_modes[it].refresh_rate)
+refresh_rate = tempmode.refresh_rate;
-{
+} else {
-tempmode=SDL_CurrentDisplay.display_modes[it];
+/* Let video driver decide what to do with this */
-break;
+refresh_rate = 0;
+}
+}
+/* Find photon's video mode number */
+for (it = 0; it < modes.num_modes; it++) {
+uint32_t jt;
+uint32_t foundrefresh;
+/* Get current video mode details */
+status = PgGetVideoModeInfo(modes.modes[it], &modeinfo);
+if (status != 0) {
+/* Maybe something wrong with this particular mode, skip it */
+continue;
+}
+if ((modeinfo.width == mode->w) && (modeinfo.height == mode->h) &&
+(modeinfo.type == photon_sdl_to_image_pixelformat(mode->format)))
+{
+/* Mode is found, find requested refresh rate, this case is for */
+/* video drivers, which provide non-generic video modes.        */
+jt = 0;
+foundrefresh = 0;
+do {
+if (modeinfo.refresh_rates[jt] != 0) {
+if (modeinfo.refresh_rates[jt] == refresh_rate) {
+foundrefresh = 1;
+break;
+}
+jt++;
+} else {
+break;
+}
+} while (1);
+if (foundrefresh != 0) {
+break;
 }
 }
 }
-if (tempmode.refresh_rate!=0x0000FFFF)
-{
+/* Check if video mode has not been found */
-refresh_rate=tempmode.refresh_rate;
+if (it == modes.num_modes) {
-}
+SDL_SetError("Photon: Can't find appropriate video mode");
-else
+return -1;
-{
+}
-/* Let video driver decide what to do with this */
-refresh_rate=0;
+/* Fill mode settings */
-}
+modesettings.flags = 0x00000000;
-}
+modesettings.mode = modes.modes[it];
+modesettings.refresh = refresh_rate;
-/* Find photon's video mode number */
-for (it=0; it<modes.num_modes; it++)
+/* Finally set new video mode */
-{
+status = PgSetVideoMode(&modesettings);
-uint32_t jt;
+if (status != 0) {
-uint32_t foundrefresh;
+SDL_SetError("Photon: Can't set new video mode");
+return -1;
-/* Get current video mode details */
+}
-status=PgGetVideoModeInfo(modes.modes[it], &modeinfo);
-if (status!=0)
+/* Store new video mode parameters */
-{
+didata->current_mode = *mode;
-/* Maybe something wrong with this particular mode, skip it */
+didata->current_mode.refresh_rate = refresh_rate;
-continue;
-}
+return 0;
-if ((modeinfo.width==mode->w) && (modeinfo.height==mode->h) &&
+}
-(modeinfo.type==photon_sdl_to_image_pixelformat(mode->format)))
-{
+int
-/* Mode is found, find requested refresh rate, this case is for */
+photon_setdisplaypalette(_THIS, SDL_Palette * palette)
-/* video drivers, which provide non-generic video modes.        */
+{
-jt=0;
+SDL_DisplayData *didata =
-foundrefresh=0;
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
-do {
-if (modeinfo.refresh_rates[jt]!=0)
+/* Setting display palette operation has been failed */
-{
+return -1;
-if (modeinfo.refresh_rates[jt]==refresh_rate)
+}
-{
-foundrefresh=1;
+int
-break;
+photon_getdisplaypalette(_THIS, SDL_Palette * palette)
-}
+{
-jt++;
+SDL_DisplayData *didata =
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+/* Getting display palette operation has been failed */
+return -1;
+}
+int
+photon_setdisplaygammaramp(_THIS, Uint16 * ramp)
+{
+SDL_DisplayData *didata =
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+/* Setting display gamma ramp operation has been failed */
+return -1;
+}
+int
+photon_getdisplaygammaramp(_THIS, Uint16 * ramp)
+{
+/* Getting display gamma ramp operation has been failed */
+return -1;
+}
+int
+photon_createwindow(_THIS, SDL_Window * window)
+{
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
+SDL_DisplayData *didata =
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+SDL_WindowData *wdata;
+PhDim_t winsize;
+PhPoint_t winpos;
+PtArg_t winargs[32];
+uint32_t winargc = 0;
+int32_t status;
+PhRegion_t wregion;
+/* Allocate window internal data */
+wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
+if (wdata == NULL) {
+SDL_OutOfMemory();
+return -1;
+}
+/* Setup driver data for this window */
+window->driverdata = wdata;
+/* Set initial window title */
+if (window->title != NULL) {
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_TITLE, window->title, 0);
+} else {
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_TITLE, "", 0);
+}
+/* TODO: handle SDL_WINDOW_INPUT_GRABBED */
+/* Disable default window filling on redraw */
+PtSetArg(&winargs[winargc++], Pt_ARG_BASIC_FLAGS, Pt_TRUE,
+Pt_BASIC_PREVENT_FILL);
+/* Reset default managed flags to disabled state */
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE,
+Ph_WM_APP_DEF_MANAGED);
+/* Set which events we will not handle, let WM to handle them */
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE,
+Ph_WM_BACKDROP | Ph_WM_TOFRONT | Ph_WM_COLLAPSE | Ph_WM_FFRONT |
+Ph_WM_FOCUS | Ph_WM_HELP | Ph_WM_HIDE | Ph_WM_MAX |
+Ph_WM_MENU | Ph_WM_MOVE | Ph_WM_RESTORE | Ph_WM_TASKBAR |
+Ph_WM_TOBACK | Ph_WM_RESIZE);
+/* Reset default notify events to disable */
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_FALSE,
+Ph_WM_RESIZE | Ph_WM_CLOSE | Ph_WM_HELP);
+/* Set which events we will handle */
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
+Ph_WM_CLOSE | Ph_WM_COLLAPSE | Ph_WM_FOCUS | Ph_WM_MAX |
+Ph_WM_MOVE | Ph_WM_RESIZE | Ph_WM_RESTORE | Ph_WM_HIDE);
+/* Borderless window can't be resizeable */
+if ((window->flags & SDL_WINDOW_BORDERLESS) == SDL_WINDOW_BORDERLESS) {
+window->flags &= ~(SDL_WINDOW_RESIZABLE);
+}
+/* Reset all default decorations */
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE,
+Ph_WM_APP_DEF_RENDER);
+/* Fullscreen window has its own decorations */
+if ((window->flags & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN) {
+window->flags |= SDL_WINDOW_BORDERLESS;
+window->flags &= ~(SDL_WINDOW_RESIZABLE);
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE,
+Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_TITLE);
+} else {
+uint32_t decorations =
+Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_MENU | Ph_WM_RENDER_MIN |
+Ph_WM_RENDER_TITLE | Ph_WM_RENDER_MOVE;
+if ((window->flags & SDL_WINDOW_RESIZABLE) == SDL_WINDOW_RESIZABLE) {
+decorations |=
+Ph_WM_RENDER_BORDER | Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX;
+PtSetArg(&winargs[winargc++], Pt_ARG_RESIZE_FLAGS, Pt_TRUE,
+Pt_RESIZE_XY_AS_REQUIRED);
+}
+if ((window->flags & SDL_WINDOW_BORDERLESS) != SDL_WINDOW_BORDERLESS) {
+decorations |= Ph_WM_RENDER_BORDER;
+}
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE,
+decorations);
+}
+/* Set initial window state */
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_STATE, Pt_FALSE,
+Ph_WM_STATE_ISFOCUS);
+PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_STATE, Pt_TRUE,
+Ph_WM_STATE_ISALTKEY);
+/* Set window dimension */
+winsize.w = window->w;
+winsize.h = window->h;
+PtSetArg(&winargs[winargc++], Pt_ARG_DIM, &winsize, 0);
+/* Check if upper level requests WM to position window */
+if ((window->x == SDL_WINDOWPOS_UNDEFINED)
+&& (window->y == SDL_WINDOWPOS_UNDEFINED)) {
+/* Do not set widget position, let WM to set it */
+} else {
+if (window->x == SDL_WINDOWPOS_UNDEFINED) {
+window->x = 0;
+}
+if (window->y == SDL_WINDOWPOS_UNDEFINED) {
+window->y = 0;
+}
+if (window->x == SDL_WINDOWPOS_CENTERED) {
+window->x = (didata->current_mode.w - window->w) / 2;
+}
+if (window->y == SDL_WINDOWPOS_CENTERED) {
+window->y = (didata->current_mode.h - window->h) / 2;
+}
+/* Now set window position */
+winpos.x = window->x;
+winpos.y = window->y;
+PtSetArg(&winargs[winargc++], Pt_ARG_POS, &winpos, 0);
+}
+/* Check if window must support OpenGL ES rendering */
+if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {
+#if defined(SDL_VIDEO_OPENGL_ES)
+EGLBoolean initstatus;
+/* Check if GF was initialized correctly */
+if (phdata->gfinitialized == SDL_FALSE) {
+SDL_SetError
+("Photon: GF initialization failed, no OpenGL ES support");
+return -1;
+}
+/* Mark this window as OpenGL ES compatible */
+wdata->uses_gles = SDL_TRUE;
+/* Create connection to OpenGL ES */
+if (phdata->egldisplay == EGL_NO_DISPLAY) {
+phdata->egldisplay = eglGetDisplay(phdata->gfdev);
+if (phdata->egldisplay == EGL_NO_DISPLAY) {
+SDL_SetError("Photon: Can't get connection to OpenGL ES");
+return -1;
 }
-else
-{
+/* Initialize OpenGL ES library, ignore EGL version */
-break;
+initstatus = eglInitialize(phdata->egldisplay, NULL, NULL);
+if (initstatus != EGL_TRUE) {
+SDL_SetError("Photon: Can't init OpenGL ES library");
+return -1;
 }
-} while(1);
+}
-if (foundrefresh!=0)
-{
+/* Increment GL ES reference count usage */
-break;
+phdata->egl_refcount++;
-}
+#else
-}
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
-}
+return -1;
+#endif /* SDL_VIDEO_OPENGL_ES */
-/* Check if video mode has not been found */
+}
-if (it==modes.num_modes)
-{
+/* Finally create the window */
-SDL_SetError("Photon: Can't find appropriate video mode");
+wdata->window = PtCreateWidget(PtWindow, Pt_NO_PARENT, winargc, winargs);
-return -1;
+if (wdata->window == NULL) {
-}
+SDL_SetError("Photon: Can't create window widget");
+SDL_free(wdata);
-/* Fill mode settings */
+return -1;
-modesettings.flags=0x00000000;
+}
-modesettings.mode=modes.modes[it];
-modesettings.refresh=refresh_rate;
+/* Show widget */
+status = PtRealizeWidget(wdata->window);
-/* Finally set new video mode */
+if (status != 0) {
-status=PgSetVideoMode(&modesettings);
+SDL_SetError("Photon: Can't realize window widget");
-if (status!=0)
+PtDestroyWidget(wdata->window);
-{
+SDL_free(wdata);
-SDL_SetError("Photon: Can't set new video mode");
+return;
-return -1;
+}
-}
+/* Just created SDL window always gets focus */
-/* Store new video mode parameters */
+window->flags |= SDL_WINDOW_INPUT_FOCUS;
-didata->current_mode=*mode;
-didata->current_mode.refresh_rate=refresh_rate;
+/* Create window-specific cursor after creation */
+if (didata->cursor_visible == SDL_TRUE) {
-return 0;
+/* Setup cursor type. shape and default color */
-}
+PtSetResource(wdata->window, Pt_ARG_CURSOR_COLOR,
+Ph_CURSOR_DEFAULT_COLOR, 0);
-int photon_setdisplaypalette(_THIS, SDL_Palette* palette)
+PtSetResource(wdata->window, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_BITMAP, 0);
-{
+PtSetResource(wdata->window, Pt_ARG_BITMAP_CURSOR, didata->cursor,
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+didata->cursor->hdr.len + sizeof(PhRegionDataHdr_t));
+} else {
-/* Setting display palette operation has been failed */
+PtSetResource(wdata->window, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_NONE, 0);
-return -1;
+}
-}
+/* Set window region sensible to mouse motion events */
-int photon_getdisplaypalette(_THIS, SDL_Palette* palette)
+status =
-{
+PhRegionQuery(PtWidgetRid(wdata->window), &wregion, NULL, NULL, 0);
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+if (status != 0) {
+SDL_SetError
-/* Getting display palette operation has been failed */
+("Photon: Can't set region sensivity to mouse motion events");
-return -1;
+PtDestroyWidget(wdata->window);
-}
+SDL_free(wdata);
+return -1;
-int photon_setdisplaygammaramp(_THIS, Uint16* ramp)
+}
-{
+wregion.events_sense |=
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+Ph_EV_PTR_MOTION_BUTTON | Ph_EV_PTR_MOTION_NOBUTTON;
+status = PhRegionChange(Ph_REGION_EV_SENSE, 0, &wregion, NULL, NULL);
-/* Setting display gamma ramp operation has been failed */
+if (status < 0) {
-return -1;
+SDL_SetError("Photon: Can't change region sensivity");
-}
+PtDestroyWidget(wdata->window);
+SDL_free(wdata);
-int photon_getdisplaygammaramp(_THIS, Uint16* ramp)
+return -1;
-{
+}
-/* Getting display gamma ramp operation has been failed */
-return -1;
+/* Flush all widget operations again */
-}
+PtFlush();
-int photon_createwindow(_THIS, SDL_Window* window)
+/* By default last created window got a input focus */
-{
+SDL_SetKeyboardFocus(0, window->id);
-SDL_VideoData*   phdata=(SDL_VideoData*)_this->driverdata;
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+/* Window has been successfully created */
-SDL_WindowData*  wdata;
+return 0;
-PhDim_t          winsize;
+}
-PhPoint_t        winpos;
-PtArg_t          winargs[32];
+int
-uint32_t         winargc=0;
+photon_createwindowfrom(_THIS, SDL_Window * window, const void *data)
-int32_t          status;
+{
-PhRegion_t       wregion;
+/* TODO: it is possible */
-/* Allocate window internal data */
+/* Failed to create window from another window */
-wdata=(SDL_WindowData*)SDL_calloc(1, sizeof(SDL_WindowData));
+return -1;
-if (wdata==NULL)
+}
-{
-SDL_OutOfMemory();
+void
-return -1;
+photon_setwindowtitle(_THIS, SDL_Window * window)
-}
+{
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-/* Setup driver data for this window */
+int32_t status;
-window->driverdata=wdata;
+/* Set window title */
-/* Set initial window title */
+if (window->title != NULL) {
-if (window->title!=NULL)
+status =
-{
+PtSetResource(wdata->window, Pt_ARG_WINDOW_TITLE, window->title,
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_TITLE, window->title, 0);
+0);
-}
+} else {
-else
+status = PtSetResource(wdata->window, Pt_ARG_WINDOW_TITLE, "", 0);
-{
+}
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_TITLE, "", 0);
-}
+if (status != 0) {
+SDL_SetError("Photon: Can't set window title");
-/* TODO: handle SDL_WINDOW_INPUT_GRABBED */
+}
-/* Disable default window filling on redraw */
+/* Flush all widget operations */
-PtSetArg(&winargs[winargc++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL);
+PtFlush();
+}
-/* Reset default managed flags to disabled state */
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE,
+void
-Ph_WM_APP_DEF_MANAGED);
+photon_setwindowicon(_THIS, SDL_Window * window, SDL_Surface * icon)
-/* Set which events we will not handle, let WM to handle them */
+{
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE,
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-Ph_WM_BACKDROP | Ph_WM_TOFRONT | Ph_WM_COLLAPSE | Ph_WM_FFRONT  |
+int32_t status;
-Ph_WM_FOCUS    | Ph_WM_HELP    | Ph_WM_HIDE     | Ph_WM_MAX     |
-Ph_WM_MENU     | Ph_WM_MOVE    | Ph_WM_RESTORE  | Ph_WM_TASKBAR |
+/* TODO: Use iconify ? */
-Ph_WM_TOBACK   | Ph_WM_RESIZE);
+/* Flush all widget operations */
-/* Reset default notify events to disable */
+PtFlush();
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_FALSE,
+}
-Ph_WM_RESIZE | Ph_WM_CLOSE | Ph_WM_HELP);
-/* Set which events we will handle */
+void
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
+photon_setwindowposition(_THIS, SDL_Window * window)
-Ph_WM_CLOSE | Ph_WM_COLLAPSE | Ph_WM_FOCUS   | Ph_WM_MAX  |
+{
-Ph_WM_MOVE  | Ph_WM_RESIZE   | Ph_WM_RESTORE | Ph_WM_HIDE);
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+SDL_DisplayData *didata =
-/* Borderless window can't be resizeable */
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
-if ((window->flags & SDL_WINDOW_BORDERLESS)==SDL_WINDOW_BORDERLESS)
+PhPoint_t winpos;
-{
+int32_t status;
-window->flags&=~(SDL_WINDOW_RESIZABLE);
-}
+/* Check if upper level requests WM to position window */
+if ((window->x == SDL_WINDOWPOS_UNDEFINED)
-/* Reset all default decorations */
+&& (window->y == SDL_WINDOWPOS_UNDEFINED)) {
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Ph_WM_APP_DEF_RENDER);
+/* Do not set widget position, let WM to set it */
+} else {
-/* Fullscreen window has its own decorations */
+if (window->x == SDL_WINDOWPOS_UNDEFINED) {
-if ((window->flags & SDL_WINDOW_FULLSCREEN)==SDL_WINDOW_FULLSCREEN)
+window->x = 0;
-{
+}
-window->flags|=SDL_WINDOW_BORDERLESS;
+if (window->y == SDL_WINDOWPOS_UNDEFINED) {
-window->flags&=~(SDL_WINDOW_RESIZABLE);
+window->y = 0;
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE,
+}
-Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_TITLE);
+if (window->x == SDL_WINDOWPOS_CENTERED) {
-}
+window->x = (didata->current_mode.w - window->w) / 2;
-else
+}
-{
+if (window->y == SDL_WINDOWPOS_CENTERED) {
-uint32_t decorations=Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_MENU | Ph_WM_RENDER_MIN |
+window->y = (didata->current_mode.h - window->h) / 2;
-Ph_WM_RENDER_TITLE | Ph_WM_RENDER_MOVE;
+}
-if ((window->flags & SDL_WINDOW_RESIZABLE)==SDL_WINDOW_RESIZABLE)
+/* Now set window position */
-{
+winpos.x = window->x;
-decorations|=Ph_WM_RENDER_BORDER | Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX;
+winpos.y = window->y;
-PtSetArg(&winargs[winargc++], Pt_ARG_RESIZE_FLAGS, Pt_TRUE, Pt_RESIZE_XY_AS_REQUIRED);
+status = PtSetResource(wdata->window, Pt_ARG_POS, &winpos, 0);
-}
+if (status != 0) {
-if ((window->flags & SDL_WINDOW_BORDERLESS)!=SDL_WINDOW_BORDERLESS)
+SDL_SetError("Photon: Can't set window position");
-{
+}
-decorations|=Ph_WM_RENDER_BORDER;
+}
-}
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, decorations);
+/* Flush all widget operations */
-}
+PtFlush();
+}
-/* Set initial window state */
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISFOCUS);
+void
-PtSetArg(&winargs[winargc++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISALTKEY);
+photon_setwindowsize(_THIS, SDL_Window * window)
+{
-/* Set window dimension */
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-winsize.w=window->w;
+PhDim_t winsize;
-winsize.h=window->h;
+int32_t status;
-PtSetArg(&winargs[winargc++], Pt_ARG_DIM, &winsize, 0);
+winsize.w = window->w;
-/* Check if upper level requests WM to position window */
+winsize.h = window->h;
-if ((window->x==SDL_WINDOWPOS_UNDEFINED) && (window->y==SDL_WINDOWPOS_UNDEFINED))
-{
+status = PtSetResource(wdata->window, Pt_ARG_DIM, &winsize, 0);
-/* Do not set widget position, let WM to set it */
+if (status != 0) {
-}
+SDL_SetError("Photon: Can't set window size");
-else
+}
-{
-if (window->x==SDL_WINDOWPOS_UNDEFINED)
+/* Flush all widget operations */
-{
+PtFlush();
-window->x=0;
+}
-}
-if (window->y==SDL_WINDOWPOS_UNDEFINED)
+void
-{
+photon_showwindow(_THIS, SDL_Window * window)
-window->y=0;
+{
-}
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-if (window->x==SDL_WINDOWPOS_CENTERED)
+int32_t status;
-{
-window->x=(didata->current_mode.w-window->w)/2;
+/* Bring focus to window and put it in front of others */
-}
+PtWindowToFront(wdata->window);
-if (window->y==SDL_WINDOWPOS_CENTERED)
-{
+/* Flush all widget operations */
-window->y=(didata->current_mode.h-window->h)/2;
+PtFlush();
 }
-/* Now set window position */
+void
-winpos.x=window->x;
+photon_hidewindow(_THIS, SDL_Window * window)
-winpos.y=window->y;
+{
-PtSetArg(&winargs[winargc++], Pt_ARG_POS, &winpos, 0);
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-}
+PhWindowEvent_t winevent;
+int32_t status;
-/* Check if window must support OpenGL ES rendering */
-if ((window->flags & SDL_WINDOW_OPENGL)==SDL_WINDOW_OPENGL)
+SDL_memset(&winevent, 0x00, sizeof(PhWindowEvent_t));
-{
+winevent.event_f = Ph_WM_HIDE;
-#if defined(SDL_VIDEO_OPENGL_ES)
+winevent.rid = PtWidgetRid(wdata->window);
-EGLBoolean initstatus;
+winevent.event_state = Ph_WM_EVSTATE_HIDE;
-/* Check if GF was initialized correctly */
+status = PtForwardWindowEvent(&winevent);
-if (phdata->gfinitialized==SDL_FALSE)
+if (status != 0) {
-{
+SDL_SetError("Photon: Can't hide window");
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+}
-return -1;
-}
+/* Flush all widget operations */
+PtFlush();
-/* Mark this window as OpenGL ES compatible */
+}
-wdata->uses_gles=SDL_TRUE;
+void
-/* Create connection to OpenGL ES */
+photon_raisewindow(_THIS, SDL_Window * window)
-if (phdata->egldisplay==EGL_NO_DISPLAY)
+{
-{
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-phdata->egldisplay=eglGetDisplay(phdata->gfdev);
+PhWindowEvent_t winevent;
-if (phdata->egldisplay==EGL_NO_DISPLAY)
+int32_t status;
-{
-SDL_SetError("Photon: Can't get connection to OpenGL ES");
+SDL_memset(&winevent, 0x00, sizeof(PhWindowEvent_t));
-return -1;
+winevent.event_f = Ph_WM_HIDE;
+winevent.rid = PtWidgetRid(wdata->window);
+winevent.event_state = Ph_WM_EVSTATE_UNHIDE;
+status = PtForwardWindowEvent(&winevent);
+if (status != 0) {
+SDL_SetError("Photon: Can't hide window");
+}
+/* Flush all widget operations */
+PtFlush();
+}
+void
+photon_maximizewindow(_THIS, SDL_Window * window)
+{
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+PhWindowEvent_t winevent;
+int32_t status;
+/* Flush all widget operations */
+PtFlush();
+}
+void
+photon_minimizewindow(_THIS, SDL_Window * window)
+{
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+PhWindowEvent_t winevent;
+int32_t status;
+SDL_memset(&winevent, 0x00, sizeof(PhWindowEvent_t));
+winevent.event_f = Ph_WM_HIDE;
+winevent.rid = PtWidgetRid(wdata->window);
+winevent.event_state = Ph_WM_EVSTATE_HIDE;
+status = PtForwardWindowEvent(&winevent);
+if (status != 0) {
+SDL_SetError("Photon: Can't hide window");
+}
+/* Flush all widget operations */
+PtFlush();
+}
+void
+photon_restorewindow(_THIS, SDL_Window * window)
+{
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+PhWindowEvent_t winevent;
+int32_t status;
+/* Flush all widget operations */
+PtFlush();
+}
+void
+photon_setwindowgrab(_THIS, SDL_Window * window)
+{
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+PhWindowEvent_t winevent;
+int32_t status;
+/* Flush all widget operations */
+PtFlush();
+}
+void
+photon_destroywindow(_THIS, SDL_Window * window)
+{
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
+SDL_DisplayData *didata =
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
+int32_t status;
+if (wdata != NULL) {
+status = PtDestroyWidget(wdata->window);
+if (status != 0) {
+SDL_SetError("Photon: Can't destroy window widget");
+}
+wdata->window = NULL;
+#if defined(SDL_VIDEO_OPENGL_ES)
+if (phdata->gfinitialized == SDL_TRUE) {
+/* Destroy OpenGL ES surface if it was created */
+if (wdata->gles_surface != EGL_NO_SURFACE) {
+eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
 }
-/* Initialize OpenGL ES library, ignore EGL version */
+/* Free OpenGL ES target surface */
-initstatus=eglInitialize(phdata->egldisplay, NULL, NULL);
+if (wdata->gfsurface != NULL) {
-if (initstatus!=EGL_TRUE)
+gf_surface_free(wdata->gfsurface);
-{
-SDL_SetError("Photon: Can't init OpenGL ES library");
-return -1;
 }
-}
+phdata->egl_refcount--;
-/* Increment GL ES reference count usage */
+if (phdata->egl_refcount == 0) {
-phdata->egl_refcount++;
+/* Terminate connection to OpenGL ES */
-#else
+if (phdata->egldisplay != EGL_NO_DISPLAY) {
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+eglTerminate(phdata->egldisplay);
-return -1;
+phdata->egldisplay = EGL_NO_DISPLAY;
-#endif /* SDL_VIDEO_OPENGL_ES */
+}
-}
-/* Finally create the window */
-wdata->window=PtCreateWidget(PtWindow, Pt_NO_PARENT, winargc, winargs);
-if (wdata->window==NULL)
-{
-SDL_SetError("Photon: Can't create window widget");
-SDL_free(wdata);
-return -1;
-}
-/* Show widget */
-status=PtRealizeWidget(wdata->window);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't realize window widget");
-PtDestroyWidget(wdata->window);
-SDL_free(wdata);
-return;
-}
-/* Just created SDL window always gets focus */
-window->flags|=SDL_WINDOW_INPUT_FOCUS;
-/* Create window-specific cursor after creation */
-if (didata->cursor_visible==SDL_TRUE)
-{
-/* Setup cursor type. shape and default color */
-PtSetResource(wdata->window, Pt_ARG_CURSOR_COLOR, Ph_CURSOR_DEFAULT_COLOR, 0);
-PtSetResource(wdata->window, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_BITMAP, 0);
-PtSetResource(wdata->window, Pt_ARG_BITMAP_CURSOR, didata->cursor, didata->cursor->hdr.len+sizeof(PhRegionDataHdr_t));
-}
-else
-{
-PtSetResource(wdata->window, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_NONE, 0);
-}
-/* Set window region sensible to mouse motion events */
-status=PhRegionQuery(PtWidgetRid(wdata->window), &wregion, NULL, NULL, 0);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't set region sensivity to mouse motion events");
-PtDestroyWidget(wdata->window);
-SDL_free(wdata);
-return -1;
-}
-wregion.events_sense|=Ph_EV_PTR_MOTION_BUTTON | Ph_EV_PTR_MOTION_NOBUTTON;
-status=PhRegionChange(Ph_REGION_EV_SENSE, 0, &wregion, NULL, NULL);
-if (status<0)
-{
-SDL_SetError("Photon: Can't change region sensivity");
-PtDestroyWidget(wdata->window);
-SDL_free(wdata);
-return -1;
-}
-/* Flush all widget operations again */
-PtFlush();
-/* By default last created window got a input focus */
-SDL_SetKeyboardFocus(0, window->id);
-/* Window has been successfully created */
-return 0;
-}
-int photon_createwindowfrom(_THIS, SDL_Window* window, const void* data)
-{
-/* TODO: it is possible */
-/* Failed to create window from another window */
-return -1;
-}
-void photon_setwindowtitle(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-int32_t status;
-/* Set window title */
-if (window->title!=NULL)
-{
-status=PtSetResource(wdata->window, Pt_ARG_WINDOW_TITLE, window->title, 0);
-}
-else
-{
-status=PtSetResource(wdata->window, Pt_ARG_WINDOW_TITLE, "", 0);
-}
-if (status!=0)
-{
-SDL_SetError("Photon: Can't set window title");
-}
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_setwindowicon(_THIS, SDL_Window* window, SDL_Surface* icon)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-int32_t   status;
-/* TODO: Use iconify ? */
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_setwindowposition(_THIS, SDL_Window* window)
-{
-SDL_WindowData*  wdata=(SDL_WindowData*)window->driverdata;
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
-PhPoint_t winpos;
-int32_t   status;
-/* Check if upper level requests WM to position window */
-if ((window->x==SDL_WINDOWPOS_UNDEFINED) && (window->y==SDL_WINDOWPOS_UNDEFINED))
-{
-/* Do not set widget position, let WM to set it */
-}
-else
-{
-if (window->x==SDL_WINDOWPOS_UNDEFINED)
-{
-window->x=0;
-}
-if (window->y==SDL_WINDOWPOS_UNDEFINED)
-{
-window->y=0;
-}
-if (window->x==SDL_WINDOWPOS_CENTERED)
-{
-window->x=(didata->current_mode.w-window->w)/2;
-}
-if (window->y==SDL_WINDOWPOS_CENTERED)
-{
-window->y=(didata->current_mode.h-window->h)/2;
-}
-/* Now set window position */
-winpos.x=window->x;
-winpos.y=window->y;
-status=PtSetResource(wdata->window, Pt_ARG_POS, &winpos, 0);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't set window position");
-}
-}
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_setwindowsize(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhDim_t winsize;
-int32_t status;
-winsize.w=window->w;
-winsize.h=window->h;
-status=PtSetResource(wdata->window, Pt_ARG_DIM, &winsize, 0);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't set window size");
-}
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_showwindow(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-int32_t status;
-/* Bring focus to window and put it in front of others */
-PtWindowToFront(wdata->window);
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_hidewindow(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhWindowEvent_t winevent;
-int32_t status;
-SDL_memset(&winevent, 0x00, sizeof(PhWindowEvent_t));
-winevent.event_f=Ph_WM_HIDE;
-winevent.rid=PtWidgetRid(wdata->window);
-winevent.event_state=Ph_WM_EVSTATE_HIDE;
-status=PtForwardWindowEvent(&winevent);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't hide window");
-}
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_raisewindow(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhWindowEvent_t winevent;
-int32_t status;
-SDL_memset(&winevent, 0x00, sizeof(PhWindowEvent_t));
-winevent.event_f=Ph_WM_HIDE;
-winevent.rid=PtWidgetRid(wdata->window);
-winevent.event_state=Ph_WM_EVSTATE_UNHIDE;
-status=PtForwardWindowEvent(&winevent);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't hide window");
-}
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_maximizewindow(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhWindowEvent_t winevent;
-int32_t status;
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_minimizewindow(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhWindowEvent_t winevent;
-int32_t status;
-SDL_memset(&winevent, 0x00, sizeof(PhWindowEvent_t));
-winevent.event_f=Ph_WM_HIDE;
-winevent.rid=PtWidgetRid(wdata->window);
-winevent.event_state=Ph_WM_EVSTATE_HIDE;
-status=PtForwardWindowEvent(&winevent);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't hide window");
-}
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_restorewindow(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhWindowEvent_t winevent;
-int32_t status;
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_setwindowgrab(_THIS, SDL_Window* window)
-{
-SDL_WindowData* wdata=(SDL_WindowData*)window->driverdata;
-PhWindowEvent_t winevent;
-int32_t status;
-/* Flush all widget operations */
-PtFlush();
-}
-void photon_destroywindow(_THIS, SDL_Window* window)
-{
-SDL_VideoData*   phdata=(SDL_VideoData*)_this->driverdata;
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
-SDL_WindowData*  wdata=(SDL_WindowData*)window->driverdata;
-int32_t status;
-if (wdata!=NULL)
-{
-status=PtDestroyWidget(wdata->window);
-if (status!=0)
-{
-SDL_SetError("Photon: Can't destroy window widget");
-}
-wdata->window=NULL;
-#if defined(SDL_VIDEO_OPENGL_ES)
-if (phdata->gfinitialized==SDL_TRUE)
-{
-/* Destroy OpenGL ES surface if it was created */
-if (wdata->gles_surface!=EGL_NO_SURFACE)
-{
-eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
 }
+}
-/* Free OpenGL ES target surface */
+#endif /* SDL_VIDEO_OPENGL_ES */
-if (wdata->gfsurface!=NULL)
+}
-{
-gf_surface_free(wdata->gfsurface);
+/* Flush all widget operations */
-}
+PtFlush();
-phdata->egl_refcount--;
-if (phdata->egl_refcount==0)
-{
-/* Terminate connection to OpenGL ES */
-if (phdata->egldisplay!=EGL_NO_DISPLAY)
-{
-eglTerminate(phdata->egldisplay);
-phdata->egldisplay=EGL_NO_DISPLAY;
-}
-}
-}
-#endif /* SDL_VIDEO_OPENGL_ES */
-}
-/* Flush all widget operations */
-PtFlush();
 }
 /*****************************************************************************/
 /* SDL Window Manager function                                               */
 /*****************************************************************************/
-SDL_bool photon_getwindowwminfo(_THIS, SDL_Window* window, struct SDL_SysWMinfo* info)
+SDL_bool
-{
+photon_getwindowwminfo(_THIS, SDL_Window * window, struct SDL_SysWMinfo *info)
-if (info->version.major<=SDL_MAJOR_VERSION)
+{
-{
+if (info->version.major <= SDL_MAJOR_VERSION) {
 return SDL_TRUE;
-}
+} else {
-else
+SDL_SetError("application not compiled with SDL %d.%d\n",
-{
+SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
-SDL_SetError("application not compiled with SDL %d.%d\n", SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
+return SDL_FALSE;
-return SDL_FALSE;
+}
-}
+/* Failed to get window manager information */
-/* Failed to get window manager information */
+return SDL_FALSE;
-return SDL_FALSE;
 }
 /*****************************************************************************/
 /* SDL OpenGL/OpenGL ES functions                                            */
 /*****************************************************************************/
-int photon_gl_loadlibrary(_THIS, const char* path)
+int
-{
+photon_gl_loadlibrary(_THIS, const char *path)
-#if defined(SDL_VIDEO_OPENGL_ES)
+{
-SDL_VideoData* phdata=(SDL_VideoData*)_this->driverdata;
+#if defined(SDL_VIDEO_OPENGL_ES)
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-if (phdata->gfinitialized!=SDL_TRUE)
-{
+if (phdata->gfinitialized != SDL_TRUE) {
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+SDL_SetError
-return NULL;
+("Photon: GF initialization failed, no OpenGL ES support");
-}
+return NULL;
+}
-/* Check if OpenGL ES library is specified for GF driver */
-if (path==NULL)
+/* Check if OpenGL ES library is specified for GF driver */
-{
+if (path == NULL) {
-path=SDL_getenv("SDL_OPENGL_LIBRARY");
+path = SDL_getenv("SDL_OPENGL_LIBRARY");
-if (path==NULL)
+if (path == NULL) {
-{
+path = SDL_getenv("SDL_OPENGLES_LIBRARY");
-path=SDL_getenv("SDL_OPENGLES_LIBRARY");
+}
 }
-}
+/* Check if default library loading requested */
-/* Check if default library loading requested */
+if (path == NULL) {
-if (path==NULL)
+/* Already linked with GF library which provides egl* subset of  */
-{
+/* functions, use Common profile of OpenGL ES library by default */
-/* Already linked with GF library which provides egl* subset of  */
+path = "/usr/lib/libGLES_CM.so.1";
-/* functions, use Common profile of OpenGL ES library by default */
+}
-path="/usr/lib/libGLES_CM.so.1";
-}
+/* Load dynamic library */
+_this->gl_config.dll_handle = SDL_LoadObject(path);
-/* Load dynamic library */
+if (!_this->gl_config.dll_handle) {
-_this->gl_config.dll_handle=SDL_LoadObject(path);
+/* Failed to load new GL ES library */
-if (!_this->gl_config.dll_handle)
+SDL_SetError("Photon: Failed to locate OpenGL ES library");
-{
+return -1;
-/* Failed to load new GL ES library */
+}
-SDL_SetError("Photon: Failed to locate OpenGL ES library");
-return -1;
+/* Store OpenGL ES library path and name */
-}
+SDL_strlcpy(_this->gl_config.driver_path, path,
+SDL_arraysize(_this->gl_config.driver_path));
-/* Store OpenGL ES library path and name */
-SDL_strlcpy(_this->gl_config.driver_path, path, SDL_arraysize(_this->gl_config.driver_path));
+/* New OpenGL ES library is loaded */
+return 0;
-/* New OpenGL ES library is loaded */
+#else
-return 0;
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
-#else
+return -1;
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+#endif /* SDL_VIDEO_OPENGL_ES */
-return -1;
+}
-#endif /* SDL_VIDEO_OPENGL_ES */
-}
+void *
+photon_gl_getprocaddres(_THIS, const char *proc)
-void* photon_gl_getprocaddres(_THIS, const char* proc)
+{
-{
+#if defined(SDL_VIDEO_OPENGL_ES)
-#if defined(SDL_VIDEO_OPENGL_ES)
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-SDL_VideoData* phdata=(SDL_VideoData*)_this->driverdata;
+void *function_address;
-void* function_address;
+if (phdata->gfinitialized != SDL_TRUE) {
-if (phdata->gfinitialized!=SDL_TRUE)
+SDL_SetError
-{
+("Photon: GF initialization failed, no OpenGL ES support");
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+return NULL;
-return NULL;
+}
-}
+/* Try to get function address through the egl interface */
-/* Try to get function address through the egl interface */
+function_address = eglGetProcAddress(proc);
-function_address=eglGetProcAddress(proc);
+if (function_address != NULL) {
-if (function_address!=NULL)
+return function_address;
-{
+}
-return function_address;
-}
+/* Then try to get function in the OpenGL ES library */
+if (_this->gl_config.dll_handle) {
-/* Then try to get function in the OpenGL ES library */
+function_address =
-if (_this->gl_config.dll_handle)
+SDL_LoadFunction(_this->gl_config.dll_handle, proc);
-{
+if (function_address != NULL) {
-function_address=SDL_LoadFunction(_this->gl_config.dll_handle, proc);
-if (function_address!=NULL)
-{
 return function_address;
 }
 }
 /* Add emulated OpenGL ES 1.1 functions */
-if (SDL_strcmp(proc, "glTexParameteri")==0)
+if (SDL_strcmp(proc, "glTexParameteri") == 0) {
-{
+return glTexParameteri;
-return glTexParameteri;
+}
-}
+if (SDL_strcmp(proc, "glTexParameteriv") == 0) {
-if (SDL_strcmp(proc, "glTexParameteriv")==0)
+return glTexParameteriv;
-{
+}
-return glTexParameteriv;
+if (SDL_strcmp(proc, "glColor4ub") == 0) {
-}
+return glColor4ub;
-if (SDL_strcmp(proc, "glColor4ub")==0)
+}
-{
-return glColor4ub;
+/* Failed to get GL ES function address pointer */
-}
+SDL_SetError("Photon: Cannot locate OpenGL ES function name");
+return NULL;
-/* Failed to get GL ES function address pointer */
+#else
-SDL_SetError("Photon: Cannot locate OpenGL ES function name");
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
 return NULL;
-#else
+#endif /* SDL_VIDEO_OPENGL_ES */
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+}
-return NULL;
-#endif /* SDL_VIDEO_OPENGL_ES */
+void
-}
+photon_gl_unloadlibrary(_THIS)
+{
-void photon_gl_unloadlibrary(_THIS)
+#if defined(SDL_VIDEO_OPENGL_ES)
-{
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-#if defined(SDL_VIDEO_OPENGL_ES)
-SDL_VideoData* phdata=(SDL_VideoData*)_this->driverdata;
+if (phdata->gfinitialized == SDL_TRUE) {
+/* Unload OpenGL ES library */
-if (phdata->gfinitialized==SDL_TRUE)
+if (_this->gl_config.dll_handle) {
-{
-/* Unload OpenGL ES library */
-if (_this->gl_config.dll_handle)
-{
 SDL_UnloadObject(_this->gl_config.dll_handle);
-_this->gl_config.dll_handle=NULL;
+_this->gl_config.dll_handle = NULL;
 }
-}
+} else {
-else
+SDL_SetError
-{
+("Photon: GF initialization failed, no OpenGL ES support");
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+}
-}
+#else
-#else
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+return;
-return;
+#endif /* SDL_VIDEO_OPENGL_ES */
-#endif /* SDL_VIDEO_OPENGL_ES */
+}
-}
+SDL_GLContext
-SDL_GLContext photon_gl_createcontext(_THIS, SDL_Window* window)
+photon_gl_createcontext(_THIS, SDL_Window * window)
 {
 #if defined(SDL_VIDEO_OPENGL_ES)
-SDL_VideoData*   phdata=(SDL_VideoData*)_this->driverdata;
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-SDL_WindowData*  wdata=(SDL_WindowData*)window->driverdata;
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+SDL_DisplayData *didata =
-EGLBoolean       status;
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
-int32_t          gfstatus;
+EGLBoolean status;
-EGLint           configs;
+int32_t gfstatus;
-uint32_t         attr_pos;
+EGLint configs;
-EGLint           attr_value;
+uint32_t attr_pos;
-EGLint           cit;
+EGLint attr_value;
+EGLint cit;
-/* Check if GF was initialized */
-if (phdata->gfinitialized!=SDL_TRUE)
+/* Check if GF was initialized */
-{
+if (phdata->gfinitialized != SDL_TRUE) {
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+SDL_SetError
-return NULL;
+("Photon: GF initialization failed, no OpenGL ES support");
-}
+return NULL;
+}
-/* Prepare attributes list to pass them to OpenGL ES */
-attr_pos=0;
+/* Prepare attributes list to pass them to OpenGL ES */
-wdata->gles_attributes[attr_pos++]=EGL_NATIVE_VISUAL_ID;
+attr_pos = 0;
-wdata->gles_attributes[attr_pos++]=qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format);
+wdata->gles_attributes[attr_pos++] = EGL_NATIVE_VISUAL_ID;
-wdata->gles_attributes[attr_pos++]=EGL_RED_SIZE;
+wdata->gles_attributes[attr_pos++] =
-wdata->gles_attributes[attr_pos++]=_this->gl_config.red_size;
+qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format);
-wdata->gles_attributes[attr_pos++]=EGL_GREEN_SIZE;
+wdata->gles_attributes[attr_pos++] = EGL_RED_SIZE;
-wdata->gles_attributes[attr_pos++]=_this->gl_config.green_size;
+wdata->gles_attributes[attr_pos++] = _this->gl_config.red_size;
-wdata->gles_attributes[attr_pos++]=EGL_BLUE_SIZE;
+wdata->gles_attributes[attr_pos++] = EGL_GREEN_SIZE;
-wdata->gles_attributes[attr_pos++]=_this->gl_config.blue_size;
+wdata->gles_attributes[attr_pos++] = _this->gl_config.green_size;
-wdata->gles_attributes[attr_pos++]=EGL_ALPHA_SIZE;
+wdata->gles_attributes[attr_pos++] = EGL_BLUE_SIZE;
+wdata->gles_attributes[attr_pos++] = _this->gl_config.blue_size;
-/* Setup alpha size in bits */
+wdata->gles_attributes[attr_pos++] = EGL_ALPHA_SIZE;
-if (_this->gl_config.alpha_size)
-{
+/* Setup alpha size in bits */
-wdata->gles_attributes[attr_pos++]=_this->gl_config.alpha_size;
+if (_this->gl_config.alpha_size) {
-}
+wdata->gles_attributes[attr_pos++] = _this->gl_config.alpha_size;
-else
+} else {
-{
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+}
-}
+/* Setup color buffer size */
-/* Setup color buffer size */
+if (_this->gl_config.buffer_size) {
-if (_this->gl_config.buffer_size)
+wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;
-{
+wdata->gles_attributes[attr_pos++] = _this->gl_config.buffer_size;
-wdata->gles_attributes[attr_pos++]=EGL_BUFFER_SIZE;
+} else {
-wdata->gles_attributes[attr_pos++]=_this->gl_config.buffer_size;
+wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;
-}
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-else
+}
-{
-wdata->gles_attributes[attr_pos++]=EGL_BUFFER_SIZE;
+/* Setup depth buffer bits */
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;
-}
+wdata->gles_attributes[attr_pos++] = _this->gl_config.depth_size;
-/* Setup depth buffer bits */
+/* Setup stencil bits */
-wdata->gles_attributes[attr_pos++]=EGL_DEPTH_SIZE;
+if (_this->gl_config.stencil_size) {
-wdata->gles_attributes[attr_pos++]=_this->gl_config.depth_size;
+wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
+wdata->gles_attributes[attr_pos++] = _this->gl_config.buffer_size;
-/* Setup stencil bits */
+} else {
-if (_this->gl_config.stencil_size)
+wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
-{
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
+}
-wdata->gles_attributes[attr_pos++]=_this->gl_config.buffer_size;
-}
+/* Set number of samples in multisampling */
-else
+if (_this->gl_config.multisamplesamples) {
-{
+wdata->gles_attributes[attr_pos++] = EGL_SAMPLES;
-wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
+wdata->gles_attributes[attr_pos++] =
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+_this->gl_config.multisamplesamples;
 }
-/* Set number of samples in multisampling */
+/* Multisample buffers, OpenGL ES 1.0 spec defines 0 or 1 buffer */
-if (_this->gl_config.multisamplesamples)
+if (_this->gl_config.multisamplebuffers) {
-{
+wdata->gles_attributes[attr_pos++] = EGL_SAMPLE_BUFFERS;
-wdata->gles_attributes[attr_pos++]=EGL_SAMPLES;
+wdata->gles_attributes[attr_pos++] =
-wdata->gles_attributes[attr_pos++]=_this->gl_config.multisamplesamples;
+_this->gl_config.multisamplebuffers;
 }
-/* Multisample buffers, OpenGL ES 1.0 spec defines 0 or 1 buffer */
+/* Finish attributes list */
-if (_this->gl_config.multisamplebuffers)
+wdata->gles_attributes[attr_pos] = EGL_NONE;
-{
-wdata->gles_attributes[attr_pos++]=EGL_SAMPLE_BUFFERS;
+/* Request first suitable framebuffer configuration */
-wdata->gles_attributes[attr_pos++]=_this->gl_config.multisamplebuffers;
+status = eglChooseConfig(phdata->egldisplay, wdata->gles_attributes,
-}
+wdata->gles_configs, SDL_VIDEO_GF_OPENGLES_CONFS,
+&configs);
-/* Finish attributes list */
+if (status != EGL_TRUE) {
-wdata->gles_attributes[attr_pos]=EGL_NONE;
+SDL_SetError
+("Photon: Can't find closest configuration for OpenGL ES");
-/* Request first suitable framebuffer configuration */
+return NULL;
-status=eglChooseConfig(phdata->egldisplay, wdata->gles_attributes,
+}
-wdata->gles_configs, SDL_VIDEO_GF_OPENGLES_CONFS, &configs);
-if (status!=EGL_TRUE)
+/* Check if nothing has been found, try "don't care" settings */
-{
+if (configs == 0) {
-SDL_SetError("Photon: Can't find closest configuration for OpenGL ES");
+int32_t it;
-return NULL;
+int32_t jt;
-}
+GLint depthbits[4] = { 32, 24, 16, EGL_DONT_CARE };
-/* Check if nothing has been found, try "don't care" settings */
+for (it = 0; it < 4; it++) {
-if (configs==0)
+for (jt = 16; jt >= 0; jt--) {
-{
+/* Don't care about color buffer bits, use what exist */
-int32_t it;
+/* Replace previous set data with EGL_DONT_CARE       */
-int32_t jt;
+attr_pos = 0;
-GLint   depthbits[4]={32, 24, 16, EGL_DONT_CARE};
+wdata->gles_attributes[attr_pos++] = EGL_NATIVE_VISUAL_ID;
+wdata->gles_attributes[attr_pos++] =
-for (it=0; it<4; it++)
+qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format);
-{
+wdata->gles_attributes[attr_pos++] = EGL_RED_SIZE;
-for (jt=16; jt>=0; jt--)
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-{
+wdata->gles_attributes[attr_pos++] = EGL_GREEN_SIZE;
-/* Don't care about color buffer bits, use what exist */
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-/* Replace previous set data with EGL_DONT_CARE       */
+wdata->gles_attributes[attr_pos++] = EGL_BLUE_SIZE;
-attr_pos=0;
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-wdata->gles_attributes[attr_pos++]=EGL_NATIVE_VISUAL_ID;
+wdata->gles_attributes[attr_pos++] = EGL_ALPHA_SIZE;
-wdata->gles_attributes[attr_pos++]=qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format);
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-wdata->gles_attributes[attr_pos++]=EGL_RED_SIZE;
+wdata->gles_attributes[attr_pos++] = EGL_BUFFER_SIZE;
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-wdata->gles_attributes[attr_pos++]=EGL_GREEN_SIZE;
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+/* Try to find requested or smallest depth */
-wdata->gles_attributes[attr_pos++]=EGL_BLUE_SIZE;
+if (_this->gl_config.depth_size) {
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;
-wdata->gles_attributes[attr_pos++]=EGL_ALPHA_SIZE;
+wdata->gles_attributes[attr_pos++] = depthbits[it];
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+} else {
-wdata->gles_attributes[attr_pos++]=EGL_BUFFER_SIZE;
+wdata->gles_attributes[attr_pos++] = EGL_DEPTH_SIZE;
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
+}
-/* Try to find requested or smallest depth */
-if (_this->gl_config.depth_size)
+if (_this->gl_config.stencil_size) {
-{
+wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
-wdata->gles_attributes[attr_pos++]=EGL_DEPTH_SIZE;
+wdata->gles_attributes[attr_pos++] = jt;
-wdata->gles_attributes[attr_pos++]=depthbits[it];
+} else {
-}
+wdata->gles_attributes[attr_pos++] = EGL_STENCIL_SIZE;
-else
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-{
+}
-wdata->gles_attributes[attr_pos++]=EGL_DEPTH_SIZE;
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+wdata->gles_attributes[attr_pos++] = EGL_SAMPLES;
-}
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
+wdata->gles_attributes[attr_pos++] = EGL_SAMPLE_BUFFERS;
-if (_this->gl_config.stencil_size)
+wdata->gles_attributes[attr_pos++] = EGL_DONT_CARE;
-{
+wdata->gles_attributes[attr_pos] = EGL_NONE;
-wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
-wdata->gles_attributes[attr_pos++]=jt;
+/* Request first suitable framebuffer configuration */
-}
+status =
-else
+eglChooseConfig(phdata->egldisplay,
-{
+wdata->gles_attributes,
-wdata->gles_attributes[attr_pos++]=EGL_STENCIL_SIZE;
+wdata->gles_configs,
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+SDL_VIDEO_GF_OPENGLES_CONFS, &configs);
-}
+if (status != EGL_TRUE) {
+SDL_SetError
-wdata->gles_attributes[attr_pos++]=EGL_SAMPLES;
+("Photon: Can't find closest configuration for OpenGL ES");
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+return NULL;
-wdata->gles_attributes[attr_pos++]=EGL_SAMPLE_BUFFERS;
+}
-wdata->gles_attributes[attr_pos++]=EGL_DONT_CARE;
+if (configs != 0) {
-wdata->gles_attributes[attr_pos]=EGL_NONE;
+break;
+}
-/* Request first suitable framebuffer configuration */
-status=eglChooseConfig(phdata->egldisplay, wdata->gles_attributes,
-wdata->gles_configs, SDL_VIDEO_GF_OPENGLES_CONFS, &configs);
-if (status!=EGL_TRUE)
-{
-SDL_SetError("Photon: Can't find closest configuration for OpenGL ES");
-return NULL;
-}
-if (configs!=0)
-{
-break;
-}
 }
-if (configs!=0)
+if (configs != 0) {
-{
+break;
-break;
 }
 }
 /* No available configs */
-if (configs==0)
+if (configs == 0) {
-{
+SDL_SetError
-SDL_SetError("Photon: Can't find any configuration for OpenGL ES");
+("Photon: Can't find any configuration for OpenGL ES");
 return NULL;
 }
 }
 /* Initialize config index */
-wdata->gles_config=0;
+wdata->gles_config = 0;
 /* Now check each configuration to find out the best */
-for (cit=0; cit<configs; cit++)
+for (cit = 0; cit < configs; cit++) {
-{
+uint32_t stencil_found;
-uint32_t stencil_found;
+uint32_t depth_found;
-uint32_t depth_found;
+stencil_found = 0;
-stencil_found=0;
+depth_found = 0;
-depth_found=0;
+if (_this->gl_config.stencil_size) {
-if (_this->gl_config.stencil_size)
+status =
-{
+eglGetConfigAttrib(phdata->egldisplay,
-status=eglGetConfigAttrib(phdata->egldisplay, wdata->gles_configs[cit], EGL_STENCIL_SIZE, &attr_value);
+wdata->gles_configs[cit], EGL_STENCIL_SIZE,
-if (status==EGL_TRUE)
+&attr_value);
-{
+if (status == EGL_TRUE) {
-if (attr_value!=0)
+if (attr_value != 0) {
-{
+stencil_found = 1;
-stencil_found=1;
+}
-}
 }
-}
+} else {
-else
+stencil_found = 1;
-{
+}
-stencil_found=1;
-}
+if (_this->gl_config.depth_size) {
+status =
-if (_this->gl_config.depth_size)
+eglGetConfigAttrib(phdata->egldisplay,
-{
+wdata->gles_configs[cit], EGL_DEPTH_SIZE,
-status=eglGetConfigAttrib(phdata->egldisplay, wdata->gles_configs[cit], EGL_DEPTH_SIZE, &attr_value);
+&attr_value);
-if (status==EGL_TRUE)
+if (status == EGL_TRUE) {
-{
+if (attr_value != 0) {
-if (attr_value!=0)
+depth_found = 1;
-{
+}
-depth_found=1;
-}
 }
-}
+} else {
-else
+depth_found = 1;
-{
+}
-depth_found=1;
-}
+/* Exit from loop if found appropriate configuration */
+if ((depth_found != 0) && (stencil_found != 0)) {
-/* Exit from loop if found appropriate configuration */
-if ((depth_found!=0) && (stencil_found!=0))
-{
 break;
 }
 }
 /* If best could not be found, use first */
-if (cit==configs)
+if (cit == configs) {
-{
+cit = 0;
-cit=0;
+}
-}
+wdata->gles_config = cit;
-wdata->gles_config=cit;
+/* Create OpenGL ES context */
-/* Create OpenGL ES context */
+wdata->gles_context =
-wdata->gles_context=eglCreateContext(phdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_NO_CONTEXT, NULL);
+eglCreateContext(phdata->egldisplay,
-if (wdata->gles_context==EGL_NO_CONTEXT)
+wdata->gles_configs[wdata->gles_config],
-{
+EGL_NO_CONTEXT, NULL);
-SDL_SetError("Photon: OpenGL ES context creation has been failed");
+if (wdata->gles_context == EGL_NO_CONTEXT) {
-return NULL;
+SDL_SetError("Photon: OpenGL ES context creation has been failed");
-}
+return NULL;
+}
-/* Check if surface is exist */
-if (wdata->gfsurface!=NULL)
+/* Check if surface is exist */
-{
+if (wdata->gfsurface != NULL) {
 gf_surface_free(wdata->gfsurface);
-wdata->gfsurface=NULL;
+wdata->gfsurface = NULL;
 }
 /* Create GF surface */
-gfstatus=gf_surface_create(&wdata->gfsurface, phdata->gfdev, window->w, window->h,
+gfstatus =
-qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format), NULL,
+gf_surface_create(&wdata->gfsurface, phdata->gfdev, window->w,
-GF_SURFACE_CREATE_2D_ACCESSIBLE | GF_SURFACE_CREATE_3D_ACCESSIBLE |
+window->h,
-GF_SURFACE_CREATE_SHAREABLE);
+qnxgf_sdl_to_gf_pixelformat(didata->current_mode.
-if (gfstatus!=GF_ERR_OK)
+format), NULL,
-{
+GF_SURFACE_CREATE_2D_ACCESSIBLE |
-eglDestroyContext(phdata->egldisplay, wdata->gles_context);
+GF_SURFACE_CREATE_3D_ACCESSIBLE |
-wdata->gles_context=EGL_NO_CONTEXT;
+GF_SURFACE_CREATE_SHAREABLE);
-SDL_SetError("Photon: Can't create GF 3D surface (%08X)", gfstatus);
+if (gfstatus != GF_ERR_OK) {
-return NULL;
+eglDestroyContext(phdata->egldisplay, wdata->gles_context);
-}
+wdata->gles_context = EGL_NO_CONTEXT;
+SDL_SetError("Photon: Can't create GF 3D surface (%08X)", gfstatus);
-/* Create pixmap 3D target surface */
+return NULL;
-wdata->gles_surface=eglCreatePixmapSurface(phdata->egldisplay, wdata->gles_configs[wdata->gles_config], wdata->gfsurface, NULL);
+}
-if (wdata->gles_surface==EGL_NO_SURFACE)
-{
+/* Create pixmap 3D target surface */
-gf_surface_free(wdata->gfsurface);
+wdata->gles_surface =
-eglDestroyContext(phdata->egldisplay, wdata->gles_context);
+eglCreatePixmapSurface(phdata->egldisplay,
-wdata->gles_context=EGL_NO_CONTEXT;
+wdata->gles_configs[wdata->gles_config],
-SDL_SetError("Photon: Can't create EGL pixmap surface");
+wdata->gfsurface, NULL);
-return NULL;
+if (wdata->gles_surface == EGL_NO_SURFACE) {
-}
+gf_surface_free(wdata->gfsurface);
+eglDestroyContext(phdata->egldisplay, wdata->gles_context);
-/* Make just created context current */
+wdata->gles_context = EGL_NO_CONTEXT;
-status=eglMakeCurrent(phdata->egldisplay, wdata->gles_surface, wdata->gles_surface, wdata->gles_context);
+SDL_SetError("Photon: Can't create EGL pixmap surface");
-if (status!=EGL_TRUE)
+return NULL;
-{
+}
-/* Destroy OpenGL ES surface */
-eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
+/* Make just created context current */
-gf_surface_free(wdata->gfsurface);
+status =
-eglDestroyContext(phdata->egldisplay, wdata->gles_context);
+eglMakeCurrent(phdata->egldisplay, wdata->gles_surface,
-wdata->gles_context=EGL_NO_CONTEXT;
+wdata->gles_surface, wdata->gles_context);
-SDL_SetError("Photon: Can't set OpenGL ES context on creation");
+if (status != EGL_TRUE) {
-return NULL;
+/* Destroy OpenGL ES surface */
-}
+eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
+gf_surface_free(wdata->gfsurface);
-/* Setup into SDL internals state of OpenGL ES:  */
+eglDestroyContext(phdata->egldisplay, wdata->gles_context);
-/* it is accelerated or not                      */
+wdata->gles_context = EGL_NO_CONTEXT;
-if ((didata->caps & SDL_PHOTON_ACCELERATED_3D)==SDL_PHOTON_ACCELERATED_3D)
+SDL_SetError("Photon: Can't set OpenGL ES context on creation");
-{
+return NULL;
-_this->gl_config.accelerated=1;
+}
-}
-else
+/* Setup into SDL internals state of OpenGL ES:  */
-{
+/* it is accelerated or not                      */
-_this->gl_config.accelerated=0;
+if ((didata->caps & SDL_PHOTON_ACCELERATED_3D) ==
-}
+SDL_PHOTON_ACCELERATED_3D) {
+_this->gl_config.accelerated = 1;
-/* Always clear stereo enable, since OpenGL ES do not supports stereo */
+} else {
-_this->gl_config.stereo=0;
+_this->gl_config.accelerated = 0;
+}
-/* Get back samples and samplebuffers configurations. Rest framebuffer */
-/* parameters could be obtained through the OpenGL ES API              */
+/* Always clear stereo enable, since OpenGL ES do not supports stereo */
-status=eglGetConfigAttrib(phdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_SAMPLES, &attr_value);
+_this->gl_config.stereo = 0;
-if (status==EGL_TRUE)
-{
+/* Get back samples and samplebuffers configurations. Rest framebuffer */
-_this->gl_config.multisamplesamples=attr_value;
+/* parameters could be obtained through the OpenGL ES API              */
-}
+status =
-status=eglGetConfigAttrib(phdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_SAMPLE_BUFFERS, &attr_value);
+eglGetConfigAttrib(phdata->egldisplay,
-if (status==EGL_TRUE)
+wdata->gles_configs[wdata->gles_config],
-{
+EGL_SAMPLES, &attr_value);
-_this->gl_config.multisamplebuffers=attr_value;
+if (status == EGL_TRUE) {
-}
+_this->gl_config.multisamplesamples = attr_value;
+}
-/* Get back stencil and depth buffer sizes */
+status =
-status=eglGetConfigAttrib(phdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_DEPTH_SIZE, &attr_value);
+eglGetConfigAttrib(phdata->egldisplay,
-if (status==EGL_TRUE)
+wdata->gles_configs[wdata->gles_config],
-{
+EGL_SAMPLE_BUFFERS, &attr_value);
-_this->gl_config.depth_size=attr_value;
+if (status == EGL_TRUE) {
-}
+_this->gl_config.multisamplebuffers = attr_value;
-status=eglGetConfigAttrib(phdata->egldisplay, wdata->gles_configs[wdata->gles_config], EGL_STENCIL_SIZE, &attr_value);
+}
-if (status==EGL_TRUE)
-{
+/* Get back stencil and depth buffer sizes */
-_this->gl_config.stencil_size=attr_value;
+status =
-}
+eglGetConfigAttrib(phdata->egldisplay,
+wdata->gles_configs[wdata->gles_config],
-/* Under Photon OpenGL ES output can't be double buffered */
+EGL_DEPTH_SIZE, &attr_value);
-_this->gl_config.double_buffer=0;
+if (status == EGL_TRUE) {
+_this->gl_config.depth_size = attr_value;
-/* Check if current device is not the same as target */
+}
-if (phdata->current_device_id!=didata->device_id)
+status =
-{
+eglGetConfigAttrib(phdata->egldisplay,
-/* Set target device as default for Pd and Pg functions */
+wdata->gles_configs[wdata->gles_config],
-status=PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
+EGL_STENCIL_SIZE, &attr_value);
-if (status!=0)
+if (status == EGL_TRUE) {
-{
+_this->gl_config.stencil_size = attr_value;
+}
+/* Under Photon OpenGL ES output can't be double buffered */
+_this->gl_config.double_buffer = 0;
+/* Check if current device is not the same as target */
+if (phdata->current_device_id != didata->device_id) {
+/* Set target device as default for Pd and Pg functions */
+status = PdSetTargetDevice(NULL, phdata->rid[didata->device_id]);
+if (status != 0) {
 /* Destroy OpenGL ES surface */
 eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
 gf_surface_free(wdata->gfsurface);
 eglDestroyContext(phdata->egldisplay, wdata->gles_context);
-wdata->gles_context=EGL_NO_CONTEXT;
+wdata->gles_context = EGL_NO_CONTEXT;
 SDL_SetError("Photon: Can't set default target device\n");
 return NULL;
 }
-phdata->current_device_id=didata->device_id;
+phdata->current_device_id = didata->device_id;
 }
-wdata->phsurface=PdCreateOffscreenContextGF(wdata->gfsurface);
+wdata->phsurface = PdCreateOffscreenContextGF(wdata->gfsurface);
-if (wdata->phsurface==NULL)
+if (wdata->phsurface == NULL) {
-{
+/* Destroy OpenGL ES surface */
-/* Destroy OpenGL ES surface */
+eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
-eglDestroySurface(phdata->egldisplay, wdata->gles_surface);
+gf_surface_free(wdata->gfsurface);
-gf_surface_free(wdata->gfsurface);
+eglDestroyContext(phdata->egldisplay, wdata->gles_context);
-eglDestroyContext(phdata->egldisplay, wdata->gles_context);
+wdata->gles_context = EGL_NO_CONTEXT;
-wdata->gles_context=EGL_NO_CONTEXT;
+SDL_SetError("Photon: Can't bind GF surface to Photon\n");
-SDL_SetError("Photon: Can't bind GF surface to Photon\n");
+return NULL;
-return NULL;
+}
-}
+/* GL ES context was successfully created */
-/* GL ES context was successfully created */
+return wdata->gles_context;
-return wdata->gles_context;
+#else
-#else
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+return NULL;
-return NULL;
+#endif /* SDL_VIDEO_OPENGL_ES */
-#endif /* SDL_VIDEO_OPENGL_ES */
+}
-}
+int
-int photon_gl_makecurrent(_THIS, SDL_Window* window, SDL_GLContext context)
+photon_gl_makecurrent(_THIS, SDL_Window * window, SDL_GLContext context)
 {
 #if defined(SDL_VIDEO_OPENGL_ES)
-SDL_VideoData*  phdata=(SDL_VideoData*)_this->driverdata;
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-SDL_WindowData* wdata;
+SDL_WindowData *wdata;
 EGLBoolean status;
-if (phdata->gfinitialized!=SDL_TRUE)
+if (phdata->gfinitialized != SDL_TRUE) {
-{
+SDL_SetError
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+("Photon: GF initialization failed, no OpenGL ES support");
 return -1;
 }
-if ((window==NULL) && (context==NULL))
+if ((window == NULL) && (context == NULL)) {
-{
+status =
-status=eglMakeCurrent(phdata->egldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+eglMakeCurrent(phdata->egldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
-if (status!=EGL_TRUE)
+EGL_NO_CONTEXT);
-{
+if (status != EGL_TRUE) {
 /* Failed to set current GL ES context */
 SDL_SetError("Photon: Can't set OpenGL ES context");
 return -1;
 }
-}
+} else {
-else
+wdata = (SDL_WindowData *) window->driverdata;
-{
+if (wdata->gles_surface == EGL_NO_SURFACE) {
-wdata=(SDL_WindowData*)window->driverdata;
+SDL_SetError
-if (wdata->gles_surface==EGL_NO_SURFACE)
+("Photon: OpenGL ES surface is not initialized for this window");
-{
-SDL_SetError("Photon: OpenGL ES surface is not initialized for this window");
 return -1;
 }
-if (wdata->gles_context==EGL_NO_CONTEXT)
+if (wdata->gles_context == EGL_NO_CONTEXT) {
-{
+SDL_SetError
-SDL_SetError("Photon: OpenGL ES context is not initialized for this window");
+("Photon: OpenGL ES context is not initialized for this window");
 return -1;
 }
-if (wdata->gles_context!=context)
+if (wdata->gles_context != context) {
-{
+SDL_SetError
-SDL_SetError("Photon: OpenGL ES context is not belong to this window");
+("Photon: OpenGL ES context is not belong to this window");
 return -1;
 }
-status=eglMakeCurrent(phdata->egldisplay, wdata->gles_surface, wdata->gles_surface, wdata->gles_context);
+status =
-if (status!=EGL_TRUE)
+eglMakeCurrent(phdata->egldisplay, wdata->gles_surface,
-{
+wdata->gles_surface, wdata->gles_context);
+if (status != EGL_TRUE) {
 /* Failed to set current GL ES context */
 SDL_SetError("Photon: Can't set OpenGL ES context");
 return -1;
 }
 }
 return 0;
 #else
 SDL_SetError("Photon: OpenGL ES support is not compiled in");
 return -1;
 #endif /* SDL_VIDEO_OPENGL_ES */
 }
-int photon_gl_setswapinterval(_THIS, int interval)
+int
-{
+photon_gl_setswapinterval(_THIS, int interval)
-#if defined(SDL_VIDEO_OPENGL_ES)
+{
-SDL_VideoData* phdata=(SDL_VideoData*)_this->driverdata;
+#if defined(SDL_VIDEO_OPENGL_ES)
-EGLBoolean     status;
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
+EGLBoolean status;
-if (phdata->gfinitialized!=SDL_TRUE)
-{
+if (phdata->gfinitialized != SDL_TRUE) {
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+SDL_SetError
-return -1;
+("Photon: GF initialization failed, no OpenGL ES support");
-}
+return -1;
+}
-/* Check if OpenGL ES connection has been initialized */
-if (phdata->egldisplay!=EGL_NO_DISPLAY)
+/* Check if OpenGL ES connection has been initialized */
-{
+if (phdata->egldisplay != EGL_NO_DISPLAY) {
 /* Set swap OpenGL ES interval */
-status=eglSwapInterval(phdata->egldisplay, interval);
+status = eglSwapInterval(phdata->egldisplay, interval);
-if (status==EGL_TRUE)
+if (status == EGL_TRUE) {
-{
 /* Return success to upper level */
-phdata->swapinterval=interval;
+phdata->swapinterval = interval;
 return 0;
 }
 }
 /* Failed to set swap interval */
 SDL_SetError("Photon: Cannot set swap interval");
 return -1;
 #else
 SDL_SetError("Photon: OpenGL ES support is not compiled in");
 return -1;
 #endif /* SDL_VIDEO_OPENGL_ES */
 }
-int photon_gl_getswapinterval(_THIS)
+int
-{
+photon_gl_getswapinterval(_THIS)
-#if defined(SDL_VIDEO_OPENGL_ES)
+{
-SDL_VideoData* phdata=(SDL_VideoData*)_this->driverdata;
+#if defined(SDL_VIDEO_OPENGL_ES)
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-if (phdata->gfinitialized!=SDL_TRUE)
-{
+if (phdata->gfinitialized != SDL_TRUE) {
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
+SDL_SetError
-return -1;
+("Photon: GF initialization failed, no OpenGL ES support");
-}
+return -1;
+}
-/* Return default swap interval value */
-return phdata->swapinterval;
+/* Return default swap interval value */
-#else
+return phdata->swapinterval;
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+#else
-return -1;
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
-#endif /* SDL_VIDEO_OPENGL_ES */
+return -1;
-}
+#endif /* SDL_VIDEO_OPENGL_ES */
+}
-void photon_gl_swapwindow(_THIS, SDL_Window* window)
-{
+void
-#if defined(SDL_VIDEO_OPENGL_ES)
+photon_gl_swapwindow(_THIS, SDL_Window * window)
-SDL_VideoData*   phdata=(SDL_VideoData*)_this->driverdata;
+{
-SDL_WindowData*  wdata=(SDL_WindowData*)window->driverdata;
+#if defined(SDL_VIDEO_OPENGL_ES)
-SDL_DisplayData* didata=(SDL_DisplayData*)SDL_CurrentDisplay.driverdata;
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-PhRect_t         dst_rect;
+SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
-PhRect_t         src_rect;
+SDL_DisplayData *didata =
+(SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
-if (phdata->gfinitialized!=SDL_TRUE)
+PhRect_t dst_rect;
-{
+PhRect_t src_rect;
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
-return;
+if (phdata->gfinitialized != SDL_TRUE) {
-}
+SDL_SetError
+("Photon: GF initialization failed, no OpenGL ES support");
-/* Many applications do not uses glFinish(), so we call it for them */
+return;
-glFinish();
+}
-/* Wait until OpenGL ES rendering is completed */
+/* Many applications do not uses glFinish(), so we call it for them */
-eglWaitGL();
+glFinish();
-/* Wait for VSYNC manually, if it was enabled */
+/* Wait until OpenGL ES rendering is completed */
-if (phdata->swapinterval!=0)
+eglWaitGL();
-{
-/* Wait for VSYNC, we use GF function, since Photon requires */
+/* Wait for VSYNC manually, if it was enabled */
-/* to enter to the Direct mode to call PgWaitVSync()         */
+if (phdata->swapinterval != 0) {
-gf_display_wait_vsync(didata->display);
+/* Wait for VSYNC, we use GF function, since Photon requires */
-}
+/* to enter to the Direct mode to call PgWaitVSync()         */
+gf_display_wait_vsync(didata->display);
-/* Set blit area */
+}
-dst_rect=*PtGetCanvas(wdata->window);
-src_rect.ul.x=0;
+/* Set blit area */
-src_rect.ul.y=0;
+dst_rect = *PtGetCanvas(wdata->window);
-src_rect.lr.x=window->w-1;
+src_rect.ul.x = 0;
-src_rect.lr.y=window->h-1;
+src_rect.ul.y = 0;
+src_rect.lr.x = window->w - 1;
-/* Blit OpenGL ES pixmap surface directly to window region */
+src_rect.lr.y = window->h - 1;
-PgFFlush(Ph_START_DRAW);
-PgSetRegionCx(PhDCGetCurrent(), PtWidgetRid(wdata->window));
+/* Blit OpenGL ES pixmap surface directly to window region */
-PgClearTranslationCx(PgGetGCCx(PhDCGetCurrent()));
+PgFFlush(Ph_START_DRAW);
-PgContextBlit(wdata->phsurface, &src_rect, NULL, &dst_rect);
+PgSetRegionCx(PhDCGetCurrent(), PtWidgetRid(wdata->window));
-PgFFlush(Ph_DONE_DRAW);
+PgClearTranslationCx(PgGetGCCx(PhDCGetCurrent()));
-PgWaitHWIdle();
+PgContextBlit(wdata->phsurface, &src_rect, NULL, &dst_rect);
+PgFFlush(Ph_DONE_DRAW);
-eglSwapBuffers(phdata->egldisplay, wdata->gles_surface);
+PgWaitHWIdle();
-#else
-SDL_SetError("Photon: OpenGL ES support is not compiled in");
+eglSwapBuffers(phdata->egldisplay, wdata->gles_surface);
-return;
+#else
-#endif /* SDL_VIDEO_OPENGL_ES */
+SDL_SetError("Photon: OpenGL ES support is not compiled in");
-}
+return;
+#endif /* SDL_VIDEO_OPENGL_ES */
-void photon_gl_deletecontext(_THIS, SDL_GLContext context)
+}
-{
-#if defined(SDL_VIDEO_OPENGL_ES)
+void
-SDL_VideoData* phdata=(SDL_VideoData*)_this->driverdata;
+photon_gl_deletecontext(_THIS, SDL_GLContext context)
-EGLBoolean     status;
+{
+#if defined(SDL_VIDEO_OPENGL_ES)
-if (phdata->gfinitialized!=SDL_TRUE)
+SDL_VideoData *phdata = (SDL_VideoData *) _this->driverdata;
-{
+EGLBoolean status;
-SDL_SetError("Photon: GF initialization failed, no OpenGL ES support");
-return;
+if (phdata->gfinitialized != SDL_TRUE) {
-}
+SDL_SetError
+("Photon: GF initialization failed, no OpenGL ES support");
-/* Check if OpenGL ES connection has been initialized */
+return;
-if (phdata->egldisplay!=EGL_NO_DISPLAY)
+}
-{
-if (context!=EGL_NO_CONTEXT)
+/* Check if OpenGL ES connection has been initialized */
-{
+if (phdata->egldisplay != EGL_NO_DISPLAY) {
-status=eglDestroyContext(phdata->egldisplay, context);
+if (context != EGL_NO_CONTEXT) {
-if (status!=EGL_TRUE)
+status = eglDestroyContext(phdata->egldisplay, context);
-{
+if (status != EGL_TRUE) {
 /* Error during OpenGL ES context destroying */
 SDL_SetError("Photon: OpenGL ES context destroy error");
 return;
 }
 }
 }
 return;
 #else
 SDL_SetError("Photon: OpenGL ES support is not compiled in");
 return;
 #endif /* SDL_VIDEO_OPENGL_ES */
 }
 /*****************************************************************************/
 /* SDL Event handling function                                               */
 /*****************************************************************************/
-void photon_pumpevents(_THIS)
+void
-{
+photon_pumpevents(_THIS)
-uint8_t    eventbuffer[SDL_VIDEO_PHOTON_EVENT_SIZE];
+{
-PhEvent_t* event=(PhEvent_t*)eventbuffer;
+uint8_t eventbuffer[SDL_VIDEO_PHOTON_EVENT_SIZE];
-int32_t    status;
+PhEvent_t *event = (PhEvent_t *) eventbuffer;
-uint32_t   finish=0;
+int32_t status;
-uint32_t   it;
+uint32_t finish = 0;
-SDL_Window* window;
+uint32_t it;
-SDL_WindowData* wdata;
+SDL_Window *window;
+SDL_WindowData *wdata;
-do {
-status=PhEventPeek(event, SDL_VIDEO_PHOTON_EVENT_SIZE);
+do {
-switch (status)
+status = PhEventPeek(event, SDL_VIDEO_PHOTON_EVENT_SIZE);
-{
+switch (status) {
 case Ph_RESIZE_MSG:
 {
 SDL_SetError("Photon: Event size too much for buffer");
 return;
 }
 break;
 case Ph_EVENT_MSG:
 {
 /* Find a window, to which this handle destinated */
-status=0;
+status = 0;
-for (it=0; it<SDL_CurrentDisplay.num_windows; it++)
+for (it = 0; it < SDL_CurrentDisplay.num_windows; it++) {
-{
+wdata =
-wdata=(SDL_WindowData*)SDL_CurrentDisplay.windows[it].driverdata;
+(SDL_WindowData *) SDL_CurrentDisplay.windows[it].
+driverdata;
 /* Find the proper window */
-if (wdata->window!=NULL)
+if (wdata->window != NULL) {
+if (PtWidgetRid(wdata->window) ==
+event->collector.rid) {
+window =
+(SDL_Window *) & SDL_CurrentDisplay.
+windows[it];
+status = 1;
+break;
+}
+} else {
+continue;
+}
+}
+if (status == 0) {
+window = NULL;
+wdata = NULL;
+}
+/* Event is ready */
+switch (event->type) {
+case Ph_EV_BOUNDARY:
 {
-if (PtWidgetRid(wdata->window)==event->collector.rid)
+switch (event->subtype) {
-{
+case Ph_EV_PTR_ENTER:
-window=(SDL_Window*)&SDL_CurrentDisplay.windows[it];
+{
-status=1;
+/* Mouse cursor over handled window */
-break;
+if (window != NULL) {
-}
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_ENTER,
+0, 0);
+SDL_SetMouseFocus(0, window->id);
+}
+}
+break;
+case Ph_EV_PTR_LEAVE:
+{
+/* Mouse cursor out of handled window */
+if (window != NULL) {
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_LEAVE,
+0, 0);
+}
+}
+break;
+}
 }
-else
+break;
+case Ph_EV_PTR_MOTION_BUTTON:
+case Ph_EV_PTR_MOTION_NOBUTTON:
 {
-continue;
+PhPointerEvent_t *pevent = NULL;
+PhRect_t *prects = NULL;
+/* Get event data */
+pevent = PhGetData(event);
+/* Get associated event rectangles */
+prects = PhGetRects(event);
+if ((pevent != NULL) && (prects != NULL)) {
+SDL_SendMouseMotion(0, 0, prects->ul.x,
+prects->ul.y, 0);
+}
 }
-}
+break;
-if (status==0)
+case Ph_EV_BUT_PRESS:
 {
-window=NULL;
+/* Button press event */
-wdata=NULL;
+PhPointerEvent_t *pevent = NULL;
-}
+uint32_t sdlbutton = 0x00000000;
-/* Event is ready */
+/* Get event data */
-switch(event->type)
+pevent = PhGetData(event);
-{
+if (pevent != NULL) {
-case Ph_EV_BOUNDARY:
+for (it = 0; it < sizeof(pevent->buttons) * 8;
-{
+it++) {
-switch(event->subtype)
+if ((pevent->buttons & (0x0001 << it)) ==
+(0x0001 << it)) {
+switch (it) {
+case 0:
+{
+sdlbutton = SDL_BUTTON_RIGHT;
+}
+break;
+case 1:
+{
+sdlbutton = SDL_BUTTON_MIDDLE;
+}
+break;
+case 2:
+{
+sdlbutton = SDL_BUTTON_LEFT;
+}
+break;
+default:
+{
+sdlbutton = it + 1;
+}
+break;
+}
+SDL_SendMouseButton(0, SDL_PRESSED,
+sdlbutton);
+}
+}
+}
+}
+break;
+case Ph_EV_BUT_RELEASE:
+{
+/* Button press event */
+PhPointerEvent_t *pevent = NULL;
+uint32_t sdlbutton = 0x00000000;
+/* Get event data */
+pevent = PhGetData(event);
+if (pevent != NULL) {
+for (it = 0; it < sizeof(pevent->buttons) * 8;
+it++) {
+if ((pevent->buttons & (0x0001 << it)) ==
+(0x0001 << it)) {
+switch (it) {
+case 0:
+{
+sdlbutton = SDL_BUTTON_RIGHT;
+}
+break;
+case 1:
+{
+sdlbutton = SDL_BUTTON_MIDDLE;
+}
+break;
+case 2:
+{
+sdlbutton = SDL_BUTTON_LEFT;
+}
+break;
+default:
+{
+sdlbutton = it + 1;
+}
+break;
+}
+}
+}
+}
+switch (event->subtype) {
+case Ph_EV_RELEASE_REAL:
 {
-case Ph_EV_PTR_ENTER:
+/* Real release button event */
-{
+SDL_SendMouseButton(0, SDL_RELEASED,
-/* Mouse cursor over handled window */
+sdlbutton);
-if (window!=NULL)
+}
-{
+break;
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_ENTER, 0, 0);
+case Ph_EV_RELEASE_PHANTOM:
-SDL_SetMouseFocus(0, window->id);
+{
-}
+/* We will get phantom button release */
+/* event in case if it was unpressed  */
+/* outside of window                  */
+if (window != NULL) {
+if ((window->
+flags & SDL_WINDOW_MOUSE_FOCUS) !=
+SDL_WINDOW_MOUSE_FOCUS) {
+/* Send phantom button release */
+SDL_SendMouseButton(0, SDL_RELEASED,
+sdlbutton);
 }
-break;
+}
-case Ph_EV_PTR_LEAVE:
+}
-{
+break;
-/* Mouse cursor out of handled window */
+}
-if (window!=NULL)
+}
-{
+break;
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_LEAVE, 0, 0);
+case Ph_EV_EXPOSE:
-}
+{
+switch (event->subtype) {
+case Ph_NORMAL_EXPOSE:
+{
+PhRect_t *rects = NULL;
+/* Get array of rectangles to be updated */
+rects = PhGetRects(event);
+if (rects == NULL) {
+break;
+}
+/* Check if expose come to one of the our windows */
+if ((wdata != NULL) && (window != NULL)) {
+/* Check if window uses OpenGL ES */
+if (wdata->uses_gles == SDL_TRUE) {
+PhRect_t dst_rect;
+PhRect_t src_rect;
+/* Cycle through each rectangle */
+for (it = 0; it < event->num_rects;
+it++) {
+/* Blit OpenGL ES pixmap surface directly to window region */
+PgFFlush(Ph_START_DRAW);
+PgSetRegionCx(PhDCGetCurrent(),
+PtWidgetRid(wdata->
+window));
+PgClearTranslationCx(PgGetGCCx
+(PhDCGetCurrent
+()));
+PgContextBlit(wdata->phsurface,
+&rects[it], NULL,
+&rects[it]);
+PgFFlush(Ph_DONE_DRAW);
+PgWaitHWIdle();
+}
+} else {
+/* Normal window */
+/* TODO: update the damaged rectangles */
 }
-break;
+}
+/* Flush all blittings */
+PgFlush();
 }
-}
+break;
-break;
+case Ph_CAPTURE_EXPOSE:
-case Ph_EV_PTR_MOTION_BUTTON:
-case Ph_EV_PTR_MOTION_NOBUTTON:
-{
-PhPointerEvent_t* pevent=NULL;
-PhRect_t* prects=NULL;
-/* Get event data */
-pevent=PhGetData(event);
-/* Get associated event rectangles */
-prects=PhGetRects(event);
-if ((pevent!=NULL) && (prects!=NULL))
 {
-SDL_SendMouseMotion(0, 0, prects->ul.x, prects->ul.y, 0);
+/* Check if expose come to one of the our windows */
+if ((wdata != NULL) && (window != NULL)) {
+/* Check if window uses OpenGL ES */
+if (wdata->uses_gles == SDL_TRUE) {
+PhRect_t dst_rect;
+PhRect_t src_rect;
+/* Set blit area */
+dst_rect =
+*PtGetCanvas(wdata->window);
+src_rect.ul.x = 0;
+src_rect.ul.y = 0;
+src_rect.lr.x = window->w - 1;
+src_rect.lr.y = window->h - 1;
+/* We need to redraw entire window */
+PgFFlush(Ph_START_DRAW);
+PgSetRegionCx(PhDCGetCurrent(),
+PtWidgetRid(wdata->
+window));
+PgClearTranslationCx(PgGetGCCx
+(PhDCGetCurrent
+()));
+PgContextBlit(wdata->phsurface,
+&src_rect, NULL,
+&dst_rect);
+PgFFlush(Ph_DONE_DRAW);
+PgWaitHWIdle();
+} else {
+/* Normal window */
+/* TODO: update the damaged rectangles */
+/* We need to redraw entire window */
+}
+}
 }
-}
+break;
-break;
+case Ph_GRAPHIC_EXPOSE:
-case Ph_EV_BUT_PRESS:
-{
-/* Button press event */
-PhPointerEvent_t* pevent=NULL;
-uint32_t sdlbutton=0x00000000;
-/* Get event data */
-pevent=PhGetData(event);
-if (pevent!=NULL)
 {
-for (it=0; it<sizeof(pevent->buttons)*8; it++)
+/* TODO: What this event means ? */
-{
-if ((pevent->buttons&(0x0001<<it))==(0x0001<<it))
-{
-switch (it)
-{
-case 0:
-{
-sdlbutton=SDL_BUTTON_RIGHT;
-}
-break;
-case 1:
-{
-sdlbutton=SDL_BUTTON_MIDDLE;
-}
-break;
-case 2:
-{
-sdlbutton=SDL_BUTTON_LEFT;
-}
-break;
-default:
-{
-sdlbutton=it+1;
-}
-break;
-}
-SDL_SendMouseButton(0, SDL_PRESSED, sdlbutton);
-}
-}
 }
-}
+break;
-break;
+}
-case Ph_EV_BUT_RELEASE:
+}
-{
+break;
-/* Button press event */
+case Ph_EV_INFO:
-PhPointerEvent_t* pevent=NULL;
+{
-uint32_t sdlbutton=0x00000000;
+}
+break;
-/* Get event data */
+case Ph_EV_KEY:
-pevent=PhGetData(event);
+{
-if (pevent!=NULL)
+PhKeyEvent_t *keyevent = NULL;
+SDL_scancode scancode = SDL_SCANCODE_UNKNOWN;
+SDL_bool pressed = SDL_FALSE;
+keyevent = PhGetData(event);
+if (keyevent == NULL) {
+break;
+}
+/* Check if key is repeated */
+if ((keyevent->key_flags & Pk_KF_Key_Repeat) ==
+Pk_KF_Key_Repeat) {
+/* Ignore such events */
+break;
+}
+/* Check if key has its own scancode */
+if ((keyevent->key_flags & Pk_KF_Scan_Valid) ==
+Pk_KF_Scan_Valid) {
+if ((keyevent->key_flags & Pk_KF_Key_Down) ==
+Pk_KF_Key_Down) {
+pressed = SDL_TRUE;
+} else {
+pressed = SDL_FALSE;
+}
+scancode =
+photon_to_sdl_keymap(keyevent->key_scan);
+/* Add details for the pressed key */
+if ((keyevent->key_flags & Pk_KF_Cap_Valid) ==
+Pk_KF_Cap_Valid) {
+switch (keyevent->key_cap) {
+case Pk_Hyper_R:       /* Right windows flag key */
+scancode = SDL_SCANCODE_RGUI;
+break;
+case Pk_Control_R:     /* Right Ctrl key */
+scancode = SDL_SCANCODE_RCTRL;
+break;
+case Pk_Alt_R: /* Right Alt key */
+scancode = SDL_SCANCODE_RALT;
+break;
+case Pk_Up:    /* Up key but with invalid scan */
+if (scancode != SDL_SCANCODE_UP) {
+/* This is a mouse wheel event */
+SDL_SendMouseWheel(0, 0, 1);
+return;
+}
+break;
+case Pk_KP_8:  /* Up arrow or 8 on keypad */
+scancode = SDL_SCANCODE_KP_8;
+break;
+case Pk_Down:  /* Down key but with invalid scan */
+if (scancode != SDL_SCANCODE_DOWN) {
+/* This is a mouse wheel event */
+SDL_SendMouseWheel(0, 0, -1);
+return;
+}
+break;
+case Pk_KP_2:  /* Down arrow or 2 on keypad */
+scancode = SDL_SCANCODE_KP_2;
+break;
+case Pk_Left:  /* Left arrow key */
+scancode = SDL_SCANCODE_LEFT;
+break;
+case Pk_KP_4:  /* Left arrow or 4 on keypad */
+scancode = SDL_SCANCODE_KP_4;
+break;
+case Pk_Right: /* Right arrow key */
+scancode = SDL_SCANCODE_RIGHT;
+break;
+case Pk_KP_6:  /* Right arrow or 6 on keypad */
+scancode = SDL_SCANCODE_KP_6;
+break;
+case Pk_Insert:        /* Insert key */
+scancode = SDL_SCANCODE_INSERT;
+break;
+case Pk_KP_0:  /* Insert or 0 on keypad */
+scancode = SDL_SCANCODE_KP_0;
+break;
+case Pk_Home:  /* Home key */
+scancode = SDL_SCANCODE_HOME;
+break;
+case Pk_KP_7:  /* Home or 7 on keypad */
+scancode = SDL_SCANCODE_KP_7;
+break;
+case Pk_Pg_Up: /* PageUp key */
+scancode = SDL_SCANCODE_PAGEUP;
+break;
+case Pk_KP_9:  /* PgUp or 9 on keypad */
+scancode = SDL_SCANCODE_KP_9;
+break;
+case Pk_Delete:        /* Delete key */
+scancode = SDL_SCANCODE_DELETE;
+break;
+case Pk_KP_Decimal:    /* Del or . on keypad */
+scancode = SDL_SCANCODE_KP_PERIOD;
+break;
+case Pk_End:   /* End key */
+scancode = SDL_SCANCODE_END;
+break;
+case Pk_KP_1:  /* End or 1 on keypad */
+scancode = SDL_SCANCODE_KP_1;
+break;
+case Pk_Pg_Down:       /* PageDown key */
+scancode = SDL_SCANCODE_PAGEDOWN;
+break;
+case Pk_KP_3:  /* PgDn or 3 on keypad */
+scancode = SDL_SCANCODE_KP_3;
+break;
+case Pk_KP_5:  /* 5 on keypad */
+scancode = SDL_SCANCODE_KP_5;
+break;
+case Pk_KP_Enter:
+scancode = SDL_SCANCODE_KP_ENTER;
+break;
+case Pk_KP_Add:
+scancode = SDL_SCANCODE_KP_PLUS;
+break;
+case Pk_KP_Subtract:
+scancode = SDL_SCANCODE_KP_MINUS;
+break;
+case Pk_KP_Multiply:
+scancode = SDL_SCANCODE_KP_MULTIPLY;
+break;
+case Pk_KP_Divide:
+scancode = SDL_SCANCODE_KP_DIVIDE;
+break;
+case Pk_Pause:
+scancode = SDL_SCANCODE_PAUSE;
+break;
+}
+}
+/* Finally check if scancode has been decoded */
+if (scancode == SDL_SCANCODE_UNKNOWN) {
+/* Something was pressed, which is not supported */
+break;
+}
+/* Report pressed/released key to SDL */
+if (pressed == SDL_TRUE) {
+SDL_SendKeyboardKey(0, SDL_PRESSED, scancode);
+} else {
+SDL_SendKeyboardKey(0, SDL_RELEASED,
+scancode);
+}
+/* Photon doesn't send a release event for PrnScr key */
+if ((scancode == SDL_SCANCODE_PRINTSCREEN)
+&& (pressed)) {
+SDL_SendKeyboardKey(0, SDL_RELEASED,
+scancode);
+}
+}
+}
+break;
+case Ph_EV_SERVICE:
+{
+}
+break;
+case Ph_EV_SYSTEM:
+{
+}
+break;
+case Ph_EV_WM:
+{
+PhWindowEvent_t *wmevent = NULL;
+/* Get associated event data */
+wmevent = PhGetData(event);
+if (wmevent == NULL) {
+break;
+}
+switch (wmevent->event_f) {
+case Ph_WM_CLOSE:
 {
-for (it=0; it<sizeof(pevent->buttons)*8; it++)
+if (window != NULL) {
-{
+SDL_SendWindowEvent(window->id,
-if ((pevent->buttons&(0x0001<<it))==(0x0001<<it))
+SDL_WINDOWEVENT_CLOSE,
-{
+0, 0);
-switch (it)
+}
-{
-case 0:
-{
-sdlbutton=SDL_BUTTON_RIGHT;
-}
-break;
-case 1:
-{
-sdlbutton=SDL_BUTTON_MIDDLE;
-}
-break;
-case 2:
-{
-sdlbutton=SDL_BUTTON_LEFT;
-}
-break;
-default:
-{
-sdlbutton=it+1;
-}
-break;
-}
-}
-}
 }
+break;
-switch(event->subtype)
+case Ph_WM_FOCUS:
 {
-case Ph_EV_RELEASE_REAL:
+if (wmevent->event_state ==
-{
+Ph_WM_EVSTATE_FOCUS) {
-/* Real release button event */
+if (window != NULL) {
-SDL_SendMouseButton(0, SDL_RELEASED, sdlbutton);
+PhRegion_t wregion;
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_FOCUS_GAINED,
+0, 0);
+SDL_SetKeyboardFocus(0, window->id);
+/* Set window region sensible to mouse motion events */
+PhRegionQuery(PtWidgetRid
+(wdata->window),
+&wregion, NULL, NULL,
+0);
+wregion.events_sense |=
+Ph_EV_PTR_MOTION_BUTTON |
+Ph_EV_PTR_MOTION_NOBUTTON;
+PhRegionChange(Ph_REGION_EV_SENSE, 0,
+&wregion, NULL, NULL);
+/* If window got a focus, the it is visible */
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_SHOWN,
+0, 0);
 }
-break;
+}
-case Ph_EV_RELEASE_PHANTOM:
+if (wmevent->event_state ==
-{
+Ph_WM_EVSTATE_FOCUSLOST) {
-/* We will get phantom button release */
+if (window != NULL) {
-/* event in case if it was unpressed  */
+PhRegion_t wregion;
-/* outside of window                  */
-if (window!=NULL)
+SDL_SendWindowEvent(window->id,
-{
+SDL_WINDOWEVENT_FOCUS_LOST,
-if ((window->flags & SDL_WINDOW_MOUSE_FOCUS)!=SDL_WINDOW_MOUSE_FOCUS)
+0, 0);
-{
-/* Send phantom button release */
+/* Set window region ignore mouse motion events */
-SDL_SendMouseButton(0, SDL_RELEASED, sdlbutton);
+PhRegionQuery(PtWidgetRid
-}
+(wdata->window),
-}
+&wregion, NULL, NULL,
+0);
+wregion.events_sense &=
+~(Ph_EV_PTR_MOTION_BUTTON |
+Ph_EV_PTR_MOTION_NOBUTTON);
+PhRegionChange(Ph_REGION_EV_SENSE, 0,
+&wregion, NULL, NULL);
 }
-break;
+}
 }
-}
+break;
-break;
+case Ph_WM_MOVE:
-case Ph_EV_EXPOSE:
-{
-switch(event->subtype)
 {
-case Ph_NORMAL_EXPOSE:
+if (window != NULL) {
-{
+SDL_SendWindowEvent(window->id,
-PhRect_t* rects=NULL;
+SDL_WINDOWEVENT_MOVED,
+wmevent->pos.x,
-/* Get array of rectangles to be updated */
+wmevent->pos.y);
-rects=PhGetRects(event);
+}
-if (rects==NULL)
-{
-break;
-}
-/* Check if expose come to one of the our windows */
-if ((wdata!=NULL) && (window!=NULL))
-{
-/* Check if window uses OpenGL ES */
-if (wdata->uses_gles==SDL_TRUE)
-{
-PhRect_t dst_rect;
-PhRect_t src_rect;
-/* Cycle through each rectangle */
-for (it=0; it<event->num_rects; it++)
-{
-/* Blit OpenGL ES pixmap surface directly to window region */
-PgFFlush(Ph_START_DRAW);
-PgSetRegionCx(PhDCGetCurrent(), PtWidgetRid(wdata->window));
-PgClearTranslationCx(PgGetGCCx(PhDCGetCurrent()));
-PgContextBlit(wdata->phsurface, &rects[it], NULL, &rects[it]);
-PgFFlush(Ph_DONE_DRAW);
-PgWaitHWIdle();
-}
-}
-else
-{
-/* Normal window */
-/* TODO: update the damaged rectangles */
-}
-}
-/* Flush all blittings */
-PgFlush();
-}
-break;
-case Ph_CAPTURE_EXPOSE:
-{
-/* Check if expose come to one of the our windows */
-if ((wdata!=NULL) && (window!=NULL))
-{
-/* Check if window uses OpenGL ES */
-if (wdata->uses_gles==SDL_TRUE)
-{
-PhRect_t dst_rect;
-PhRect_t src_rect;
-/* Set blit area */
-dst_rect=*PtGetCanvas(wdata->window);
-src_rect.ul.x=0;
-src_rect.ul.y=0;
-src_rect.lr.x=window->w-1;
-src_rect.lr.y=window->h-1;
-/* We need to redraw entire window */
-PgFFlush(Ph_START_DRAW);
-PgSetRegionCx(PhDCGetCurrent(), PtWidgetRid(wdata->window));
-PgClearTranslationCx(PgGetGCCx(PhDCGetCurrent()));
-PgContextBlit(wdata->phsurface, &src_rect, NULL, &dst_rect);
-PgFFlush(Ph_DONE_DRAW);
-PgWaitHWIdle();
-}
-else
-{
-/* Normal window */
-/* TODO: update the damaged rectangles */
-/* We need to redraw entire window */
-}
-}
-}
-break;
-case Ph_GRAPHIC_EXPOSE:
-{
-/* TODO: What this event means ? */
-}
-break;
 }
-}
+break;
-break;
+case Ph_WM_RESIZE:
-case Ph_EV_INFO:
-{
-}
-break;
-case Ph_EV_KEY:
-{
-PhKeyEvent_t* keyevent=NULL;
-SDL_scancode scancode=SDL_SCANCODE_UNKNOWN;
-SDL_bool pressed=SDL_FALSE;
-keyevent=PhGetData(event);
-if (keyevent==NULL)
 {
-break;
+if (window != NULL) {
+/* Set new window position after resize */
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_MOVED,
+wmevent->pos.x,
+wmevent->pos.y);
+/* Set new window size after resize */
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_RESIZED,
+wmevent->size.w,
+wmevent->size.h);
+}
 }
+break;
-/* Check if key is repeated */
+case Ph_WM_HIDE:
-if ((keyevent->key_flags & Pk_KF_Key_Repeat)==Pk_KF_Key_Repeat)
 {
-/* Ignore such events */
+if (window != NULL) {
-break;
+/* Send new window state: minimized */
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_MINIMIZED,
+0, 0);
+/* In case window is minimized, then it is hidden */
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_HIDDEN,
+0, 0);
+}
 }
+break;
-/* Check if key has its own scancode */
+case Ph_WM_MAX:
-if ((keyevent->key_flags & Pk_KF_Scan_Valid)==Pk_KF_Scan_Valid)
 {
-if ((keyevent->key_flags & Pk_KF_Key_Down)==Pk_KF_Key_Down)
+if (window != NULL) {
-{
+SDL_SendWindowEvent(window->id,
-pressed=SDL_TRUE;
+SDL_WINDOWEVENT_MAXIMIZED,
-}
+0, 0);
-else
+}
-{
-pressed=SDL_FALSE;
-}
-scancode=photon_to_sdl_keymap(keyevent->key_scan);
-/* Add details for the pressed key */
-if ((keyevent->key_flags & Pk_KF_Cap_Valid)==Pk_KF_Cap_Valid)
-{
-switch(keyevent->key_cap)
-{
-case Pk_Hyper_R: /* Right windows flag key */
-scancode=SDL_SCANCODE_RGUI;
-break;
-case Pk_Control_R: /* Right Ctrl key */
-scancode=SDL_SCANCODE_RCTRL;
-break;
-case Pk_Alt_R: /* Right Alt key */
-scancode=SDL_SCANCODE_RALT;
-break;
-case Pk_Up: /* Up key but with invalid scan */
-if (scancode!=SDL_SCANCODE_UP)
-{
-/* This is a mouse wheel event */
-SDL_SendMouseWheel(0, 0, 1);
-return;
-}
-break;
-case Pk_KP_8: /* Up arrow or 8 on keypad */
-scancode=SDL_SCANCODE_KP_8;
-break;
-case Pk_Down: /* Down key but with invalid scan */
-if (scancode!=SDL_SCANCODE_DOWN)
-{
-/* This is a mouse wheel event */
-SDL_SendMouseWheel(0, 0, -1);
-return;
-}
-break;
-case Pk_KP_2: /* Down arrow or 2 on keypad */
-scancode=SDL_SCANCODE_KP_2;
-break;
-case Pk_Left: /* Left arrow key */
-scancode=SDL_SCANCODE_LEFT;
-break;
-case Pk_KP_4: /* Left arrow or 4 on keypad */
-scancode=SDL_SCANCODE_KP_4;
-break;
-case Pk_Right: /* Right arrow key */
-scancode=SDL_SCANCODE_RIGHT;
-break;
-case Pk_KP_6: /* Right arrow or 6 on keypad */
-scancode=SDL_SCANCODE_KP_6;
-break;
-case Pk_Insert: /* Insert key */
-scancode=SDL_SCANCODE_INSERT;
-break;
-case Pk_KP_0: /* Insert or 0 on keypad */
-scancode=SDL_SCANCODE_KP_0;
-break;
-case Pk_Home: /* Home key */
-scancode=SDL_SCANCODE_HOME;
-break;
-case Pk_KP_7: /* Home or 7 on keypad */
-scancode=SDL_SCANCODE_KP_7;
-break;
-case Pk_Pg_Up: /* PageUp key */
-scancode=SDL_SCANCODE_PAGEUP;
-break;
-case Pk_KP_9: /* PgUp or 9 on keypad */
-scancode=SDL_SCANCODE_KP_9;
-break;
-case Pk_Delete: /* Delete key */
-scancode=SDL_SCANCODE_DELETE;
-break;
-case Pk_KP_Decimal: /* Del or . on keypad */
-scancode=SDL_SCANCODE_KP_PERIOD;
-break;
-case Pk_End: /* End key */
-scancode=SDL_SCANCODE_END;
-break;
-case Pk_KP_1: /* End or 1 on keypad */
-scancode=SDL_SCANCODE_KP_1;
-break;
-case Pk_Pg_Down: /* PageDown key */
-scancode=SDL_SCANCODE_PAGEDOWN;
-break;
-case Pk_KP_3: /* PgDn or 3 on keypad */
-scancode=SDL_SCANCODE_KP_3;
-break;
-case Pk_KP_5: /* 5 on keypad */
-scancode=SDL_SCANCODE_KP_5;
-break;
-case Pk_KP_Enter:
-scancode=SDL_SCANCODE_KP_ENTER;
-break;
-case Pk_KP_Add:
-scancode=SDL_SCANCODE_KP_PLUS;
-break;
-case Pk_KP_Subtract:
-scancode=SDL_SCANCODE_KP_MINUS;
-break;
-case Pk_KP_Multiply:
-scancode=SDL_SCANCODE_KP_MULTIPLY;
-break;
-case Pk_KP_Divide:
-scancode=SDL_SCANCODE_KP_DIVIDE;
-break;
-case Pk_Pause:
-scancode=SDL_SCANCODE_PAUSE;
-break;
-}
-}
-/* Finally check if scancode has been decoded */
-if (scancode==SDL_SCANCODE_UNKNOWN)
-{
-/* Something was pressed, which is not supported */
-break;
-}
-/* Report pressed/released key to SDL */
-if (pressed==SDL_TRUE)
-{
-SDL_SendKeyboardKey(0, SDL_PRESSED, scancode);
-}
-else
-{
-SDL_SendKeyboardKey(0, SDL_RELEASED, scancode);
-}
-/* Photon doesn't send a release event for PrnScr key */
-if ((scancode==SDL_SCANCODE_PRINTSCREEN) && (pressed))
-{
-SDL_SendKeyboardKey(0, SDL_RELEASED, scancode);
-}
 }
-}
+break;
-break;
+case Ph_WM_RESTORE:
-case Ph_EV_SERVICE:
-{
-}
-break;
-case Ph_EV_SYSTEM:
-{
-}
-break;
-case Ph_EV_WM:
-{
-PhWindowEvent_t* wmevent=NULL;
-/* Get associated event data */
-wmevent=PhGetData(event);
-if (wmevent==NULL)
 {
-break;
+if (window != NULL) {
+SDL_SendWindowEvent(window->id,
+SDL_WINDOWEVENT_RESTORED,
+0, 0);
+}
 }
+break;
-switch(wmevent->event_f)
+}
-{
+}
-case Ph_WM_CLOSE:
+break;
-{
+}
-if (window!=NULL)
+PtEventHandler(event);
-{
+}
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_CLOSE, 0, 0);
+break;
-}
+case 0:
-}
+{
-break;
+/* All events are read */
-case Ph_WM_FOCUS:
+finish = 1;
-{
+break;
-if (wmevent->event_state==Ph_WM_EVSTATE_FOCUS)
+}
-{
+case -1:
-if (window!=NULL)
+{
-{
+/* Error occured in event reading */
-PhRegion_t wregion;
+SDL_SetError("Photon: Can't read event");
+return;
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);
+}
-SDL_SetKeyboardFocus(0, window->id);
+break;
+}
-/* Set window region sensible to mouse motion events */
+if (finish != 0) {
-PhRegionQuery(PtWidgetRid(wdata->window), &wregion, NULL, NULL, 0);
+break;
-wregion.events_sense|=Ph_EV_PTR_MOTION_BUTTON | Ph_EV_PTR_MOTION_NOBUTTON;
+}
-PhRegionChange(Ph_REGION_EV_SENSE, 0, &wregion, NULL, NULL);
+} while (1);
-/* If window got a focus, the it is visible */
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);
-}
-}
-if (wmevent->event_state==Ph_WM_EVSTATE_FOCUSLOST)
-{
-if (window!=NULL)
-{
-PhRegion_t wregion;
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
-/* Set window region ignore mouse motion events */
-PhRegionQuery(PtWidgetRid(wdata->window), &wregion, NULL, NULL, 0);
-wregion.events_sense&=~(Ph_EV_PTR_MOTION_BUTTON | Ph_EV_PTR_MOTION_NOBUTTON);
-PhRegionChange(Ph_REGION_EV_SENSE, 0, &wregion, NULL, NULL);
-}
-}
-}
-break;
-case Ph_WM_MOVE:
-{
-if (window!=NULL)
-{
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MOVED, wmevent->pos.x, wmevent->pos.y);
-}
-}
-break;
-case Ph_WM_RESIZE:
-{
-if (window!=NULL)
-{
-/* Set new window position after resize */
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MOVED, wmevent->pos.x, wmevent->pos.y);
-/* Set new window size after resize */
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESIZED, wmevent->size.w, wmevent->size.h);
-}
-}
-break;
-case Ph_WM_HIDE:
-{
-if (window!=NULL)
-{
-/* Send new window state: minimized */
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
-/* In case window is minimized, then it is hidden */
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);
-}
-}
-break;
-case Ph_WM_MAX:
-{
-if (window!=NULL)
-{
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
-}
-}
-break;
-case Ph_WM_RESTORE:
-{
-if (window!=NULL)
-{
-SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);
-}
-}
-break;
-}
-}
-break;
-}
-PtEventHandler(event);
-}
-break;
-case 0:
-{
-/* All events are read */
-finish=1;
-break;
-}
-case -1:
-{
-/* Error occured in event reading */
-SDL_SetError("Photon: Can't read event");
-return;
-}
-break;
-}
-if (finish!=0)
-{
-break;
-}
-} while(1);
 }
 /*****************************************************************************/
 /* SDL screen saver related functions                                        */
 /*****************************************************************************/
-void photon_suspendscreensaver(_THIS)
+void
-{
+photon_suspendscreensaver(_THIS)
-/* There is no screensaver in pure console, it may exist when running */
+{
-/* GF under Photon, but I do not know, how to disable screensaver     */
+/* There is no screensaver in pure console, it may exist when running */
+/* GF under Photon, but I do not know, how to disable screensaver     */
 }
 /* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/video/photon/SDL_photon.c @ 3139:7f684f249ec9