[sdl_omap.git] / src / video / photon / SDL_ph_video.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 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;
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	#include <unistd.h>
	25	#include <sys/ioctl.h>
	26
	27	#include "SDL_endian.h"
	28	#include "SDL_timer.h"
	29	#include "SDL_thread.h"
	30	#include "SDL_video.h"
	31	#include "SDL_mouse.h"
	32	#include "../SDL_sysvideo.h"
	33	#include "../SDL_pixels_c.h"
	34	#include "../../events/SDL_events_c.h"
	35	#include "SDL_ph_video.h"
	36	#include "SDL_ph_modes_c.h"
	37	#include "SDL_ph_image_c.h"
	38	#include "SDL_ph_events_c.h"
	39	#include "SDL_ph_mouse_c.h"
	40	#include "SDL_ph_wm_c.h"
	41	#include "SDL_ph_gl.h"
	42	#include "SDL_phyuv_c.h"
	43	#include "../blank_cursor.h"
	44
	45	static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat);
	46	static SDL_Surface ph_SetVideoMode(_THIS, SDL_Surface current, int width, int height, int bpp, Uint32 flags);
	47	static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
	48	static void ph_VideoQuit(_THIS);
	49	static void ph_DeleteDevice(SDL_VideoDevice *device);
	50
	51	static int phstatus=-1;
	52
	53	static int ph_Available(void)
	54	{
	55	if (phstatus!=0)
	56	{
	57	phstatus=PtInit(NULL);
	58	if (phstatus==0)
	59	{
	60	return 1;
	61	}
	62	else
	63	{
	64	return 0;
65	}
66	}
67	return 1;
68	}
69
70	static SDL_VideoDevice* ph_CreateDevice(int devindex)
71	{
72	SDL_VideoDevice* device;
73
74	/* Initialize all variables that we clean on shutdown */
75	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
76	if (device)
77	{
78	SDL_memset(device, 0, (sizeof *device));
79	device->hidden = (struct SDL_PrivateVideoData)SDL_malloc((sizeof device->hidden));
80	device->gl_data = NULL;
81	}
82	if ((device == NULL) \|\| (device->hidden == NULL))
83	{
84	SDL_OutOfMemory();
85	ph_DeleteDevice(device);
86	return NULL;
87	}
88	SDL_memset(device->hidden, 0, (sizeof *device->hidden));
89
90	/* Set the driver flags */
91	device->handles_any_size = 1;
92
93	/* Set the function pointers */
94	device->CreateYUVOverlay = ph_CreateYUVOverlay;
95	device->VideoInit = ph_VideoInit;
96	device->ListModes = ph_ListModes;
97	device->SetVideoMode = ph_SetVideoMode;
98	device->ToggleFullScreen = ph_ToggleFullScreen;
99	device->UpdateMouse = ph_UpdateMouse;
100	device->SetColors = ph_SetColors;
101	device->UpdateRects = NULL; /* set up in ph_SetupUpdateFunction */
102	device->VideoQuit = ph_VideoQuit;
103	device->AllocHWSurface = ph_AllocHWSurface;
104	device->CheckHWBlit = ph_CheckHWBlit;
105	device->FillHWRect = ph_FillHWRect;
106	device->SetHWColorKey = ph_SetHWColorKey;
107	device->SetHWAlpha = ph_SetHWAlpha;
108	device->LockHWSurface = ph_LockHWSurface;
109	device->UnlockHWSurface = ph_UnlockHWSurface;
110	device->FlipHWSurface = ph_FlipHWSurface;
111	device->FreeHWSurface = ph_FreeHWSurface;
112	device->SetCaption = ph_SetCaption;
113	device->SetIcon = NULL;
114	device->IconifyWindow = ph_IconifyWindow;
115	device->GrabInput = ph_GrabInput;
116	device->GetWMInfo = ph_GetWMInfo;
117	device->FreeWMCursor = ph_FreeWMCursor;
118	device->CreateWMCursor = ph_CreateWMCursor;
119	device->ShowWMCursor = ph_ShowWMCursor;
120	device->WarpWMCursor = ph_WarpWMCursor;
121	device->MoveWMCursor = NULL;
122	device->CheckMouseMode = ph_CheckMouseMode;
123	device->InitOSKeymap = ph_InitOSKeymap;
124	device->PumpEvents = ph_PumpEvents;
125
126	/* OpenGL support. */
127	#if SDL_VIDEO_OPENGL
128	device->GL_MakeCurrent = ph_GL_MakeCurrent;
129	device->GL_SwapBuffers = ph_GL_SwapBuffers;
130	device->GL_GetAttribute = ph_GL_GetAttribute;
131	device->GL_LoadLibrary = ph_GL_LoadLibrary;
132	device->GL_GetProcAddress = ph_GL_GetProcAddress;
133	#endif /* SDL_VIDEO_OPENGL */
134
135	device->free = ph_DeleteDevice;
136
137	return device;
138	}
139
140	VideoBootStrap ph_bootstrap = {
141	"photon", "QNX Photon video output",
142	ph_Available, ph_CreateDevice
143	};
144
145	static void ph_DeleteDevice(SDL_VideoDevice *device)
146	{
147	if (device)
148	{
149	if (device->hidden)
150	{
151	SDL_free(device->hidden);
152	device->hidden = NULL;
153	}
154	if (device->gl_data)
155	{
156	SDL_free(device->gl_data);
157	device->gl_data = NULL;
158	}
159	SDL_free(device);
160	device = NULL;
161	}
162	}
163
164	static PtWidget_t *ph_CreateWindow(_THIS)
165	{
166	PtWidget_t *widget;
167
168	widget = PtCreateWidget(PtWindow, NULL, 0, NULL);
169
170	return widget;
171	}
172
173	static int ph_SetupWindow(_THIS, int w, int h, int flags)
174	{
175	PtArg_t args[32];
176	PhPoint_t pos = {0, 0};
177	PhDim_t* olddim;
178	PhDim_t dim = {w, h};
179	PhRect_t desktopextent;
180	int nargs = 0;
181	const char* windowpos;
182	const char* iscentered;
183	int x, y;
184
185	/* check if window size has been changed by Window Manager */
186	PtGetResource(window, Pt_ARG_DIM, &olddim, 0);
187	if ((olddim->w!=w) \|\| (olddim->h!=h))
188	{
189	PtSetArg(&args[nargs++], Pt_ARG_DIM, &dim, 0);
190	}
191
192	if ((flags & SDL_RESIZABLE) == SDL_RESIZABLE)
193	{
194	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE);
195	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_MAX \| Ph_WM_RESTORE \| Ph_WM_RESIZE);
196	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);
197	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);
198	PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_TRUE, Pt_RESIZE_XY_AS_REQUIRED);
199	}
200	else
201	{
202	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_RESIZE \| Ph_WM_MAX \| Ph_WM_RESTORE \| Ph_WM_CLOSE);
203	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_FALSE, Ph_WM_RESIZE \| Ph_WM_MAX \| Ph_WM_RESTORE);
204	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_MOVE \| Ph_WM_CLOSE);
205	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);
206	PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED);
207	}
208
209	if (((flags & SDL_NOFRAME)==SDL_NOFRAME) \|\| ((flags & SDL_FULLSCREEN)==SDL_FULLSCREEN))
210	{
211	if ((flags & SDL_RESIZABLE) != SDL_RESIZABLE)
212	{
213	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Pt_TRUE);
214	}
215	else
216	{
217	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Pt_TRUE);
218	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_RESIZE \| Ph_WM_RENDER_BORDER);
219	}
220	}
221	else
222	{
223	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_BORDER \| Ph_WM_RENDER_TITLE \|
224	Ph_WM_RENDER_CLOSE \| Ph_WM_RENDER_MENU \| Ph_WM_RENDER_MIN);
225	}
226
227	if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)
228	{
229	PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);
230	PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL);
231	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_FFRONT \| Ph_WM_MAX \| Ph_WM_TOFRONT \| Ph_WM_CONSWITCH);
232	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT \| Ph_WM_STATE_ISFOCUS \| Ph_WM_STATE_ISALTKEY);
233	}
234	else
235	{
236	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_FFRONT \| Ph_WM_CONSWITCH);
237	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISFRONT);
238	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISALTKEY);
239
240	if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE)
241	{
242	PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL);
243	}
244	else
245	{
246	PtSetArg(&args[nargs++], Pt_ARG_FILL_COLOR, Pg_BLACK, 0);
247	}
248	if (!currently_maximized)
249	{
250	windowpos = SDL_getenv("SDL_VIDEO_WINDOW_POS");
251	iscentered = SDL_getenv("SDL_VIDEO_CENTERED");
252
253	if ((iscentered) \|\| ((windowpos) && (SDL_strcmp(windowpos, "center")==0)))
254	{
255	PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent);
256	if (desktop_mode.width>w)
257	{
258	pos.x = (desktop_mode.width - w)/2;
259	}
260	if (desktop_mode.height>h)
261	{
262	pos.y = (desktop_mode.height - h)/2;
263	}
264
265	pos.x+=desktopextent.ul.x;
266	pos.y+=desktopextent.ul.y;
267	PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);
268	}
269	else
270	{
271	if (windowpos)
272	{
273	if (SDL_sscanf(windowpos, "%d,%d", &x, &y) == 2)
274	{
275	if ((x<desktop_mode.width) && (y<desktop_mode.height))
276	{
277	PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent);
278	pos.x=x+desktopextent.ul.x;
279	pos.y=y+desktopextent.ul.y;
280	}
281	PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0);
282	}
283	}
284	}
285	}
286
287	/* if window is maximized render it as maximized */
288	if (currently_maximized)
289	{
290	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISMAX);
291	}
292	else
293	{
294	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISMAX);
295	}
296
297	/* do not grab the keyboard by default */
298	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISALTKEY);
299
300	/* bring the focus to the window */
301	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFOCUS);
302
303	/* allow to catch hide event */
304	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_HIDE);
305	PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_HIDE);
306	}
307
308	PtSetResources(window, nargs, args);
309	PtRealizeWidget(window);
310	PtWindowToFront(window);
311
312	#if 0 /* FIXME */
313	PtGetResource(window, Pt_ARG_POS, &olddim, 0);
314	fprintf(stderr, "POSITION: %d, %d\n", olddim->w, olddim->h);
315	#endif
316
317	return 0;
318	}
319
320	static const struct ColourMasks* ph_GetColourMasks(int bpp)
321	{
322	/* The alpha mask doesn't appears to be needed */
323	static const struct ColourMasks phColorMasks[5] = {
324	/* 8 bit */ {0, 0, 0, 0, 8},
325	/* 15 bit ARGB */ {0x7C00, 0x03E0, 0x001F, 0x8000, 15},
326	/* 16 bit RGB */ {0xF800, 0x07E0, 0x001F, 0x0000, 16},
327	/* 24 bit RGB */ {0xFF0000, 0x00FF00, 0x0000FF, 0x000000, 24},
328	/* 32 bit ARGB */ {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000, 32},
329	};
330
331	switch (bpp)
332	{
333	case 8:
334	return &phColorMasks[0];
335	case 15:
336	return &phColorMasks[1];
337	case 16:
338	return &phColorMasks[2];
339	case 24:
340	return &phColorMasks[3];
341	case 32:
342	return &phColorMasks[4];
343	}
344	return NULL;
345	}
346
347	static int ph_VideoInit(_THIS, SDL_PixelFormat* vformat)
348	{
349	PgHWCaps_t hwcaps;
350	int i;
351
352	window=NULL;
353	desktoppal=SDLPH_PAL_NONE;
354
355	#if SDL_VIDEO_OPENGL
356	oglctx=NULL;
357	oglbuffers=NULL;
358	oglflags=0;
359	oglbpp=0;
360	#endif
361
362	old_video_mode=-1;
363	old_refresh_rate=-1;
364
365	if (NULL == (phevent = SDL_malloc(EVENT_SIZE)))
366	{
367	SDL_OutOfMemory();
368	return -1;
369	}
370	SDL_memset(phevent, 0x00, EVENT_SIZE);
371
372	window = ph_CreateWindow(this);
373	if (window == NULL)
374	{
375	SDL_SetError("ph_VideoInit(): Couldn't create video window !\n");
376	return -1;
377	}
378
379	/* Create the blank cursor */
380	SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
381	(int)BLANK_CWIDTH, (int)BLANK_CHEIGHT,
382	(int)BLANK_CHOTX, (int)BLANK_CHOTY);
383
384	if (SDL_BlankCursor == NULL)
385	{
386	return -1;
387	}
388
389	if (PgGetGraphicsHWCaps(&hwcaps) < 0)
390	{
391	SDL_SetError("ph_VideoInit(): GetGraphicsHWCaps function failed !\n");
392	this->FreeWMCursor(this, SDL_BlankCursor);
393	return -1;
394	}
395
396	if (PgGetVideoModeInfo(hwcaps.current_video_mode, &desktop_mode) < 0)
397	{
398	SDL_SetError("ph_VideoInit(): PgGetVideoModeInfo function failed !\n");
399	this->FreeWMCursor(this, SDL_BlankCursor);
400	return -1;
401	}
402
403	/* Determine the current screen size */
404	this->info.current_w = desktop_mode.width;
405	this->info.current_h = desktop_mode.height;
406
407	/* We need to return BytesPerPixel as it in used by CreateRGBsurface */
408	vformat->BitsPerPixel = desktop_mode.bits_per_pixel;
409	vformat->BytesPerPixel = desktop_mode.bytes_per_scanline/desktop_mode.width;
410	desktopbpp = desktop_mode.bits_per_pixel;
411
412	/* save current palette */
413	if (desktopbpp==8)
414	{
415	PgGetPalette(savedpal);
416	PgGetPalette(syspalph);
417	}
418	else
419	{
420	for(i=0; i<_Pg_MAX_PALETTE; i++)
421	{
422	savedpal[i]=PgRGB(0, 0, 0);
423	syspalph[i]=PgRGB(0, 0, 0);
424	}
425	}
426
427	currently_fullscreen = 0;
428	currently_hided = 0;
429	currently_maximized = 0;
430	current_overlay = NULL;
431
432	OCImage.direct_context = NULL;
433	OCImage.offscreen_context = NULL;
434	OCImage.offscreen_backcontext = NULL;
435	OCImage.oldDC = NULL;
436	OCImage.CurrentFrameData = NULL;
437	OCImage.FrameData0 = NULL;
438	OCImage.FrameData1 = NULL;
439	videomode_emulatemode = 0;
440
441	this->info.wm_available = 1;
442
443	ph_UpdateHWInfo(this);
444
445	return 0;
446	}
447
448	static SDL_Surface* ph_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
449	{
450	const struct ColourMasks* mask;
451
452	/* Lock the event thread, in multi-threading environments */
453	SDL_Lock_EventThread();
454
455	current->flags = flags;
456
457	/* if we do not have desired fullscreen mode, then fallback into window mode */
458	if (((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) && (ph_GetVideoMode(width, height, bpp)==0))
459	{
460	current->flags &= ~SDL_FULLSCREEN;
461	current->flags &= ~SDL_NOFRAME;
462	current->flags &= ~SDL_RESIZABLE;
463	}
464
465	ph_SetupWindow(this, width, height, current->flags);
466
467	mask = ph_GetColourMasks(bpp);
468	if (mask != NULL)
469	{
470	SDL_ReallocFormat(current, mask->bpp, mask->red, mask->green, mask->blue, 0);
471	}
472	else
473	{
474	SDL_SetError("ph_SetVideoMode(): desired bpp is not supported by photon !\n");
475	return NULL;
476	}
477
478	if ((current->flags & SDL_OPENGL)==SDL_OPENGL)
479	{
480	#if !SDL_VIDEO_OPENGL
481	/* if no built-in OpenGL support */
482	SDL_SetError("ph_SetVideoMode(): no OpenGL support, you need to recompile SDL.\n");
483	current->flags &= ~SDL_OPENGL;
484	return NULL;
485	#endif /* SDL_VIDEO_OPENGL */
486	}
487	else
488	{
489	/* Initialize internal variables */
490	if ((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)
491	{
492	if (bpp==8)
493	{
494	desktoppal=SDLPH_PAL_SYSTEM;
495	}
496
497	current->flags &= ~SDL_RESIZABLE; /* no resize for Direct Context */
498	current->flags \|= SDL_HWSURFACE;
499	}
500	else
501	{
502	/* remove this if we'll have support for the non-fullscreen sw/hw+doublebuf one day */
503	current->flags &= ~SDL_DOUBLEBUF;
504
505	/* Use offscreen memory if SDL_HWSURFACE flag is set */
506	if ((current->flags & SDL_HWSURFACE) == SDL_HWSURFACE)
507	{
508	if (desktopbpp!=bpp)
509	{
510	current->flags &= ~SDL_HWSURFACE;
511	}
512	}
513
514	/* using palette emulation code in window mode */
515	if (bpp==8)
516	{
517	if (desktopbpp>=15)
518	{
519	desktoppal = SDLPH_PAL_EMULATE;
520	}
521	else
522	{
523	desktoppal = SDLPH_PAL_SYSTEM;
524	}
525	}
526	else
527	{
528	desktoppal = SDLPH_PAL_NONE;
529	}
530	}
531	}
532
533	current->w = width;
534	current->h = height;
535
536	if (desktoppal==SDLPH_PAL_SYSTEM)
537	{
538	current->flags\|=SDL_HWPALETTE;
539	}
540
541	/* Must call at least once for setup image planes */
542	if (ph_SetupUpdateFunction(this, current, current->flags)==-1)
543	{
544	/* Error string was filled in the ph_SetupUpdateFunction() */
545	return NULL;
546	}
547
548	/* finish window drawing, if we are not in fullscreen, of course */
549	if ((current->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN)
550	{
551	PtFlush();
552	}
553	else
554	{
555	PgFlush();
556	}
557
558	visualbpp=bpp;
559
560	ph_UpdateHWInfo(this);
561
562	SDL_Unlock_EventThread();
563
564	/* We've done! */
565	return (current);
566	}
567
568	static void ph_VideoQuit(_THIS)
569	{
570	/* restore palette */
571	if (desktopbpp==8)
572	{
573	PgSetPalette(syspalph, 0, -1, 0, 0, 0);
574	PgSetPalette(savedpal, 0, 0, _Pg_MAX_PALETTE, Pg_PALSET_GLOBAL \| Pg_PALSET_FORCE_EXPOSE, 0);
575	PgFlush();
576	}
577
578	ph_DestroyImage(this, SDL_VideoSurface);
579
580	if (window)
581	{
582	PtUnrealizeWidget(window);
583	PtDestroyWidget(window);
584	window=NULL;
585	}
586
587	if (phevent!=NULL)
588	{
589	SDL_free(phevent);
590	phevent=NULL;
591	}
592	}
593
594	static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
595	{
596	int i;
597	SDL_Rect updaterect;
598
599	updaterect.x = updaterect.y = 0;
600	updaterect.w = this->screen->w;
601	updaterect.h = this->screen->h;
602
603	/* palette emulation code, using palette of the PhImage_t struct */
604	if (desktoppal==SDLPH_PAL_EMULATE)
605	{
606	if ((SDL_Image) && (SDL_Image->palette))
607	{
608	for (i=firstcolor; i<firstcolor+ncolors; i++)
609	{
610	syspalph[i] = PgRGB(colors[i-firstcolor].r, colors[i-firstcolor].g, colors[i-firstcolor].b);
611	SDL_Image->palette[i] = syspalph[i];
612	}
613
614	/* image needs to be redrawn */
615	this->UpdateRects(this, 1, &updaterect);
616	}
617	}
618	else
619	{
620	if (desktoppal==SDLPH_PAL_SYSTEM)
621	{
622	for (i=firstcolor; i<firstcolor+ncolors; i++)
623	{
624	syspalph[i] = PgRGB(colors[i-firstcolor].r, colors[i-firstcolor].g, colors[i-firstcolor].b);
625	}
626
627	if ((this->screen->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN)
628	{
629	/* window mode must use soft palette */
630	PgSetPalette(&syspalph[firstcolor], 0, firstcolor, ncolors, Pg_PALSET_GLOBAL, 0);
631	/* image needs to be redrawn */
632	this->UpdateRects(this, 1, &updaterect);
633	}
634	else
635	{
636	/* fullscreen mode must use hardware palette */
637	PgSetPalette(&syspalph[firstcolor], 0, firstcolor, ncolors, Pg_PALSET_GLOBAL, 0);
638	}
639	}
640	else
641	{
642	/* SDLPH_PAL_NONE do nothing */
643	}
644	}
645
646	return 1;
647	}
648