/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997-2012 Sam Lantinga

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

#include "SDL_config.h"

#include <unistd.h>

#include <sys/ioctl.h>

#include "SDL_endian.h"

#include "SDL_timer.h"

#include "SDL_thread.h"

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "../../events/SDL_events_c.h"

#include "SDL_ph_video.h"

#include "SDL_ph_modes_c.h"

#include "SDL_ph_image_c.h"

#include "SDL_ph_events_c.h"

#include "SDL_ph_mouse_c.h"

#include "SDL_ph_wm_c.h"

#include "SDL_ph_gl.h"

#include "SDL_phyuv_c.h"

#include "../blank_cursor.h"

static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat);

static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);

static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);

static void ph_VideoQuit(_THIS);

static void ph_DeleteDevice(SDL_VideoDevice *device);

static int phstatus=-1;

static int ph_Available(void)

{

if (phstatus!=0)

{

phstatus=PtInit(NULL);

if (phstatus==0)

{

return 1;

}

else

{

return 0;

}

}

return 1;

}

static SDL_VideoDevice* ph_CreateDevice(int devindex)

{

SDL_VideoDevice* device;

/* Initialize all variables that we clean on shutdown */

device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));

if (device)

{

SDL_memset(device, 0, (sizeof *device));

device->hidden = (struct SDL_PrivateVideoData*)SDL_malloc((sizeof *device->hidden));

device->gl_data = NULL;

}

if ((device == NULL) || (device->hidden == NULL))

{

SDL_OutOfMemory();

ph_DeleteDevice(device);

return NULL;

}

SDL_memset(device->hidden, 0, (sizeof *device->hidden));

/* Set the driver flags */

device->handles_any_size = 1;

/* Set the function pointers */

device->CreateYUVOverlay = ph_CreateYUVOverlay;

device->VideoInit = ph_VideoInit;

device->ListModes = ph_ListModes;

device->SetVideoMode = ph_SetVideoMode;

device->ToggleFullScreen = ph_ToggleFullScreen;

device->UpdateMouse = ph_UpdateMouse;

device->SetColors = ph_SetColors;

device->UpdateRects = NULL; /* set up in ph_SetupUpdateFunction */

device->VideoQuit = ph_VideoQuit;

device->AllocHWSurface = ph_AllocHWSurface;

device->CheckHWBlit = ph_CheckHWBlit;

device->FillHWRect = ph_FillHWRect;

device->SetHWColorKey = ph_SetHWColorKey;

device->SetHWAlpha = ph_SetHWAlpha;

device->LockHWSurface = ph_LockHWSurface;

device->UnlockHWSurface = ph_UnlockHWSurface;

device->FlipHWSurface = ph_FlipHWSurface;

device->FreeHWSurface = ph_FreeHWSurface;

device->SetCaption = ph_SetCaption;

device->SetIcon = NULL;

device->IconifyWindow = ph_IconifyWindow;

device->GrabInput = ph_GrabInput;

device->GetWMInfo = ph_GetWMInfo;

device->FreeWMCursor = ph_FreeWMCursor;

device->CreateWMCursor = ph_CreateWMCursor;

device->ShowWMCursor = ph_ShowWMCursor;

device->WarpWMCursor = ph_WarpWMCursor;

device->MoveWMCursor = NULL;

device->CheckMouseMode = ph_CheckMouseMode;

device->InitOSKeymap = ph_InitOSKeymap;

device->PumpEvents = ph_PumpEvents;

/* OpenGL support. */

#if SDL_VIDEO_OPENGL

device->GL_MakeCurrent = ph_GL_MakeCurrent;

device->GL_SwapBuffers = ph_GL_SwapBuffers;

device->GL_GetAttribute = ph_GL_GetAttribute;

device->GL_LoadLibrary = ph_GL_LoadLibrary;

device->GL_GetProcAddress = ph_GL_GetProcAddress;

#endif /* SDL_VIDEO_OPENGL */

device->free = ph_DeleteDevice;

return device;

}

VideoBootStrap ph_bootstrap = {

"photon", "QNX Photon video output",

ph_Available, ph_CreateDevice

};

static void ph_DeleteDevice(SDL_VideoDevice *device)

{

if (device)

{

if (device->hidden)

{

SDL_free(device->hidden);

device->hidden = NULL;

}

if (device->gl_data)

{

SDL_free(device->gl_data);

device->gl_data = NULL;

}

SDL_free(device);

device = NULL;

}

}

static PtWidget_t *ph_CreateWindow(_THIS)

{

PtWidget_t *widget;

widget = PtCreateWidget(PtWindow, NULL, 0, NULL);

return widget;

}

static int ph_SetupWindow(_THIS, int w, int h, int flags)

{

PtArg_t args[32];

PhPoint_t pos = {0, 0};

PhDim_t* olddim;

PhDim_t dim = {w, h};

PhRect_t desktopextent;

int nargs = 0;

const char* windowpos;

const char* iscentered;

int x, y;

/* check if window size has been changed by Window Manager */

PtGetResource(window, Pt_ARG_DIM, &olddim, 0);

if ((olddim->w!=w) || (olddim->h!=h))

{

PtSetArg(&args[nargs++], Pt_ARG_DIM, &dim, 0);

}

if ((flags & SDL_RESIZABLE) == SDL_RESIZABLE)

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_MAX | Ph_WM_RESTORE | Ph_WM_RESIZE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_RESIZE | Ph_WM_MOVE | Ph_WM_CLOSE | Ph_WM_MAX | Ph_WM_RESTORE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX | Ph_WM_RENDER_COLLAPSE | Ph_WM_RENDER_RETURN);

PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_TRUE, Pt_RESIZE_XY_AS_REQUIRED);

}

else

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_RESIZE | Ph_WM_MAX | Ph_WM_RESTORE | Ph_WM_CLOSE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_FALSE, Ph_WM_RESIZE | Ph_WM_MAX | Ph_WM_RESTORE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_MOVE | Ph_WM_CLOSE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX | Ph_WM_RENDER_COLLAPSE | Ph_WM_RENDER_RETURN);

PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED);

}

if (((flags & SDL_NOFRAME)==SDL_NOFRAME) || ((flags & SDL_FULLSCREEN)==SDL_FULLSCREEN))

{

if ((flags & SDL_RESIZABLE) != SDL_RESIZABLE)

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Pt_TRUE);

}

else

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Pt_TRUE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_BORDER);

}

}

else

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_BORDER | Ph_WM_RENDER_TITLE |

Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_MENU | Ph_WM_RENDER_MIN);

}

if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)

{

PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);

PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_FFRONT | Ph_WM_MAX | Ph_WM_TOFRONT | Ph_WM_CONSWITCH);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT | Ph_WM_STATE_ISFOCUS | Ph_WM_STATE_ISALTKEY);

}

else

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_FFRONT | Ph_WM_CONSWITCH);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISFRONT);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISALTKEY);

if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE)

{

PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL);

}

else

{

PtSetArg(&args[nargs++], Pt_ARG_FILL_COLOR, Pg_BLACK, 0);

}

if (!currently_maximized)

{

windowpos = SDL_getenv("SDL_VIDEO_WINDOW_POS");

iscentered = SDL_getenv("SDL_VIDEO_CENTERED");

if ((iscentered) || ((windowpos) && (SDL_strcmp(windowpos, "center")==0)))

{

PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent);

if (desktop_mode.width>w)

{

pos.x = (desktop_mode.width - w)/2;

}

if (desktop_mode.height>h)

{

pos.y = (desktop_mode.height - h)/2;

}

pos.x+=desktopextent.ul.x;

pos.y+=desktopextent.ul.y;

PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);

}

else

{

if (windowpos)

{

if (SDL_sscanf(windowpos, "%d,%d", &x, &y) == 2)

{

if ((x<desktop_mode.width) && (y<desktop_mode.height))

{

PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent);

pos.x=x+desktopextent.ul.x;

pos.y=y+desktopextent.ul.y;

}

PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);

}

}

}

}

/* if window is maximized render it as maximized */

if (currently_maximized)

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISMAX);

}

else

{

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISMAX);

}

/* do not grab the keyboard by default */

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISALTKEY);

/* bring the focus to the window */

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFOCUS);

/* allow to catch hide event */

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_HIDE);

PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_HIDE);

}

PtSetResources(window, nargs, args);

PtRealizeWidget(window);

PtWindowToFront(window);

#if 0 /* FIXME */

PtGetResource(window, Pt_ARG_POS, &olddim, 0);

fprintf(stderr, "POSITION: %d, %d\n", olddim->w, olddim->h);

#endif

return 0;

}

static const struct ColourMasks* ph_GetColourMasks(int bpp)

{

/* The alpha mask doesn't appears to be needed */

static const struct ColourMasks phColorMasks[5] = {

/* 8 bit */ {0, 0, 0, 0, 8},

/* 15 bit ARGB */ {0x7C00, 0x03E0, 0x001F, 0x8000, 15},

/* 16 bit RGB */ {0xF800, 0x07E0, 0x001F, 0x0000, 16},

/* 24 bit RGB */ {0xFF0000, 0x00FF00, 0x0000FF, 0x000000, 24},

/* 32 bit ARGB */ {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000, 32},

};

switch (bpp)

{

case 8:

return &phColorMasks[0];

case 15:

return &phColorMasks[1];

case 16:

return &phColorMasks[2];

case 24:

return &phColorMasks[3];

case 32:

return &phColorMasks[4];

}

return NULL;

}

static int ph_VideoInit(_THIS, SDL_PixelFormat* vformat)

{

PgHWCaps_t hwcaps;

int i;

window=NULL;

desktoppal=SDLPH_PAL_NONE;

#if SDL_VIDEO_OPENGL

oglctx=NULL;

oglbuffers=NULL;

oglflags=0;

oglbpp=0;

#endif

old_video_mode=-1;

old_refresh_rate=-1;

if (NULL == (phevent = SDL_malloc(EVENT_SIZE)))

{

SDL_OutOfMemory();

return -1;

}

SDL_memset(phevent, 0x00, EVENT_SIZE);

window = ph_CreateWindow(this);

if (window == NULL)

{

SDL_SetError("ph_VideoInit(): Couldn't create video window !\n");

return -1;

}

/* Create the blank cursor */

SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,

(int)BLANK_CWIDTH, (int)BLANK_CHEIGHT,

(int)BLANK_CHOTX, (int)BLANK_CHOTY);

if (SDL_BlankCursor == NULL)

{

return -1;

}

if (PgGetGraphicsHWCaps(&hwcaps) < 0)

{

SDL_SetError("ph_VideoInit(): GetGraphicsHWCaps function failed !\n");

this->FreeWMCursor(this, SDL_BlankCursor);

return -1;

}

if (PgGetVideoModeInfo(hwcaps.current_video_mode, &desktop_mode) < 0)

{

SDL_SetError("ph_VideoInit(): PgGetVideoModeInfo function failed !\n");

this->FreeWMCursor(this, SDL_BlankCursor);

return -1;

}

/* Determine the current screen size */

this->info.current_w = desktop_mode.width;

this->info.current_h = desktop_mode.height;

/* We need to return BytesPerPixel as it in used by CreateRGBsurface */

vformat->BitsPerPixel = desktop_mode.bits_per_pixel;

vformat->BytesPerPixel = desktop_mode.bytes_per_scanline/desktop_mode.width;

desktopbpp = desktop_mode.bits_per_pixel;

/* save current palette */

if (desktopbpp==8)

{

PgGetPalette(savedpal);

PgGetPalette(syspalph);

}

else

{

for(i=0; i<_Pg_MAX_PALETTE; i++)

{

savedpal[i]=PgRGB(0, 0, 0);

syspalph[i]=PgRGB(0, 0, 0);

}

}

currently_fullscreen = 0;

currently_hided = 0;

currently_maximized = 0;

current_overlay = NULL;

OCImage.direct_context = NULL;

OCImage.offscreen_context = NULL;

OCImage.offscreen_backcontext = NULL;

OCImage.oldDC = NULL;

OCImage.CurrentFrameData = NULL;

OCImage.FrameData0 = NULL;

OCImage.FrameData1 = NULL;

videomode_emulatemode = 0;

this->info.wm_available = 1;

ph_UpdateHWInfo(this);

return 0;

}

static SDL_Surface* ph_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)

{

const struct ColourMasks* mask;

/* Lock the event thread, in multi-threading environments */

SDL_Lock_EventThread();

current->flags = flags;

/* if we do not have desired fullscreen mode, then fallback into window mode */

if (((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) && (ph_GetVideoMode(width, height, bpp)==0))

{

current->flags &= ~SDL_FULLSCREEN;

current->flags &= ~SDL_NOFRAME;

current->flags &= ~SDL_RESIZABLE;

}

ph_SetupWindow(this, width, height, current->flags);

mask = ph_GetColourMasks(bpp);

if (mask != NULL)

{

SDL_ReallocFormat(current, mask->bpp, mask->red, mask->green, mask->blue, 0);

}

else

{

SDL_SetError("ph_SetVideoMode(): desired bpp is not supported by photon !\n");

return NULL;

}

if ((current->flags & SDL_OPENGL)==SDL_OPENGL)

{

#if !SDL_VIDEO_OPENGL

/* if no built-in OpenGL support */

SDL_SetError("ph_SetVideoMode(): no OpenGL support, you need to recompile SDL.\n");

current->flags &= ~SDL_OPENGL;

return NULL;

#endif /* SDL_VIDEO_OPENGL */

}

else

{

/* Initialize internal variables */

if ((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)

{

if (bpp==8)

{

desktoppal=SDLPH_PAL_SYSTEM;

}

current->flags &= ~SDL_RESIZABLE; /* no resize for Direct Context */

current->flags |= SDL_HWSURFACE;

}

else

{

/* remove this if we'll have support for the non-fullscreen sw/hw+doublebuf one day */

current->flags &= ~SDL_DOUBLEBUF;

/* Use offscreen memory if SDL_HWSURFACE flag is set */

if ((current->flags & SDL_HWSURFACE) == SDL_HWSURFACE)

{

if (desktopbpp!=bpp)

{

current->flags &= ~SDL_HWSURFACE;

}

}

/* using palette emulation code in window mode */

if (bpp==8)

{

if (desktopbpp>=15)

{

desktoppal = SDLPH_PAL_EMULATE;

}

else

{

desktoppal = SDLPH_PAL_SYSTEM;

}

}

else

{

desktoppal = SDLPH_PAL_NONE;

}

}

}

current->w = width;

current->h = height;

if (desktoppal==SDLPH_PAL_SYSTEM)

{

current->flags|=SDL_HWPALETTE;

}

/* Must call at least once for setup image planes */

if (ph_SetupUpdateFunction(this, current, current->flags)==-1)

{

/* Error string was filled in the ph_SetupUpdateFunction() */

return NULL;

}

/* finish window drawing, if we are not in fullscreen, of course */

if ((current->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN)

{

PtFlush();

}

else

{

PgFlush();

}

visualbpp=bpp;

ph_UpdateHWInfo(this);

SDL_Unlock_EventThread();

/* We've done! */

return (current);

}

static void ph_VideoQuit(_THIS)

{

/* restore palette */

if (desktopbpp==8)

{

PgSetPalette(syspalph, 0, -1, 0, 0, 0);

PgSetPalette(savedpal, 0, 0, _Pg_MAX_PALETTE, Pg_PALSET_GLOBAL | Pg_PALSET_FORCE_EXPOSE, 0);

PgFlush();

}

ph_DestroyImage(this, SDL_VideoSurface);

if (window)

{

PtUnrealizeWidget(window);

PtDestroyWidget(window);

window=NULL;

}

if (phevent!=NULL)

{

SDL_free(phevent);

phevent=NULL;

}

}

static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)

{

int i;

SDL_Rect updaterect;

updaterect.x = updaterect.y = 0;

updaterect.w = this->screen->w;

updaterect.h = this->screen->h;

/* palette emulation code, using palette of the PhImage_t struct */

if (desktoppal==SDLPH_PAL_EMULATE)

{

if ((SDL_Image) && (SDL_Image->palette))

{

for (i=firstcolor; i<firstcolor+ncolors; i++)

{

syspalph[i] = PgRGB(colors[i-firstcolor].r, colors[i-firstcolor].g, colors[i-firstcolor].b);

SDL_Image->palette[i] = syspalph[i];

}

/* image needs to be redrawn */

this->UpdateRects(this, 1, &updaterect);

}

}

else

{

if (desktoppal==SDLPH_PAL_SYSTEM)

{

for (i=firstcolor; i<firstcolor+ncolors; i++)

{

syspalph[i] = PgRGB(colors[i-firstcolor].r, colors[i-firstcolor].g, colors[i-firstcolor].b);

}

if ((this->screen->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN)

{

/* window mode must use soft palette */

PgSetPalette(&syspalph[firstcolor], 0, firstcolor, ncolors, Pg_PALSET_GLOBAL, 0);

/* image needs to be redrawn */

this->UpdateRects(this, 1, &updaterect);

}

else

{

/* fullscreen mode must use hardware palette */

PgSetPalette(&syspalph[firstcolor], 0, firstcolor, ncolors, Pg_PALSET_GLOBAL, 0);

}

}

else

{

/* SDLPH_PAL_NONE do nothing */

}

}

return 1;

}