This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_ph_video.c
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.
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
#include "SDL_config.h"
23
24
25
26
#include <unistd.h>
#include <sys/ioctl.h>
27
#include "SDL_endian.h"
28
29
30
31
#include "SDL_timer.h"
#include "SDL_thread.h"
#include "SDL_video.h"
#include "SDL_mouse.h"
32
33
34
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
35
36
37
38
39
#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"
40
#include "SDL_ph_wm_c.h"
41
#include "SDL_ph_gl.h"
42
#include "SDL_phyuv_c.h"
43
#include "../blank_cursor.h"
45
46
47
48
49
50
51
52
53
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);
static void ph_VideoQuit (_THIS);
static void ph_DeleteDevice (SDL_VideoDevice * device);
static int phstatus = -1;
static int
ph_Available (void)
58
59
60
61
62
63
if (phstatus != 0) {
phstatus = PtInit (NULL);
if (phstatus == 0) {
return 1;
} else {
return 0;
66
return 1;
67
68
}
69
70
static SDL_VideoDevice *
ph_CreateDevice (int devindex)
72
SDL_VideoDevice *device;
73
74
/* Initialize all variables that we clean on shutdown */
75
76
77
78
79
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));
80
81
device->gl_data = NULL;
}
82
83
84
if ((device == NULL) || (device->hidden == NULL)) {
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
/* OpenGL support. */
126
#if SDL_VIDEO_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
#endif /* SDL_VIDEO_OPENGL */
134
device->free = ph_DeleteDevice;
136
137
138
return device;
}
139
VideoBootStrap ph_bootstrap = {
140
141
"photon", "QNX Photon video output",
ph_Available, ph_CreateDevice
142
143
};
144
145
static void
ph_DeleteDevice (SDL_VideoDevice * device)
146
{
147
148
149
if (device) {
if (device->hidden) {
SDL_free (device->hidden);
150
151
device->hidden = NULL;
}
152
153
if (device->gl_data) {
SDL_free (device->gl_data);
154
155
device->gl_data = NULL;
}
156
SDL_free (device);
157
158
159
160
device = NULL;
}
}
161
162
static PtWidget_t *
ph_CreateWindow (_THIS)
163
164
{
PtWidget_t *widget;
165
166
widget = PtCreateWidget (PtWindow, NULL, 0, NULL);
167
168
169
170
return widget;
}
171
172
static int
ph_SetupWindow (_THIS, int w, int h, int flags)
174
175
176
177
178
179
180
181
182
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;
184
/* check if window size has been changed by Window Manager */
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
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);
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
} 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);
257
258
259
260
261
262
263
264
265
266
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;
268
269
if (desktop_mode.height > h) {
pos.y = (desktop_mode.height - h) / 2;
272
273
274
275
276
277
278
279
280
281
282
283
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;
285
PtSetArg (&args[nargs++], Pt_ARG_POS, &pos, 0);
286
287
288
289
}
}
}
}
291
/* if window is maximized render it as maximized */
292
293
294
295
296
297
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);
298
299
300
}
/* do not grab the keyboard by default */
301
302
PtSetArg (&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE,
Ph_WM_STATE_ISALTKEY);
303
304
/* bring the focus to the window */
305
306
PtSetArg (&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE,
Ph_WM_STATE_ISFOCUS);
308
/* allow to catch hide event */
309
310
311
312
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);
315
316
317
PtSetResources (window, nargs, args);
PtRealizeWidget (window);
PtWindowToFront (window);
319
320
321
#if 0 /* FIXME */
PtGetResource (window, Pt_ARG_POS, &olddim, 0);
fprintf (stderr, "POSITION: %d, %d\n", olddim->w, olddim->h);
322
323
#endif
324
325
326
return 0;
}
327
328
static const struct ColourMasks *
ph_GetColourMasks (int bpp)
329
330
331
{
/* The alpha mask doesn't appears to be needed */
static const struct ColourMasks phColorMasks[5] = {
332
333
334
335
336
337
/* 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},
338
339
};
340
341
342
343
344
345
346
347
348
349
350
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];
351
352
353
354
}
return NULL;
}
355
356
static int
ph_VideoInit (_THIS, SDL_PixelFormat * vformat)
357
{
358
PgHWCaps_t hwcaps;
359
int i;
361
362
window = NULL;
desktoppal = SDLPH_PAL_NONE;
364
#if SDL_VIDEO_OPENGL
365
366
367
368
oglctx = NULL;
oglbuffers = NULL;
oglflags = 0;
oglbpp = 0;
370
371
372
373
374
375
old_video_mode = -1;
old_refresh_rate = -1;
if (NULL == (phevent = SDL_malloc (EVENT_SIZE))) {
SDL_OutOfMemory ();
376
return -1;
378
SDL_memset (phevent, 0x00, EVENT_SIZE);
380
381
382
window = ph_CreateWindow (this);
if (window == NULL) {
SDL_SetError ("ph_VideoInit(): Couldn't create video window !\n");
383
384
385
return -1;
}
386
/* Create the blank cursor */
387
388
389
390
391
SDL_BlankCursor = this->CreateWMCursor (this, blank_cdata, blank_cmask,
(int) BLANK_CWIDTH,
(int) BLANK_CHEIGHT,
(int) BLANK_CHOTX,
(int) BLANK_CHOTY);
393
if (SDL_BlankCursor == NULL) {
394
return -1;
395
396
}
397
398
399
400
if (PgGetGraphicsHWCaps (&hwcaps) < 0) {
SDL_SetError
("ph_VideoInit(): GetGraphicsHWCaps function failed !\n");
this->FreeWMCursor (this, SDL_BlankCursor);
401
return -1;
402
403
}
404
405
406
407
if (PgGetVideoModeInfo (hwcaps.current_video_mode, &desktop_mode) < 0) {
SDL_SetError
("ph_VideoInit(): PgGetVideoModeInfo function failed !\n");
this->FreeWMCursor (this, SDL_BlankCursor);
408
return -1;
409
410
}
411
412
413
/* Determine the current screen size */
this->info.current_w = desktop_mode.width;
this->info.current_h = desktop_mode.height;
415
/* We need to return BytesPerPixel as it in used by CreateRGBsurface */
416
vformat->BitsPerPixel = desktop_mode.bits_per_pixel;
417
418
vformat->BytesPerPixel =
desktop_mode.bytes_per_scanline / desktop_mode.width;
419
desktopbpp = desktop_mode.bits_per_pixel;
421
/* save current palette */
422
423
424
425
426
427
428
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);
429
430
}
}
432
currently_fullscreen = 0;
433
currently_hided = 0;
434
currently_maximized = 0;
435
436
437
438
439
440
441
442
443
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;
444
videomode_emulatemode = 0;
446
this->info.wm_available = 1;
448
449
ph_UpdateHWInfo (this);
450
451
452
return 0;
}
453
454
455
static SDL_Surface *
ph_SetVideoMode (_THIS, SDL_Surface * current, int width, int height, int bpp,
Uint32 flags)
456
{
457
const struct ColourMasks *mask;
458
459
/* Lock the event thread, in multi-threading environments */
460
SDL_Lock_EventThread ();
462
463
current->flags = flags;
464
/* if we do not have desired fullscreen mode, then fallback into window mode */
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
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");
481
482
return NULL;
}
484
if (current->flags & SDL_INTERNALOPENGL) {
485
#if !SDL_VIDEO_OPENGL
486
/* if no built-in OpenGL support */
487
488
SDL_SetError
("ph_SetVideoMode(): no OpenGL support, you need to recompile SDL.\n");
489
current->flags &= ~SDL_INTERNALOPENGL;
490
return NULL;
491
#endif /* SDL_VIDEO_OPENGL */
493
/* Initialize internal variables */
494
495
496
if ((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
if (bpp == 8) {
desktoppal = SDLPH_PAL_SYSTEM;
499
current->flags &= ~SDL_RESIZABLE; /* no resize for Direct Context */
500
current->flags |= SDL_HWSURFACE;
502
/* remove this if we'll have support for the non-fullscreen sw/hw+doublebuf one day */
503
504
505
current->flags &= ~SDL_DOUBLEBUF;
/* Use offscreen memory if SDL_HWSURFACE flag is set */
506
507
508
if ((current->flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
if (desktopbpp != bpp) {
current->flags &= ~SDL_HWSURFACE;
512
/* using palette emulation code in window mode */
513
514
if (bpp == 8) {
if (desktopbpp >= 15) {
515
desktoppal = SDLPH_PAL_EMULATE;
517
desktoppal = SDLPH_PAL_SYSTEM;
519
520
} else {
desktoppal = SDLPH_PAL_NONE;
523
524
525
526
}
current->w = width;
current->h = height;
528
529
if (desktoppal == SDLPH_PAL_SYSTEM) {
current->flags |= SDL_HWPALETTE;
532
/* Must call at least once for setup image planes */
533
if (ph_SetupUpdateFunction (this, current, current->flags) == -1) {
534
/* Error string was filled in the ph_SetupUpdateFunction() */
535
536
return NULL;
}
538
/* finish window drawing, if we are not in fullscreen, of course */
539
540
541
542
if ((current->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
PtFlush ();
} else {
PgFlush ();
545
visualbpp = bpp;
547
ph_UpdateHWInfo (this);
549
SDL_Unlock_EventThread ();
551
/* We've done! */
552
return (current);
553
554
}
555
556
static void
ph_VideoQuit (_THIS)
557
{
558
/* restore palette */
559
560
561
562
563
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 ();
566
ph_DestroyImage (this, SDL_VideoSurface);
568
569
570
571
if (window) {
PtUnrealizeWidget (window);
PtDestroyWidget (window);
window = NULL;
572
573
}
574
575
576
if (phevent != NULL) {
SDL_free (phevent);
phevent = NULL;
580
581
static int
ph_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
582
{
583
int i;
584
585
586
587
588
SDL_Rect updaterect;
updaterect.x = updaterect.y = 0;
updaterect.w = this->screen->w;
updaterect.h = this->screen->h;
590
/* palette emulation code, using palette of the PhImage_t struct */
591
592
593
594
595
596
597
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);
598
SDL_Image->palette[i] = syspalph[i];
601
/* image needs to be redrawn */
602
this->UpdateRects (this, 1, &updaterect);
604
605
606
607
608
609
610
} 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);
613
614
615
616
if ((this->screen->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) {
/* window mode must use soft palette */
PgSetPalette (&syspalph[firstcolor], 0, firstcolor,
ncolors, Pg_PALSET_GLOBAL, 0);
617
/* image needs to be redrawn */
618
619
this->UpdateRects (this, 1, &updaterect);
} else {
620
/* fullscreen mode must use hardware palette */
621
622
PgSetPalette (&syspalph[firstcolor], 0, firstcolor,
ncolors, Pg_PALSET_GLOBAL, 0);
625
/* SDLPH_PAL_NONE do nothing */
626
}
629
return 1;
630
631
}
632
/* vi: set ts=4 sw=4 expandtab: */