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