/
SDL_wimpvideo.c
473 lines (380 loc) · 13.1 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2012 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
#include "SDL_config.h"
23
24
/*
25
File added by Alan Buckley (alan_baa@hotmail.com) for RISC OS compatability
26
27
27 March 2003
28
Implements RISC OS Wimp display.
29
30
31
32
*/
#include "SDL_video.h"
#include "SDL_mouse.h"
33
#include "SDL_timer.h"
34
35
36
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
37
38
39
40
41
42
43
44
45
#include "SDL_riscostask.h"
#include "SDL_riscosvideo.h"
#include "SDL_riscosevents_c.h"
#include "SDL_riscosmouse_c.h"
#include "kernel.h"
#include "swis.h"
46
47
static int WIMP_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
static void WIMP_SetWMCaption(_THIS, const char *title, const char *icon);
48
static int WIMP_IconifyWindow(_THIS);
49
50
51
static void WIMP_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
/* RISC OS Wimp handling helpers */
52
53
static unsigned int WIMP_SetupWindow(_THIS, SDL_Surface *surface);
static void WIMP_SetDeviceMode(_THIS);
54
55
56
57
58
SDL_Surface *WIMP_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags)
{
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
unsigned char *buffer = NULL;
int bytesPerPixel;
const RISCOS_SDL_PixelFormat *fmt;
/* Don't support double buffering in Wimp mode */
flags &= ~SDL_DOUBLEBUF;
flags &= ~SDL_HWSURFACE;
/* Identify the current pixel format */
fmt = RISCOS_CurrentPixelFormat();
/* If it's the same (approximate) BPP as the desired BPP, use it directly (less overhead in sprite rendering) */
if ((fmt == NULL) || (fmt->sdl_bpp != ((bpp+1)&~1)))
{
/* Not a good match - look for a supported format which is correct */
fmt = WIMP_FindSupportedSpriteFormat(bpp);
if (fmt == NULL)
{
76
SDL_SetError("Pixel depth %d not supported", bpp);
77
78
79
return NULL;
}
}
80
81
82
if (fmt->sdl_bpp == 8)
{
83
84
/* Emulated palette using ColourTrans */
flags |= SDL_HWPALETTE;
85
86
}
bytesPerPixel = 1 << (fmt->ro.log2bpp - 3);
87
88
89
90
/* printf("Setting mode %dx%d\n", width, height);*/
/* Allocate the new pixel format for the screen */
91
if ( ! SDL_ReallocFormat(current, fmt->sdl_bpp, fmt->rmask, fmt->gmask, fmt->bmask, 0) ) {
92
93
94
95
96
97
98
99
return(NULL);
}
/* Set up the new mode framebuffer */
current->w = width;
this->hidden->height = current->h = height;
if (bpp == 15) bpp = 16;
100
buffer = WIMP_CreateBuffer(width, height, &fmt->ro);
101
102
103
104
105
106
107
108
109
110
111
if (buffer == NULL)
{
return (NULL);
}
this->hidden->bank[0] = buffer + 60; /* Start of sprite data */
if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */
this->hidden->bank[1] = buffer; /* Start of buffer */
/* Remember sprite buffer so it can be freed later */
112
if (this->hidden->alloc_bank) SDL_free(this->hidden->alloc_bank);
113
114
115
116
117
118
119
120
this->hidden->alloc_bank = buffer;
current->pitch = width * bytesPerPixel;
if ((current->pitch & 3))
{
/* Sprites are 32bit word aligned */
current->pitch += (4 - (current->pitch & 3));
}
121
this->hidden->format = fmt;
122
123
124
125
126
current->flags = flags | SDL_PREALLOC;
WIMP_ReadModeInfo(this);
127
SDL_memset(this->hidden->bank[0], 0, height * current->pitch);
128
129
130
131
132
133
134
135
136
137
138
139
140
this->hidden->current_bank = 0;
current->pixels = this->hidden->bank[0];
if (WIMP_SetupWindow(this, current) == 0)
{
return NULL;
}
/* Reset device functions for the wimp */
WIMP_SetDeviceMode(this);
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/* Needs to set up plot info after window has been created */
/* Not sure why, but plots don't work if I do it earlier */
WIMP_SetupPlotInfo(this);
/* Poll until window is shown */
{
/* We wait until it gets the focus, but give up after 5 seconds
in case the focus is prevented in any way.
*/
Uint32 now = SDL_GetTicks();
while (!hasFocus && SDL_GetTicks() - now < 5000)
{
WIMP_Poll(this, 0);
}
}
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
/* We're done */
return(current);
}
void WIMP_ReadModeInfo(_THIS)
{
_kernel_swi_regs regs;
int vars[6];
int vals[5];
vars[0] = 4; /* XEig */
vars[1] = 5; /* YEig */
vars[2] = 9; /* Log base 2 bpp */
vars[3] = 11; /* Screen Width - 1 */
vars[4] = 12; /* Screen Depth - 1 */
vars[5] = -1; /* Terminate list */
regs.r[0] = (int)vars;
regs.r[1] = (int)vals;
_kernel_swi(OS_ReadVduVariables, ®s, ®s);
this->hidden->xeig = vals[0];
this->hidden->yeig = vals[1];
this->hidden->screen_width = vals[3] + 1;
this->hidden->screen_height = vals[4] + 1;
}
/* Set device function to call the correct versions for running
in a wimp window */
void WIMP_SetDeviceMode(_THIS)
{
if (this->UpdateRects == WIMP_UpdateRects) return; /* Already set up */
this->SetColors = WIMP_SetColors;
this->UpdateRects = WIMP_UpdateRects;
this->FlipHWSurface = NULL;
this->SetCaption = WIMP_SetWMCaption;
this->SetIcon = NULL;
198
this->IconifyWindow = WIMP_IconifyWindow;
199
200
201
202
this->ShowWMCursor = WIMP_ShowWMCursor;
this->WarpWMCursor = WIMP_WarpWMCursor;
203
204
/* Currently need to set this up here as it only works if you
start up in a Wimp mode */
205
206
207
208
209
210
211
212
213
this->ToggleFullScreen = RISCOS_ToggleFullScreen;
this->PumpEvents = WIMP_PumpEvents;
}
/* Setup the Window to display the surface */
unsigned int WIMP_SetupWindow(_THIS, SDL_Surface *surface)
{
_kernel_swi_regs regs;
214
_kernel_oserror *error;
215
216
int window_data[23];
int *window_block = window_data+1;
217
218
219
int x = ((this->hidden->screen_width << this->hidden->xeig) - (surface->w << 1)) / 2;
int y = ((this->hidden->screen_height << this->hidden->yeig) - (surface->h << 1)) / 2;
220
221
222
223
/* Always delete the window and recreate on a change */
if (this->hidden->window_handle) WIMP_DeleteWindow(this);
/* Setup window co-ordinates */
224
225
226
227
window_block[0] = x;
window_block[1] = y;
window_block[2] = window_block[0] + (surface->w << 1);
window_block[3] = window_block[1] + (surface->h << 1);
228
229
230
231
232
233
234
235
236
237
238
239
240
241
window_block[4] = 0; /* Scroll offsets */
window_block[5] = 0;
window_block[6] = -1; /* Open on top of window stack */
window_block[7] = 0x85040042; /* Window flags */
if (riscos_closeaction != 0) window_block[7] |= 0x2000000;
/* TODO: Take into account surface->flags */
window_block[8] = 0xff070207; /* Window colours */
window_block[9] = 0x000c0103;
window_block[10] = 0; /* Work area minimum */
242
243
window_block[11] = -surface->h << 1;
window_block[12] = surface->w << 1; /* Work area maximum */
244
245
246
247
248
249
250
251
252
253
254
255
256
window_block[13] = 0;
window_block[14] = 0x2700013d; /* Title icon flags */
window_block[15] = 0x00003000; /* Work area flags - Mouse click down reported */
window_block[16] = 1; /* Sprite area control block pointer */
window_block[17] = 0x00100010; /* Minimum window size (width & height) (16x16)*/
window_block[18] = (int)this->hidden->title; /* Title data */
window_block[19] = -1;
window_block[20] = 256;
window_block[21] = 0; /* Number of icons */
regs.r[1] = (unsigned int)(window_block);
/* Create the window */
257
258
error = _kernel_swi(Wimp_CreateWindow, ®s, ®s);
if (error == NULL)
259
260
261
262
263
264
265
266
267
268
269
270
{
this->hidden->window_handle = window_data[0] = regs.r[0];
/* Show the window on the screen */
regs.r[1] = (unsigned int)window_data;
if (_kernel_swi(Wimp_OpenWindow, ®s, ®s) == NULL)
{
WIMP_SetFocus(this->hidden->window_handle);
} else
{
WIMP_DeleteWindow(this);
}
271
272
} else {
SDL_SetError("Unable to create window: %s (%i)", error->errmess, error->errnum);
273
}
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
return this->hidden->window_handle;
}
/* Destroy the Window */
void WIMP_DeleteWindow(_THIS)
{
_kernel_swi_regs regs;
regs.r[1] = (unsigned int)&(this->hidden->window_handle);
_kernel_swi(Wimp_DeleteWindow, ®s, ®s);
this->hidden->window_handle = 0;
}
void WIMP_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
{
_kernel_swi_regs regs;
int update_block[12];
int j;
update_block[0] = this->hidden->window_handle;
for (j = 0; j < numrects; j++)
{
298
299
300
301
update_block[1] = rects[j].x << 1; /* Min X */
update_block[4] = -(rects[j].y << 1);
update_block[3] = update_block[1] + (rects[j].w << 1);
update_block[2] = update_block[4] - (rects[j].h << 1);
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
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
regs.r[1] = (int)update_block;
/* Update window can fail if called before first poll */
if (_kernel_swi(Wimp_UpdateWindow, ®s, ®s) == 0)
{
while (regs.r[0])
{
WIMP_PlotSprite(this, update_block[1], update_block[2]);
_kernel_swi(Wimp_GetRectangle, ®s, ®s);
}
}
}
}
int WIMP_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
{
unsigned int *pal = (unsigned int *)(this->hidden->bank[1]+60);
int j;
SDL_Rect update;
pal += firstcolor*2;
for (j = 0; j < ncolors; j++)
{
*pal = (((unsigned int)colors->r) << 8)
+ (((unsigned int)colors->g) << 16)
+ (((unsigned int)colors->b) << 24);
pal[1] = *pal;
pal += 2;
colors++;
}
WIMP_SetupPlotInfo(this);
/* Need to refresh the window */
update.x = 0;
update.y = 0;
update.w = SDL_VideoSurface->w;
update.h = SDL_VideoSurface->h;
WIMP_UpdateRects(this, 1, &update);
return 1;
}
void WIMP_SetWMCaption(_THIS, const char *title, const char *icon)
{
_kernel_swi_regs regs;
350
SDL_strlcpy(this->hidden->title, title, SDL_arraysize(this->hidden->title));
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
if (RISCOS_GetWimpVersion() < 380)
{
int block[6];
regs.r[1] = (int)block;
_kernel_swi(Wimp_GetCaretPosition, ®s, ®s);
if (block[0] == (int)this->hidden->window_handle)
{
regs.r[0] = -1;
_kernel_swi(Wimp_SetCaretPosition, ®s,®s);
} else
{
regs.r[0] = this->hidden->window_handle;
regs.r[1] = -1;
regs.r[2] = -1;
regs.r[3] = -1;
_kernel_swi(Wimp_SetCaretPosition, ®s,®s);
}
regs.r[0] = block[0];
regs.r[1] = block[1];
regs.r[2] = block[2];
regs.r[3] = block[3];
regs.r[4] = block[4];
regs.r[5] = block[5];
_kernel_swi(Wimp_SetCaretPosition, ®s,®s);
} else
{
regs.r[0] = this->hidden->window_handle;
regs.r[1] = 0x4b534154; /* "TASK" */
regs.r[2] = 3; /* Redraw title */
_kernel_swi(Wimp_ForceRedraw, ®s, ®s);
}
}
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
int WIMP_IconifyWindow(_THIS)
{
_kernel_swi_regs regs;
int block[12];
block[0] = 48;
block[1] = RISCOS_GetTaskHandle();
block[2] = 0;
block[3] = 0;
block[4] = 0x400ca; /* Message_Iconize */
block[5] = this->hidden->window_handle;
block[6] = RISCOS_GetTaskHandle();
SDL_strlcpy((char *)&block[7], this->hidden->title, 20);
regs.r[0] = 17; /* User_Message */
regs.r[1] = (int)block;
regs.r[2] = 0;
_kernel_swi(Wimp_SendMessage, ®s, ®s);
return 1;
}
409
410
411
412
413
414
/* Toggle to window from full screen */
int WIMP_ToggleFromFullScreen(_THIS)
{
int width = this->screen->w;
int height = this->screen->h;
int bpp = this->screen->format->BitsPerPixel;
415
416
417
unsigned char *buffer = NULL;
unsigned char *old_bank[2];
unsigned char *old_alloc_bank;
418
419
420
421
422
423
424
/* Ensure flags are OK */
this->screen->flags &= ~(SDL_DOUBLEBUF|SDL_HWSURFACE);
if (this->hidden->bank[0] == this->hidden->alloc_bank || riscos_backbuffer == 0)
{
/* Need to create a sprite for the screen and copy the data to it */
425
unsigned char *data;
426
buffer = WIMP_CreateBuffer(width, height, &this->hidden->format->ro);
427
428
429
430
data = buffer + 60; /* Start of sprite data */
if (bpp == 8) data += 2048; /* 8bpp sprite have palette first */
if (buffer == NULL) return 0;
431
SDL_memcpy(data, this->hidden->bank[0], width * height * this->screen->format->BytesPerPixel);
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
}
/* else We've switch to full screen before so we already have a sprite */
old_bank[0] = this->hidden->bank[0];
old_bank[1] = this->hidden->bank[1];
old_alloc_bank = this->hidden->alloc_bank;
if (buffer != NULL) this->hidden->alloc_bank = buffer;
this->hidden->bank[1] = this->hidden->alloc_bank;
this->hidden->bank[0] = this->hidden->bank[1] + 60; /* Start of sprite data */
if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */
this->hidden->current_bank = 0;
this->screen->pixels = this->hidden->bank[0];
RISCOS_RestoreWimpMode();
WIMP_ReadModeInfo(this);
if (WIMP_SetupWindow(this, this->screen))
{
WIMP_SetDeviceMode(this);
WIMP_SetupPlotInfo(this);
455
if (riscos_backbuffer == 0) riscos_backbuffer = 1;
456
457
if (buffer && old_alloc_bank) SDL_free(old_alloc_bank);
458
459
460
461
462
463
464
465
return 1;
} else
{
/* Drop back to full screen mode on failure */
this->hidden->bank[0] = old_bank[0];
this->hidden->bank[1] = old_bank[1];
this->hidden->alloc_bank = old_alloc_bank;
466
if (buffer) SDL_free(buffer);
467
468
469
470
471
472
473
RISCOS_StoreWimpMode();
FULLSCREEN_SetMode(width, height, bpp);
}
return 0;
}