Index: backends/sdl/graphics.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/sdl/graphics.cpp,v
retrieving revision 1.12
diff -u -r1.12 graphics.cpp
--- backends/sdl/graphics.cpp	4 Sep 2004 01:31:02 -0000	1.12
+++ backends/sdl/graphics.cpp	20 Sep 2004 23:53:22 -0000
@@ -41,6 +41,14 @@
 	{0, 0, 0}
 };
 
+// Table of relative scalers magnitudes
+// [definedScale-1][_scaleFactor-1]
+static ScalerProc *scalersMagn[3][3] = {
+	{ Normal1x, Normal2x, Normal3x },
+	{ Normal1x, Normal1x, Normal1o5x },
+	{ Normal1x, Normal1x, Normal1x }
+};
+
 const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
 	return s_supportedGraphicsModes;
 }
@@ -327,9 +335,6 @@
 		_forceFull = true;
 	}
 
-	// Make sure the mouse is drawn, if it should be drawn.
-	draw_mouse();
-	
 	// Check whether the palette was changed in the meantime and update the
 	// screen surface accordingly. 
 	if (_paletteDirtyEnd != 0) {
@@ -362,6 +367,8 @@
 	}
 #endif
 
+	undraw_mouse();
+
 	// Force a full redraw if requested
 	if (_forceFull) {
 		_num_dirty_rects = 1;
@@ -457,8 +464,14 @@
 		}
 #endif
 
+		draw_mouse();
+
 		// Finally, blit all our changes to the screen
 		SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
+	} else {
+		draw_mouse();
+		if (_num_dirty_rects)
+			SDL_UpdateRects(_hwscreen, _num_dirty_rects, _dirty_rect_list);
 	}
 
 	_num_dirty_rects = 0;
@@ -480,8 +493,6 @@
 		assert(_hwscreen != 0);
 		_full_screen ^= true;
 
-		undraw_mouse();
-	
 #if defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)
 		// On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
 		// before SDL 1.2.6 it always returned -1 (which would indicate a
@@ -544,9 +555,6 @@
 		add_dirty_rect(x, y, w, h);
 	}
 
-	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
-	undraw_mouse();
-
 	// Try to lock the screen surface
 	if (SDL_LockSurface(_screen) == -1)
 		error("SDL_LockSurface failed: %s", SDL_GetError());
@@ -568,10 +576,19 @@
 }
 
 
-void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
+void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h, bool mouseRect) {
 	if (_forceFull)
 		return;
 
+	if (mouseRect) {
+		SDL_Rect *r = &_dirty_rect_list[_num_dirty_rects++];
+		r->x = x;
+		r->y = y;
+		r->w = w;
+		r->h = h;
+		return;
+	}
+
 	if (_num_dirty_rects == NUM_DIRTY_RECT)
 		_forceFull = true;
 	else {
@@ -718,6 +735,10 @@
 
 	if (start + num > _paletteDirtyEnd)
 		_paletteDirtyEnd = start + num;
+
+	// Some games blink cursors with palette
+	if (!_overlayVisible)
+		blit_cursor();
 }
 
 void OSystem_SDL::set_shake_pos(int shake_pos) {
@@ -730,17 +751,11 @@
 #pragma mark -
 
 void OSystem_SDL::showOverlay() {
-	// hide the mouse
-	undraw_mouse();
-
 	_overlayVisible = true;
 	clearOverlay();
 }
 
 void OSystem_SDL::hideOverlay() {
-	// hide the mouse
-	undraw_mouse();
-
 	_overlayVisible = false;
 	_forceFull = true;
 }
@@ -751,9 +766,6 @@
 	
 	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
 	
-	// hide the mouse
-	undraw_mouse();
-
 	// Clear the overlay by making the game screen "look through" everywhere.
 	SDL_Rect src, dst;
 	src.x = src.y = 0;
@@ -773,9 +785,6 @@
 	if (_tmpscreen == NULL)
 		return;
 
-	// hide the mouse
-	undraw_mouse();
-
 	if (SDL_LockSurface(_tmpscreen) == -1)
 		error("SDL_LockSurface failed: %s", SDL_GetError());
 
@@ -824,9 +833,6 @@
 	cksum_valid = false;
 	add_dirty_rect(x, y, w, h);
 
-	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
-	undraw_mouse();
-
 	if (SDL_LockSurface(_tmpscreen) == -1)
 		error("SDL_LockSurface failed: %s", SDL_GetError());
 
@@ -860,17 +866,13 @@
 	bool last = _mouseVisible;
 	_mouseVisible = visible;
 
-	if (visible)
-		draw_mouse();
-	else
-		undraw_mouse();
+	updateScreen();
 
 	return last;
 }
 
 void OSystem_SDL::set_mouse_pos(int x, int y) {
 	if (x != _mouseCurState.x || y != _mouseCurState.y) {
-		undraw_mouse();
 		_mouseCurState.x = x;
 		_mouseCurState.y = y;
 		updateScreen();
@@ -892,186 +894,172 @@
 	}
 }
 	
-void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor) {
-
-	undraw_mouse();
-
-	assert(w <= MAX_MOUSE_W);
-	assert(h <= MAX_MOUSE_H);
-	_mouseCurState.w = w;
-	_mouseCurState.h = h;
+void OSystem_SDL::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorScale) {
+	byte *tmpPtr, *dstPtr;
+	const byte *srcPtr = buf;
+	int dstPitch;
 
 	_mouseHotspotX = hotspot_x;
 	_mouseHotspotY = hotspot_y;
 
 	_mouseKeycolor = keycolor;
 
-	if (_mouseData)
-		free(_mouseData);
+	_cursorScale = cursorScale;
 
-	_mouseData = (byte *)malloc(w * h);
-	memcpy(_mouseData, buf, w * h);
-}
+	if (_mouseCurState.w != (int)w * cursorScale || _mouseCurState.h != (int)h * cursorScale) {
+		_mouseCurState.w = w * cursorScale;
+		_mouseCurState.h = h * cursorScale;
+
+		if (_mouseSurface)
+			SDL_FreeSurface(_mouseSurface); 
+
+		_mouseSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_mouseCurState.w,
+						_mouseCurState.h,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
 
-void OSystem_SDL::toggleMouseGrab() {
-	if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
-		SDL_WM_GrabInput(SDL_GRAB_ON);
-	else
-		SDL_WM_GrabInput(SDL_GRAB_OFF);
-}
+		if (_mouseSurface == NULL)
+			error("allocating _mouseSurface failed");
+		SDL_SetColorKey(_mouseSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
+	}
 
-void OSystem_SDL::draw_mouse() {
-	if (_mouseDrawn || !_mouseVisible)
-		return;
+	if (_mouseData)
+		free(_mouseData);
 
-	int x = _mouseCurState.x - _mouseHotspotX;
-	int y = _mouseCurState.y - _mouseHotspotY;
-	int w = _mouseCurState.w;
-	int h = _mouseCurState.h;
-	byte color;
-	const byte *src = _mouseData;		// Image representing the mouse
+	dstPtr = _mouseData = (byte *)malloc(w * h * cursorScale * cursorScale);
 
-	// clip the mouse rect, and addjust the src pointer accordingly
-	if (x < 0) {
-		w += x;
-		src -= x;
-		x = 0;
+	if (cursorScale == 1) {
+		memcpy(_mouseData, buf, w * h);
+		blit_cursor();
+		return;
 	}
-	if (y < 0) {
-		h += y;
-		src -= y * _mouseCurState.w;
-		y = 0;
+
+	dstPitch = w * cursorScale;
+	for (uint i = 0; i < h; i++) {
+		for (uint j = 0; j < w; j++) {
+			for (int k = 0; k < cursorScale; k++) {
+				tmpPtr = dstPtr + dstPitch * k;
+				for (int l = 0; l < cursorScale; l++) {
+					*tmpPtr++ = *srcPtr;
+				}
+			}
+			srcPtr++;
+			dstPtr += cursorScale;
+		}
+		dstPtr += dstPitch * (cursorScale - 1);
 	}
 
-	if (w > _screenWidth - x)
-		w = _screenWidth - x;
-	if (h > _screenHeight - y)
-		h = _screenHeight - y;
+	blit_cursor();
+}
 
-	// Quick check to see if anything has to be drawn at all
-	if (w <= 0 || h <= 0)
+void OSystem_SDL::blit_cursor() {
+	byte *dstPtr;
+	const byte *srcPtr = _mouseData;
+	byte color;
+	int w, h;
+
+	if (!_mouseSurface)
 		return;
 
-	// Draw the mouse cursor; backup the covered area in "bak"
-	if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
+	w = _mouseCurState.w;
+	h = _mouseCurState.h;
 
-	// Mark as dirty
-	add_dirty_rect(x, y, w, h);
+	SDL_LockSurface(_mouseSurface);
+	dstPtr = (byte *)_mouseSurface->pixels;
 
-	if (!_overlayVisible) {
-		byte *bak = _mouseBackup;		// Surface used to backup the area obscured by the mouse
-		byte *dst;					// Surface we are drawing into
-	
-		dst = (byte *)_screen->pixels + y * _screenWidth + x;
-		while (h > 0) {
-			int width = w;
-			while (width > 0) {
-				*bak++ = *dst;
-				color = *src++;
-				if (color != _mouseKeycolor)	// transparent, don't draw
-					*dst = color;
-				dst++;
-				width--;
-			}
-			src += _mouseCurState.w - w;
-			bak += MAX_MOUSE_W - w;
-			dst += _screenWidth - w;
-			h--;
-		}
-	
-	} else {
-		uint16 *bak = (uint16 *)_mouseBackup;	// Surface used to backup the area obscured by the mouse
-		byte *dst;					// Surface we are drawing into
-	
-		dst = (byte *)_tmpscreen->pixels + (y + 1) * _tmpscreen->pitch + (x + 1) * 2;
-		while (h > 0) {
-			int width = w;
-			while (width > 0) {
-				*bak++ = *(uint16 *)dst;
-				color = *src++;
-				if (color != 0xFF)	// 0xFF = transparent, don't draw
-					*(uint16 *)dst = RGBToColor(_currentPalette[color].r, _currentPalette[color].g, _currentPalette[color].b);
-				dst += 2;
-				width--;
+	for (int i = 0; i < h; i++) {
+		for (int j = 0; j < w; j++) {
+			color = *srcPtr;
+			if (color != _mouseKeycolor) {	// transparent, don't draw
+				*(uint16 *)dstPtr = SDL_MapRGB(_mouseSurface->format, _currentPalette[color].r, 
+									 _currentPalette[color].g, _currentPalette[color].b);
+			} else {
+				*(uint16 *)dstPtr = kMouseColorKey;
 			}
-			src += _mouseCurState.w - w;
-			bak += MAX_MOUSE_W - w;
-			dst += _tmpscreen->pitch - w * 2;
-			h--;
+			dstPtr += 2;
+			srcPtr++;
 		}
+		dstPtr += _mouseSurface->pitch - w * 2;
 	}
+	SDL_UnlockSurface(_mouseSurface);
+}
 
-	SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
-
-	// Finally, set the flag to indicate the mouse has been drawn
-	_mouseDrawn = true;
+void OSystem_SDL::toggleMouseGrab() {
+	if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
+		SDL_WM_GrabInput(SDL_GRAB_ON);
+	else
+		SDL_WM_GrabInput(SDL_GRAB_OFF);
 }
 
 void OSystem_SDL::undraw_mouse() {
-	if (!_mouseDrawn)
+	if (_mouseBackup.w) {
+		if (_adjustAspectRatio)
+			add_dirty_rect(_mouseBackup.x, aspect2Real(_mouseBackup.y), _mouseBackup.w, 
+						   _mouseBackup.h);
+		else
+			add_dirty_rect(_mouseBackup.x, _mouseBackup.y, _mouseBackup.w, 
+						   _mouseBackup.h);
+	}
+}
+
+void OSystem_SDL::draw_mouse() {
+	if (!_mouseVisible) {
+		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
 		return;
-	_mouseDrawn = false;
+	}
 
-	if (SDL_LockSurface(_overlayVisible ? _tmpscreen : _screen) == -1)
-		error("SDL_LockSurface failed: %s", SDL_GetError());
+	SDL_Rect src, dst;
 
-	int old_mouse_x = _mouseCurState.x - _mouseHotspotX;
-	int old_mouse_y = _mouseCurState.y - _mouseHotspotY;
-	int old_mouse_w = _mouseCurState.w;
-	int old_mouse_h = _mouseCurState.h;
-
-	// clip the mouse rect, and addjust the src pointer accordingly
-	if (old_mouse_x < 0) {
-		old_mouse_w += old_mouse_x;
-		old_mouse_x = 0;
-	}
-	if (old_mouse_y < 0) {
-		old_mouse_h += old_mouse_y;
-		old_mouse_y = 0;
-	}
-
-	if (old_mouse_w > _screenWidth - old_mouse_x)
-		old_mouse_w = _screenWidth - old_mouse_x;
-	if (old_mouse_h > _screenHeight - old_mouse_y)
-		old_mouse_h = _screenHeight - old_mouse_y;
+	dst.x = _mouseCurState.x - _mouseHotspotX * _cursorScale;
+	dst.y = _mouseCurState.y - _mouseHotspotY * _cursorScale;
+	dst.w = _mouseCurState.w;
+	dst.h = _mouseCurState.h;
+	src.x = src.y = 0;
+
+	// clip the mouse rect, and adjust the src pointer accordingly
+	if (dst.x < 0) {
+		dst.w += dst.x;
+		src.x -= dst.x;
+		dst.x = 0;
+	}
+	if (dst.y < 0) {
+		dst.h += dst.y;
+		src.y -= dst.y;
+		dst.y = 0;
+	}
+
+	if (dst.w > _screenWidth - dst.x)
+		dst.w = _screenWidth - dst.x;
+	if (dst.h > _screenHeight - dst.y)
+		dst.h = _screenHeight - dst.y;
 
 	// Quick check to see if anything has to be drawn at all
-	if (old_mouse_w <= 0 || old_mouse_h <= 0)
+	if (dst.w <= 0 || dst.h <= 0)
 		return;
 
+	src.w = dst.w;
+	src.h = dst.h;
 
-	int x, y;
-	if (!_overlayVisible) {
-		byte *dst, *bak = _mouseBackup;
-
-		// No need to do clipping here, since draw_mouse() did that already
-		dst = (byte *)_screen->pixels + old_mouse_y * _screenWidth + old_mouse_x;
-		for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _screenWidth) {
-			for (x = 0; x < old_mouse_w; ++x) {
-				dst[x] = bak[x];
-			}
-		}
-	
-	} else {
+	if (_adjustAspectRatio)
+		dst.y = real2Aspect(dst.y);
 
-		byte *dst;
-		uint16 *bak = (uint16 *)_mouseBackup;
-	
-		// No need to do clipping here, since draw_mouse() did that already
-		dst = (byte *)_tmpscreen->pixels + (old_mouse_y + 1) * _tmpscreen->pitch + (old_mouse_x + 1) * 2;
-		for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += _tmpscreen->pitch) {
-			for (x = 0; x < old_mouse_w; ++x) {
-				*((uint16 *)dst + x) = bak[x];
-			}
-		}
-	}
+	_mouseBackup.x = dst.x;
+	_mouseBackup.y = dst.y;
+	_mouseBackup.w = dst.w;
+	_mouseBackup.h = dst.h;
 
-	add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
+	dst.x *= _scaleFactor;
+	dst.y *= _scaleFactor;
 
-	SDL_UnlockSurface(_overlayVisible ? _tmpscreen : _screen);
-}
+	if (SDL_BlitSurface(_mouseSurface, &src, _hwscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
 
+	add_dirty_rect(dst.x, dst.y, dst.w, dst.h, true);
+}
 
 #pragma mark -
 #pragma mark --- Mouse ---
Index: backends/sdl/sdl-common.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl-common.h,v
retrieving revision 1.63
diff -u -r1.63 sdl-common.h
--- backends/sdl/sdl-common.h	4 Sep 2004 01:31:03 -0000	1.63
+++ backends/sdl/sdl-common.h	20 Sep 2004 23:53:22 -0000
@@ -64,7 +64,7 @@
 	void warpMouse(int x, int y);
 
 	// Set the bitmap that's used when drawing the cursor.
-	void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor);
+	void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, byte keycolor, int cursorScale);
 
 	// Shaking is used in SCUMM. Set current shake position.
 	void set_shake_pos(int shake_pos);
@@ -221,11 +221,16 @@
 	bool _mouseVisible;
 	bool _mouseDrawn;
 	byte *_mouseData;
-	byte *_mouseBackup;
+	SDL_Rect _mouseBackup;
 	MousePos _mouseCurState;
 	int16 _mouseHotspotX;
 	int16 _mouseHotspotY;
 	byte _mouseKeycolor;
+	int _cursorScale;
+	SDL_Surface *_mouseSurface;
+	enum {
+		kMouseColorKey = 1
+	};
 
 	// joystick
 	SDL_Joystick *_joystick;
@@ -248,10 +253,11 @@
 	void add_dirty_rgn_auto(const byte *buf);
 	void mk_checksums(const byte *buf);
 
-	virtual void add_dirty_rect(int x, int y, int w, int h);
+	virtual void add_dirty_rect(int x, int y, int w, int h, bool mouseRect = false);
 
 	void draw_mouse();
 	void undraw_mouse();
+	void blit_cursor();
 	/** Set the position of the virtual mouse cursor. */
 	void set_mouse_pos(int x, int y);
 	void fillMouseEvent(Event &event, int x, int y);
Index: backends/sdl/sdl.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl.cpp,v
retrieving revision 1.72
diff -u -r1.72 sdl.cpp
--- backends/sdl/sdl.cpp	16 Jul 2004 10:24:29 -0000	1.72
+++ backends/sdl/sdl.cpp	20 Sep 2004 23:53:28 -0000
@@ -97,7 +97,7 @@
 	_tmpscreen(0), _overlayVisible(false),
 	_samplesPerSec(0),
 	_cdrom(0), _scaler_proc(0), _modeChanged(false), _dirty_checksums(0),
-	_mouseVisible(false), _mouseDrawn(false), _mouseData(0),
+	_mouseVisible(false), _mouseDrawn(false), _mouseData(0), _mouseSurface(0),
 	_mouseHotspotX(0), _mouseHotspotY(0),
 	_currentShakePos(0), _newShakePos(0),
 	_paletteDirtyStart(0), _paletteDirtyEnd(0),
@@ -106,8 +106,7 @@
 	// allocate palette storage
 	_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
 
-	// allocate the dirty rect storage
-	_mouseBackup = (byte *)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING * 2);
+	_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
 
 	// reset mouse state
 	memset(&km, 0, sizeof(km));
@@ -121,7 +120,6 @@
 	if (_dirty_checksums)
 		free(_dirty_checksums);
 	free(_currentPalette);
-	free(_mouseBackup);
 	deleteMutex(_graphicsMutex);
 
 	SDL_ShowCursor(SDL_ENABLE);
Index: common/scaler.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/common/scaler.cpp,v
retrieving revision 1.63
diff -u -r1.63 scaler.cpp
--- common/scaler.cpp	10 Aug 2004 17:46:04 -0000	1.63
+++ common/scaler.cpp	20 Sep 2004 23:53:28 -0000
@@ -169,6 +169,46 @@
 	}
 }
 
+#define INTERPOLATE		INTERPOLATE<bitFormat>
+#define Q_INTERPOLATE	Q_INTERPOLATE<bitFormat>
+
+/**
+ * Trivial nearest-neighbour 1.5x scaler.
+ */
+template<int bitFormat>
+void Normal1o5xTemplate(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch,
+							int width, int height) {
+	uint8 *r;
+	const uint32 dstPitch2 = dstPitch * 2;
+	const uint32 dstPitch3 = dstPitch * 3;
+	const uint32 srcPitch2 = srcPitch * 2;
+
+	assert(((int)dstPtr & 1) == 0);
+	while (height) {
+		r = dstPtr;
+		for (int i = 0; i < width; i += 2, r += 6) {
+			uint16 color0 = *(((const uint16 *)srcPtr) + i);
+			uint16 color1 = *(((const uint16 *)srcPtr) + i + 1);
+			uint16 color2 = *(((const uint16 *)(srcPtr + srcPitch)) + i);
+			uint16 color3 = *(((const uint16 *)(srcPtr + srcPitch)) + i + 1);
+
+			*(uint16 *)(r + 0) = color0;
+			*(uint16 *)(r + 2) = INTERPOLATE(color0, color1);
+			*(uint16 *)(r + 4) = color1;
+			*(uint16 *)(r + 0 + dstPitch) = INTERPOLATE(color0, color2);
+			*(uint16 *)(r + 2 + dstPitch) = Q_INTERPOLATE(color0, color1, color2, color3);
+			*(uint16 *)(r + 4 + dstPitch) = INTERPOLATE(color1, color3);
+			*(uint16 *)(r + 0 + dstPitch2) = color2;
+			*(uint16 *)(r + 2 + dstPitch2) = INTERPOLATE(color2, color3);
+			*(uint16 *)(r + 4 + dstPitch2) = color3;
+		}
+		srcPtr += srcPitch2;
+		dstPtr += dstPitch3;
+		height -= 2;
+	}
+}
+MAKE_WRAPPER(Normal1o5x)
+
 /**
  * The Scale2x filter, also known as AdvMame2x.
  * See also http://scale2x.sourceforge.net
Index: common/scaler.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/common/scaler.h,v
retrieving revision 1.26
diff -u -r1.26 scaler.h
--- common/scaler.h	21 May 2004 20:43:07 -0000	1.26
+++ common/scaler.h	20 Sep 2004 23:53:28 -0000
@@ -41,6 +41,7 @@
 DECLARE_SCALER(Normal1x);
 DECLARE_SCALER(Normal2x);
 DECLARE_SCALER(Normal3x);
+DECLARE_SCALER(Normal1o5x);
 DECLARE_SCALER(TV2x);
 DECLARE_SCALER(DotMatrix);
 DECLARE_SCALER(HQ2x);
Index: common/system.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/common/system.h,v
retrieving revision 1.69
diff -u -r1.69 system.h
--- common/system.h	4 Sep 2004 01:31:03 -0000	1.69
+++ common/system.h	20 Sep 2004 23:53:28 -0000
@@ -345,7 +345,7 @@
 	 * @param hotspotY	vertical offset from the top side to the hotspot
 	 * @param keycolor	transparency color index
 	 */
-	virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255) = 0;
+	virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, byte keycolor = 255, int cursorScale = 1) = 0;
 
 	//@}
 
