• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2     SDL - Simple DirectMedia Layer
3     Copyright (C) 1997-2006 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 
ph_Available(void)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 
ph_CreateDevice(int devindex)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 
ph_DeleteDevice(SDL_VideoDevice * device)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 
ph_CreateWindow(_THIS)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 
ph_SetupWindow(_THIS,int w,int h,int flags)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 
ph_GetColourMasks(int bpp)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 
ph_VideoInit(_THIS,SDL_PixelFormat * vformat)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 
ph_SetVideoMode(_THIS,SDL_Surface * current,int width,int height,int bpp,Uint32 flags)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 
ph_VideoQuit(_THIS)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 
ph_SetColors(_THIS,int firstcolor,int ncolors,SDL_Color * colors)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 
649