[sdl_omap.git] / src / video / ggi / SDL_ggivideo.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    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

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* GGI-based SDL video driver implementation.
*/

#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>

#include <ggi/ggi.h>
#include <ggi/gii.h>

#include "SDL_video.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
#include "SDL_ggivideo.h"
#include "SDL_ggimouse_c.h"
#include "SDL_ggievents_c.h"


struct private_hwdata
{
	ggi_visual_t vis;
};

ggi_visual_t VIS;

/* Initialization/Query functions */
static int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat);
static SDL_Rect **GGI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
static SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
static int GGI_SetColors(_THIS, int firstcolor, int ncolors,
			 SDL_Color *colors);
static void GGI_VideoQuit(_THIS);

/* Hardware surface functions */
static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface);
static int GGI_LockHWSurface(_THIS, SDL_Surface *surface);
static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface);
static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface);

/* GGI driver bootstrap functions */

static int GGI_Available(void)
{
	ggi_visual_t *vis;

	vis = NULL;
	if (ggiInit() == 0) {
		vis = ggiOpen(NULL);
		if (vis != NULL) {
			ggiClose(vis);
		}
	}
	return (vis != NULL);
}

static void GGI_DeleteDevice(SDL_VideoDevice *device)
{
	SDL_free(device->hidden);
	SDL_free(device);
}

static SDL_VideoDevice *GGI_CreateDevice(int devindex)
{
	SDL_VideoDevice *device;

	/* Initialize all variables that we clean on shutdown */
	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));
	}
	if ( (device == NULL) || (device->hidden == NULL) ) {
		SDL_OutOfMemory();
		if ( device ) {
			SDL_free(device);
		}
		return(0);
	}
	SDL_memset(device->hidden, 0, (sizeof *device->hidden));

	/* Set the function pointers */
	device->VideoInit = GGI_VideoInit;
	device->ListModes = GGI_ListModes;
	device->SetVideoMode = GGI_SetVideoMode;
	device->SetColors = GGI_SetColors;
	device->UpdateRects = NULL;
	device->VideoQuit = GGI_VideoQuit;
	device->AllocHWSurface = GGI_AllocHWSurface;
	device->CheckHWBlit = NULL;
	device->FillHWRect = NULL;
	device->SetHWColorKey = NULL;
	device->SetHWAlpha = NULL;
	device->LockHWSurface = GGI_LockHWSurface;
	device->UnlockHWSurface = GGI_UnlockHWSurface;
	device->FlipHWSurface = NULL;
	device->FreeHWSurface = GGI_FreeHWSurface;
	device->SetCaption = NULL;
	device->SetIcon = NULL;
	device->IconifyWindow = NULL;
	device->GrabInput = NULL;
	device->GetWMInfo = NULL;
	device->InitOSKeymap = GGI_InitOSKeymap;
	device->PumpEvents = GGI_PumpEvents;

	device->free = GGI_DeleteDevice;

	return device;
}

VideoBootStrap GGI_bootstrap = {
	"ggi", "General Graphics Interface (GGI)",
	GGI_Available, GGI_CreateDevice
};


static SDL_Rect video_mode;
static SDL_Rect *SDL_modelist[4] = { NULL, NULL, NULL, NULL };

int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
	ggi_mode mode =
	{
		1,
		{ GGI_AUTO, GGI_AUTO },
		{ GGI_AUTO, GGI_AUTO },
		{ 0, 0 },
		GT_AUTO,
		{ GGI_AUTO, GGI_AUTO }
	};	
	struct private_hwdata *priv;
	ggi_color pal[256], map[256];
	const ggi_directbuffer *db;
	int err, num_bufs;
	ggi_pixel white, black;
	
	priv = SDL_malloc(sizeof(struct private_hwdata));
	if (priv == NULL)
	{
		SDL_SetError("Unhandled GGI mode type!\n");
		GGI_VideoQuit(NULL);
	}
	
	if (ggiInit() != 0)
	{
		SDL_SetError("Unable to initialize GGI!\n");
		GGI_VideoQuit(NULL);
	}
	
	VIS = ggiOpen(NULL);
	if (VIS == NULL)
	{
		SDL_SetError("Unable to open default GGI visual!\n");
		ggiExit();
		GGI_VideoQuit(NULL);
	}
	
	ggiSetFlags(VIS, GGIFLAG_ASYNC);
	
	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
	ggiCheckMode(VIS, &mode);
	
	/* At this point we should have a valid mode - try to set it */
	err = ggiSetMode(VIS, &mode);
	
	/* If we couldn't set _any_ modes, something is very wrong */
	if (err)
	{
		SDL_SetError("Can't set a mode!\n");
		ggiClose(VIS);
		ggiExit();
		GGI_VideoQuit(NULL);
	}

	/* Determine the current screen size */
	this->info.current_w = mode.virt.x;
	this->info.current_h = mode.virt.y;

	/* Set a palette for palletized modes */
	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
	{
		ggiSetColorfulPalette(VIS);
		ggiGetPalette(VIS, 0, 1 << vformat->BitsPerPixel, pal);
	}
	
	/* Now we try to get the DirectBuffer info, which determines whether
	 * SDL can access hardware surfaces directly. */
	
	num_bufs = ggiDBGetNumBuffers(VIS);

	if (num_bufs > 0)
	{
		db = ggiDBGetBuffer(VIS, 0); /* Only handle one DB for now */
		
		vformat->BitsPerPixel = db->buffer.plb.pixelformat->depth;
		
		vformat->Rmask = db->buffer.plb.pixelformat->red_mask;
		vformat->Gmask = db->buffer.plb.pixelformat->green_mask;
		vformat->Bmask = db->buffer.plb.pixelformat->blue_mask;
		
		/* Fill in our hardware acceleration capabilities */
	
		this->info.wm_available = 0;
		this->info.hw_available = 1;
		this->info.video_mem = db->buffer.plb.stride * mode.virt.y;
	}

	video_mode.x = 0;
	video_mode.y = 0;
	video_mode.w = mode.virt.x;
	video_mode.h = mode.virt.y;
	SDL_modelist[((vformat->BitsPerPixel + 7) / 8) - 1] = &video_mode;

	/* We're done! */
	return(0);
}

static SDL_Rect **GGI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
{
	return(&SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]);
}

/* Various screen update functions available */
static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);

SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
{
	ggi_mode mode =
	{
		1,
		{ GGI_AUTO, GGI_AUTO },
		{ GGI_AUTO, GGI_AUTO },
		{ 0, 0 },
		GT_AUTO,
		{ GGI_AUTO, GGI_AUTO }
	};
        const ggi_directbuffer *db;
	ggi_color pal[256];
	int err;

	fprintf(stderr, "GGI_SetVideoMode()\n");
	
	mode.visible.x = mode.virt.x = width;
	mode.visible.y = mode.virt.y = height;
	
	/* Translate requested SDL bit depth into a GGI mode */	
	switch (bpp)
	{
		case 1:  mode.graphtype = GT_1BIT;  break;
		case 2:  mode.graphtype = GT_2BIT;  break;
		case 4:  mode.graphtype = GT_4BIT;  break;
		case 8:  mode.graphtype = GT_8BIT;  break;
		case 15: mode.graphtype = GT_15BIT; break;
		case 16: mode.graphtype = GT_16BIT; break;
		case 24: mode.graphtype = GT_24BIT; break;
		case 32: mode.graphtype = GT_32BIT; break;
		default:
		SDL_SetError("Unknown SDL bit depth, using GT_AUTO....\n");
		mode.graphtype = GT_AUTO;
	}
	
	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
	ggiCheckMode(VIS, &mode);
	
	/* At this point we should have a valid mode - try to set it */
	err = ggiSetMode(VIS, &mode);

	/* If we couldn't set _any_ modes, something is very wrong */
	if (err)
	{
		SDL_SetError("Can't set a mode!\n");
		ggiClose(VIS);
		ggiExit();
		GGI_VideoQuit(NULL);
	}
	
	/* Set a palette for palletized modes */
	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
	{
		ggiSetColorfulPalette(VIS);
		ggiGetPalette(VIS, 0, 1 << bpp, pal);
	}
	
	db = ggiDBGetBuffer(VIS, 0);
	
	/* Set up the new mode framebuffer */
	current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE);
	current->w = mode.virt.x;
	current->h = mode.virt.y;
	current->pitch = db->buffer.plb.stride;
	current->pixels = db->read;

	/* Set the blit function */
	this->UpdateRects = GGI_DirectUpdate;

	/* We're done */
	return(current);
}

static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface)
{
	return(-1);
}
static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface)
{
	return;
}
static int GGI_LockHWSurface(_THIS, SDL_Surface *surface)
{
	return(0);
}
static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
	return;
}

static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
{
	int i;
	
/*	ggiFlush(VIS); */
	
	for (i = 0; i < numrects; i++)
	{
		ggiFlushRegion(VIS, rects[i].x, rects[i].y, rects[i].w, rects[i].h);
	}
	return;
}

int GGI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
{
	int i;
	ggi_color pal[256];

	/* Set up the colormap */
	for (i = 0; i < ncolors; i++)
	{
		pal[i].r = (colors[i].r << 8) | colors[i].r;
		pal[i].g = (colors[i].g << 8) | colors[i].g;
		pal[i].b = (colors[i].b << 8) | colors[i].b;
	}
	
	ggiSetPalette(VIS, firstcolor, ncolors, pal);
	
	return 1;
}
	
void GGI_VideoQuit(_THIS)
{
}
void GGI_FinalQuit(void) 
{
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 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	/* GGI-based SDL video driver implementation.
	25	*/
	26
	27	#include <fcntl.h>
	28	#include <unistd.h>
	29	#include <sys/mman.h>
	30
	31	#include <ggi/ggi.h>
	32	#include <ggi/gii.h>
	33
	34	#include "SDL_video.h"
	35	#include "SDL_mouse.h"
	36	#include "../SDL_sysvideo.h"
	37	#include "../SDL_pixels_c.h"
	38	#include "../../events/SDL_events_c.h"
	39	#include "SDL_ggivideo.h"
	40	#include "SDL_ggimouse_c.h"
	41	#include "SDL_ggievents_c.h"
	42
	43
	44	struct private_hwdata
	45	{
	46	ggi_visual_t vis;
	47	};
	48
	49	ggi_visual_t VIS;
	50
	51	/* Initialization/Query functions */
	52	static int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat);
	53	static SDL_Rect *GGI_ListModes(_THIS, SDL_PixelFormat format, Uint32 flags);
	54	static SDL_Surface GGI_SetVideoMode(_THIS, SDL_Surface current, int width, int height, int bpp, Uint32 flags);
	55	static int GGI_SetColors(_THIS, int firstcolor, int ncolors,
	56	SDL_Color *colors);
	57	static void GGI_VideoQuit(_THIS);
	58
	59	/* Hardware surface functions */
	60	static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface);
	61	static int GGI_LockHWSurface(_THIS, SDL_Surface *surface);
	62	static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface);
	63	static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface);
	64
65	/* GGI driver bootstrap functions */
66
67	static int GGI_Available(void)
68	{
69	ggi_visual_t *vis;
70
71	vis = NULL;
72	if (ggiInit() == 0) {
73	vis = ggiOpen(NULL);
74	if (vis != NULL) {
75	ggiClose(vis);
76	}
77	}
78	return (vis != NULL);
79	}
80
81	static void GGI_DeleteDevice(SDL_VideoDevice *device)
82	{
83	SDL_free(device->hidden);
84	SDL_free(device);
85	}
86
87	static SDL_VideoDevice *GGI_CreateDevice(int devindex)
88	{
89	SDL_VideoDevice *device;
90
91	/* Initialize all variables that we clean on shutdown */
92	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
93	if ( device ) {
94	SDL_memset(device, 0, (sizeof *device));
95	device->hidden = (struct SDL_PrivateVideoData *)
96	SDL_malloc((sizeof *device->hidden));
97	}
98	if ( (device == NULL) \|\| (device->hidden == NULL) ) {
99	SDL_OutOfMemory();
100	if ( device ) {
101	SDL_free(device);
102	}
103	return(0);
104	}
105	SDL_memset(device->hidden, 0, (sizeof *device->hidden));
106
107	/* Set the function pointers */
108	device->VideoInit = GGI_VideoInit;
109	device->ListModes = GGI_ListModes;
110	device->SetVideoMode = GGI_SetVideoMode;
111	device->SetColors = GGI_SetColors;
112	device->UpdateRects = NULL;
113	device->VideoQuit = GGI_VideoQuit;
114	device->AllocHWSurface = GGI_AllocHWSurface;
115	device->CheckHWBlit = NULL;
116	device->FillHWRect = NULL;
117	device->SetHWColorKey = NULL;
118	device->SetHWAlpha = NULL;
119	device->LockHWSurface = GGI_LockHWSurface;
120	device->UnlockHWSurface = GGI_UnlockHWSurface;
121	device->FlipHWSurface = NULL;
122	device->FreeHWSurface = GGI_FreeHWSurface;
123	device->SetCaption = NULL;
124	device->SetIcon = NULL;
125	device->IconifyWindow = NULL;
126	device->GrabInput = NULL;
127	device->GetWMInfo = NULL;
128	device->InitOSKeymap = GGI_InitOSKeymap;
129	device->PumpEvents = GGI_PumpEvents;
130
131	device->free = GGI_DeleteDevice;
132
133	return device;
134	}
135
136	VideoBootStrap GGI_bootstrap = {
137	"ggi", "General Graphics Interface (GGI)",
138	GGI_Available, GGI_CreateDevice
139	};
140
141
142	static SDL_Rect video_mode;
143	static SDL_Rect *SDL_modelist[4] = { NULL, NULL, NULL, NULL };
144
145	int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat)
146	{
147	ggi_mode mode =
148	{
149	1,
150	{ GGI_AUTO, GGI_AUTO },
151	{ GGI_AUTO, GGI_AUTO },
152	{ 0, 0 },
153	GT_AUTO,
154	{ GGI_AUTO, GGI_AUTO }
155	};
156	struct private_hwdata *priv;
157	ggi_color pal[256], map[256];
158	const ggi_directbuffer *db;
159	int err, num_bufs;
160	ggi_pixel white, black;
161
162	priv = SDL_malloc(sizeof(struct private_hwdata));
163	if (priv == NULL)
164	{
165	SDL_SetError("Unhandled GGI mode type!\n");
166	GGI_VideoQuit(NULL);
167	}
168
169	if (ggiInit() != 0)
170	{
171	SDL_SetError("Unable to initialize GGI!\n");
172	GGI_VideoQuit(NULL);
173	}
174
175	VIS = ggiOpen(NULL);
176	if (VIS == NULL)
177	{
178	SDL_SetError("Unable to open default GGI visual!\n");
179	ggiExit();
180	GGI_VideoQuit(NULL);
181	}
182
183	ggiSetFlags(VIS, GGIFLAG_ASYNC);
184
185	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
186	ggiCheckMode(VIS, &mode);
187
188	/* At this point we should have a valid mode - try to set it */
189	err = ggiSetMode(VIS, &mode);
190
191	/* If we couldn't set _any_ modes, something is very wrong */
192	if (err)
193	{
194	SDL_SetError("Can't set a mode!\n");
195	ggiClose(VIS);
196	ggiExit();
197	GGI_VideoQuit(NULL);
198	}
199
200	/* Determine the current screen size */
201	this->info.current_w = mode.virt.x;
202	this->info.current_h = mode.virt.y;
203
204	/* Set a palette for palletized modes */
205	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
206	{
207	ggiSetColorfulPalette(VIS);
208	ggiGetPalette(VIS, 0, 1 << vformat->BitsPerPixel, pal);
209	}
210
211	/* Now we try to get the DirectBuffer info, which determines whether
212	* SDL can access hardware surfaces directly. */
213
214	num_bufs = ggiDBGetNumBuffers(VIS);
215
216	if (num_bufs > 0)
217	{
218	db = ggiDBGetBuffer(VIS, 0); /* Only handle one DB for now */
219
220	vformat->BitsPerPixel = db->buffer.plb.pixelformat->depth;
221
222	vformat->Rmask = db->buffer.plb.pixelformat->red_mask;
223	vformat->Gmask = db->buffer.plb.pixelformat->green_mask;
224	vformat->Bmask = db->buffer.plb.pixelformat->blue_mask;
225
226	/* Fill in our hardware acceleration capabilities */
227
228	this->info.wm_available = 0;
229	this->info.hw_available = 1;
230	this->info.video_mem = db->buffer.plb.stride * mode.virt.y;
231	}
232
233	video_mode.x = 0;
234	video_mode.y = 0;
235	video_mode.w = mode.virt.x;
236	video_mode.h = mode.virt.y;
237	SDL_modelist[((vformat->BitsPerPixel + 7) / 8) - 1] = &video_mode;
238
239	/* We're done! */
240	return(0);
241	}
242
243	static SDL_Rect *GGI_ListModes(_THIS, SDL_PixelFormat format, Uint32 flags)
244	{
245	return(&SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]);
246	}
247
248	/* Various screen update functions available */
249	static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
250
251	SDL_Surface GGI_SetVideoMode(_THIS, SDL_Surface current, int width, int height, int bpp, Uint32 flags)
252	{
253	ggi_mode mode =
254	{
255	1,
256	{ GGI_AUTO, GGI_AUTO },
257	{ GGI_AUTO, GGI_AUTO },
258	{ 0, 0 },
259	GT_AUTO,
260	{ GGI_AUTO, GGI_AUTO }
261	};
262	const ggi_directbuffer *db;
263	ggi_color pal[256];
264	int err;
265
266	fprintf(stderr, "GGI_SetVideoMode()\n");
267
268	mode.visible.x = mode.virt.x = width;
269	mode.visible.y = mode.virt.y = height;
270
271	/* Translate requested SDL bit depth into a GGI mode */
272	switch (bpp)
273	{
274	case 1: mode.graphtype = GT_1BIT; break;
275	case 2: mode.graphtype = GT_2BIT; break;
276	case 4: mode.graphtype = GT_4BIT; break;
277	case 8: mode.graphtype = GT_8BIT; break;
278	case 15: mode.graphtype = GT_15BIT; break;
279	case 16: mode.graphtype = GT_16BIT; break;
280	case 24: mode.graphtype = GT_24BIT; break;
281	case 32: mode.graphtype = GT_32BIT; break;
282	default:
283	SDL_SetError("Unknown SDL bit depth, using GT_AUTO....\n");
284	mode.graphtype = GT_AUTO;
285	}
286
287	/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
288	ggiCheckMode(VIS, &mode);
289
290	/* At this point we should have a valid mode - try to set it */
291	err = ggiSetMode(VIS, &mode);
292
293	/* If we couldn't set _any_ modes, something is very wrong */
294	if (err)
295	{
296	SDL_SetError("Can't set a mode!\n");
297	ggiClose(VIS);
298	ggiExit();
299	GGI_VideoQuit(NULL);
300	}
301
302	/* Set a palette for palletized modes */
303	if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
304	{
305	ggiSetColorfulPalette(VIS);
306	ggiGetPalette(VIS, 0, 1 << bpp, pal);
307	}
308
309	db = ggiDBGetBuffer(VIS, 0);
310
311	/* Set up the new mode framebuffer */
312	current->flags = (SDL_FULLSCREEN \| SDL_HWSURFACE);
313	current->w = mode.virt.x;
314	current->h = mode.virt.y;
315	current->pitch = db->buffer.plb.stride;
316	current->pixels = db->read;
317
318	/* Set the blit function */
319	this->UpdateRects = GGI_DirectUpdate;
320
321	/* We're done */
322	return(current);
323	}
324
325	static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface)
326	{
327	return(-1);
328	}
329	static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface)
330	{
331	return;
332	}
333	static int GGI_LockHWSurface(_THIS, SDL_Surface *surface)
334	{
335	return(0);
336	}
337	static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface)
338	{
339	return;
340	}
341
342	static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects)
343	{
344	int i;
345
346	/* ggiFlush(VIS); */
347
348	for (i = 0; i < numrects; i++)
349	{
350	ggiFlushRegion(VIS, rects[i].x, rects[i].y, rects[i].w, rects[i].h);
351	}
352	return;
353	}
354
355	int GGI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
356	{
357	int i;
358	ggi_color pal[256];
359
360	/* Set up the colormap */
361	for (i = 0; i < ncolors; i++)
362	{
363	pal[i].r = (colors[i].r << 8) \| colors[i].r;
364	pal[i].g = (colors[i].g << 8) \| colors[i].g;
365	pal[i].b = (colors[i].b << 8) \| colors[i].b;
366	}
367
368	ggiSetPalette(VIS, firstcolor, ncolors, pal);
369
370	return 1;
371	}
372
373	void GGI_VideoQuit(_THIS)
374	{
375	}
376	void GGI_FinalQuit(void)
377	{
378	}