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