Removed many bogus return values in the SCI graphics functions - some functions always returned "true", whereas in others they errored out in fatal conditions before any value was returned. FreeSCI was returning values from the graphics drivers it used. In ScummVM, we have one graphics driver, and we error out in fatal conditions anyway, so these error checks are no longer necessary, and the resulting code looks much neater

svn-id: r43851

6 files changed, 182 insertions, 391 deletions

diff --git a/engines/sci/gfx/gfx_driver.cpp b/engines/sci/gfx/gfx_driver.cpp
index b71152822c..7803fbbe11 100644
--- a/engines/sci/gfx/gfx_driver.cpp
+++ b/engines/sci/gfx/gfx_driver.cpp
@@ -87,7 +87,7 @@ static void drawProc(int x, int y, int c, void *data) {
 	memcpy(p + (y * 320* drv->getMode()->xfact + x) * COPY_BYTES, &col, COPY_BYTES);
 }
 
-int GfxDriver::drawLine(Common::Point start, Common::Point end, gfx_color_t color, 
+void GfxDriver::drawLine(Common::Point start, Common::Point end, gfx_color_t color, 
 						gfx_line_mode_t line_mode, gfx_line_style_t line_style) {
 	uint32 scolor = color.visual.parent_index;
 	int xfact = (line_mode == GFX_LINE_MODE_FINE)? 1: _mode->xfact;
@@ -136,11 +136,9 @@ int GfxDriver::drawLine(Common::Point start, Common::Point end, gfx_color_t colo
 			}
 		}
 	}
-
-	return GFX_OK;
 }
 
-int GfxDriver::drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color2,
+void GfxDriver::drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color2,
 	gfx_rectangle_fill_t shade_mode) {
 	if (color1.mask & GFX_MASK_VISUAL) {
 		for (int i = rect.y; i < rect.y + rect.height; i++) {
@@ -151,38 +149,30 @@ int GfxDriver::drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color
 
 	if (color1.mask & GFX_MASK_PRIORITY)
 		gfx_draw_box_pixmap_i(_priority[0], rect, color1.priority);
-
-	return GFX_OK;
 }
 
 // Pixmap operations
 
-int GfxDriver::drawPixmap(gfx_pixmap_t *pxm, int priority, rect_t src, rect_t dest, gfx_buffer_t buffer) {
+void GfxDriver::drawPixmap(gfx_pixmap_t *pxm, int priority, rect_t src, rect_t dest, gfx_buffer_t buffer) {
 	int bufnr = (buffer == GFX_BUFFER_STATIC) ? 1 : 0;
 
 	if (dest.width != src.width || dest.height != src.height) {
-		printf("Attempt to scale pixmap (%dx%d)->(%dx%d): Not supported\n", src.width, src.height, dest.width, dest.height);
-		return GFX_ERROR;
+		warning("Attempt to scale pixmap (%dx%d)->(%dx%d): Not supported\n", src.width, src.height, dest.width, dest.height);
+		return;
 	}
 
 	gfx_crossblit_pixmap(_mode, pxm, priority, src, dest, _visual[bufnr],
 	                     _mode->xsize * _mode->bytespp,
 	                     _priority[bufnr]->index_data,
 	                     _priority[bufnr]->index_width, 1, 0);
-
-	return GFX_OK;
 }
 
-int GfxDriver::grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map) {
-	if (src.x < 0 || src.y < 0) {
-		printf("Attempt to grab pixmap from invalid coordinates (%d,%d)\n", src.x, src.y);
-		return GFX_ERROR;
-	}
+void GfxDriver::grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map) {
+	if (src.x < 0 || src.y < 0)
+		error("Attempt to grab pixmap from invalid coordinates (%d,%d)", src.x, src.y);
 
-	if (!pxm->data) {
-		printf("Attempt to grab pixmap to unallocated memory\n");
-		return GFX_ERROR;
-	}
+	if (!pxm->data)
+		error("Attempt to grab pixmap to unallocated memory");
 
 	switch (map) {
 
@@ -197,20 +187,17 @@ int GfxDriver::grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map) {
 		break;
 
 	case GFX_MASK_PRIORITY:
-		printf("FIXME: priority map grab not implemented yet!\n");
+		warning("FIXME: priority map grab not implemented yet");
 		break;
 
 	default:
-		printf("Attempt to grab pixmap from invalid map 0x%02x\n", map);
-		return GFX_ERROR;
+		error("Attempt to grab pixmap from invalid map 0x%02x", map);
 	}
-
-	return GFX_OK;
 }
 
 // Buffer operations
 
-int GfxDriver::update(rect_t src, Common::Point dest, gfx_buffer_t buffer) {
+void GfxDriver::update(rect_t src, Common::Point dest, gfx_buffer_t buffer) {
 	//TODO
 
 	/*
@@ -238,17 +225,12 @@ int GfxDriver::update(rect_t src, Common::Point dest, gfx_buffer_t buffer) {
 	}
 	default:
 		error("Invalid buffer %d in update", buffer);
-		return GFX_ERROR;
 	}
-
-	return GFX_OK;
 }
 
-int GfxDriver::setStaticBuffer(gfx_pixmap_t *pic, gfx_pixmap_t *priority) {
+void GfxDriver::setStaticBuffer(gfx_pixmap_t *pic, gfx_pixmap_t *priority) {
 	memcpy(_visual[1], pic->data, _mode->xsize * _mode->ysize * _mode->bytespp);
 	gfx_copy_pixmap_box_i(_priority[1], priority, gfx_rect(0, 0, _mode->xsize, _mode->ysize));
-
-	return GFX_OK;
 }
 
 // Mouse pointer operations
@@ -283,7 +265,7 @@ byte *GfxDriver::createCursor(gfx_pixmap_t *pointer) {
 }
 
 
-int GfxDriver::setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot) {
+void GfxDriver::setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot) {
 	if ((pointer == NULL) || (hotspot == NULL)) {
 		CursorMan.showMouse(false);
 	} else {
@@ -304,8 +286,6 @@ int GfxDriver::setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot) {
 		delete[] cursorData;
 		cursorData = 0;
 	}
-
-	return GFX_OK;
 }
 
 } // End of namespace Sci
diff --git a/engines/sci/gfx/gfx_driver.h b/engines/sci/gfx/gfx_driver.h
index cc8a5208d4..d12d82395e 100644
--- a/engines/sci/gfx/gfx_driver.h
+++ b/engines/sci/gfx/gfx_driver.h
@@ -119,9 +119,8 @@ public:
 	 * @param[in] color			The color to draw with
 	 * @param[in] line_mode		Any of the line modes
 	 * @param[in] line_style	Any of the line styles
-	 * @return					GFX_OK or GFX_FATAL
 	 */
-	int drawLine(Common::Point start, Common::Point end, gfx_color_t color,
+	void drawLine(Common::Point start, Common::Point end, gfx_color_t color,
 	             gfx_line_mode_t line_mode, gfx_line_style_t line_style);
 
 	/**
@@ -137,9 +136,8 @@ public:
 	 * @param[in] color1		The first color to draw with
 	 * @param[in] color2		The second color to draw with
 	 * @param[in] shade_mode	Any of GFX_SHADE_*.
-	 * @return					GFX_OK or GFX_FATAL
 	 */
-	int drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color2,
+	void drawFilledRect(rect_t rect, gfx_color_t color1, gfx_color_t color2,
 	                   gfx_rectangle_fill_t shade_mode);
 	/** @} */
 
@@ -156,10 +154,8 @@ public:
 	 * @param[in] src		The pixmap-relative source rectangle
 	 * @param[in] dest		The destination rectangle
 	 * @param[in] buffer	One of GFX_BUFFER_STATIC and GFX_BUFFER_BACK
-	 * @return				GFX_OK or GFX_FATAL, or GFX_ERROR if pxm was
-	 * 						not (but should have been) registered.
 	 */
-	int drawPixmap(gfx_pixmap_t *pxm, int priority,
+	void drawPixmap(gfx_pixmap_t *pxm, int priority,
 	               rect_t src, rect_t dest, gfx_buffer_t buffer);
 
 	/**
@@ -170,11 +166,8 @@ public:
 	 * @param[in] src	The rectangle to grab
 	 * @param[in] pxm	The pixmap structure the data is to be written to
 	 * @param[in] map	GFX_MASK_VISUAL or GFX_MASK_PRIORITY
-	 * @return			GFX_OK, GFX_FATAL, or GFX_ERROR for invalid map
-	 * 					values pxm may be assumed to be empty and
-	 * 					pre-allocated with an appropriate memory size.
 	 */
-	int grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map);
+	void grabPixmap(rect_t src, gfx_pixmap_t *pxm, gfx_map_mask_t map);
 	/** @} */
 
 	/** @name Buffer operations */
@@ -193,9 +186,8 @@ public:
 	 * @param[in] src:		Source rectangle
 	 * @param[in] dest:		Destination point
 	 * @param[in] buffer:	One of GFX_BUFFER_FRONT or GFX_BUFFER_BACK
-	 * @return				GFX_OK, GFX_ERROR or GFX_FATAL
 	 */
-	int update(rect_t src, Common::Point dest, gfx_buffer_t buffer);
+	void update(rect_t src, Common::Point dest, gfx_buffer_t buffer);
 
 	/**
 	 * Sets the contents of the static visual and priority buffers.
@@ -212,9 +204,8 @@ public:
 	 * 						visual back buffer
 	 * @param[in] priority	The priority map containing the new content of
 	 * 						the priority back buffer in the index buffer
-	 * @return				GFX_OK or GFX_FATAL
 	 */
-	int setStaticBuffer(gfx_pixmap_t *pic, gfx_pixmap_t *priority);
+	void setStaticBuffer(gfx_pixmap_t *pic, gfx_pixmap_t *priority);
 	/** @} */
 
 	/** @name Mouse pointer operations */
@@ -232,9 +223,8 @@ public:
 	 * @param[in] pointer	The pointer to set, or NULL to set no pointer.
 	 * @param[in] hotspot	The coordinates of the hotspot, or NULL to set
 	 * 						no pointer.
-	 * @return				GFX_OK or GFX_FATAL
 	 */
-	int setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot);
+	void setPointer(gfx_pixmap_t *pointer, Common::Point *hotspot);
 	/** @} */
 
 	gfx_mode_t *getMode() { return _mode; }
diff --git a/engines/sci/gfx/gfx_gui.cpp b/engines/sci/gfx/gfx_gui.cpp
index 218bf1523e..2659704d7e 100644
--- a/engines/sci/gfx/gfx_gui.cpp
+++ b/engines/sci/gfx/gfx_gui.cpp
@@ -220,10 +220,7 @@ GfxPort *sciw_new_window(EngineState *s,
 		// Draw backdrop shadow
 
 		if (!(flags & kWindowNoDropShadow)) {
-			if (gfxop_set_color(state, &black, 0, 0, 0, 0x80, bgcolor.priority, -1)) {
-				error("Could not get black/semitrans color entry");
-				return NULL;
-			}
+			gfxop_set_color(state, &black, 0, 0, 0, 0x80, bgcolor.priority, -1);
 
 			decorations->add((GfxContainer *)decorations, (GfxWidget *)
 			                 gfxw_new_box(state, gfx_rect(shadow_offset + 1, frame.height - 1,
@@ -236,10 +233,7 @@ GfxPort *sciw_new_window(EngineState *s,
 
 		// Draw frame
 
-		if (gfxop_set_color(state, &black, 0, 0, 0, 0, bgcolor.priority, -1)) {
-			error("Could not get black color entry");
-			return NULL;
-		}
+		gfxop_set_color(state, &black, 0, 0, 0, 0, bgcolor.priority, -1);
 
 		if (!(flags & kWindowNoDropShadow)) {
 
diff --git a/engines/sci/gfx/gfx_widgets.cpp b/engines/sci/gfx/gfx_widgets.cpp
index 6a3bddee0d..fbe682bab4 100644
--- a/engines/sci/gfx/gfx_widgets.cpp
+++ b/engines/sci/gfx/gfx_widgets.cpp
@@ -165,17 +165,6 @@ static int verify_widget(GfxWidget *widget) {
 #define VERIFY_WIDGET(w) \
 	if (verify_widget((GfxWidget *)(w))) { error("Error occured while validating widget"); }
 
-#define GFX_ASSERT(_x) \
-{ \
-	int retval = (_x); \
-	if (retval == GFX_ERROR) { \
-		warning("Error occured while drawing widget"); \
-		return 1; \
-	} else if (retval == GFX_FATAL) { \
-		error("Fatal error occured while drawing widget!\nGraphics state invalid; aborting program..."); \
-	} \
-}
-
 //********** Widgets *************
 
 // Base class operations and common stuff
@@ -334,7 +323,7 @@ static Common::Point _move_point(rect_t rect, Common::Point point) {
 
 int GfxBox::draw(const Common::Point &pos) {
 	DRAW_ASSERT(this, GFXW_BOX);
-	GFX_ASSERT(gfxop_draw_box(_visual->_gfxState, _move_rect(_bounds, pos), _color1, _color2, _shadeType));
+	gfxop_draw_box(_visual->_gfxState, _move_rect(_bounds, pos), _color1, _color2, _shadeType);
 	return 0;
 }
 
@@ -464,8 +453,8 @@ static int _gfxwop_primitive_equals(GfxWidget *widget, GfxWidget *other) {
 int GfxRect::draw(const Common::Point &pos) {
 	DRAW_ASSERT(this, GFXW_RECT);
 
-	GFX_ASSERT(gfxop_draw_rectangle(_visual->_gfxState, gfx_rect(_bounds.x + pos.x, _bounds.y + pos.y,
-	                                         _bounds.width - 1, _bounds.height - 1), _color, _lineMode, _lineStyle));
+	gfxop_draw_rectangle(_visual->_gfxState, gfx_rect(_bounds.x + pos.x, _bounds.y + pos.y,
+	                                         _bounds.width - 1, _bounds.height - 1), _color, _lineMode, _lineStyle);
 	return 0;
 }
 
@@ -511,7 +500,7 @@ int GfxLine::draw(const Common::Point &pos) {
 	DRAW_ASSERT(this, GFXW_LINE);
 
 	_split_rect(_move_rect(linepos, pos), &p1, &p2);
-	GFX_ASSERT(gfxop_draw_line(_visual->_gfxState, p1, p2, _color, _lineMode, _lineStyle));
+	gfxop_draw_line(_visual->_gfxState, p1, p2, _color, _lineMode, _lineStyle);
 	return 0;
 }
 
@@ -581,14 +570,14 @@ GfxView::GfxView(GfxState *state, Common::Point pos_, int view_, int loop_, int
 int GfxView::draw(const Common::Point &pos) {
 	if (_type == GFXW_VIEW) {
 		DRAW_ASSERT(this, GFXW_VIEW);
-		GFX_ASSERT(gfxop_draw_cel(_visual->_gfxState, _view, _loop, _cel,
-					Common::Point(_pos.x + pos.x, _pos.y + pos.y), _color, _palette));
+		gfxop_draw_cel(_visual->_gfxState, _view, _loop, _cel,
+					Common::Point(_pos.x + pos.x, _pos.y + pos.y), _color, _palette);
 	} else {
 		// FIXME: _gfxwop_static_view_draw checked for GFXW_VIEW here, instead of GFXW_STATIC_VIEW.
 		//DRAW_ASSERT(this, GFXW_VIEW);
 		DRAW_ASSERT(this, GFXW_STATIC_VIEW);
-		GFX_ASSERT(gfxop_draw_cel_static(_visual->_gfxState, _view, _loop, _cel,
-	                _move_point(_bounds, pos), _color, _palette));
+		gfxop_draw_cel_static(_visual->_gfxState, _view, _loop, _cel,
+	                _move_point(_bounds, pos), _color, _palette);
 	}
 	return 0;
 }
@@ -638,16 +627,16 @@ int GfxDynView::draw(const Common::Point &pos) {
 	if (_type == GFXW_DYN_VIEW) {
 		DRAW_ASSERT(this, GFXW_DYN_VIEW);
 
-		GFX_ASSERT(gfxop_draw_cel(_visual->_gfxState, _view, _loop,  _cel,
-		                         _move_point(draw_bounds, pos), _color, _palette));
+		gfxop_draw_cel(_visual->_gfxState, _view, _loop,  _cel,
+		                         _move_point(draw_bounds, pos), _color, _palette);
 
 		/*
 		  gfx_color_t red;
 		  red.visual.r = 0xff;
 		  red.visual.g = red.visual.b = 0;
 		  red.mask = GFX_MASK_VISUAL;
-		  GFX_ASSERT(gfxop_draw_rectangle(view->visual->_gfxState,
-		  gfx_rect(view->_bounds.x + pos.x, view->_bounds.y + pos.y, view->_bounds.width - 1, view->_bounds.height - 1), red, 0, 0));
+		  gfxop_draw_rectangle(view->visual->_gfxState,
+		  gfx_rect(view->_bounds.x + pos.x, view->_bounds.y + pos.y, view->_bounds.width - 1, view->_bounds.height - 1), red, 0, 0);
 		*/
 	} else {
 		DRAW_ASSERT(this, GFXW_PIC_VIEW);
@@ -655,13 +644,13 @@ int GfxDynView::draw(const Common::Point &pos) {
 		if (_isDrawn)
 			return 0;
 
-		GFX_ASSERT(gfxop_set_clip_zone(_visual->_gfxState, _parent->zone));
-		GFX_ASSERT(gfxop_draw_cel_static_clipped(_visual->_gfxState, _view, _loop,
-				   _cel, _move_point(draw_bounds, pos), _color, _palette));
+		gfxop_set_clip_zone(_visual->_gfxState, _parent->zone);
+		gfxop_draw_cel_static_clipped(_visual->_gfxState, _view, _loop,
+				   _cel, _move_point(draw_bounds, pos), _color, _palette);
 
 		// Draw again on the back buffer
-		GFX_ASSERT(gfxop_draw_cel(_visual->_gfxState, _view, _loop, _cel,
-								  _move_point(draw_bounds, pos), _color, _palette));
+		gfxop_draw_cel(_visual->_gfxState, _view, _loop, _cel,
+					  _move_point(draw_bounds, pos), _color, _palette);
 
 
 		_isDrawn = true; // No more drawing needs to be done
@@ -830,7 +819,7 @@ int GfxText::draw(const Common::Point &pos) {
 	                   halign, valign, _color1, _color2, _bgcolor, _textFlags);
 	}
 
-	GFX_ASSERT(gfxop_draw_text(_visual->_gfxState, _textHandle, _move_rect(_bounds, pos)));
+	gfxop_draw_text(_visual->_gfxState, _textHandle, _move_rect(_bounds, pos));
 	return 0;
 }
 
@@ -1060,7 +1049,7 @@ static int _gfxwop_container_draw_contents(GfxWidget *widget, GfxWidget *content
 				if (seeker->_flags & GFXW_FLAG_DIRTY) {
 
 					if (!GFXW_IS_CONTAINER(seeker) && draw_noncontainers) {
-						GFX_ASSERT(gfxop_set_clip_zone(gfx_state, small_rect));
+						gfxop_set_clip_zone(gfx_state, small_rect);
 					}
 					/* Clip zone must be reset after each element, because we might
 					** descend into containers.
@@ -1383,14 +1372,7 @@ int GfxVisual::draw(const Common::Point &pos) {
 	DRAW_ASSERT(this, GFXW_VISUAL);
 
 	for (DirtyRectList::iterator dirty = _dirtyRects.begin(); dirty != _dirtyRects.end(); ++dirty) {
-		int err = gfxop_clear_box(_gfxState, *dirty);
-
-		if (err) {
-			error("Error while clearing dirty rect (%d,%d,(%dx%d))", dirty->x,
-			         dirty->y, dirty->width, dirty->height);
-			if (err == GFX_FATAL)
-				return err;
-		}
+		gfxop_clear_box(_gfxState, *dirty);
 	}
 
 	_gfxwop_container_draw_contents(this, _contents);
diff --git a/engines/sci/gfx/operations.cpp b/engines/sci/gfx/operations.cpp
index a23bae5350..226f477b8a 100644
--- a/engines/sci/gfx/operations.cpp
+++ b/engines/sci/gfx/operations.cpp
@@ -114,7 +114,7 @@ int _gfxop_clip(rect_t *rect, rect_t clipzone) {
 	return (rect->width <= 0 || rect->height <= 0);
 }
 
-static int _gfxop_grab_pixmap(GfxState *state, gfx_pixmap_t **pxmp, int x, int y,
+static void _gfxop_grab_pixmap(GfxState *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->getMode()->xfact;
@@ -124,7 +124,7 @@ static int _gfxop_grab_pixmap(GfxState *state, gfx_pixmap_t **pxmp, int x, int y
 	*zone = gfx_rect(x, y, xl, yl);
 
 	if (_gfxop_clip(zone, gfx_rect(0, 0, 320 * state->driver->getMode()->xfact, 200 * state->driver->getMode()->yfact)))
-		return GFX_ERROR;
+		error("_gfxop_grab_pixmap: zone was empty");
 
 	if (!*pxmp)
 		*pxmp = gfx_new_pixmap(unscaled_xl, unscaled_yl, GFX_RESID_NONE, 0, 0);
@@ -139,7 +139,7 @@ static int _gfxop_grab_pixmap(GfxState *state, gfx_pixmap_t **pxmp, int x, int y
 		(*pxmp)->index_height = unscaled_yl + 1;
 		gfx_pixmap_alloc_data(*pxmp, state->driver->getMode());
 	}
-	return state->driver->grabPixmap(*zone, *pxmp, priority ? GFX_MASK_PRIORITY : GFX_MASK_VISUAL);
+	state->driver->grabPixmap(*zone, *pxmp, priority ? GFX_MASK_PRIORITY : GFX_MASK_VISUAL);
 }
 
 #define DRAW_LOOP(condition)										\
@@ -185,9 +185,11 @@ DRAW_LOOP(map->index_data[offset] < color) // Draw only lower priority
 
 #undef DRAW_LOOP
 
-static int _gfxop_install_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm) {
-	if (!driver->getMode()->palette) return GFX_OK;
-	if (!pxm->palette) return GFX_OK;
+static void _gfxop_install_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm) {
+	if (!driver->getMode()->palette)
+		return;
+	if (!pxm->palette)
+		return;
 
 	pxm->palette->mergeInto(driver->getMode()->palette);
 	assert(pxm->palette->getParent() == driver->getMode()->palette);
@@ -195,7 +197,8 @@ static int _gfxop_install_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm) {
 	if (pxm->palette_revision != pxm->palette->getRevision())
 		gfx_xlate_pixmap(pxm, driver->getMode(), GFX_XLATE_FILTER_NONE);
 
-	if (!driver->getMode()->palette->isDirty()) return GFX_OK;
+	if (!driver->getMode()->palette->isDirty())
+		return;
 
 	// TODO: We probably want to only update the colours used by this pixmap
 	// here. This will require updating the 'dirty' system.
@@ -211,13 +214,10 @@ static int _gfxop_install_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm) {
 
 	g_system->setPalette(paletteData, 0, paletteSize);
 	driver->getMode()->palette->markClean();
-
-	return GFX_OK;
 }
 
-static int _gfxop_draw_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm, int priority, int control,
+static void _gfxop_draw_pixmap(GfxDriver *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 err;
 	rect_t clipped_dest = gfx_rect(dest.x, dest.y, dest.width, dest.height);
 
 	if (control >= 0 || priority >= 0) {
@@ -233,28 +233,19 @@ static int _gfxop_draw_pixmap(GfxDriver *driver, gfx_pixmap_t *pxm, int priority
 	}
 
 	if (_gfxop_clip(&clipped_dest, clip))
-		return GFX_OK;
+		return;
 
 	src.x += clipped_dest.x - dest.x;
 	src.y += clipped_dest.y - dest.y;
 	src.width = clipped_dest.width;
 	src.height = clipped_dest.height;
 
-	err = _gfxop_install_pixmap(driver, pxm);
-	if (err)
-		return err;
+	_gfxop_install_pixmap(driver, pxm);
 
 	DDIRTY(stderr, "\\-> Drawing to actual %d %d %d %d\n", clipped_dest.x / driver->getMode()->xfact,
 	       clipped_dest.y / driver->getMode()->yfact, clipped_dest.width / driver->getMode()->xfact, clipped_dest.height / driver->getMode()->yfact);
 
-	err = driver->drawPixmap(pxm, priority, src, clipped_dest, static_buf ? GFX_BUFFER_STATIC : GFX_BUFFER_BACK);
-
-	if (err) {
-		error("driver->draw_pixmap() returned error code");
-		return err;
-	}
-
-	return GFX_OK;
+	driver->drawPixmap(pxm, priority, src, clipped_dest, static_buf ? GFX_BUFFER_STATIC : GFX_BUFFER_BACK);
 }
 
 static void _gfxop_full_pointer_refresh(GfxState *state) {
@@ -286,7 +277,7 @@ static void _gfxop_full_pointer_refresh(GfxState *state) {
 							state->pointer_pos.y * state->driver->getMode()->yfact);
 }
 
-static int _gfxop_buffer_propagate_box(GfxState *state, rect_t box, gfx_buffer_t buffer);
+static void _gfxop_buffer_propagate_box(GfxState *state, rect_t box, gfx_buffer_t buffer);
 
 gfx_pixmap_t *_gfxr_get_cel(GfxState *state, int nr, int *loop, int *cel, int palette) {
 	gfxr_view_t *view = state->gfxResMan->getView(nr, loop, cel, palette);
@@ -312,15 +303,9 @@ gfx_pixmap_t *_gfxr_get_cel(GfxState *state, int nr, int *loop, int *cel, int pa
 
 //** Dirty rectangle operations **
 
-static int _gfxop_update_box(GfxState *state, rect_t box) {
-	int retval;
+static void _gfxop_update_box(GfxState *state, rect_t box) {
 	_gfxop_scale_rect(&box, state->driver->getMode());
-
-	if ((retval = _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_FRONT))) {
-		error("Error occured while propagating box (%d,%d,%d,%d) to front buffer", box.x, box.y, box.width, box.height);
-		return retval;
-	}
-	return GFX_OK;
+	_gfxop_buffer_propagate_box(state, box, GFX_BUFFER_FRONT);
 }
 
 void gfxdr_add_dirty(DirtyRectList &list, rect_t box, int strategy) {
@@ -401,9 +386,7 @@ static void _gfxop_add_dirty_x(GfxState *state, rect_t box) {
 	_gfxop_add_dirty(state, box);
 }
 
-static int _gfxop_clear_dirty_rec(GfxState *state, DirtyRectList &dirtyRects) {
-	int retval = GFX_OK;
-
+static void _gfxop_clear_dirty_rec(GfxState *state, DirtyRectList &dirtyRects) {
 	DirtyRectList::iterator dirty = dirtyRects.begin();
 	while (dirty != dirtyRects.end()) {
 
@@ -411,12 +394,10 @@ static int _gfxop_clear_dirty_rec(GfxState *state, DirtyRectList &dirtyRects) {
 		fprintf(stderr, "\tClearing dirty (%d %d %d %d)\n", GFX_PRINT_RECT(*dirty));
 	#endif
 		if (!state->fullscreen_override)
-			retval |= _gfxop_update_box(state, *dirty);
+			_gfxop_update_box(state, *dirty);
 		++dirty;
 	}
 	dirtyRects.clear();
-
-	return retval;
 }
 
 //** Exported operations **
@@ -427,7 +408,7 @@ static void init_aux_pixmap(gfx_pixmap_t **pixmap) {
 	(*pixmap)->palette = new Palette(default_colors, DEFAULT_COLORS_NR);
 }
 
-int gfxop_init(int version, GfxState *state,
+void gfxop_init(int version, GfxState *state,
 				gfx_options_t *options, ResourceManager *resManager,
 				Graphics::PixelFormat mode, int xfact, int yfact) {
 	//int color_depth = bpp ? bpp : 1;
@@ -455,11 +436,9 @@ int gfxop_init(int version, GfxState *state,
 	init_aux_pixmap(&(state->control_map));
 	init_aux_pixmap(&(state->priority_map));
 	init_aux_pixmap(&(state->static_priority_map));
-
-	return GFX_OK;
 }
 
-int gfxop_exit(GfxState *state) {
+void gfxop_exit(GfxState *state) {
 	state->gfxResMan->freeResManager();
 
 	if (state->control_map) {
@@ -478,8 +457,6 @@ int gfxop_exit(GfxState *state) {
 	}
 
 	delete state->driver;
-
-	return GFX_OK;
 }
 
 static int _gfxop_scan_one_bitmask(gfx_pixmap_t *pixmap, rect_t zone) {
@@ -532,7 +509,7 @@ int gfxop_scan_bitmask(GfxState *state, rect_t area, gfx_map_mask_t map) {
 #define MAX_X 319
 #define MAX_Y 199
 
-int gfxop_set_clip_zone(GfxState *state, rect_t zone) {
+void gfxop_set_clip_zone(GfxState *state, rect_t zone) {
 	int xfact, yfact;
 
 	DDIRTY(stderr, "-- Setting clip zone %d %d %d %d\n", GFX_PRINT_RECT(zone));
@@ -562,11 +539,9 @@ int gfxop_set_clip_zone(GfxState *state, rect_t zone) {
 	state->clip_zone.y = state->clip_zone_unscaled.y * yfact;
 	state->clip_zone.width = state->clip_zone_unscaled.width * xfact;
 	state->clip_zone.height = state->clip_zone_unscaled.height * yfact;
-
-	return GFX_OK;
 }
 
-int gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b, int a, int priority, int control) {
+void gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b, int a, int priority, int control) {
 	int mask = ((r >= 0 && g >= 0 && b >= 0) ? GFX_MASK_VISUAL : 0) | ((priority >= 0) ? GFX_MASK_PRIORITY : 0)
 	           | ((control >= 0) ? GFX_MASK_CONTROL : 0);
 
@@ -588,13 +563,11 @@ int gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b, in
 			color->visual.parent_index = state->driver->getMode()->palette->findNearbyColor(r,g,b,true);
 		}
 	}
-
-	return GFX_OK;
 }
 
 // Wrapper for gfxop_set_color
-int gfxop_set_color(GfxState *state, gfx_color_t *colorOut, gfx_color_t &colorIn) {
-	return gfxop_set_color(state, colorOut,
+void gfxop_set_color(GfxState *state, gfx_color_t *colorOut, gfx_color_t &colorIn) {
+	gfxop_set_color(state, colorOut,
 	              (colorIn.mask & GFX_MASK_VISUAL) ? colorIn.visual.r : -1,
 	              (colorIn.mask & GFX_MASK_VISUAL) ? colorIn.visual.g : -1,
 	              (colorIn.mask & GFX_MASK_VISUAL) ? colorIn.visual.b : -1,
@@ -603,23 +576,19 @@ int gfxop_set_color(GfxState *state, gfx_color_t *colorOut, gfx_color_t &colorIn
 	              (colorIn.mask & GFX_MASK_CONTROL) ? colorIn.control : -1);
 }
 
-int gfxop_set_system_color(GfxState *state, unsigned int index, gfx_color_t *color) {
+void gfxop_set_system_color(GfxState *state, unsigned int index, gfx_color_t *color) {
 	if (!PALETTE_MODE)
-		return GFX_OK;
+		return;
 
 	if (index >= state->driver->getMode()->palette->size()) {
 		error("Attempt to set invalid color index %02x as system color", color->visual.parent_index);
-		return GFX_ERROR;
 	}
 
 	state->driver->getMode()->palette->makeSystemColor(index, color->visual);
-
-	return GFX_OK;
 }
 
-int gfxop_free_color(GfxState *state, gfx_color_t *color) {
+void gfxop_free_color(GfxState *state, gfx_color_t *color) {
 	// FIXME: implement. (And call in the appropriate places!)
-	return GFX_OK;
 }
 
 
@@ -717,7 +686,7 @@ static void draw_line_to_control_map(GfxState *state, Common::Point start, Commo
 			gfx_draw_line_pixmap_i(state->control_map, start, end, color.control);
 }
 
-static int simulate_stippled_line_draw(GfxDriver *driver, int skipone, Common::Point start, Common::Point end, gfx_color_t color, gfx_line_mode_t line_mode) {
+static void simulate_stippled_line_draw(GfxDriver *driver, int skipone, Common::Point start, Common::Point 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;
@@ -757,18 +726,12 @@ static int simulate_stippled_line_draw(GfxDriver *driver, int skipone, Common::P
 		yl = linelength;
 
 	while (length--) {
-		int retval;
 		Common::Point nextpos = Common::Point(start.x + xl, start.y + yl);
-
-		if ((retval = driver->drawLine(start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
-			error("Failed to draw partial stippled line (%d,%d) -- (%d,%d)", start.x, start.y, nextpos.x, nextpos.y);
-			return retval;
-		}
+		driver->drawLine(start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL);
 		*posvar += delta;
 	}
 
 	if (length_left) {
-		int retval;
 		Common::Point nextpos;
 
 		if (length_left > stepwidth)
@@ -782,18 +745,12 @@ static int simulate_stippled_line_draw(GfxDriver *driver, int skipone, Common::P
 
 		nextpos = Common::Point(start.x + xl, start.y + yl);
 
-		if ((retval = driver->drawLine(start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) {
-			error("Failed to draw partial stippled line (%d,%d) -- (%d,%d)", start.x, start.y, nextpos.x, nextpos.y);
-			return retval;
-		}
+		driver->drawLine(start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL);
 	}
-
-	return GFX_OK;
 }
 
-static int _gfxop_draw_line_clipped(GfxState *state, Common::Point start, Common::Point end, gfx_color_t color, gfx_line_mode_t line_mode,
+static void _gfxop_draw_line_clipped(GfxState *state, Common::Point start, Common::Point 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
 
 	_gfxop_full_pointer_refresh(state);
@@ -810,25 +767,18 @@ static int _gfxop_draw_line_clipped(GfxState *state, Common::Point start, Common
 	        || end.x >= (state->clip_zone.x + state->clip_zone.width)
 	        || end.y >= (state->clip_zone.y + state->clip_zone.height))
 		if (point_clip(&start, &end, state->clip_zone, state->driver->getMode()->xfact - 1, state->driver->getMode()->yfact - 1))
-			return GFX_OK; // Clipped off
+			return; // Clipped off
 
 	if (line_style == GFX_LINE_STYLE_STIPPLED) {
-		if (start.x != end.x && start.y != end.y) {
-			warning("[GFX] Attempt to draw stippled line which is neither an hbar nor a vbar: (%d,%d) -- (%d,%d)", start.x, start.y, end.x, end.y);
-			return GFX_ERROR;
-		}
-		return simulate_stippled_line_draw(state->driver, skipone, start, end, color, line_mode);
-	}
-
-	if ((retval = state->driver->drawLine(start, end, color, line_mode, line_style))) {
-		error("Failed to draw line (%d,%d) -- (%d,%d)", start.x, start.y, end.x, end.y);
-		return retval;
+		if (start.x != end.x && start.y != end.y)
+			error("[GFX] Attempt to draw stippled line which is neither an hbar nor a vbar: (%d,%d) -- (%d,%d)", start.x, start.y, end.x, end.y);
+		simulate_stippled_line_draw(state->driver, skipone, start, end, color, line_mode);
 	}
 
-	return GFX_OK;
+	state->driver->drawLine(start, end, color, line_mode, line_style);
 }
 
-int gfxop_draw_line(GfxState *state, Common::Point start, Common::Point end,
+void gfxop_draw_line(GfxState *state, Common::Point start, Common::Point end,
 	gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) {
 	int xfact, yfact;
 
@@ -852,11 +802,10 @@ int gfxop_draw_line(GfxState *state, Common::Point start, Common::Point end,
 
 	if (color.visual.parent_index == GFX_COLOR_INDEX_UNMAPPED)
 		gfxop_set_color(state, &color, color);
-	return _gfxop_draw_line_clipped(state, start, end, color, line_mode, line_style);
+	_gfxop_draw_line_clipped(state, start, end, color, line_mode, line_style);
 }
 
-int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) {
-	int retval = 0;
+void gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) {
 	int xfact, yfact;
 	int x, y, xl, yl;
 	Common::Point upper_left_u, upper_right_u, lower_left_u, lower_right_u;
@@ -884,7 +833,7 @@ int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color, gfx_li
 	lower_right = Common::Point(x + xl, y + yl);
 
 #define PARTIAL_LINE(pt1, pt2)									\
-	retval |= _gfxop_draw_line_clipped(state, pt1, pt2, color, line_mode, line_style);	\
+	_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))
 
@@ -894,18 +843,12 @@ int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color, gfx_li
 	PARTIAL_LINE(lower_left, upper_left);
 
 #undef PARTIAL_LINE
-	if (retval) {
-		error("Failed to draw rectangle (%d,%d)+(%d,%d)", rect.x, rect.y, rect.width, rect.height);
-		return retval;
-	}
-
-	return GFX_OK;
 }
 
 
 #define COLOR_MIX(type, dist) ((color1.type * dist) + (color2.type * (1.0 - dist)))
 
-int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t color2, gfx_box_shade_t shade_type) {
+void gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t color2, gfx_box_shade_t shade_type) {
 	GfxDriver *drv = state->driver;
 	int reverse = 0; // switch color1 and color2
 	float mod_offset = 0.0f, mod_breadth = 1.0f; // 0.0 to 1.0: Color adjustment
@@ -930,16 +873,16 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
 	_gfxop_scale_rect(&box, state->driver->getMode());
 
 	if (!(color1.mask & (GFX_MASK_VISUAL | GFX_MASK_PRIORITY)))
-		return GFX_OK;
+		return;
 
 	if (box.width <= 1 || box.height <= 1) {
 		debugC(2, kDebugLevelGraphics, "Attempt to draw box with size %dx%d", box.width, box.height);
-		return GFX_OK;
+		return;
 	}
 
 	memcpy(&new_box, &box, sizeof(rect_t));
 	if (_gfxop_clip(&new_box, state->clip_zone))
-		return GFX_OK;
+		return;
 
 	switch (shade_type) {
 
@@ -965,7 +908,6 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
 
 	default:
 		error("Invalid shade type: %d", shade_type);
-		return GFX_ERROR;
 	}
 
 
@@ -978,11 +920,12 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
 		color1.control = 0;
 		if (color1.visual.parent_index == GFX_COLOR_INDEX_UNMAPPED)
 			gfxop_set_color(state, &color1, color1);
-		return drv->drawFilledRect(new_box, color1, color1, GFX_SHADE_FLAT);
+		drv->drawFilledRect(new_box, color1, color1, GFX_SHADE_FLAT);
+		return;
 	} else {
 		if (PALETTE_MODE) {
 			warning("[GFX] Attempting to draw shaded box in palette mode");
-			return GFX_ERROR;
+			return;	// not critical
 		}
 
 		gfx_color_t draw_color1; // CHECKME
@@ -1014,27 +957,20 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1, gfx_color_t
 }
 #undef COLOR_MIX
 
-int gfxop_fill_box(GfxState *state, rect_t box, gfx_color_t color) {
-	return gfxop_draw_box(state, box, color, color, GFX_BOX_SHADE_FLAT);
+void gfxop_fill_box(GfxState *state, rect_t box, gfx_color_t color) {
+	gfxop_draw_box(state, box, color, color, GFX_BOX_SHADE_FLAT);
 }
 
-static int _gfxop_buffer_propagate_box(GfxState *state, rect_t box, gfx_buffer_t buffer) {
-	int err;
-
+static void _gfxop_buffer_propagate_box(GfxState *state, rect_t box, gfx_buffer_t buffer) {
 	if (_gfxop_clip(&box, gfx_rect(0, 0, 320 * state->driver->getMode()->xfact, 200 * state->driver->getMode()->yfact)))
-		return GFX_OK;
-
-	if ((err = state->driver->update(box, Common::Point(box.x, box.y), buffer))) {
-		error("Error occured while updating region (%d,%d,%d,%d) in buffer %d", box.x, box.y, box.width, box.height, buffer);
-		return err;
-	}
+		return;
 
-	return GFX_OK;
+	state->driver->update(box, Common::Point(box.x, box.y), buffer);
 }
 
 extern int sci0_palette;
 
-int gfxop_clear_box(GfxState *state, rect_t box) {
+void gfxop_clear_box(GfxState *state, rect_t box) {
 	_gfxop_full_pointer_refresh(state);
 	_gfxop_add_dirty(state, box);
 	DDIRTY(stderr, "[]  clearing box %d %d %d %d\n", GFX_PRINT_RECT(box));
@@ -1047,10 +983,10 @@ int gfxop_clear_box(GfxState *state, rect_t box) {
 
 	_gfxop_scale_rect(&box, state->driver->getMode());
 
-	return _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_BACK);
+	_gfxop_buffer_propagate_box(state, box, GFX_BUFFER_BACK);
 }
 
-int gfxop_set_visible_map(GfxState *state, gfx_map_mask_t visible_map) {
+void gfxop_set_visible_map(GfxState *state, gfx_map_mask_t visible_map) {
 	switch (visible_map) {
 
 	case GFX_MASK_VISUAL:
@@ -1072,64 +1008,50 @@ int gfxop_set_visible_map(GfxState *state, gfx_map_mask_t visible_map) {
 
 	default:
 		warning("Invalid display map %d selected", visible_map);
-		return GFX_ERROR;
+		return;
 	}
 
 	state->visible_map = visible_map;
-
-	return GFX_OK;
 }
 
-int gfxop_update(GfxState *state) {
-	int retval = _gfxop_clear_dirty_rec(state, state->_dirtyRects);
+void gfxop_update(GfxState *state) {
+	_gfxop_clear_dirty_rec(state, state->_dirtyRects);
 
 	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->getMode(), GFX_XLATE_FILTER_NONE);
 		gfxop_draw_pixmap(state, state->fullscreen_override, rect, Common::Point(0, 0));
-		retval |= _gfxop_update_box(state, rect);
-	}
-
-	if (retval) {
-		error("Clearing the dirty rectangles failed");
+		_gfxop_update_box(state, rect);
 	}
 
 	if (state->tag_mode) {
 		// This usually happens after a pic and all resources have been drawn
-
 		state->gfxResMan->freeTaggedResources();
-
 		state->tag_mode = 0;
 	}
-
-	return retval;
 }
 
-int gfxop_update_box(GfxState *state, rect_t box) {
+void gfxop_update_box(GfxState *state, rect_t box) {
 	if (state->disable_dirty)
 		_gfxop_update_box(state, box);
 	else
 		_gfxop_add_dirty(state, box);
 
-	return gfxop_update(state);
+	gfxop_update(state);
 }
 
-int gfxop_enable_dirty_frames(GfxState *state) {
+void gfxop_enable_dirty_frames(GfxState *state) {
 	state->disable_dirty = 0;
-
-	return GFX_OK;
 }
 
-int gfxop_disable_dirty_frames(GfxState *state) {
+void gfxop_disable_dirty_frames(GfxState *state) {
 	state->disable_dirty = 1;
-
-	return GFX_OK;
 }
 
 
 // Pointer and IO ops
-int gfxop_sleep(GfxState *state, uint32 msecs) {
+void gfxop_sleep(GfxState *state, uint32 msecs) {
 	uint32 time;
 	const uint32 wakeup_time = g_system->getMillis() + msecs;
 
@@ -1147,11 +1069,9 @@ int gfxop_sleep(GfxState *state, uint32 msecs) {
 		}
 
 	}
-
-	return GFX_OK;
 }
 
-static int _gfxop_set_pointer(GfxState *state, gfx_pixmap_t *pxm, Common::Point *hotspot) {
+static void _gfxop_set_pointer(GfxState *state, gfx_pixmap_t *pxm, Common::Point *hotspot) {
 	// FIXME: We may have to store this pxm somewhere, as the global palette
 	// may change when a new PIC is loaded. The cursor has to be regenerated
 	// from this pxm at that point. (An alternative might be to ensure the
@@ -1161,26 +1081,24 @@ static int _gfxop_set_pointer(GfxState *state, gfx_pixmap_t *pxm, Common::Point
 		pxm->palette->mergeInto(state->driver->getMode()->palette);
 	}
 	state->driver->setPointer(pxm, hotspot);
-
-	return GFX_OK;
 }
 
-int gfxop_set_pointer_cursor(GfxState *state, int nr) {
+void gfxop_set_pointer_cursor(GfxState *state, int nr) {
 	if (nr == GFXOP_NO_POINTER)
-		return _gfxop_set_pointer(state, NULL, NULL);
+		_gfxop_set_pointer(state, NULL, NULL);
 
 	gfx_pixmap_t *new_pointer = state->gfxResMan->getCursor(nr);
 
 	if (!new_pointer) {
 		warning("[GFX] Attempt to set invalid pointer #%d\n", nr);
-		return GFX_ERROR;
+		return;
 	}
 
 	Common::Point p = Common::Point(new_pointer->xoffset, new_pointer->yoffset);
-	return _gfxop_set_pointer(state, new_pointer, &p);
+	_gfxop_set_pointer(state, new_pointer, &p);
 }
 
-int gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::Point *hotspot) {
+void gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::Point *hotspot) {
 	int real_loop = loop;
 	int real_cel = cel;
 	// FIXME: For now, don't palettize pointers
@@ -1188,7 +1106,7 @@ int gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::P
 
 	if (!new_pointer) {
 		warning("[GFX] Attempt to set invalid pointer #%d", nr);
-		return GFX_ERROR;
+		return;
 	}
 
 	if (real_loop != loop || real_cel != cel) {
@@ -1197,23 +1115,23 @@ int gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::P
 
 	// Eco Quest 1 uses a 1x1 transparent cursor to hide the cursor from the user. Some scalers don't seem to support this.
 	if (new_pointer->width < 2 || new_pointer->height < 2)
-		return _gfxop_set_pointer(state, NULL, NULL);
+		_gfxop_set_pointer(state, NULL, NULL);
 
 	if (hotspot)
-		return _gfxop_set_pointer(state, new_pointer, hotspot);
+		_gfxop_set_pointer(state, new_pointer, hotspot);
 	else {
 		// Compute hotspot from xoffset/yoffset
 		Common::Point p = Common::Point(new_pointer->xoffset + (new_pointer->width >> 1), new_pointer->yoffset + new_pointer->height - 1);
-		return _gfxop_set_pointer(state, new_pointer, &p);
+		_gfxop_set_pointer(state, new_pointer, &p);
 	}
 }
 
-int gfxop_set_pointer_position(GfxState *state, Common::Point pos) {
+void gfxop_set_pointer_position(GfxState *state, Common::Point pos) {
 	state->pointer_pos = pos;
 
 	if (pos.x > 320 || pos.y > 200) {
 		warning("[GFX] Attempt to place pointer at invalid coordinates (%d, %d)", pos.x, pos.y);
-		return 0; // Not fatal
+		return; // Not fatal
 	}
 
 	g_system->warpMouse(pos.x * state->driver->getMode()->xfact, pos.y * state->driver->getMode()->yfact);
@@ -1221,13 +1139,10 @@ int gfxop_set_pointer_position(GfxState *state, Common::Point pos) {
 	// Trigger event reading to make sure the mouse coordinates will
 	// actually have changed the next time we read them.
 	gfxop_get_event(state, SCI_EVT_PEEK);
-
-	return 0;
 }
 
-int gfxop_set_pointer_zone(GfxState *state, Common::Rect rect) {
+void gfxop_set_pointer_zone(GfxState *state, Common::Rect rect) {
 	state->pointerZone = rect;
-	return GFX_OK;
 }
 
 #define SCANCODE_ROWS_NR 3
@@ -1685,7 +1600,7 @@ int gfxop_get_cel_parameters(GfxState *state, int nr, int loop, int cel, int *wi
 	return GFX_OK;
 }
 
-static int _gfxop_draw_cel_buffer(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int static_buf, int palette) {
+static void _gfxop_draw_cel_buffer(GfxState *state, int nr, int loop, int cel, Common::Point 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;
@@ -1696,7 +1611,7 @@ static int _gfxop_draw_cel_buffer(GfxState *state, int nr, int loop, int cel, Co
 
 	if (!view) {
 		warning("[GFX] Attempt to draw loop/cel %d/%d in invalid view %d\n", loop, cel, nr);
-		return GFX_ERROR;
+		return;
 	}
 	pxm = view->loops[loop].cels[cel];
 
@@ -1709,35 +1624,32 @@ static int _gfxop_draw_cel_buffer(GfxState *state, int nr, int loop, int cel, Co
 	if (!static_buf)
 		_gfxop_add_dirty(state, gfx_rect(old_x, old_y, pxm->index_width, pxm->index_height));
 
-	return _gfxop_draw_pixmap(state->driver, pxm, priority, control, gfx_rect(0, 0, pxm->width, pxm->height),
+	_gfxop_draw_pixmap(state->driver, pxm, priority, control, gfx_rect(0, 0, pxm->width, pxm->height),
 	                          gfx_rect(pos.x, pos.y, pxm->width, pxm->height), state->clip_zone, static_buf , state->control_map,
 	                          static_buf ? state->static_priority_map : state->priority_map);
 }
 
-int gfxop_draw_cel(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int palette) {
-	return _gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 0, palette);
+void gfxop_draw_cel(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int palette) {
+	_gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 0, palette);
 }
 
-int gfxop_draw_cel_static(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int palette) {
-	int retval;
+void gfxop_draw_cel_static(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int palette) {
 	rect_t oldclip = state->clip_zone;
 
 	state->clip_zone = gfx_rect_fullscreen;
 	_gfxop_scale_rect(&(state->clip_zone), state->driver->getMode());
-	retval = gfxop_draw_cel_static_clipped(state, nr, loop, cel, pos, color, palette);
+	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(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int palette) {
-	return _gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 1, palette);
+void gfxop_draw_cel_static_clipped(GfxState *state, int nr, int loop, int cel, Common::Point pos, gfx_color_t color, int palette) {
+	_gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 1, palette);
 }
 
 // Pic operations
 
-static int _gfxop_set_pic(GfxState *state) {
+static void _gfxop_set_pic(GfxState *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));
@@ -1755,14 +1667,14 @@ static int _gfxop_set_pic(GfxState *state) {
 	if (state->options->pic0_unscaled)
 #endif
 		state->pic->priority_map = gfx_pixmap_scale_index_data(state->pic->priority_map, state->driver->getMode());
-	return state->driver->setStaticBuffer(state->pic->visual_map, state->pic->priority_map);
+	state->driver->setStaticBuffer(state->pic->visual_map, state->pic->priority_map);
 }
 
 int *gfxop_get_pic_metainfo(GfxState *state) {
 	return (state->pic) ? state->pic->priorityTable : NULL;
 }
 
-int gfxop_new_pic(GfxState *state, int nr, int flags, int default_palette) {
+void gfxop_new_pic(GfxState *state, int nr, int flags, int default_palette) {
 	state->gfxResMan->tagResources();
 	state->tag_mode = 1;
 	state->palette_nr = default_palette;
@@ -1786,30 +1698,25 @@ int gfxop_new_pic(GfxState *state, int nr, int flags, int default_palette) {
 
 		error("Error occured in gfxop_new_pic()");
 		state->pic = state->pic_unscaled = NULL;
-		return GFX_ERROR;
 	}
 
 	state->pic_nr = nr;
 
-	return _gfxop_set_pic(state);
+	_gfxop_set_pic(state);
 }
 
-int gfxop_add_to_pic(GfxState *state, int nr, int flags, int default_palette) {
-	if (!state->pic) {
+void gfxop_add_to_pic(GfxState *state, int nr, int flags, int default_palette) {
+	if (!state->pic)
 		error("Attempt to add to pic with no pic active");
-		return GFX_ERROR;
-	}
 
 	state->pic = state->gfxResMan->addToPic(state->pic_nr, nr, flags, state->palette_nr, default_palette);
 
-	if (!state->pic) {
+	if (!state->pic)
 		error("Could not add pic #%d to pic #%d", state->pic_nr, nr);
-		return GFX_ERROR;
-	}
 
 	state->pic_unscaled = state->gfxResMan->addToPic(state->pic_nr, nr, flags, state->palette_nr, default_palette);
 
-	return _gfxop_set_pic(state);
+	_gfxop_set_pic(state);
 }
 
 // Text operations
@@ -1864,16 +1771,11 @@ TextHandle *gfxop_new_text(GfxState *state, int font_nr, const Common::String &t
 								  gfx_alignment_t valign, gfx_color_t color1, gfx_color_t color2, gfx_color_t bg_color, int flags) {
 	TextHandle *handle;
 	gfx_bitmap_font_t *font;
-	int err = 0;
 
 	// mapping text colors to palette
-	err |= gfxop_set_color(state, &color1, color1);
-	err |= gfxop_set_color(state, &color2, color2);
-	err |= gfxop_set_color(state, &bg_color, bg_color);
-	if (err) {
-		error("Unable to set up colors");
-		return NULL;
-	}
+	gfxop_set_color(state, &color1, color1);
+	gfxop_set_color(state, &color2, color2);
+	gfxop_set_color(state, &bg_color, bg_color);
 
 	font = state->gfxResMan->getFont(font_nr);
 
@@ -1935,10 +1837,8 @@ TextHandle *gfxop_new_text(GfxState *state, int font_nr, const Common::String &t
 	return handle;
 }
 
-int gfxop_free_text(GfxState *state, TextHandle *handle) {
+void gfxop_free_text(GfxState *state, TextHandle *handle) {
 	delete handle;
-
-	return GFX_OK;
 }
 
 TextHandle::TextHandle() {
@@ -1957,19 +1857,17 @@ TextHandle::~TextHandle() {
 			gfx_free_pixmap(text_pixmaps[j]);
 }
 
-int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
+void gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
 	int line_height;
 	rect_t pos;
 	_gfxop_full_pointer_refresh(state);
 
-	if (!handle) {
+	if (!handle)
 		error("Attempt to draw text with NULL handle");
-		return GFX_ERROR;
-	}
 
 	if (handle->lines.empty()) {
 		debugC(2, kDebugLevelGraphics, "Skipping draw_text operation because number of lines is zero\n");
-		return GFX_OK;
+		return;
 	}
 
 	_gfxop_scale_rect(&zone, state->driver->getMode());
@@ -1993,7 +1891,6 @@ int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
 
 	default:
 		error("Invalid vertical alignment %d", handle->valign);
-		return GFX_FATAL; // Internal error...
 	}
 
 	for (uint i = 0; i < handle->lines.size(); i++) {
@@ -2007,10 +1904,8 @@ int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
 			gfx_xlate_pixmap(pxm, state->driver->getMode(), GFX_XLATE_FILTER_NONE);
 #endif
 		}
-		if (!pxm) {
+		if (!pxm)
 			error("Could not find text pixmap %d/%d", i, handle->lines.size());
-			return GFX_ERROR;
-		}
 
 		pos.x = zone.x;
 
@@ -2029,7 +1924,6 @@ int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
 
 		default:
 			error("Invalid vertical alignment %d", handle->valign);
-			return GFX_FATAL; // Internal error...
 		}
 
 		pos.width = pxm->width;
@@ -2041,8 +1935,6 @@ int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone) {
 
 		pos.y += line_height;
 	}
-
-	return GFX_OK;
 }
 
 gfx_pixmap_t *gfxop_grab_pixmap(GfxState *state, rect_t area) {
@@ -2051,31 +1943,20 @@ gfx_pixmap_t *gfxop_grab_pixmap(GfxState *state, rect_t area) {
 	_gfxop_full_pointer_refresh(state);
 
 	_gfxop_scale_rect(&area, state->driver->getMode());
-	if (_gfxop_grab_pixmap(state, &pixmap, area.x, area.y, area.width, area.height, 0, &resultzone))
-		return NULL; // area CUT the visual screen had a null or negative size
+	_gfxop_grab_pixmap(state, &pixmap, area.x, area.y, area.width, area.height, 0, &resultzone);
 
 	return pixmap;
 }
 
-int gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone, Common::Point pos) {
-	rect_t target;
+void gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone, Common::Point pos) {
+	rect_t target = gfx_rect(pos.x, pos.y, zone.width, zone.height);
 
-	if (!pxm) {
+	if (!pxm)
 		error("Attempt to draw NULL pixmap");
-		return GFX_ERROR;
-	}
 
 	_gfxop_full_pointer_refresh(state);
-
-	target = gfx_rect(pos.x, pos.y, zone.width, zone.height);
-
 	_gfxop_add_dirty(state, target);
 
-	if (!pxm) {
-		error("Attempt to draw_pixmap with pxm=NULL");
-		return GFX_ERROR;
-	}
-
 	_gfxop_scale_rect(&zone, state->driver->getMode());
 	_gfxop_scale_rect(&target, state->driver->getMode());
 
@@ -2083,9 +1964,8 @@ int gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone, Common::P
 	                                   200*state->driver->getMode()->yfact), 0, NULL, NULL);
 }
 
-int gfxop_free_pixmap(GfxState *state, gfx_pixmap_t *pxm) {
+void gfxop_free_pixmap(GfxState *state, gfx_pixmap_t *pxm) {
 	gfx_free_pixmap(pxm);
-	return GFX_OK;
 }
 
 } // End of namespace Sci
diff --git a/engines/sci/gfx/operations.h b/engines/sci/gfx/operations.h
index 865b420681..5419388eb2 100644
--- a/engines/sci/gfx/operations.h
+++ b/engines/sci/gfx/operations.h
@@ -142,11 +142,8 @@ struct GfxState {
  * @param[in] mode			Graphics mode to use
  * @param[in] options		Rendering options
  * @param[in] resManager	Resource manager to use
- * @return					GFX_OK on success, GFX_ERROR if that particular mode
- * 							is unavailable, or GFX_FATAL if the graphics driver
- * 							is unable to provide any useful graphics support
  */
-int gfxop_init(int version, GfxState *state, 
+void gfxop_init(int version, GfxState *state, 
 		gfx_options_t *options, ResourceManager *resManager,
 		Graphics::PixelFormat mode, int xfact = 1, int yfact = 1);
 
@@ -154,9 +151,8 @@ int gfxop_init(int version, GfxState *state,
  * Deinitializes a currently active driver.
  *
  * @param[in] state	The state encapsulating the driver in question
- * @return			GFX_OK
  */
-int gfxop_exit(GfxState *state);
+void gfxop_exit(GfxState *state);
 
 /**
  * Calculates a bit mask calculated from some pixels on the specified
@@ -186,18 +182,16 @@ int gfxop_scan_bitmask(GfxState *state, rect_t area, gfx_map_mask_t map);
  *
  * @param[in] state	The state to modify
  * @param[in] map	The GFX_MASK to set
- * @return			GFX_OK, or GFX_ERROR if map was invalid
  */
-int gfxop_set_visible_map(GfxState *state, gfx_map_mask_t map);
+void gfxop_set_visible_map(GfxState *state, gfx_map_mask_t map);
 
 /**
  * Sets a new clipping zone.
  *
  * @param[in] state	The affected state
  * @param[in] zone	The new clipping zone
- * @return			GFX_OK
  */
-int gfxop_set_clip_zone(GfxState *state, rect_t zone);
+void gfxop_set_clip_zone(GfxState *state, rect_t zone);
 /** @} */
 
 
@@ -213,9 +207,8 @@ int gfxop_set_clip_zone(GfxState *state, rect_t zone);
  * @param[in] color			The color to use for drawing
  * @param[in] line_mode		Any valid line mode to use
  * @param[in] line_style	The line style to use
- * @return					GFX_OK or GFX_FATAL
  */
-int gfxop_draw_line(GfxState *state,
+void gfxop_draw_line(GfxState *state,
 	Common::Point start, Common::Point end, gfx_color_t color,
 	gfx_line_mode_t line_mode, gfx_line_style_t line_style);
 
@@ -229,9 +222,8 @@ int gfxop_draw_line(GfxState *state,
  * @param[in] color			The color the box is to be drawn in
  * @param[in] line_mode		The line mode to use
  * @param[in] line_style	The line style to use for the box
- * @return					GFX_OK or GFX_FATAL
  */
-int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color,
+void gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color,
 	gfx_line_mode_t line_mode, gfx_line_style_t line_style);
 
 /**
@@ -244,9 +236,8 @@ int gfxop_draw_rectangle(GfxState *state, rect_t rect, gfx_color_t color,
  * @param[in] color1		The primary color to use for drawing
  * @param[in] color2		The secondary color to draw in
  * @param[in] shade_type	The shading system to use (e.g. GFX_BOX_SHADE_FLAT)
- * @return					GFX_OK or GFX_FATAL
  */
-int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1,
+void gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1,
 	gfx_color_t color2, gfx_box_shade_t shade_type);
 
 /**
@@ -257,18 +248,16 @@ int gfxop_draw_box(GfxState *state, rect_t box, gfx_color_t color1,
  * @param[in] state	The state to draw to
  * @param[in] box	The box to fill
  * @param[in] color	The color to use for filling
- * @return			GFX_OK or GFX_FATAL
  */
-int gfxop_fill_box(GfxState *state, rect_t box, gfx_color_t color);
+void gfxop_fill_box(GfxState *state, rect_t box, gfx_color_t color);
 
 /**
  * Copies a box from the static buffer to the back buffer.
  *
  * @param[in] state	The affected state
  * @param[in] box	The box to propagate from the static buffer
- * @return			GFX_OK or GFX_FATAL
  */
-int gfxop_clear_box(GfxState *state, rect_t box);
+void gfxop_clear_box(GfxState *state, rect_t box);
 
 
 /**
@@ -279,9 +268,8 @@ int gfxop_clear_box(GfxState *state, rect_t box);
  * occasions (see gfxop_new_pic).
  *
  * @param[in] state	The relevant state
- * @return			GFX_OK or GFX_FATAL if reported by the driver
  */
-int gfxop_update(GfxState *state);
+void gfxop_update(GfxState *state);
 
 
 /**
@@ -294,9 +282,8 @@ int gfxop_update(GfxState *state);
  *
  * @param[in] state	The affected state
  * @param[in] box	The box to propagate to the front buffer
- * @return			GFX_OK or GFX_FATAL
  */
-int gfxop_update_box(GfxState *state, rect_t box);
+void gfxop_update_box(GfxState *state, rect_t box);
 
 /**
  * Enables dirty frame accounting.
@@ -304,17 +291,15 @@ int gfxop_update_box(GfxState *state, rect_t box);
  * Dirty frame accounting is enabled by default.
  *
  * @param[in] state	The state dirty frame accounting is to be enabled in
- * @return			GFX_OK or GFX_ERROR if state was invalid
  */
-int gfxop_enable_dirty_frames(GfxState *state);
+void gfxop_enable_dirty_frames(GfxState *state);
 
 /**
  * Disables dirty frame accounting.
  *
  * @param[in] state	The state dirty frame accounting is to be disabled in
- * @return			GFX_OK or GFX_ERROR if state was invalid
  */
-int gfxop_disable_dirty_frames(GfxState *state);
+void gfxop_disable_dirty_frames(GfxState *state);
 /** @} */
 
 
@@ -344,9 +329,8 @@ int gfxop_disable_dirty_frames(GfxState *state);
  * @param[in] priority	The priority to use for drawing, or -1 for none
  * @param[in] control	The control to use for drawing, or -1 to disable drawing
  * 						to the control map
- * @return				GFX_OK or GFX_ERROR if state is invalid
  */
-int gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b,
+void gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b,
 	int a, int priority, int control);
 
 /**
@@ -357,9 +341,8 @@ int gfxop_set_color(GfxState *state, gfx_color_t *color, int r, int g, int b,
  * @param[in] state	The affected state
  * @param[in] index	The index for the new system color
  * @param[in] color	The color to designate as a system color
- * @return			GFX_OK or GFX_ERROR if state is invalid
  */
-int gfxop_set_system_color(GfxState *state, unsigned int index, gfx_color_t *color);
+void gfxop_set_system_color(GfxState *state, unsigned int index, gfx_color_t *color);
 
 /**
  * Frees a color allocated by gfxop_set_color().
@@ -368,9 +351,8 @@ int gfxop_set_system_color(GfxState *state, unsigned int index, gfx_color_t *col
  *
  * @param[in] state	The state affected
  * @param[in] color	The color to de-allocate
- * @return			GFX_OK or GFX_ERROR if state is invalid
  */
-int gfxop_free_color(GfxState *state, gfx_color_t *color);
+void gfxop_free_color(GfxState *state, gfx_color_t *color);
 /** @} */
 
 /** @name Pointer and IO ops */
@@ -383,21 +365,16 @@ int gfxop_free_color(GfxState *state, gfx_color_t *color);
  *
  * @param[in] state	The state affected
  * @param[in] msecs	The amount of milliseconds to wait
- * @return			GFX_OK or GFX_ERROR
  */
-int gfxop_sleep(GfxState *state, uint32 msecs);
+void gfxop_sleep(GfxState *state, uint32 msecs);
 
 /**
  * Sets the mouse pointer to a cursor resource.
  *
  * @param[in] state	The affected state
  * @param[in] nr	Number of the cursor resource to use
- * @return			GFX_OK, GFX_ERROR if the resource did not exist and was not
- * 					GFXOP_NO_POINTER, or GFX_FATAL on fatal error conditions.
- * 					Use nr = GFX_NO_POINTER to disable the mouse pointer
- * 					(default).
  */
-int gfxop_set_pointer_cursor(GfxState *state, int nr);
+void gfxop_set_pointer_cursor(GfxState *state, int nr);
 
 /**
  * Sets the mouse pointer to a view resource.
@@ -409,9 +386,8 @@ int gfxop_set_pointer_cursor(GfxState *state, int nr);
  * @param[in] loop		View loop to use
  * @param[in] cel		View cel to use
  * @param[in] hotspot	Manually set hotspot to use, or NULL for default.
- * @return				GFX_OK or GFX_FATAL
  */
-int gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::Point *hotspot);
+void gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::Point *hotspot);
 
 /**
  * Teleports the mouse pointer to a specific position.
@@ -420,18 +396,16 @@ int gfxop_set_pointer_view(GfxState *state, int nr, int loop, int cel, Common::P
  *
  * @param[in] state	The state the pointer is in
  * @param[in] pos	The position to teleport it to
- * @return			Any error code or GFX_OK
  */
-int gfxop_set_pointer_position(GfxState *state, Common::Point pos);
+void gfxop_set_pointer_position(GfxState *state, Common::Point pos);
 
 /**
  * Limits the mouse movement to a given rectangle.
  *
  * @param[in] state	The affected state
  * @param[in] rect	The rectangle
- * @return			Any error code or GFX_OK
  */
-int gfxop_set_pointer_zone(GfxState *state, Common::Rect rect);
+void gfxop_set_pointer_zone(GfxState *state, Common::Rect rect);
 
 /**
  * Retrieves the next input event from the driver.
@@ -521,9 +495,8 @@ int gfxop_get_cel_parameters(GfxState *state, int nr, int loop, int cel,
  * @param[in] pos		The positino the cel is to be drawn to
  * @param[in] color		The priority and control values to use for drawing
  * @param[in] palette	The palette to use
- * @return				GFX_OK or GFX_FATAL
  */
-int gfxop_draw_cel(GfxState *state, int nr, int loop, int cel,
+void gfxop_draw_cel(GfxState *state, int nr, int loop, int cel,
 	Common::Point pos, gfx_color_t color, int palette);
 
 
@@ -539,9 +512,8 @@ int gfxop_draw_cel(GfxState *state, int nr, int loop, int cel,
  * @param[in] pos		The positino the cel is to be drawn to
  * @param[in] color		The priority and control values to use for drawing
  * @param[in] palette	The palette to use
- * @return				GFX_OK or GFX_FATAL
  */
-int gfxop_draw_cel_static(GfxState *state, int nr, int loop, int cel,
+void gfxop_draw_cel_static(GfxState *state, int nr, int loop, int cel,
 	Common::Point pos, gfx_color_t color, int palette);
 
 
@@ -557,9 +529,8 @@ int gfxop_draw_cel_static(GfxState *state, int nr, int loop, int cel,
  * @param[in] pos		The positino the cel is to be drawn to
  * @param[in] color		The priority and control values to use for drawing
  * @param[in] palette	The palette to use
- * @return				GFX_OK or GFX_FATAL
  */
-int gfxop_draw_cel_static_clipped(GfxState *state, int nr, int loop, int cel,
+void gfxop_draw_cel_static_clipped(GfxState *state, int nr, int loop, int cel,
 	Common::Point pos, gfx_color_t color, int palette);
 /** @} */
 
@@ -578,9 +549,8 @@ int gfxop_draw_cel_static_clipped(GfxState *state, int nr, int loop, int cel,
  * @param[in] nr				Number of the pic to draw
  * @param[in] flags				Interpreter-dependant flags to use for drawing
  * @param[in] default_palette	The default palette for drawing
- * @return						GFX_OK or GFX_FATAL
  */
-int gfxop_new_pic(GfxState *state, int nr, int flags, int default_palette);
+void gfxop_new_pic(GfxState *state, int nr, int flags, int default_palette);
 
 /**
  * Retrieves all meta-information assigned to the current pic.
@@ -599,9 +569,8 @@ int *gfxop_get_pic_metainfo(GfxState *state);
  * @param[in] nr				Number of the pic to add
  * @param[in] flags				Interpreter-dependant flags to use for drawing
  * @param[in] default_palette	The default palette for drawing
- * @return						GFX_OK or GFX_FATAL
  */
-int gfxop_add_to_pic(GfxState *state, int nr, int flags, int default_palette);
+void gfxop_add_to_pic(GfxState *state, int nr, int flags, int default_palette);
 /** @} */
 
 
@@ -670,9 +639,8 @@ TextHandle *gfxop_new_text(GfxState *state, int font_nr,
  *
  * @param[in] state		The state to use
  * @param[in] handle	The handle to free
- * @return				GFX_OK
  */
-int gfxop_free_text(GfxState *state, TextHandle *handle);
+void gfxop_free_text(GfxState *state, TextHandle *handle);
 
 /**
  * Draws text stored in a text handle.
@@ -682,9 +650,8 @@ int gfxop_free_text(GfxState *state, TextHandle *handle);
  * @param[in] zone		The rectangular box to draw to. In combination with
  * 						halign and valign, this defines where the text is drawn
  * 						to.
- * @return				GFX_OK or GFX_FATAL
  */
-int gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone);
+void gfxop_draw_text(GfxState *state, TextHandle *handle, rect_t zone);
 /** @} */
 
 
@@ -709,9 +676,8 @@ gfx_pixmap_t *gfxop_grab_pixmap(GfxState *state, rect_t area);
  * @param[in] pxm	The pixmap to draw
  * @param[in] zone	The segment of the pixmap to draw
  * @param[in] pos	The position the pixmap should be drawn to
- * @return			GFX_OK or any error code
  */
-int gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone,
+void gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone,
 	Common::Point pos);
 
 /**
@@ -719,9 +685,8 @@ int gfxop_draw_pixmap(GfxState *state, gfx_pixmap_t *pxm, rect_t zone,
  *
  * @param[in] state	The affected state
  * @param[in] pxm	The pixmap to free
- * @return			GFX_OK, or GFX_ERROR if the state was invalid
  */
-int gfxop_free_pixmap(GfxState *state, gfx_pixmap_t *pxm);
+void gfxop_free_pixmap(GfxState *state, gfx_pixmap_t *pxm);
 /** @} */