- Remove some unneeded files

- Mass rename .c to .cpp

svn-id: r38227

1 files changed, 2490 insertions, 0 deletions

diff --git a/engines/sci/gfx/operations.cpp b/engines/sci/gfx/operations.cpp
new file mode 100644
index 0000000000..110f52a52c
--- /dev/null
+++ b/engines/sci/gfx/operations.cpp
@@ -0,0 +1,2490 @@
+/***************************************************************************
+ gfx_operations Copyright (C) 2000 Christoph Reichenbach
+
+ This program may be modified and copied freely according to the terms of
+ the GNU general public license (GPL), as long as the above copyright
+ notice and the licensing information contained herein are preserved.
+
+ Please refer to www.gnu.org for licensing details.
+
+ This work is provided AS IS, without warranty of any kind, expressed or
+ implied, including but not limited to the warranties of merchantibility,
+ noninfringement, and fitness for a specific purpose. The author will not
+ be held liable for any damage caused by this work or derivatives of it.
+
+ By using this source code, you agree to the licensing terms as stated
+ above.
+
+
+ Please contact the maintainer for bug reports or inquiries.
+
+ Current Maintainer:
+
+    Christoph Reichenbach (CR) <jameson@linuxgames.com>
+
+***************************************************************************/
+/* Graphical operations, called from the widget state manager */
+
+#include "sci/include/sci_memory.h"
+#include "sci/include/gfx_operations.h"
+
+#include <ctype.h>
+
+#define PRECISE_PRIORITY_MAP /* Duplicate all operations on the local priority map as appropriate */
+
+#undef GFXW_DEBUG_DIRTY /* Enable to debug stuff relevant for dirty rects
+			 ** in widget management  */
+
+#ifdef GFXW_DEBUG_DIRTY
+#  define DDIRTY fprintf(stderr, "%s:%5d| ", __FILE__, __LINE__); fprintf
+#else
+#  define DDIRTY if (0) fprintf
+#endif
+
+/* Default color maps */
+#define DEFAULT_COLORS_NR 16
+gfx_pixmap_color_t default_colors[DEFAULT_COLORS_NR] =
+	{{GFX_COLOR_SYSTEM, 0x00, 0x00, 0x00}, {GFX_COLOR_SYSTEM, 0x00, 0x00, 0xaa},
+	 {GFX_COLOR_SYSTEM, 0x00, 0xaa, 0x00}, {GFX_COLOR_SYSTEM, 0x00, 0xaa, 0xaa},
+	 {GFX_COLOR_SYSTEM, 0xaa, 0x00, 0x00}, {GFX_COLOR_SYSTEM, 0xaa, 0x00, 0xaa},
+	 {GFX_COLOR_SYSTEM, 0xaa, 0x55, 0x00}, {GFX_COLOR_SYSTEM, 0xaa, 0xaa, 0xaa},
+	 {GFX_COLOR_SYSTEM, 0x55, 0x55, 0x55}, {GFX_COLOR_SYSTEM, 0x55, 0x55, 0xff},
+	 {GFX_COLOR_SYSTEM, 0x55, 0xff, 0x55}, {GFX_COLOR_SYSTEM, 0x55, 0xff, 0xff},
+	 {GFX_COLOR_SYSTEM, 0xff, 0x55, 0x55}, {GFX_COLOR_SYSTEM, 0xff, 0x55, 0xff},
+	 {GFX_COLOR_SYSTEM, 0xff, 0xff, 0x55}, {GFX_COLOR_SYSTEM, 0xff, 0xff, 0xff}}; /* "Normal" EGA */
+
+
+#define POINTER_VISIBLE_BUT_CLIPPED 2
+
+/* Performs basic checks that apply to most functions */
+#define BASIC_CHECKS(error_retval) \
+if (!state) { \
+	GFXERROR("Null state!\n"); \
+	return error_retval; \
+} \
+if (!state->driver) { \
+	GFXERROR("GFX driver invalid!\n"); \
+	return error_retval; \
+}
+
+/* How to determine whether colors have to be allocated */
+#define PALETTE_MODE state->driver->mode->palette
+
+#define DRAW_POINTER { int __x = _gfxop_draw_pointer(state); if (__x) { GFXERROR("Drawing the mouse pointer failed!\n"); return __x;} }
+#define REMOVE_POINTER { int __x = _gfxop_remove_pointer(state); if (__x) { GFXERROR("Removing the mouse pointer failed!\n"); return __x;} }
+
+/* #define GFXOP_DEBUG_DIRTY */
+
+/* Internal operations */
+
+static void
+_gfxop_scale_rect(rect_t *rect, gfx_mode_t *mode)
+{
+	int xfact = mode->xfact;
+	int yfact = mode->yfact;
+
+	rect->x *= xfact;
+	rect->y *= yfact;
+	rect->xl *= xfact;
+	rect->yl *= yfact;
+}
+
+static void
+_gfxop_scale_point(point_t *point, gfx_mode_t *mode)
+{
+	int xfact = mode->xfact;
+	int yfact = mode->yfact;
+
+	point->x *= xfact;
+	point->y *= yfact;
+}
+
+static void
+_gfxop_alloc_colors(gfx_state_t *state, gfx_pixmap_color_t *colors, int colors_nr)
+{
+	int i;
+
+	if (!PALETTE_MODE)
+		return;
+
+	for (i = 0; i < colors_nr; i++)
+		gfx_alloc_color(state->driver->mode->palette, colors + i);
+}
+
+static void
+_gfxop_free_colors(gfx_state_t *state, gfx_pixmap_color_t *colors, int colors_nr)
+{
+	int i;
+
+	if (!PALETTE_MODE)
+		return;
+
+	for (i = 0; i < colors_nr; i++)
+		gfx_free_color(state->driver->mode->palette, colors + i);
+}
+
+
+int _gfxop_clip(rect_t *rect, rect_t clipzone)
+/* Returns 1 if nothing is left */
+{
+#if 0
+	printf ("Clipping (%d, %d) size (%d, %d)  by (%d,%d)(%d,%d)\n", rect->x, rect->y, rect->xl, rect->yl,
+		clipzone.x, clipzone.y, clipzone.xl, clipzone.yl);
+#endif
+
+	if (rect->x < clipzone.x) {
+		rect->xl -= (clipzone.x - rect->x);
+		rect->x = clipzone.x;
+	}
+
+	if (rect->y < clipzone.y) {
+		rect->yl -= (clipzone.y - rect->y);
+		rect->y = clipzone.y;
+	}
+
+	if (rect->x + rect->xl > clipzone.x + clipzone.xl)
+		rect->xl = (clipzone.x + clipzone.xl) - rect->x;
+
+	if (rect->y + rect->yl > clipzone.y + clipzone.yl)
+		rect->yl = (clipzone.y + clipzone.yl) - rect->y;
+
+	if (rect->xl < 0)
+		rect->xl = 0;
+	if (rect->yl < 0)
+		rect->yl = 0;
+
+#if 0
+	printf (" => (%d, %d) size (%d, %d)\n", rect->x, rect->y, rect->xl, rect->yl);
+#endif
+	return (rect->xl <= 0 || rect->yl <= 0);
+}
+
+static int
+_gfxop_grab_pixmap(gfx_state_t *state, gfx_pixmap_t **pxmp, int x, int y,
+		   int xl, int yl, int priority, rect_t *zone)
+     /* Returns 1 if the resulting data size was zero, GFX_OK or an error code otherwise */
+{
+	int xfact = state->driver->mode->xfact;
+	int yfact = state->driver->mode->yfact;
+	int unscaled_xl = (xl + xfact - 1) / xfact;
+	int unscaled_yl = (yl + yfact - 1) / yfact;
+	*zone = gfx_rect(x, y, xl, yl);
+
+	if (_gfxop_clip(zone, gfx_rect(0, 0,
+				       320 * state->driver->mode->xfact,
+				       200 * state->driver->mode->yfact)))
+		return GFX_ERROR;
+
+	if (!*pxmp)
+		*pxmp = gfx_new_pixmap(unscaled_xl, unscaled_yl, GFX_RESID_NONE, 0, 0);
+	else
+		if (xl * yl > (*pxmp)->xl * (*pxmp)->yl) {
+			gfx_pixmap_free_data(*pxmp);
+			(*pxmp)->data = NULL;
+		}
+
+	if (!(*pxmp)->data) {
+		(*pxmp)->index_xl = unscaled_xl + 1;
+		(*pxmp)->index_yl = unscaled_yl + 1;
+		gfx_pixmap_alloc_data(*pxmp, state->driver->mode);
+	}
+	return state->driver->grab_pixmap(state->driver, *zone, *pxmp,
+					  priority? GFX_MASK_PRIORITY : GFX_MASK_VISUAL);
+}
+
+
+#define DRAW_LOOP(condition)										\
+{													\
+	rect_t drawrect = gfx_rect(pos.x, pos.y, pxm->index_xl, pxm->index_yl);				\
+	int offset, base_offset;									\
+	int read_offset, base_read_offset;								\
+	int x,y;											\
+													\
+	if (!pxm->index_data) {										\
+		GFXERROR("Attempt to draw control color %d on pixmap %d/%d/%d without index data!\n",	\
+			 color, pxm->ID, pxm->loop, pxm->cel);						\
+		return;											\
+	}												\
+													\
+	if (_gfxop_clip(&drawrect, gfx_rect(0, 0, 320, 200)))						\
+		return;											\
+													\
+	offset = base_offset = drawrect.x + drawrect.y * 320;						\
+	read_offset = base_read_offset = (drawrect.x - pos.x) + ((drawrect.y - pos.y) * pxm->index_xl);	\
+													\
+	for (y = 0; y < drawrect.yl; y++) {								\
+		for (x = 0; x < drawrect.xl; x++)							\
+			if (pxm->index_data[read_offset++] != pxm->color_key) {				\
+				if (condition)								\
+					map->index_data[offset++] = color;				\
+				else									\
+					++offset;							\
+			} else ++offset;								\
+													\
+		offset = base_offset += 320;								\
+		read_offset = base_read_offset += pxm->index_xl;					\
+	}												\
+}
+
+static void
+_gfxop_draw_control(gfx_pixmap_t *map, gfx_pixmap_t *pxm, int color, point_t pos)
+DRAW_LOOP(1) /* Always draw */
+
+#ifdef PRECISE_PRIORITY_MAP
+static void
+_gfxop_draw_priority(gfx_pixmap_t *map, gfx_pixmap_t *pxm, int color, point_t pos)
+DRAW_LOOP(map->index_data[offset] < color) /* Draw only lower priority */
+#endif
+
+#undef DRAW_LOOP
+
+static int
+_gfxop_install_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm)
+{
+	int error;
+
+	if (driver->capabilities & GFX_CAPABILITY_PIXMAP_REGISTRY
+	    && !(pxm->flags & GFX_PIXMAP_FLAG_INSTALLED)) {
+		error = driver->register_pixmap(driver, pxm);
+
+		if (error) {
+			GFXERROR("driver->register_pixmap() returned error!\n");
+			return error;
+		}
+		pxm->flags |= GFX_PIXMAP_FLAG_INSTALLED;
+	}
+
+	if (driver->mode->palette &&
+	    (!(pxm->flags & GFX_PIXMAP_FLAG_PALETTE_SET))) {
+		int i;
+		int error;
+
+		for (i = 0; i < pxm->colors_nr; i++) {
+			if ((error = driver->set_palette(driver, pxm->colors[i].global_index,
+							 pxm->colors[i].r,
+							 pxm->colors[i].g,
+							 pxm->colors[i].b))) {
+
+				GFXWARN("driver->set_palette(%d, %02x/%02x/%02x) failed!\n",
+					pxm->colors[i].global_index,
+					pxm->colors[i].r,
+					pxm->colors[i].g,
+					pxm->colors[i].b);
+
+				if (error == GFX_FATAL)
+					return GFX_FATAL;
+			}
+		}
+
+		pxm->flags |= GFX_PIXMAP_FLAG_PALETTE_SET;
+	}
+	return GFX_OK;
+}
+
+static int
+_gfxop_draw_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm, int priority, int control,
+		   rect_t src, rect_t dest, rect_t clip, int static_buf, gfx_pixmap_t *control_map,
+		   gfx_pixmap_t *priority_map)
+{
+	int error;
+	rect_t clipped_dest = gfx_rect(dest.x, dest.y, dest.xl, dest.yl);
+
+	if (control >= 0 || priority >= 0) {
+		point_t original_pos = gfx_point(dest.x / driver->mode->xfact,
+						     dest.y / driver->mode->yfact);
+
+		if (control >= 0)
+			_gfxop_draw_control(control_map, pxm, control, original_pos);
+
+#ifdef PRECISE_PRIORITY_MAP
+		if (priority >= 0)
+			_gfxop_draw_priority(priority_map, pxm, priority, original_pos);
+#endif
+	}
+
+					   
+	if (_gfxop_clip(&clipped_dest, clip))
+		return GFX_OK;
+
+	src.x += clipped_dest.x - dest.x;
+	src.y += clipped_dest.y - dest.y;
+	src.xl = clipped_dest.xl;
+	src.yl = clipped_dest.yl;
+
+	error = _gfxop_install_pixmap(driver, pxm);
+	if (error) return error;
+
+	DDIRTY(stderr, "\\-> Drawing to actual %d %d %d %d\n",
+	       clipped_dest.x / driver->mode->xfact,
+	       clipped_dest.y / driver->mode->yfact,
+	       clipped_dest.xl / driver->mode->xfact,
+	       clipped_dest.yl / driver->mode->yfact);
+
+	error = driver->draw_pixmap(driver, pxm, priority, src, clipped_dest,
+				    static_buf? GFX_BUFFER_STATIC : GFX_BUFFER_BACK);
+
+	if (error) {
+		GFXERROR("driver->draw_pixmap() returned error!\n");
+		return error;
+	}
+	return GFX_OK;
+}
+
+static int
+_gfxop_remove_pointer(gfx_state_t *state)
+{
+	if (state->mouse_pointer_visible
+	    && !state->mouse_pointer_in_hw
+	    && state->mouse_pointer_bg) {
+		int retval;
+
+		if (state->mouse_pointer_visible == POINTER_VISIBLE_BUT_CLIPPED) {
+			state->mouse_pointer_visible = 0;
+			state->pointer_pos.x = state->driver->pointer_x / state->driver->mode->xfact;
+			state->pointer_pos.y = state->driver->pointer_y / state->driver->mode->yfact;
+			return GFX_OK;
+		}
+
+		state->mouse_pointer_visible = 0;
+
+		retval = state->driver->draw_pixmap(state->driver, state->mouse_pointer_bg, GFX_NO_PRIORITY,
+						   gfx_rect(0, 0, state->mouse_pointer_bg->xl, state->mouse_pointer_bg->yl),
+						   state->pointer_bg_zone,
+						   GFX_BUFFER_BACK);
+
+		state->pointer_pos.x = state->driver->pointer_x / state->driver->mode->xfact;
+		state->pointer_pos.y = state->driver->pointer_y / state->driver->mode->yfact;
+
+		return retval;
+
+	} else {
+		state->pointer_pos.x = state->driver->pointer_x / state->driver->mode->xfact;
+		state->pointer_pos.y = state->driver->pointer_y / state->driver->mode->yfact;
+		return GFX_OK;
+	}
+}
+
+static int /* returns 1 if there are no pointer bounds, 0 otherwise */
+_gfxop_get_pointer_bounds(gfx_state_t *state, rect_t *rect)
+{
+	gfx_pixmap_t *ppxm = state->mouse_pointer;
+
+	if (!ppxm)
+		return 1;
+
+	rect->x = state->driver->pointer_x - ppxm->xoffset * (state->driver->mode->xfact);
+	rect->y = state->driver->pointer_y - ppxm->yoffset * (state->driver->mode->yfact);
+	rect->xl = ppxm->xl;
+	rect->yl = ppxm->yl;
+
+	return (_gfxop_clip(rect, gfx_rect(0, 0, 320 * state->driver->mode->xfact,
+					   200 * state->driver->mode->yfact)));
+}
+
+static int
+_gfxop_buffer_propagate_box(gfx_state_t *state, rect_t box, gfx_buffer_t buffer);
+
+static int
+_gfxop_draw_pointer(gfx_state_t *state)
+{
+	if (state->mouse_pointer_visible || !state->mouse_pointer || state->mouse_pointer_in_hw)
+		return GFX_OK;
+	else {
+		int retval;
+		gfx_pixmap_t *ppxm = state->mouse_pointer;
+		int xfact, yfact;
+		int x = state->driver->pointer_x - ppxm->xoffset * (xfact = state->driver->mode->xfact);
+		int y = state->driver->pointer_y - ppxm->yoffset * (yfact = state->driver->mode->yfact);
+		int error;
+
+		state->mouse_pointer_visible = 1;
+
+		state->old_pointer_draw_pos.x = x;
+		state->old_pointer_draw_pos.y = y;
+
+		/* FIXME: we are leaking the mouse_pointer_bg, but freeing it causes weirdness in jones
+		 * we should reuse the buffer instead of malloc/free for better performance */
+
+		retval = _gfxop_grab_pixmap(state, &(state->mouse_pointer_bg), x, y,
+					    ppxm->xl, ppxm->yl, 0,
+					    &(state->pointer_bg_zone));
+
+		if (retval == GFX_ERROR) {
+			state->pointer_bg_zone = gfx_rect(0, 0, 320, 200);
+			state->mouse_pointer_visible = POINTER_VISIBLE_BUT_CLIPPED;
+			return GFX_OK;
+		}
+
+		if (retval)
+			return retval;
+
+		error = _gfxop_draw_pixmap(state->driver, ppxm, -1, -1,
+					   gfx_rect(0, 0, ppxm->xl, ppxm->yl),
+					   gfx_rect(x, y, ppxm->xl, ppxm->yl),
+					   gfx_rect(0, 0, xfact * 320 , yfact * 200),
+					   0, state->control_map, state->priority_map);
+
+		if (error)
+			return error;
+
+
+		return GFX_OK;
+	}
+}
+
+gfx_pixmap_t *
+_gfxr_get_cel(gfx_state_t *state, int nr, int *loop, int *cel, int palette)
+{
+	gfxr_view_t *view = gfxr_get_view(state->resstate, nr, loop, cel, palette);
+	gfxr_loop_t *indexed_loop;
+
+	if (!view)
+		return NULL;
+
+	if (*loop >= view->loops_nr
+	    || *loop < 0) {
+		GFXWARN("Attempt to get cel from loop %d/%d inside view %d\n", *loop,
+			view->loops_nr, nr);
+		return NULL;
+	}
+	indexed_loop = view->loops + *loop;
+
+	if (*cel >= indexed_loop->cels_nr
+	    || *cel < 0) {
+		GFXWARN("Attempt to get cel %d/%d from view %d/%d\n", *cel, indexed_loop->cels_nr,
+			nr, *loop);
+		return NULL;
+	}
+
+	return indexed_loop->cels[*cel]; /* Yes, view->cels uses a malloced pointer list. */
+}
+
+/*** Dirty rectangle operations ***/
+
+static inline int
+_gfxop_update_box(gfx_state_t *state, rect_t box)
+{
+	int retval;
+	_gfxop_scale_rect(&box, state->driver->mode);
+
+	if ((retval = _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_FRONT))) {
+		GFXERROR("Error occured while propagating box (%d,%d,%d,%d) to front buffer\n",
+			 box.x, box.y, box.xl, box.yl);
+		return retval;
+	}
+	return GFX_OK;
+}
+
+
+static struct _dirty_rect *
+_rect_create(rect_t box)
+{
+	struct _dirty_rect *rect;
+
+	rect = (struct _dirty_rect*)sci_malloc(sizeof(struct _dirty_rect));
+	rect->next = NULL;
+	rect->rect = box;
+
+	return rect;
+}
+
+
+gfx_dirty_rect_t *
+gfxdr_add_dirty(gfx_dirty_rect_t *base, rect_t box, int strategy)
+{
+	if (box.xl < 0) {
+		box.x += box.xl;
+		box.xl = - box.xl;
+	}
+
+	if (box.yl < 0) {
+		box.y += box.yl;
+		box.yl = - box.yl;
+	}
+#ifdef GFXOP_DEBUG_DIRTY
+	fprintf(stderr, "Adding new dirty (%d %d %d %d)\n",
+		GFX_PRINT_RECT(box));
+#endif
+	if (_gfxop_clip(&box, gfx_rect(0, 0, 320, 200)))
+		return base;
+
+	switch (strategy) {
+
+	case GFXOP_DIRTY_FRAMES_ONE:
+		if (base)
+			base->rect = gfx_rects_merge(box, base->rect);
+		else
+			base = _rect_create(box);
+		break;
+
+	case GFXOP_DIRTY_FRAMES_CLUSTERS: {
+		struct _dirty_rect **rectp = &(base);
+
+		while (*rectp) {
+			if (gfx_rects_overlap((*rectp)->rect, box)) {
+				struct _dirty_rect *next = (*rectp)->next;
+				box = gfx_rects_merge((*rectp)->rect, box);
+				free(*rectp);
+				*rectp = next;
+			} else
+				rectp = &((*rectp)->next);
+		}
+		*rectp = _rect_create(box);
+
+	} break;
+
+	default:
+		GFXERROR("Attempt to use invalid dirty frame mode %d!\nPlease refer to gfx_options.h.", strategy);
+
+	}
+
+	return base;
+}
+
+static void
+_gfxop_add_dirty(gfx_state_t *state, rect_t box)
+{
+	if (state->disable_dirty)
+		return;
+
+	state->dirty_rects = gfxdr_add_dirty(state->dirty_rects, box, state->options->dirty_frames);
+}
+
+static inline void
+_gfxop_add_dirty_x(gfx_state_t *state, rect_t box)
+     /* Extends the box size by one before adding (used for lines) */
+{
+	if (box.xl < 0)
+		box.xl--;
+	else
+		box.xl++;
+
+	if (box.yl < 0)
+		box.yl--;
+	else
+		box.yl++;
+
+	_gfxop_add_dirty(state, box);
+}
+
+static int
+_gfxop_clear_dirty_rec(gfx_state_t *state, struct _dirty_rect *rect)
+{
+	int retval;
+
+	if (!rect)
+		return GFX_OK;
+
+#ifdef GFXOP_DEBUG_DIRTY
+	fprintf(stderr, "\tClearing dirty (%d %d %d %d)\n",
+		GFX_PRINT_RECT(rect->rect));
+#endif
+	if (!state->fullscreen_override)
+		retval = _gfxop_update_box(state, rect->rect);
+	else
+		retval = GFX_OK;
+
+	retval |= _gfxop_clear_dirty_rec(state, rect->next);
+
+	free(rect);
+	return retval;
+}
+
+
+/*** Exported operations ***/
+
+static void
+init_aux_pixmap(gfx_pixmap_t **pixmap)
+{
+	*pixmap = gfx_pixmap_alloc_index_data(gfx_new_pixmap(320, 200, GFX_RESID_NONE, 0, 0));
+	(*pixmap)->flags |= GFX_PIXMAP_FLAG_EXTERNAL_PALETTE;
+	(*pixmap)->colors_nr = DEFAULT_COLORS_NR;
+	(*pixmap)->colors = default_colors;
+}
+
+static int
+_gfxop_init_common(gfx_state_t *state, gfx_options_t *options, void *misc_payload)
+{
+	state->options = options;
+
+	if (!((state->resstate = gfxr_new_resource_manager(state->version,
+							   state->options,
+							   state->driver,
+							   misc_payload)))) {
+		GFXERROR("Failed to initialize resource manager!\n");
+		return GFX_FATAL;
+	}
+
+	if ((state->static_palette =
+	     gfxr_interpreter_get_static_palette(state->resstate,
+						 state->version,
+					         &(state->static_palette_entries),
+					         misc_payload)))
+		_gfxop_alloc_colors(state, state->static_palette, state->static_palette_entries);
+
+	state->visible_map = GFX_MASK_VISUAL;
+	state->fullscreen_override = NULL; /* No magical override */
+	gfxop_set_clip_zone(state, gfx_rect(0, 0, 320, 200));
+
+	state->mouse_pointer = state->mouse_pointer_bg = NULL;
+	state->mouse_pointer_visible = 0;
+
+	init_aux_pixmap(&(state->control_map));
+	init_aux_pixmap(&(state->priority_map));
+	init_aux_pixmap(&(state->static_priority_map));
+
+	state->options = options;
+	state->mouse_pointer_in_hw = 0;
+	state->disable_dirty = 0;
+	state->events = NULL;
+
+	state->pic = state->pic_unscaled = NULL;
+
+	state->pic_nr = -1; /* Set background pic number to an invalid value */
+
+	state->tag_mode = 0;
+
+	state->dirty_rects = NULL;
+
+
+	return GFX_OK;
+}
+
+int
+gfxop_init_default(gfx_state_t *state, gfx_options_t *options, void *misc_info)
+{
+	BASIC_CHECKS(GFX_FATAL);
+	if (state->driver->init(state->driver))
+		return GFX_FATAL;
+
+	return _gfxop_init_common(state, options, misc_info);
+}
+
+
+int
+gfxop_init(gfx_state_t *state, int xfact, int yfact, gfx_color_mode_t bpp,
+	   gfx_options_t *options, void *misc_info)
+{
+	int color_depth = bpp? bpp : 1;
+	int initialized = 0;
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	do {
+		if (!state->driver->init_specific(state->driver, xfact, yfact, color_depth))
+			initialized = 1;
+		else
+			color_depth++;
+	} while (!initialized && color_depth < 9 && !bpp);
+
+	if (!initialized)
+		return GFX_FATAL;
+
+	return _gfxop_init_common(state, options, misc_info);
+}
+
+
+int
+gfxop_set_parameter(gfx_state_t *state, char *attribute, char *value)
+{
+	BASIC_CHECKS(GFX_FATAL);
+
+	return state->driver->set_parameter(state->driver, attribute, value);
+}
+
+
+int
+gfxop_exit(gfx_state_t *state)
+{
+	BASIC_CHECKS(GFX_ERROR);
+	gfxr_free_resource_manager(state->driver, state->resstate);
+
+	if (state->control_map) {
+		gfx_free_pixmap(state->driver, state->control_map);
+		state->control_map = NULL;
+	}
+
+	if (state->priority_map) {
+		gfx_free_pixmap(state->driver, state->priority_map);
+		state->priority_map = NULL;
+	}
+
+	if (state->static_priority_map) {
+		gfx_free_pixmap(state->driver, state->static_priority_map);
+		state->static_priority_map = NULL;
+	}
+
+	if (state->mouse_pointer_bg) {
+		gfx_free_pixmap(state->driver, state->mouse_pointer_bg);
+		state->mouse_pointer_bg = NULL;
+	}
+
+	state->driver->exit(state->driver);
+	return GFX_OK;
+}
+
+
+int
+gfxop_have_mouse(gfx_state_t *state)
+{
+	return state->driver->capabilities & GFX_CAPABILITY_MOUSE_SUPPORT;
+}
+
+
+static int
+_gfxop_scan_one_bitmask(gfx_pixmap_t *pixmap, rect_t zone)
+{
+	int retval = 0;
+	int pixmap_xscale = pixmap->index_xl / 320;
+	int pixmap_yscale = pixmap->index_yl / 200;
+	int line_width = pixmap_yscale * pixmap->index_xl;
+	int startindex = (line_width * zone.y) + (zone.x * pixmap_xscale);
+
+	startindex += pixmap_xscale >> 1; /* Center on X */
+	startindex += (pixmap_yscale >> 1) * pixmap->index_xl; /* Center on Y */
+
+	if (_gfxop_clip(&zone, gfx_rect(0, 0, pixmap->index_xl, pixmap->index_yl)))
+		return 0;
+
+	while (zone.yl--) {
+		int i;
+		for (i = 0; i < (zone.xl * pixmap_xscale); i += pixmap_xscale)
+			retval |= (1 << ((pixmap->index_data[startindex + i]) & 0xf));
+
+		startindex += line_width;
+	}
+
+	return retval;
+}
+
+int
+gfxop_scan_bitmask(gfx_state_t *state, rect_t area, gfx_map_mask_t map)
+{
+	gfxr_pic_t *pic = (state->pic_unscaled)? state->pic_unscaled : state->pic;
+	int retval = 0;
+
+	_gfxop_clip(&area, gfx_rect(0, 10, 320, 200));
+
+	if (area.xl <= 0
+	    || area.yl <= 0)
+		return 0;
+
+	if (map & GFX_MASK_VISUAL)
+		retval |= _gfxop_scan_one_bitmask(pic->visual_map, area);
+
+	if (map & GFX_MASK_PRIORITY)
+		retval |= _gfxop_scan_one_bitmask(state->priority_map, area);
+	if (map & GFX_MASK_CONTROL)
+		retval |= _gfxop_scan_one_bitmask(state->control_map, area);
+
+	return retval;
+}
+
+
+#define MIN_X 0
+#define MIN_Y 0
+#define MAX_X 319
+#define MAX_Y 199
+
+int
+gfxop_set_clip_zone(gfx_state_t *state, rect_t zone)
+{
+	int xfact, yfact;
+	BASIC_CHECKS(GFX_ERROR);
+
+	DDIRTY(stderr, "-- Setting clip zone %d %d %d %d\n", GFX_PRINT_RECT(zone));
+
+	xfact = state->driver->mode->xfact;
+	yfact = state->driver->mode->yfact;
+
+	if (zone.x < MIN_X) {
+		zone.xl -= (zone.x - MIN_X);
+		zone.x = MIN_X;
+	}
+
+	if (zone.y < MIN_Y) {
+		zone.yl -= (zone.y - MIN_Y);
+		zone.y = MIN_Y;
+	}
+
+	if (zone.x + zone.xl > MAX_X)
+		zone.xl = MAX_X + 1 - zone.x;
+
+	if (zone.y + zone.yl > MAX_Y)
+		zone.yl = MAX_Y + 1 - zone.y;
+
+	memcpy(&(state->clip_zone_unscaled), &zone, sizeof(rect_t));
+
+	state->clip_zone.x = state->clip_zone_unscaled.x * xfact;
+	state->clip_zone.y = state->clip_zone_unscaled.y * yfact;
+	state->clip_zone.xl = state->clip_zone_unscaled.xl * xfact;
+	state->clip_zone.yl = state->clip_zone_unscaled.yl * yfact;
+
+	return GFX_OK;
+}
+
+int
+gfxop_set_color(gfx_state_t *state, gfx_color_t *color, int r, int g, int b, int a,
+		int priority, int control)
+{
+	gfx_pixmap_color_t pixmap_color = {0};
+	int error_code;
+	int mask = ((r >= 0 && g >= 0 && b >= 0) ? GFX_MASK_VISUAL : 0)
+		| ((priority >= 0)? GFX_MASK_PRIORITY : 0)
+		| ((control >= 0)? GFX_MASK_CONTROL : 0);
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	if (PALETTE_MODE && a >= GFXOP_ALPHA_THRESHOLD)
+		mask &= ~GFX_MASK_VISUAL;
+
+	color->mask = mask;
+
+	color->priority = priority;
+	color->control = control;
+
+	if (mask & GFX_MASK_VISUAL) {
+
+		color->visual.r = r;
+		color->visual.g = g;
+		color->visual.b = b;
+		color->alpha = a;
+
+		if (PALETTE_MODE) {
+			pixmap_color.r = r;
+			pixmap_color.g = g;
+			pixmap_color.b = b;
+			pixmap_color.global_index = GFX_COLOR_INDEX_UNMAPPED;
+			if ((error_code = gfx_alloc_color(state->driver->mode->palette, &pixmap_color))) {
+				if (error_code < 0) {
+					GFXWARN("Could not get color entry for %02x/%02x/%02x\n", r, g, b);
+					return error_code;
+				} else if ((error_code = state->driver->set_palette(state->driver, pixmap_color.global_index, (byte) r, (byte) g, (byte) b))) {
+					GFXWARN("Graphics driver failed to set color index %d to (%02x/%02x/%02x)\n",
+						pixmap_color.global_index, r, g, b);
+					return error_code;
+				}
+			}
+			color->visual.global_index = pixmap_color.global_index;
+		}
+	}
+	return GFX_OK;
+}
+
+int
+gfxop_set_system_color(gfx_state_t *state, gfx_color_t *color)
+{
+	gfx_palette_color_t *palette_colors;
+	BASIC_CHECKS(GFX_FATAL);
+
+	if (!PALETTE_MODE)
+		return GFX_OK;
+
+	if (color->visual.global_index < 0
+	    || color->visual.global_index >= state->driver->mode->palette->max_colors_nr) {
+		GFXERROR("Attempt to set invalid color index %02x as system color\n", color->visual.global_index);
+		return GFX_ERROR;
+	}
+
+	palette_colors = state->driver->mode->palette->colors;
+	palette_colors[color->visual.global_index].lockers = GFX_COLOR_SYSTEM;
+
+	return GFX_OK;
+}
+
+int
+gfxop_free_color(gfx_state_t *state, gfx_color_t *color)
+{
+	gfx_palette_color_t *palette_color	= {0};
+	gfx_pixmap_color_t pixmap_color		= {0};
+	int error_code;
+	BASIC_CHECKS(GFX_FATAL);
+
+	if (!PALETTE_MODE)
+		return GFX_OK;
+
+	if (color->visual.global_index < 0
+	    || color->visual.global_index >= state->driver->mode->palette->max_colors_nr) {
+		GFXERROR("Attempt to free invalid color index %02x\n", color->visual.global_index);
+		return GFX_ERROR;
+	}
+
+	pixmap_color.global_index = color->visual.global_index;
+	palette_color = state->driver->mode->palette->colors + pixmap_color.global_index;
+	pixmap_color.r = palette_color->r;
+	pixmap_color.g = palette_color->g;
+	pixmap_color.b = palette_color->b;
+
+	if ((error_code = gfx_free_color(state->driver->mode->palette, &pixmap_color))) {
+		GFXWARN("Failed to free color with color index %02x\n", color->visual.global_index);
+		return error_code;
+	}
+
+	return GFX_OK;
+}
+
+/******************************/
+/* Generic drawing operations */
+/******************************/
+
+
+static int
+line_check_bar(int *start, int *length, int clipstart, int cliplength)
+{
+	int overlength;
+
+	if (*start < clipstart) {
+		*length -= (clipstart - *start);
+		*start = clipstart;
+	}
+
+	overlength = 1 + (*start + *length) - (clipstart + cliplength);
+
+	if (overlength > 0)
+		*length -= overlength;
+
+	return (*length < 0);
+}
+
+static void
+clip_line_partial(float *start, float *end, float delta_val, float pos_val, float start_val, float end_val)
+{
+	float my_start = (start_val - pos_val) * delta_val;
+	float my_end = (end_val - pos_val) * delta_val;
+
+	if (my_end < *end)
+		*end = my_end;
+	if (my_start > *start)
+		*start = my_start;
+}
+
+static int
+line_clip(rect_t *line, rect_t clip, int xfact, int yfact)
+/* returns 1 if nothing is left, or 0 if part of the line is in the clip window */
+{
+	/* Compensate for line thickness (should match precisely) */
+	clip.xl -= xfact;
+	clip.yl -= yfact;
+
+	if (!line->xl) {/* vbar */
+		if (line->x < clip.x || line->x >= (clip.x + clip.xl))
+			return 1;
+
+		return line_check_bar(&(line->y), &(line->yl), clip.y, clip.yl);
+
+	} else
+
+	if (!line->yl) {/* hbar */
+		if (line->y < clip.y || line->y >= (clip.y + clip.yl))
+			return 1;
+
+		return line_check_bar(&(line->x), &(line->xl), clip.x, clip.xl);
+
+	} else { /* "normal" line */
+		float start = 0.0, end = 1.0;
+		float xv = (float) line->xl;
+		float yv = (float) line->yl;
+
+		if (line->xl < 0)
+			clip_line_partial(&start, &end, (float) (1.0 / xv), (float) line->x, (float) (clip.x + clip.xl), (float) clip.x);
+		else
+			clip_line_partial(&start, &end, (float) (1.0 / xv), (float) line->x, (float) clip.x, (float) (clip.x + clip.xl));
+
+		if (line->yl < 0)
+			clip_line_partial(&start, &end, (float) (1.0 / yv), (float) line->y, (float) (clip.y + clip.yl), (float) clip.y);
+		else
+			clip_line_partial(&start, &end, (float) (1.0 / yv), (float) line->y, (float) clip.y, (float) (clip.y + clip.yl));
+
+		line->x += (int) (xv * start);
+		line->y += (int) (yv * start);
+
+		line->xl = (int) (xv * (end-start));
+		line->yl = (int) (yv * (end-start));
+
+		return (start > 1.0 || end < 0.0);
+	}
+	return 0;
+}
+
+static int
+point_clip(point_t *start, point_t *end, rect_t clip, int xfact, int yfact)
+{
+	rect_t line = gfx_rect(start->x, start->y, end->x - start->x, end->y - start->y);
+	int retval = line_clip(&line, clip, xfact, yfact);
+
+	start->x = line.x;
+	start->y = line.y;
+
+	end->x = line.x + line.xl;
+	end->y = line.y + line.yl;
+
+	return retval;
+}
+
+
+
+static void
+draw_line_to_control_map(gfx_state_t *state, point_t start, point_t end, gfx_color_t color)
+{
+	if (color.mask & GFX_MASK_CONTROL)
+		if (!point_clip(&start, &end, state->clip_zone_unscaled, 0, 0))
+			gfx_draw_line_pixmap_i(state->control_map, start, end, color.control);
+}
+
+static int
+simulate_stippled_line_draw(gfx_driver_t *driver, int skipone, point_t start, point_t end, gfx_color_t color, gfx_line_mode_t line_mode)
+     /* Draws a stippled line if this isn't supported by the driver (skipone is ignored ATM) */
+{
+	int xl = end.x - start.x;
+	int yl = end.y - start.y;
+	int stepwidth = (xl)? driver->mode->xfact : driver->mode->yfact;
+	int dbl_stepwidth = 2*stepwidth;
+	int linelength = (line_mode == GFX_LINE_MODE_FINE)? stepwidth - 1 : 0;
+	int *posvar;
+	int length;
+	int delta;
+	int length_left;
+
+	if (!xl) { /* xl = 0, so we move along yl */
+		posvar = &start.y;
+		length = yl;
+		delta = (yl < 0)? -dbl_stepwidth : dbl_stepwidth;
+	} else {
+		assert (!yl); /* We don't do diagonals; that's not needed ATM. */
+		posvar = &start.x;
+		length = xl;
+		delta = (xl < 0)? -dbl_stepwidth : dbl_stepwidth;
+	}
+
+	length_left = length;
+
+	if (skipone) {
+		length_left -= stepwidth;
+		*posvar += stepwidth;
+	}
+
+	length /= delta;
+
+	length_left -= length * dbl_stepwidth;
+
+	if (xl)
+		xl = linelength;
+	else
+		yl = linelength;
+
+	while (length--) {
+		int retval;
+		point_t nextpos = gfx_point(start.x + xl, start.y + yl);
+
+		if ((retval = driver->draw_line(driver, start, nextpos,
+						color, line_mode, GFX_LINE_STYLE_NORMAL))) {
+			GFXERROR("Failed to draw partial stippled line (%d,%d) -- (%d,%d)\n",
+				 GFX_PRINT_POINT(start), GFX_PRINT_POINT(nextpos));
+			return retval;
+		}
+		*posvar += delta;
+	}
+
+	if (length_left) {
+		int retval;
+		point_t nextpos;
+
+		if (length_left > stepwidth)
+			length_left = stepwidth;
+
+		if (xl)
+			xl = length_left;
+		else
+			if (yl)
+				yl = length_left;
+
+		nextpos = gfx_point(start.x + xl, start.y + yl);
+
+		if ((retval = driver->draw_line(driver, start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
+			GFXERROR("Failed to draw partial stippled line (%d,%d) -- (%d,%d)\n",
+				 GFX_PRINT_POINT(start), GFX_PRINT_POINT(nextpos));
+			return retval;
+		}
+	}
+
+	return GFX_OK;
+}
+
+
+static int
+_gfxop_draw_line_clipped(gfx_state_t *state, point_t start, point_t end, gfx_color_t color, gfx_line_mode_t line_mode,
+			 gfx_line_style_t line_style)
+{
+	int retval;
+	int skipone = (start.x ^ end.y) & 1; /* Used for simulated line stippling */
+
+	BASIC_CHECKS(GFX_FATAL);
+	REMOVE_POINTER;
+
+	/* First, make sure that the line is normalized */
+	if (start.y > end.y) {
+		point_t swap = start;
+		start = end;
+		end = swap;
+	}
+
+	if (start.x < state->clip_zone.x
+	    || start.y < state->clip_zone.y
+	    || end.x >= (state->clip_zone.x + state->clip_zone.xl)
+	    || end.y >= (state->clip_zone.y + state->clip_zone.yl))
+		if (point_clip(&start, &end, state->clip_zone, state->driver->mode->xfact - 1,
+			      state->driver->mode->yfact - 1))
+			return GFX_OK; /* Clipped off */
+
+	if (line_style == GFX_LINE_STYLE_STIPPLED) {
+		if (start.x != end.x && start.y != end.y) {
+			GFXWARN("Attempt to draw stippled line which is neither an hbar nor a vbar: (%d,%d) -- (%d,%d)\n",
+				 GFX_PRINT_POINT(start), GFX_PRINT_POINT(end));
+			return GFX_ERROR;
+		}
+		if (!(state->driver->capabilities & GFX_CAPABILITY_STIPPLED_LINES))
+			return simulate_stippled_line_draw(state->driver, skipone, start, end, color, line_mode);
+	}
+
+	if (line_mode == GFX_LINE_MODE_FINE
+	    && !(state->driver->capabilities & GFX_CAPABILITY_FINE_LINES))
+		line_mode = GFX_LINE_MODE_FAST;
+
+	if ((retval = state->driver->draw_line(state->driver, start, end, color, line_mode, line_style))) {
+		GFXERROR("Failed to draw line (%d,%d) -- (%d,%d)\n",
+			 GFX_PRINT_POINT(start), GFX_PRINT_POINT(end));
+		return retval;
+	}
+	return GFX_OK;
+}
+
+int
+gfxop_draw_line(gfx_state_t *state, point_t start, point_t end,
+		gfx_color_t color, gfx_line_mode_t line_mode,
+		gfx_line_style_t line_style)
+{
+	int xfact, yfact;
+
+	BASIC_CHECKS(GFX_FATAL);
+	_gfxop_add_dirty_x(state, gfx_rect(start.x, start.y, end.x - start.x, end.y - start.y));
+
+	xfact = state->driver->mode->xfact;
+	yfact = state->driver->mode->yfact;
+
+	draw_line_to_control_map(state, start, end, color);
+
+	_gfxop_scale_point(&start, state->driver->mode);
+	_gfxop_scale_point(&end, state->driver->mode);
+
+	if (line_mode == GFX_LINE_MODE_FINE) {
+		start.x += xfact >> 1;
+		start.y += yfact >> 1;
+
+		end.x += xfact >> 1;
+		end.y += yfact >> 1;
+	}
+
+	return _gfxop_draw_line_clipped(state, start, end, color, line_mode, line_style);
+}
+
+int
+gfxop_draw_rectangle(gfx_state_t *state, rect_t rect, gfx_color_t color, gfx_line_mode_t line_mode,
+		     gfx_line_style_t line_style)
+{
+	int retval = 0;
+	int xfact, yfact;
+	int xunit, yunit;
+	int x, y, xl, yl;
+	point_t upper_left_u, upper_right_u, lower_left_u, lower_right_u;
+	point_t upper_left, upper_right, lower_left, lower_right;
+
+	BASIC_CHECKS(GFX_FATAL);
+	REMOVE_POINTER;
+
+	xfact = state->driver->mode->xfact;
+	yfact = state->driver->mode->yfact;
+
+	if (line_mode == GFX_LINE_MODE_FINE
+	    && state->driver->capabilities & GFX_CAPABILITY_FINE_LINES) {
+		xunit = yunit = 1;
+		xl = 1 + (rect.xl - 1) * xfact;
+		yl = 1 + (rect.yl - 1) * yfact;
+		x = rect.x * xfact + (xfact - 1);
+		y = rect.y * yfact + (yfact - 1);
+	} else {
+		xunit = xfact;
+		yunit = yfact;
+		xl = rect.xl * xfact;
+		yl = rect.yl * yfact;
+		x = rect.x * xfact;
+		y = rect.y * yfact;
+	}
+
+	upper_left_u = gfx_point(rect.x, rect.y);
+	upper_right_u = gfx_point(rect.x + rect.xl, rect.y);
+	lower_left_u = gfx_point(rect.x, rect.y + rect.yl);
+	lower_right_u = gfx_point(rect.x + rect.xl, rect.y + rect.yl);
+
+	upper_left = gfx_point(x, y);
+	upper_right = gfx_point(x + xl, y);
+	lower_left = gfx_point(x, y + yl);
+	lower_right = gfx_point(x + xl, y + yl);
+
+#define PARTIAL_LINE(pt1, pt2)	 								\
+	retval |= _gfxop_draw_line_clipped(state, pt1, pt2, color, line_mode, line_style);	\
+	draw_line_to_control_map(state, pt1##_u, pt2##_u, color);				\
+	_gfxop_add_dirty_x(state,								\
+			   gfx_rect(pt1##_u.x, pt1##_u.y, pt2##_u.x - pt1##_u.x, pt2##_u.y - pt1##_u.y))
+
+	PARTIAL_LINE (upper_left, upper_right);
+	PARTIAL_LINE (upper_right, lower_right);
+	PARTIAL_LINE (lower_right, lower_left);
+	PARTIAL_LINE (lower_left, upper_left);
+
+#undef PARTIAL_LINE
+	if (retval) {
+		GFXERROR("Failed to draw rectangle (%d,%d)+(%d,%d)\n", rect.x, rect.y, rect.xl, rect.yl);
+		return retval;
+	}
+	return GFX_OK;
+}
+
+
+#define COLOR_MIX(type, dist) ((color1.type * dist) + (color2.type * (1.0 - dist)))
+
+
+int
+gfxop_draw_box(gfx_state_t *state, rect_t box, gfx_color_t color1, gfx_color_t color2,
+	       gfx_box_shade_t shade_type)
+{
+	gfx_driver_t *drv = state->driver;
+	int reverse = 0; /* switch color1 and color2 */
+	float mod_offset = 0.0, mod_breadth = 1.0; /* 0.0 to 1.0: Color adjustment */
+	gfx_rectangle_fill_t driver_shade_type;
+	rect_t new_box;
+	gfx_color_t draw_color1, draw_color2	= {{0, 0, 0}, 0, 0, 0, 0};
+
+	BASIC_CHECKS(GFX_FATAL);
+	REMOVE_POINTER;
+
+	if (PALETTE_MODE || !(state->driver->capabilities & GFX_CAPABILITY_SHADING))
+		shade_type = GFX_BOX_SHADE_FLAT;
+
+
+	_gfxop_add_dirty(state, box);
+
+	if (color1.mask & GFX_MASK_CONTROL) {
+		/* Write control block, clipped by 320x200 */
+		memcpy(&new_box, &box, sizeof(rect_t));
+		_gfxop_clip(&new_box, gfx_rect(0, 0, 320, 200));
+
+		gfx_draw_box_pixmap_i(state->control_map, new_box, color1.control);
+	}
+
+	_gfxop_scale_rect(&box, state->driver->mode);
+
+	if (!(color1.mask & (GFX_MASK_VISUAL | GFX_MASK_PRIORITY)))
+		return GFX_OK; /* So long... */
+
+	if (box.xl <= 1 || box.yl <= 1) {
+		GFXDEBUG("Attempt to draw box with size %dx%d\n", box.xl, box.yl);
+		return GFX_OK;
+	}
+
+	memcpy(&new_box, &box, sizeof(rect_t));
+	if (_gfxop_clip(&new_box, state->clip_zone))
+		return GFX_OK;
+
+	switch (shade_type) {
+
+	case GFX_BOX_SHADE_FLAT:
+		driver_shade_type = GFX_SHADE_FLAT;
+		break;
+
+	case GFX_BOX_SHADE_LEFT: reverse = 1;
+	case GFX_BOX_SHADE_RIGHT:
+		driver_shade_type = GFX_SHADE_HORIZONTALLY;
+		mod_offset = (float) (((new_box.x - box.x) * 1.0) / (box.xl * 1.0));
+		mod_breadth = (float) ((new_box.xl * 1.0) / (box.xl * 1.0));
+		break;
+
+	case GFX_BOX_SHADE_UP: reverse = 1;
+	case GFX_BOX_SHADE_DOWN:
+		driver_shade_type = GFX_SHADE_VERTICALLY;
+		mod_offset = (float) (((new_box.y - box.y) * 1.0) / (box.yl * 1.0));
+		mod_breadth = (float) ((new_box.yl * 1.0) / (box.yl * 1.0));
+		break;
+
+	default:
+		GFXERROR("Invalid shade type: %d\n", shade_type);
+		return GFX_ERROR;
+	}
+
+
+	if (reverse)
+		mod_offset = (float) (1.0 - (mod_offset + mod_breadth));
+	/* Reverse offset if we have to interpret colors inversely */
+
+	if (shade_type == GFX_BOX_SHADE_FLAT)
+		return drv->draw_filled_rect(drv, new_box, color1, color1, GFX_SHADE_FLAT);
+	else {
+		if (PALETTE_MODE) {
+			GFXWARN("Attempting to draw shaded box in palette mode!\n");
+			return GFX_ERROR;
+		}
+
+		draw_color1.mask = draw_color2.mask = color1.mask;
+		draw_color1.priority = draw_color2.priority = color1.priority;
+
+		if (draw_color1.mask & GFX_MASK_VISUAL) {
+			draw_color1.visual.r = (guint8) COLOR_MIX(visual.r, mod_offset);
+			draw_color1.visual.g = (guint8) COLOR_MIX(visual.g, mod_offset);
+			draw_color1.visual.b = (guint8) COLOR_MIX(visual.b, mod_offset);
+			draw_color1.alpha = (guint8) COLOR_MIX(alpha, mod_offset);
+
+			mod_offset += mod_breadth;
+
+			draw_color2.visual.r = (guint8) COLOR_MIX(visual.r, mod_offset);
+			draw_color2.visual.g = (guint8) COLOR_MIX(visual.g, mod_offset);
+			draw_color2.visual.b = (guint8) COLOR_MIX(visual.b, mod_offset);
+			draw_color2.alpha = (guint8) COLOR_MIX(alpha, mod_offset);
+		}
+		if (reverse)
+			return drv->draw_filled_rect(drv, new_box, draw_color2, draw_color1, driver_shade_type);
+		else
+			return drv->draw_filled_rect(drv, new_box, draw_color1, draw_color2, driver_shade_type);
+	}
+}
+#undef COLOR_MIX
+
+
+int
+gfxop_fill_box(gfx_state_t *state, rect_t box, gfx_color_t color)
+{
+	return gfxop_draw_box(state, box, color, color, GFX_BOX_SHADE_FLAT);
+}
+
+
+
+static int
+_gfxop_buffer_propagate_box(gfx_state_t *state, rect_t box, gfx_buffer_t buffer)
+{
+	int error;
+
+	if (_gfxop_clip(&box, gfx_rect(0, 0, 320 * state->driver->mode->xfact, 200 * state->driver->mode->yfact)))
+		return GFX_OK;
+
+	if ((error = state->driver->update(state->driver, box, gfx_point(box.x, box.y), buffer))) {
+		GFXERROR("Error occured while updating region (%d,%d,%d,%d) in buffer %d\n",
+			 box.x, box.y, box.xl, box.yl, buffer);
+		return error;
+	}
+	return GFX_OK;
+}
+
+extern int sci0_palette;
+int
+gfxop_clear_box(gfx_state_t *state, rect_t box)
+{
+	BASIC_CHECKS(GFX_FATAL);
+	REMOVE_POINTER;
+	_gfxop_add_dirty(state, box);
+	DDIRTY(stderr, "[]  clearing box %d %d %d %d\n", GFX_PRINT_RECT(box));
+	if (box.x == 29
+	    && box.y == 77
+	    && (sci0_palette == 1)) {
+		BREAKPOINT();
+	}
+
+	_gfxop_clip(&box, gfx_rect(0, 0, 320, 200));
+#ifdef PRECISE_PRIORITY_MAP
+	if (state->pic_unscaled)
+		gfx_copy_pixmap_box_i(state->priority_map, state->static_priority_map, box);
+#endif
+
+	_gfxop_scale_rect(&box, state->driver->mode);
+
+	return _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_BACK);
+}
+
+int
+gfxop_set_visible_map(gfx_state_t *state, gfx_map_mask_t visible_map)
+{
+	switch (visible_map) {
+
+	case GFX_MASK_VISUAL:
+		state->fullscreen_override = NULL;
+		if (visible_map != state->visible_map) {
+			rect_t rect = gfx_rect(0, 0, 320, 200);
+			gfxop_clear_box(state, rect);
+			gfxop_update_box(state, rect);
+		}
+		break;
+
+	case GFX_MASK_PRIORITY:
+		state->fullscreen_override = state->priority_map;
+		break;
+
+	case GFX_MASK_CONTROL:
+		state->fullscreen_override = state->control_map;
+		break;
+
+	default:
+		fprintf(stderr, "Invalid display map %d selected!\n", visible_map);
+		return GFX_ERROR;
+	}
+
+	state->visible_map = visible_map;
+	return GFX_OK;
+}
+
+int
+gfxop_update(gfx_state_t *state)
+{
+	int retval;
+
+	BASIC_CHECKS(GFX_FATAL);
+	DRAW_POINTER;
+
+	retval = _gfxop_clear_dirty_rec(state, state->dirty_rects);
+
+	state->dirty_rects = NULL;
+
+	if (state->fullscreen_override) {
+		/* We've been asked to re-draw the active full-screen image, essentially. */
+		rect_t rect = gfx_rect(0, 0, 320, 200);
+		gfx_xlate_pixmap(state->fullscreen_override, state->driver->mode, GFX_XLATE_FILTER_NONE);
+		gfxop_draw_pixmap(state, state->fullscreen_override, rect, gfx_point(0,0));
+		retval |= _gfxop_update_box(state, rect);
+	}
+
+	if (retval) {
+		GFXERROR("Clearing the dirty rectangles failed!\n");
+	}
+
+	if (state->tag_mode) {
+		/* This usually happens after a pic and all resources have been drawn */
+		gfxr_free_tagged_resources(state->driver, state->resstate);
+		state->tag_mode = 0;
+	}
+
+	return retval;
+}
+
+
+int
+gfxop_update_box(gfx_state_t *state, rect_t box)
+{
+	BASIC_CHECKS(GFX_FATAL);
+	DRAW_POINTER;
+
+	if (state->disable_dirty)
+		_gfxop_update_box(state, box);
+	else
+		_gfxop_add_dirty(state, box);
+
+	return gfxop_update(state);
+}
+
+int
+gfxop_enable_dirty_frames(gfx_state_t *state)
+{
+	BASIC_CHECKS(GFX_ERROR);
+	state->disable_dirty = 0;
+
+	return GFX_OK;
+}
+
+int
+gfxop_disable_dirty_frames(gfx_state_t *state)
+{
+	BASIC_CHECKS(GFX_ERROR);
+
+	state->disable_dirty = 1;
+
+	return GFX_OK;
+}
+
+
+/**********************/
+/* Pointer and IO ops */
+/**********************/
+
+#define SECONDS_OF_DAY (24*60*60)
+#define MILLION 1000000
+/* Sure, this may seem silly, but it's too easy to miss a zero...) */
+
+
+#define GFXOP_FULL_POINTER_REFRESH if (_gfxop_full_pointer_refresh(state)) { GFXERROR("Failed to do full pointer refresh!\n"); return GFX_ERROR; }
+
+static int
+_gfxop_full_pointer_refresh(gfx_state_t *state)
+{
+	rect_t pointer_bounds;
+	rect_t old_pointer_bounds	= {0, 0, 0, 0};
+	int new_x			= state->driver->pointer_x;
+	int new_y			= state->driver->pointer_y;
+
+	if (new_x != state->old_pointer_draw_pos.x
+	    || new_y != state->old_pointer_draw_pos.y) {
+		point_t pp_new = gfx_point(new_x / state->driver->mode->xfact,
+					   new_y / state->driver->mode->yfact);
+
+		if (!_gfxop_get_pointer_bounds(state, &pointer_bounds)) {
+			memcpy(&old_pointer_bounds, &(state->pointer_bg_zone), sizeof(rect_t));
+			REMOVE_POINTER;
+			state->pointer_pos = pp_new;
+
+			DRAW_POINTER;
+			if (_gfxop_buffer_propagate_box(state, pointer_bounds, GFX_BUFFER_FRONT)) return 1;
+			if (_gfxop_buffer_propagate_box(state, old_pointer_bounds, GFX_BUFFER_FRONT)) return 1;
+
+			state->old_pointer_draw_pos = gfx_point(new_x, new_y);
+		} else
+			state->pointer_pos = pp_new;
+	}
+	return 0;
+}
+
+int
+gfxop_usleep(gfx_state_t *state, long usecs)
+{
+	long time, utime;
+	long wakeup_time, wakeup_utime;
+	long add_seconds;
+	int retval = GFX_OK;
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	sci_gettime(&wakeup_time, &wakeup_utime);
+	wakeup_utime += usecs;
+
+	add_seconds = (wakeup_utime / MILLION);
+	wakeup_time += add_seconds;
+	wakeup_utime -= (MILLION * add_seconds);
+
+	do {
+		GFXOP_FULL_POINTER_REFRESH;
+		sci_gettime(&time, &utime);
+		usecs = (wakeup_time - time) * MILLION + wakeup_utime - utime;
+	} while ((usecs > 0) && !(retval = state->driver->usec_sleep(state->driver, usecs)));
+
+	if (retval) {
+		GFXWARN("Waiting failed\n");
+	}
+
+	return retval;
+}
+
+
+int
+_gfxop_set_pointer(gfx_state_t *state, gfx_pixmap_t *pxm)
+{
+	rect_t old_pointer_bounds = {0};
+	rect_t pointer_bounds = {0};
+	int retval = -1;
+	int draw_old;
+	int draw_new = 0;
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	draw_old = state->mouse_pointer != NULL;
+
+	if (state->driver->capabilities & GFX_CAPABILITY_MOUSE_POINTER) {
+
+		if (draw_old && state->mouse_pointer->colors_nr > 2)
+			draw_old = state->driver->capabilities & GFX_CAPABILITY_COLOR_MOUSE_POINTER;
+
+		if (!draw_old
+		    && state->mouse_pointer
+		    && (state->driver->capabilities & GFX_CAPABILITY_POINTER_PIXMAP_REGISTRY))
+			if ((retval = state->driver->unregister_pixmap(state->driver, state->mouse_pointer))){
+				GFXERROR("Pointer un-registration failed!\n");
+				return retval;
+			}
+
+		if (pxm == NULL
+		    || (state->driver->capabilities & GFX_CAPABILITY_COLOR_MOUSE_POINTER)
+		    || pxm->colors_nr <= 2) {
+			if (state->driver->capabilities & GFX_CAPABILITY_POINTER_PIXMAP_REGISTRY) {
+				if ((pxm) && (retval = state->driver->register_pixmap(state->driver, pxm))) {
+					GFXERROR("Pixmap-registering a new mouse pointer failed!\n");
+					return retval;
+				}
+			}
+			draw_new = 0;
+			state->driver->set_pointer(state->driver, pxm);
+			state->mouse_pointer_in_hw = 1;
+		} else {
+			draw_new = 1;
+			state->mouse_pointer_in_hw = 0;
+		}
+
+	} else draw_new = 1;
+
+	if (!state->mouse_pointer_in_hw)
+		draw_old = state->mouse_pointer != NULL;
+
+
+	if (draw_old) {
+		_gfxop_get_pointer_bounds(state, &old_pointer_bounds);
+		REMOVE_POINTER;
+	}
+
+
+	if (draw_new) {
+		state->mouse_pointer = pxm;
+		DRAW_POINTER;
+		_gfxop_get_pointer_bounds(state, &pointer_bounds);
+	}
+
+	if (draw_new && state->mouse_pointer)
+		_gfxop_buffer_propagate_box(state, pointer_bounds, GFX_BUFFER_FRONT);
+
+	if (draw_old)
+		_gfxop_buffer_propagate_box(state, old_pointer_bounds, GFX_BUFFER_FRONT);
+
+	if (state->mouse_pointer == NULL)
+		state->mouse_pointer_visible = 0;
+	else if (!state->mouse_pointer_visible)
+		state->mouse_pointer_visible = 1;
+	/* else don't touch it, as it might be VISIBLE_BUT_CLIPPED! */
+
+	return GFX_OK;
+}
+
+
+int
+gfxop_set_pointer_cursor(gfx_state_t *state, int nr)
+{
+	gfx_pixmap_t *new_pointer = NULL;
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	if (nr == GFXOP_NO_POINTER)
+		new_pointer = NULL;
+	else {
+		new_pointer = gfxr_get_cursor(state->resstate, nr);
+
+		if (!new_pointer) {
+			GFXWARN("Attempt to set invalid pointer #%d\n", nr);
+		}
+	}
+
+	return _gfxop_set_pointer(state, new_pointer);
+}
+
+
+int
+gfxop_set_pointer_view(gfx_state_t *state, int nr, int loop, int cel, point_t  *hotspot)
+{
+	int real_loop = loop;
+	int real_cel = cel;
+	gfx_pixmap_t *new_pointer = NULL;
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	new_pointer = _gfxr_get_cel(state, nr, &real_loop, &real_cel,
+				    0); /* FIXME: For now, don't palettize pointers */
+
+	if (hotspot)
+	{
+		new_pointer->xoffset = hotspot->x;
+		new_pointer->yoffset = hotspot->y;
+	}
+
+	if (!new_pointer) {
+		GFXWARN("Attempt to set invalid pointer #%d\n", nr);
+		return GFX_ERROR;
+	} else 
+	{
+		if (real_loop != loop || real_cel != cel) {
+			GFXDEBUG("Changed loop/cel from %d/%d to %d/%d in view %d\n",
+				 loop, cel, real_loop, real_cel, nr);
+		}
+		return _gfxop_set_pointer(state, new_pointer);
+	}
+}
+
+int
+gfxop_set_pointer_position(gfx_state_t *state, point_t pos)
+{
+	BASIC_CHECKS(GFX_ERROR);
+
+	state->pointer_pos = pos;
+
+	if (pos.x > 320 || pos.y > 200)
+	{
+		GFXWARN("Attempt to place pointer at invalid coordinates (%d, %d)\n", pos.x, pos.y);
+		return 0; /* Not fatal */
+	}
+
+	state->driver->pointer_x = pos.x * state->driver->mode->xfact;
+	state->driver->pointer_y = pos.y * state->driver->mode->yfact;
+
+	GFXOP_FULL_POINTER_REFRESH;
+	return 0;
+}
+
+#define SCANCODE_ROWS_NR 3
+
+struct scancode_row {
+	int offset;
+	const char *keys;
+} scancode_rows[SCANCODE_ROWS_NR] = {
+	{0x10, "QWERTYUIOP[]"},
+	{0x1e, "ASDFGHJKL;'\\"},
+	{0x2c, "ZXCVBNM,./"}
+};
+
+static int
+_gfxop_scancode(int ch)
+     /* Calculates a PC keyboard scancode from a character */
+{
+	int row;
+	int c = toupper((char)ch);
+
+	for (row = 0; row < SCANCODE_ROWS_NR; row++) {
+		const char *keys = scancode_rows[row].keys;
+		int offset = scancode_rows[row].offset;
+
+		while (*keys) {
+			if (*keys == c)
+				return offset << 8;
+
+			offset++;
+			keys++;
+		}
+	}
+
+	return ch; /* not found */
+}
+
+/* static */ int
+_gfxop_shiftify(int c)
+{
+	char shifted_numbers[] = ")!@#$%^&*(";
+	
+	if (c < 256)
+	{
+		c = toupper((char)c);
+
+		if (c >= 'A' && c <= 'Z')
+			return c;
+
+		if (c >= '0' && c <= '9')
+			return shifted_numbers[c-'0'];
+	
+		switch (c) {
+		case SCI_K_TAB: return SCI_K_SHIFT_TAB;
+		case ']': return '}';
+		case '[': return '{';
+		case '`': return '~';
+		case '-': return '_';
+		case '=': return '+';
+		case ';': return ':';
+		case '\'': return '"';
+		case '\\': return '|';
+		case ',': return '<';
+		case '.': return '>';
+		case '/': return '?';
+		default: return c; /* No match */
+		}
+	}
+
+	switch (c)
+	{
+	case SCI_K_F1 : return SCI_K_SHIFT_F1;
+	case SCI_K_F2 : return SCI_K_SHIFT_F2;
+	case SCI_K_F3 : return SCI_K_SHIFT_F3;
+	case SCI_K_F4 : return SCI_K_SHIFT_F4;
+	case SCI_K_F5 : return SCI_K_SHIFT_F5;
+	case SCI_K_F6 : return SCI_K_SHIFT_F6;
+	case SCI_K_F7 : return SCI_K_SHIFT_F7;
+	case SCI_K_F8 : return SCI_K_SHIFT_F8;
+	case SCI_K_F9 : return SCI_K_SHIFT_F9;
+	case SCI_K_F10 : return SCI_K_SHIFT_F10;
+	}
+
+	return c;
+}
+
+static int
+_gfxop_numlockify(int c)
+{
+	switch (c) {
+	case SCI_K_DELETE: return '.';
+	case SCI_K_INSERT: return '0';
+	case SCI_K_END: return '1';
+	case SCI_K_DOWN: return '2';
+	case SCI_K_PGDOWN: return '3';
+	case SCI_K_LEFT: return '4';
+	case SCI_K_CENTER: return '5';
+	case SCI_K_RIGHT: return '6';
+	case SCI_K_HOME: return '7';
+	case SCI_K_UP: return '8';
+	case SCI_K_PGUP: return '9';
+	default: return c; /* Unchanged */
+	}
+}
+
+
+sci_event_t
+gfxop_get_event(gfx_state_t *state, unsigned int mask)
+{
+	sci_event_t error_event = { SCI_EVT_ERROR, 0, 0 };
+	sci_event_t event;
+	gfx_input_event_t **seekerp = &(state->events);
+
+	BASIC_CHECKS(error_event);
+	if (_gfxop_remove_pointer(state)) {
+		GFXERROR("Failed to remove pointer before processing event!\n");
+	}
+
+	while (*seekerp && !((*seekerp)->event.type & mask))
+		seekerp = &((*seekerp)->next);
+
+	if (*seekerp) {
+		gfx_input_event_t *goner = *seekerp;
+		event = goner->event;
+		*seekerp = goner->next;
+		free(goner);
+	} else {
+		event.type = 0;
+
+		if (!(mask & SCI_EVT_NONBLOCK))
+		{
+			do {
+				if (event.type) {
+					*seekerp = (gfx_input_event_t*)sci_malloc(sizeof(gfx_input_event_t));
+					(*seekerp)->next = NULL;
+					
+					event.data = (char) (event.data);
+					/* Clip illegal bits */
+					
+					(*seekerp)->event = event;
+					seekerp = &((*seekerp)->next);
+				}
+				event = state->driver->get_event(state->driver);
+				
+			} while (event.type && !(event.type & mask));
+		}
+	}
+
+	if (_gfxop_full_pointer_refresh(state)) {
+		GFXERROR("Failed to update the mouse pointer!\n");
+		return error_event;
+	}
+
+	if (event.type == SCI_EVT_KEYBOARD
+	    && !(state->driver->capabilities & GFX_CAPABILITY_KEYTRANSLATE)) {
+		/* Do we still have to translate the key? */
+
+		event.character = event.data;
+
+		/* Scancodify if appropriate */
+		if (event.buckybits & SCI_EVM_ALT)
+			event.character = _gfxop_scancode(event.character);
+
+		/* Shift if appropriate */
+		else if (((event.buckybits & (SCI_EVM_RSHIFT | SCI_EVM_LSHIFT))
+			  && !(event.buckybits & SCI_EVM_CAPSLOCK))
+			 ||
+			 (!(event.buckybits & (SCI_EVM_RSHIFT | SCI_EVM_LSHIFT))
+			  && (event.buckybits & SCI_EVM_CAPSLOCK)))
+			event.character = _gfxop_shiftify(event.character);
+
+		/* Numlockify if appropriate */
+		else if (event.buckybits & SCI_EVM_NUMLOCK)
+			event.data = _gfxop_numlockify(event.data);
+	}
+
+	return event;
+}
+
+
+/*******************/
+/* View operations */
+/*******************/
+
+int
+gfxop_lookup_view_get_loops(gfx_state_t *state, int nr)
+{
+	int loop = 0, cel = 0;
+	gfxr_view_t *view = NULL;
+
+	BASIC_CHECKS(GFX_ERROR);
+
+	view = gfxr_get_view(state->resstate, nr, &loop, &cel, 0);
+
+	if (!view) {
+		GFXWARN("Attempt to retreive number of loops from invalid view %d\n", nr);
+		return 0;
+	}
+
+	return view->loops_nr;
+}
+
+
+int
+gfxop_lookup_view_get_cels(gfx_state_t *state, int nr, int loop)
+{
+	int real_loop = loop, cel = 0;
+	gfxr_view_t *view = NULL;
+
+	BASIC_CHECKS(GFX_ERROR);
+
+	view = gfxr_get_view(state->resstate, nr, &real_loop, &cel, 0);
+
+	if (!view) {
+		GFXWARN("Attempt to retreive number of cels from invalid/broken view %d\n", nr);
+		return 0;
+	} else if (real_loop != loop) {
+		GFXWARN("Loop number was corrected from %d to %d in view %d\n", loop, real_loop, nr);
+	}
+
+	return view->loops[real_loop].cels_nr;
+}
+
+
+int
+gfxop_check_cel(gfx_state_t *state, int nr, int *loop, int *cel)
+{
+        BASIC_CHECKS(GFX_ERROR);
+
+	if (!gfxr_get_view(state->resstate, nr, loop, cel, 0)) {
+		GFXWARN("Attempt to verify loop/cel values for invalid view %d\n", nr);
+		return GFX_ERROR;
+	}
+
+	return GFX_OK;
+}
+
+int
+gfxop_overflow_cel(gfx_state_t *state, int nr, int *loop, int *cel)
+{
+	int loop_v = *loop;
+	int cel_v = *cel;
+        BASIC_CHECKS(GFX_ERROR);
+
+	if (!gfxr_get_view(state->resstate, nr, &loop_v, &cel_v, 0)) {
+		GFXWARN("Attempt to verify loop/cel values for invalid view %d\n", nr);
+		return GFX_ERROR;
+	}
+
+	if (loop_v != *loop)
+		*loop = 0;
+
+	if (loop_v != *loop
+	    || cel_v != *cel)
+		*cel = 0;
+
+	return GFX_OK;
+}
+
+
+int
+gfxop_get_cel_parameters(gfx_state_t *state, int nr, int loop, int cel,
+			 int *width, int *height, point_t *offset)
+{
+	gfxr_view_t *view = NULL;
+	gfx_pixmap_t *pxm = NULL;
+	BASIC_CHECKS(GFX_ERROR);
+
+	if (!(view = gfxr_get_view(state->resstate, nr, &loop, &cel, 0))) {
+		GFXWARN("Attempt to get cel parameters for invalid view %d\n", nr);
+		return GFX_ERROR;
+	}
+
+	pxm = view->loops[loop].cels[cel];
+	*width = pxm->index_xl;
+	*height = pxm->index_yl;
+	offset->x = pxm->xoffset;
+	offset->y = pxm->yoffset;
+
+	return GFX_OK;
+}
+
+
+static int
+_gfxop_draw_cel_buffer(gfx_state_t *state, int nr, int loop, int cel,
+		       point_t pos, gfx_color_t color, int static_buf,
+		       int palette)
+{
+	int priority = (color.mask & GFX_MASK_PRIORITY)? color.priority : -1;
+	int control = (color.mask & GFX_MASK_CONTROL)? color.control : -1;
+	gfxr_view_t *view = NULL;
+	gfx_pixmap_t *pxm = NULL;
+	int old_x, old_y;
+	BASIC_CHECKS(GFX_FATAL);
+
+	if (!(view = gfxr_get_view(state->resstate, nr, &loop, &cel, palette))) {
+		GFXWARN("Attempt to draw loop/cel %d/%d in invalid view %d\n", loop, cel, nr);
+		return GFX_ERROR;
+	}
+	pxm = view->loops[loop].cels[cel];
+
+	old_x = pos.x -= pxm->xoffset;
+	old_y = pos.y -= pxm->yoffset;
+
+	pos.x *= state->driver->mode->xfact;
+	pos.y *= state->driver->mode->yfact;
+
+	if (!static_buf)
+		_gfxop_add_dirty(state, gfx_rect(old_x, old_y, pxm->index_xl, pxm->index_yl));
+
+	return _gfxop_draw_pixmap(state->driver, pxm, priority, control,
+				  gfx_rect(0, 0, pxm->xl, pxm->yl),
+				  gfx_rect(pos.x, pos.y, pxm->xl, pxm->yl),
+				  state->clip_zone,
+				  static_buf , state->control_map,
+				  static_buf
+				  ? state->static_priority_map
+				  : state->priority_map);
+}
+
+
+int
+gfxop_draw_cel(gfx_state_t *state, int nr, int loop, int cel, point_t pos,
+	       gfx_color_t color, int palette)
+{
+	return _gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 0, palette);
+}
+
+
+int
+gfxop_draw_cel_static(gfx_state_t *state, int nr, int loop, int cel, point_t pos,
+		      gfx_color_t color, int palette)
+{
+	int retval;
+	rect_t oldclip = state->clip_zone;
+
+	state->clip_zone = gfx_rect_fullscreen;
+	_gfxop_scale_rect(&(state->clip_zone), state->driver->mode);
+	retval = gfxop_draw_cel_static_clipped(state, nr, loop, cel, pos, color,
+					       palette);
+	/* Except that the area it's clipped against is... unusual ;-) */
+	state->clip_zone = oldclip;
+
+	return retval;
+}
+
+
+int
+gfxop_draw_cel_static_clipped(gfx_state_t *state, int nr, int loop, int cel,
+			      point_t pos, gfx_color_t color, int palette)
+{
+	return _gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 1, palette);
+}
+
+
+/******************/
+/* Pic operations */
+/******************/
+
+static int
+_gfxop_set_pic(gfx_state_t *state)
+{
+	gfx_copy_pixmap_box_i(state->control_map, state->pic->control_map, gfx_rect(0, 0, 320, 200));
+	gfx_copy_pixmap_box_i(state->priority_map, state->pic_unscaled->priority_map, gfx_rect(0, 0, 320, 200)); 
+	gfx_copy_pixmap_box_i(state->static_priority_map, state->pic_unscaled->priority_map, gfx_rect(0, 0, 320, 200));
+
+	_gfxop_install_pixmap(state->driver, state->pic->visual_map);
+
+	if (state->options->pic0_unscaled)
+		state->pic->priority_map = gfx_pixmap_scale_index_data(state->pic->priority_map, state->driver->mode);
+	return state->driver->set_static_buffer(state->driver, state->pic->visual_map, state->pic->priority_map);
+}
+
+
+void *
+gfxop_get_pic_metainfo(gfx_state_t *state)
+{
+	return (state->pic)? state->pic->internal : NULL;
+}
+
+
+int
+gfxop_new_pic(gfx_state_t *state, int nr, int flags, int default_palette)
+{
+	BASIC_CHECKS(GFX_FATAL);
+
+	gfxr_tag_resources(state->resstate);
+	state->tag_mode = 1;
+	state->palette_nr = default_palette;
+
+	state->pic = gfxr_get_pic(state->resstate, nr, GFX_MASK_VISUAL, flags, default_palette, 1);
+
+	if (state->driver->mode->xfact == 1 && state->driver->mode->yfact == 1)
+		state->pic_unscaled = state->pic;
+	else
+		state->pic_unscaled = gfxr_get_pic(state->resstate, nr, GFX_MASK_VISUAL, flags, default_palette, 0);
+
+	if (!state->pic || !state->pic_unscaled) {
+		GFXERROR("Could not retreive background pic %d!\n", nr);
+		if (state->pic) {
+			GFXERROR("  -- Inconsistency: scaled pic _was_ retreived!\n");
+		}
+
+		if (state->pic_unscaled) {
+			GFXERROR("  -- Inconsistency: unscaled pic _was_ retreived!\n");
+		}
+
+		state->pic = state->pic_unscaled = NULL;
+		return GFX_ERROR;
+	}
+
+	state->pic_nr = nr;
+
+	return _gfxop_set_pic(state);
+}
+
+
+int
+gfxop_add_to_pic(gfx_state_t *state, int nr, int flags, int default_palette)
+{
+	BASIC_CHECKS(GFX_FATAL);
+
+	if (!state->pic) {
+		GFXERROR("Attempt to add to pic with no pic active!\n");
+		return GFX_ERROR;
+	}
+
+	if (!(state->pic = gfxr_add_to_pic(state->resstate, state->pic_nr, nr,
+					   GFX_MASK_VISUAL, flags, state->palette_nr, default_palette, 1))) {
+		GFXERROR("Could not add pic #%d to pic #%d!\n", state->pic_nr, nr);
+		return GFX_ERROR;
+	}
+	state->pic_unscaled = gfxr_add_to_pic(state->resstate, state->pic_nr, nr,
+					      GFX_MASK_VISUAL, flags,
+					      state->palette_nr,
+					      default_palette, 1);
+
+	return _gfxop_set_pic(state);
+}
+
+
+/*******************/
+/* Text operations */
+/*******************/
+
+
+int
+gfxop_get_font_height(gfx_state_t *state, int font_nr)
+{
+	gfx_bitmap_font_t *font;
+	BASIC_CHECKS(GFX_FATAL);
+
+	font = gfxr_get_font(state->resstate, font_nr, 0);
+	if (!font)
+		return GFX_ERROR;
+
+	return font->line_height;
+}
+
+int
+gfxop_get_text_params(gfx_state_t *state, int font_nr, const char *text,
+		      int maxwidth, int *width, int *height, int text_flags,
+		      int *lines_nr, int *lineheight, int *lastline_width)
+{
+	text_fragment_t *textsplits;
+	gfx_bitmap_font_t *font;
+
+	BASIC_CHECKS(GFX_FATAL);
+
+	font = gfxr_get_font(state->resstate, font_nr, 0);
+
+	if (!font) {
+		GFXERROR("Attempt to calculate text size with invalid font #%d\n", font_nr);
+		*width = *height = 0;
+		return GFX_ERROR;
+	}
+
+	textsplits = gfxr_font_calculate_size(font, maxwidth, text, width,
+					      height, lines_nr,
+					      lineheight, lastline_width,
+					      (state->options->workarounds & GFX_WORKAROUND_WHITESPACE_COUNT)
+					      | text_flags);
+
+
+	if (!textsplits) {
+		GFXERROR("Could not calculate text size!");
+		*width = *height = 0;
+		return GFX_ERROR;
+	}
+
+	free(textsplits);
+	return GFX_OK;
+}
+
+
+#define COL_XLATE(des,src) \
+  des = src.visual; /* The new gfx_color_t structure makes things a lot easier :-) */ /* \
+  if (gfxop_set_color(state, &src, \
+		      src.visual.r, \
+		      src.visual.g, \
+		      src.visual.b, \
+		      src.alpha, \
+		      src.priority, \
+		      src.control)) \
+  { \
+	  GFXERROR("Unable to set up colors"); \
+	  return NULL; \
+  }
+*/
+
+gfx_text_handle_t *
+gfxop_new_text(gfx_state_t *state, int font_nr, char *text, int maxwidth,
+	       gfx_alignment_t halign, gfx_alignment_t valign,
+	       gfx_color_t color1, gfx_color_t color2, gfx_color_t bg_color,
+	       int flags)
+{
+	gfx_text_handle_t *handle			= {0};
+	gfx_bitmap_font_t *font				= {0};
+	int i;
+	gfx_pixmap_color_t pxm_col1, pxm_col2, pxm_colbg= {0};
+	BASIC_CHECKS(NULL);
+
+	COL_XLATE(pxm_col1, color1);
+	COL_XLATE(pxm_col2, color2);
+	COL_XLATE(pxm_colbg, bg_color);
+
+	font = gfxr_get_font(state->resstate, font_nr, 0);
+
+	if (!font) {
+		GFXERROR("Attempt to draw text with invalid font #%d\n", font_nr);
+		return NULL;
+	}
+
+	handle = (gfx_text_handle_t*)sci_malloc(sizeof(gfx_text_handle_t));
+
+	handle->text = (char*)sci_malloc(strlen(text) + 1);
+	strcpy(handle->text, text);
+	handle->halign = halign;
+	handle->valign = valign;
+	handle->line_height = font->line_height;
+
+	handle->lines =
+		gfxr_font_calculate_size(font, maxwidth, handle->text, &(handle->width), &(handle->height),
+					 &(handle->lines_nr),
+					 NULL, NULL,
+					 ((state->options->workarounds & GFX_WORKAROUND_WHITESPACE_COUNT)?
+					  GFXR_FONT_FLAG_COUNT_WHITESPACE : 0)
+					 | flags);
+
+	if (!handle->lines) {
+		free(handle->text);
+		free(handle);
+		GFXERROR("Could not calculate text parameters in font #%d\n", font_nr);
+		return NULL;
+	}
+
+
+	if (flags & GFXR_FONT_FLAG_NO_NEWLINES) {
+		handle->lines_nr = 1;
+		handle->lines->length = strlen(text);
+	}
+
+	handle->text_pixmaps = (gfx_pixmap_t**)sci_malloc(sizeof(gfx_pixmap_t *) * handle->lines_nr);
+
+	for (i = 0; i < handle->lines_nr; i++) {
+		int chars_nr = handle->lines[i].length;
+
+		handle->text_pixmaps[i] = gfxr_draw_font(font, handle->lines[i].offset, chars_nr,
+							 (color1.mask & GFX_MASK_VISUAL)? &pxm_col1 : NULL,
+							 (color2.mask & GFX_MASK_VISUAL)? &pxm_col2 : NULL,
+							 (bg_color.mask & GFX_MASK_VISUAL)? &pxm_colbg : NULL);
+
+		if (!handle->text_pixmaps[i]) {
+			int j;
+
+			for (j = 0; j < i; j++)
+				gfx_free_pixmap(state->driver, handle->text_pixmaps[j]);
+			sci_free(handle->text_pixmaps);
+			sci_free(handle->text);
+			sci_free(handle->lines);
+			GFXERROR("Failed to draw text pixmap for line %d/%d\n", i, handle->lines_nr);
+			sci_free(handle);
+			return NULL;
+		}
+	}
+
+	handle->font = font;
+
+	handle->priority = (color1.mask & GFX_MASK_PRIORITY)? color1.priority : -1;
+	handle->control = (color1.mask & GFX_MASK_CONTROL)? color1.control : -1;
+
+	return handle;
+}
+
+
+int
+gfxop_free_text(gfx_state_t *state, gfx_text_handle_t *handle)
+{
+	int j;
+
+	BASIC_CHECKS(GFX_ERROR);
+
+	if (handle->text_pixmaps) {
+		for (j = 0; j < handle->lines_nr; j++)
+			gfx_free_pixmap(state->driver, handle->text_pixmaps[j]);
+		free(handle->text_pixmaps);
+	}
+
+	free(handle->text);
+	free(handle->lines);
+	free(handle);
+	return GFX_OK;
+}
+
+
+int
+gfxop_draw_text(gfx_state_t *state, gfx_text_handle_t *handle, rect_t zone)
+{
+	int line_height;
+	rect_t pos;
+	int i;
+	BASIC_CHECKS(GFX_FATAL);
+	REMOVE_POINTER;
+
+	if (!handle) {
+		GFXERROR("Attempt to draw text with NULL handle!\n");
+		return GFX_ERROR;
+	}
+
+	if (!handle->lines_nr) {
+		GFXDEBUG("Skipping draw_text operation because number of lines is zero\n");
+		return GFX_OK;
+	}
+
+	_gfxop_scale_rect(&zone, state->driver->mode);
+
+	line_height = handle->line_height * state->driver->mode->yfact;
+
+	pos.y = zone.y;
+
+	switch (handle->valign) {
+
+	case ALIGN_TOP:
+		break;
+
+	case ALIGN_CENTER:
+		pos.y += (zone.yl - (line_height * handle->lines_nr)) >> 1;
+		break;
+
+	case ALIGN_BOTTOM:
+		pos.y += (zone.yl - (line_height * handle->lines_nr));
+		break;
+
+	default:
+		GFXERROR("Invalid vertical alignment %d!\n", handle->valign);
+		return GFX_FATAL; /* Internal error... */
+	}
+
+	for (i = 0; i < handle->lines_nr; i++) {
+
+		gfx_pixmap_t *pxm = handle->text_pixmaps[i];
+
+		if (!pxm->data) {
+			gfx_xlate_pixmap(pxm, state->driver->mode, state->options->text_xlate_filter);
+			gfxr_endianness_adjust(pxm, state->driver->mode); /* FIXME: resmgr layer! */
+		}
+		if (!pxm) {
+			GFXERROR("Could not find text pixmap %d/%d\n", i, handle->lines_nr);
+			return GFX_ERROR;
+		}
+
+		pos.x = zone.x;
+
+		switch (handle->halign) {
+
+		case ALIGN_LEFT:
+			break;
+
+		case ALIGN_CENTER:
+			pos.x += (zone.xl - pxm->xl) >> 1;
+			break;
+
+		case ALIGN_RIGHT:
+			pos.x += (zone.xl - pxm->xl);
+			break;
+
+		default:
+			GFXERROR("Invalid vertical alignment %d!\n", handle->valign);
+			return GFX_FATAL; /* Internal error... */
+		}
+
+		pos.xl = pxm->xl;
+		pos.yl = pxm->yl;
+
+		_gfxop_add_dirty(state, pos);
+
+		_gfxop_draw_pixmap(state->driver, pxm, handle->priority, handle->control,
+				   gfx_rect(0, 0, pxm->xl, pxm->yl), pos, state->clip_zone, 0,
+				   state->control_map, state->priority_map);
+
+		pos.y += line_height;
+	}
+
+	return GFX_OK;
+}
+
+
+gfx_pixmap_t *
+gfxop_grab_pixmap(gfx_state_t *state, rect_t area)
+{
+	gfx_pixmap_t *pixmap = NULL;
+	rect_t resultzone; /* Ignored for this application */
+	BASIC_CHECKS(NULL);
+	if (_gfxop_remove_pointer(state)) {
+		GFXERROR("Could not remove pointer!\n");
+		return NULL;
+	}
+
+	_gfxop_scale_rect(&area, state->driver->mode);
+	if (_gfxop_grab_pixmap(state, &pixmap, area.x, area.y, area.xl, area.yl, 0, &resultzone))
+		return NULL; /* area CUT the visual screen had a null or negative size */
+
+	pixmap->flags |= GFX_PIXMAP_FLAG_PALETTE_SET | GFX_PIXMAP_FLAG_DONT_UNALLOCATE_PALETTE;
+
+	return pixmap;
+}
+
+int
+gfxop_draw_pixmap(gfx_state_t *state, gfx_pixmap_t *pxm, rect_t zone, point_t pos)
+{
+	rect_t target;
+	BASIC_CHECKS(GFX_ERROR);
+
+	if (!pxm) {
+		GFXERROR("Attempt to draw NULL pixmap!\n");
+		return GFX_ERROR;
+	}
+
+	REMOVE_POINTER;
+
+	target = gfx_rect(pos.x, pos.y, zone.xl, zone.yl);
+
+	_gfxop_add_dirty(state, target);
+
+	if (!pxm) {
+		GFXERROR("Attempt to draw_pixmap with pxm=NULL\n");
+		return GFX_ERROR;
+	}
+
+	_gfxop_scale_rect(&zone, state->driver->mode);
+	_gfxop_scale_rect(&target, state->driver->mode);
+
+	return _gfxop_draw_pixmap(state->driver, pxm, -1, -1, zone, target,
+				  gfx_rect(0, 0, 320*state->driver->mode->xfact,
+					   200*state->driver->mode->yfact), 0, NULL, NULL);
+}
+
+int
+gfxop_free_pixmap(gfx_state_t *state, gfx_pixmap_t *pxm)
+{
+	BASIC_CHECKS(GFX_ERROR);
+	gfx_free_pixmap(state->driver, pxm);
+	return GFX_OK;
+}
+