X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsystem.c;h=c3d9575489c60fb74c5bb67c6fd8a926b2341268;hb=ade0034b74cb1213bfe0a73213f459081e10b85a;hp=ed73cb5bf3c5129092af6f764c38cd8f725ddd23;hpb=9583e9c55b889974e0df9a8ca1930efdf29bda29;p=rocksndiamonds.git

diff --git a/src/libgame/system.c b/src/libgame/system.c
index ed73cb5b..c3d95754 100644
--- a/src/libgame/system.c
+++ b/src/libgame/system.c
@@ -1,7 +1,7 @@
 /***********************************************************
 * Artsoft Retro-Game Library                               *
 *----------------------------------------------------------*
-* (c) 1994-2002 Artsoft Entertainment                      *
+* (c) 1994-2006 Artsoft Entertainment                      *
 *               Holger Schemel                             *
 *               Detmolder Strasse 189                      *
 *               33604 Bielefeld                            *
@@ -41,6 +41,7 @@ struct ArtworkInfo	artwork;
 struct JoystickInfo	joystick;
 struct SetupInfo	setup;
 
+LevelDirTree	       *leveldir_first_all = NULL;
 LevelDirTree	       *leveldir_first = NULL;
 LevelDirTree	       *leveldir_current = NULL;
 int			level_nr;
@@ -68,22 +69,27 @@ int			FrameCounter = 0;
 /* ========================================================================= */
 
 void InitProgramInfo(char *argv0,
-		     char *userdata_directory, char *program_title,
-		     char *window_title, char *icon_title,
+		     char *userdata_subdir, char *userdata_subdir_unix,
+		     char *program_title, char *window_title, char *icon_title,
 		     char *x11_icon_filename, char *x11_iconmask_filename,
-		     char *msdos_cursor_filename,
+		     char *sdl_icon_filename, char *msdos_cursor_filename,
 		     char *cookie_prefix, char *filename_prefix,
 		     int program_version)
 {
-  program.command_basename =
-    (strrchr(argv0, '/') ? strrchr(argv0, '/') + 1 : argv0);
+  program.command_basepath = getBasePath(argv0);
+  program.command_basename = getBaseName(argv0);
+
+  program.userdata_subdir = userdata_subdir;
+  program.userdata_subdir_unix = userdata_subdir_unix;
+  program.userdata_path = getUserGameDataDir();
 
-  program.userdata_directory = userdata_directory;
   program.program_title = program_title;
   program.window_title = window_title;
   program.icon_title = icon_title;
+
   program.x11_icon_filename = x11_icon_filename;
   program.x11_iconmask_filename = x11_iconmask_filename;
+  program.sdl_icon_filename = sdl_icon_filename;
   program.msdos_cursor_filename = msdos_cursor_filename;
 
   program.cookie_prefix = cookie_prefix;
@@ -92,6 +98,9 @@ void InitProgramInfo(char *argv0,
   program.version_major = VERSION_MAJOR(program_version);
   program.version_minor = VERSION_MINOR(program_version);
   program.version_patch = VERSION_PATCH(program_version);
+
+  program.error_filename = getErrorFilename(ERROR_BASENAME);
+  program.error_file = stderr;
 }
 
 void InitExitFunction(void (*exit_function)(int))
@@ -112,7 +121,14 @@ void InitPlatformDependentStuff(void)
 {
 #if defined(PLATFORM_MSDOS)
   _fmode = O_BINARY;
-  initErrorFile();
+#endif
+
+#if defined(PLATFORM_MACOSX)
+  updateUserGameDataDir();
+#endif
+
+#if !defined(PLATFORM_UNIX) || defined(PLATFORM_MACOSX)
+  openErrorFile();
 #endif
 
 #if defined(TARGET_SDL)
@@ -125,6 +141,10 @@ void InitPlatformDependentStuff(void)
 
 void ClosePlatformDependentStuff(void)
 {
+#if defined(PLATFORM_WIN32) || defined(PLATFORM_MSDOS)
+  closeErrorFile();
+#endif
+
 #if defined(PLATFORM_MSDOS)
   dumpErrorFile();
 #endif
@@ -169,13 +189,34 @@ void InitGfxDoor2Info(int vx, int vy, int vxsize, int vysize)
   gfx.vysize = vysize;
 }
 
+void InitGfxWindowInfo(int win_xsize, int win_ysize)
+{
+  gfx.win_xsize = win_xsize;
+  gfx.win_ysize = win_ysize;
+}
+
 void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height)
 {
   /* currently only used by MSDOS code to alloc VRAM buffer, if available */
+  /* 2009-03-24: also (temporarily?) used for overlapping blit workaround */
   gfx.scrollbuffer_width = scrollbuffer_width;
   gfx.scrollbuffer_height = scrollbuffer_height;
 }
 
+void InitGfxDrawBusyAnimFunction(void (*draw_busy_anim_function)(void))
+{
+  gfx.draw_busy_anim_function = draw_busy_anim_function;
+}
+
+void InitGfxCustomArtworkInfo()
+{
+  gfx.override_level_graphics = FALSE;
+  gfx.override_level_sounds = FALSE;
+  gfx.override_level_music = FALSE;
+
+  gfx.draw_init_text = TRUE;
+}
+
 void SetDrawDeactivationMask(int draw_deactivation_mask)
 {
   gfx.draw_deactivation_mask = draw_deactivation_mask;
@@ -213,27 +254,7 @@ static void DrawBitmapFromTile(Bitmap *bitmap, Bitmap *tile,
 
 void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
 {
-  static Bitmap *main_bitmap_tile = NULL;
-  static Bitmap *door_bitmap_tile = NULL;
-
-  if (mask == REDRAW_FIELD)
-  {
-    if (background_bitmap_tile == main_bitmap_tile)
-      return;		/* main background tile has not changed */
-
-    main_bitmap_tile = background_bitmap_tile;
-  }
-  else if (mask == REDRAW_DOOR_1)
-  {
-    if (background_bitmap_tile == door_bitmap_tile)
-      return;	/* main background tile has not changed */
-
-    door_bitmap_tile = background_bitmap_tile;
-  }
-  else		/* should not happen */
-    return;
-
-  if (background_bitmap_tile)
+  if (background_bitmap_tile != NULL)
     gfx.background_bitmap_mask |= mask;
   else
     gfx.background_bitmap_mask &= ~mask;
@@ -245,23 +266,42 @@ void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
   if (background_bitmap_tile == NULL)	/* empty background requested */
     return;
 
-  if (mask == REDRAW_FIELD)
+  if (mask == REDRAW_ALL)
+    DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
+		       0, 0, video.width, video.height);
+  else if (mask == REDRAW_FIELD)
     DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
 		       gfx.real_sx, gfx.real_sy,
 		       gfx.full_sxsize, gfx.full_sysize);
-  else
+  else if (mask == REDRAW_DOOR_1)
+  {
     DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
 		       gfx.dx, gfx.dy,
 		       gfx.dxsize, gfx.dysize);
+  }
+}
+
+void SetWindowBackgroundBitmap(Bitmap *background_bitmap_tile)
+{
+  /* remove every mask before setting mask for window */
+  /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
+  SetBackgroundBitmap(NULL, 0xffff);		/* !!! FIX THIS !!! */
+  SetBackgroundBitmap(background_bitmap_tile, REDRAW_ALL);
 }
 
 void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
 {
+  /* remove window area mask before setting mask for main area */
+  /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
+  SetBackgroundBitmap(NULL, REDRAW_ALL);	/* !!! FIX THIS !!! */
   SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
 }
 
 void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
 {
+  /* remove window area mask before setting mask for door area */
+  /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
+  SetBackgroundBitmap(NULL, REDRAW_ALL);	/* !!! FIX THIS !!! */
   SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
 }
 
@@ -298,7 +338,7 @@ inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 #endif
 }
 
-inline void InitVideoDisplay(void)
+void InitVideoDisplay(void)
 {
 #if defined(TARGET_SDL)
   SDLInitVideoDisplay();
@@ -307,7 +347,7 @@ inline void InitVideoDisplay(void)
 #endif
 }
 
-inline void CloseVideoDisplay(void)
+void CloseVideoDisplay(void)
 {
   KeyboardAutoRepeatOn();
 
@@ -319,24 +359,27 @@ inline void CloseVideoDisplay(void)
 #endif
 }
 
-inline void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
-			    int width, int height, int depth,
-			    boolean fullscreen)
+void InitVideoBuffer(int width, int height, int depth, boolean fullscreen)
 {
   video.width = width;
   video.height = height;
   video.depth = GetRealDepth(depth);
+
   video.fullscreen_available = FULLSCREEN_STATUS;
   video.fullscreen_enabled = FALSE;
+  video.fullscreen_modes = NULL;
+  video.fullscreen_mode_current = NULL;
 
 #if defined(TARGET_SDL)
-  SDLInitVideoBuffer(backbuffer, window, fullscreen);
+  SDLInitVideoBuffer(&backbuffer, &window, fullscreen);
 #else
-  X11InitVideoBuffer(backbuffer, window);
+  X11InitVideoBuffer(&backbuffer, &window);
 #endif
+
+  drawto = backbuffer;
 }
 
-inline Bitmap *CreateBitmapStruct(void)
+Bitmap *CreateBitmapStruct(void)
 {
 #if defined(TARGET_SDL)
   return checked_calloc(sizeof(struct SDLSurfaceInfo));
@@ -345,19 +388,21 @@ inline Bitmap *CreateBitmapStruct(void)
 #endif
 }
 
-inline Bitmap *CreateBitmap(int width, int height, int depth)
+Bitmap *CreateBitmap(int width, int height, int depth)
 {
   Bitmap *new_bitmap = CreateBitmapStruct();
-  int real_depth = GetRealDepth(depth);
+  int real_width  = MAX(1, width);	/* prevent zero bitmap width */
+  int real_height = MAX(1, height);	/* prevent zero bitmap height */
+  int real_depth  = GetRealDepth(depth);
 
 #if defined(TARGET_SDL)
-  SDLCreateBitmapContent(new_bitmap, width, height, real_depth);
+  SDLCreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
 #else
-  X11CreateBitmapContent(new_bitmap, width, height, real_depth);
+  X11CreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
 #endif
 
-  new_bitmap->width = width;
-  new_bitmap->height = height;
+  new_bitmap->width  = real_width;
+  new_bitmap->height = real_height;
 
   return new_bitmap;
 }
@@ -388,7 +433,7 @@ inline static void TransferBitmapPointers(Bitmap *src_bitmap,
   *dst_bitmap = *src_bitmap;
 }
 
-inline void FreeBitmap(Bitmap *bitmap)
+void FreeBitmap(Bitmap *bitmap)
 {
   if (bitmap == NULL)
     return;
@@ -398,7 +443,7 @@ inline void FreeBitmap(Bitmap *bitmap)
   free(bitmap);
 }
 
-inline void CloseWindow(DrawWindow *window)
+void CloseWindow(DrawWindow *window)
 {
 #if defined(TARGET_X11)
   if (window->drawable)
@@ -411,7 +456,7 @@ inline void CloseWindow(DrawWindow *window)
 #endif
 }
 
-static inline boolean CheckDrawingArea(int x, int y, int width, int height,
+inline static boolean CheckDrawingArea(int x, int y, int width, int height,
 				       int draw_mask)
 {
   if (draw_mask == REDRAW_NONE)
@@ -420,42 +465,105 @@ static inline boolean CheckDrawingArea(int x, int y, int width, int height,
   if (draw_mask & REDRAW_ALL)
     return TRUE;
 
-  if ((draw_mask & REDRAW_FIELD) && x < gfx.real_sx + gfx.full_sxsize)
+  if ((draw_mask & REDRAW_FIELD) &&
+      x >= gfx.real_sx && x < gfx.real_sx + gfx.full_sxsize)
     return TRUE;
 
-  if ((draw_mask & REDRAW_DOOR_1) && x >= gfx.dx && y < gfx.dy + gfx.dysize)
+  if ((draw_mask & REDRAW_DOOR_1) &&
+      x >= gfx.dx && y < gfx.dy + gfx.dysize)
     return TRUE;
 
-  if ((draw_mask & REDRAW_DOOR_2) && x >= gfx.dx && y >= gfx.vy)
+  if ((draw_mask & REDRAW_DOOR_2) &&
+      x >= gfx.dx && y >= gfx.vy)
     return TRUE;
 
   return FALSE;
 }
 
-inline boolean DrawingDeactivated(int x, int y, int width, int height)
+boolean DrawingDeactivated(int x, int y, int width, int height)
 {
   return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
 }
 
-inline boolean DrawingOnBackground(int x, int y)
+boolean DrawingOnBackground(int x, int y)
 {
-  return ((gfx.draw_background_mask & gfx.background_bitmap_mask) &&
+  return (CheckDrawingArea(x, y, 1, 1, gfx.background_bitmap_mask) &&
 	  CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
 }
 
-inline void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
-		       int src_x, int src_y, int width, int height,
-		       int dst_x, int dst_y)
+void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+		int src_x, int src_y, int width, int height,
+		int dst_x, int dst_y)
 {
   if (DrawingDeactivated(dst_x, dst_y, width, height))
     return;
 
-  sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
-	      dst_x, dst_y, BLIT_OPAQUE);
+#if 0
+  /* !!! 2009-03-24: It seems that this problem still exists with 1.2.12 !!! */
+#if defined(TARGET_SDL) && defined(PLATFORM_WIN32)
+  if (src_bitmap == dst_bitmap)
+  {
+    /* !!! THIS IS A BUG (IN THE SDL LIBRARY?) AND SHOULD BE FIXED !!! */
+
+    /* needed when blitting directly to same bitmap -- should not be needed with
+       recent SDL libraries, but apparently does not work in 1.2.11 directly */
+
+    static Bitmap *tmp_bitmap = NULL;
+    static int tmp_bitmap_xsize = 0;
+    static int tmp_bitmap_ysize = 0;
+
+    /* start with largest static bitmaps for initial bitmap size ... */
+    if (tmp_bitmap_xsize == 0 && tmp_bitmap_ysize == 0)
+    {
+      tmp_bitmap_xsize = MAX(gfx.win_xsize, gfx.scrollbuffer_width);
+      tmp_bitmap_ysize = MAX(gfx.win_ysize, gfx.scrollbuffer_height);
+    }
+
+    /* ... and allow for later re-adjustments due to custom artwork bitmaps */
+    if (src_bitmap->width > tmp_bitmap_xsize ||
+	src_bitmap->height > tmp_bitmap_ysize)
+    {
+      tmp_bitmap_xsize = MAX(tmp_bitmap_xsize, src_bitmap->width);
+      tmp_bitmap_ysize = MAX(tmp_bitmap_ysize, src_bitmap->height);
+
+      FreeBitmap(tmp_bitmap);
+
+      tmp_bitmap = NULL;
+    }
+
+    if (tmp_bitmap == NULL)
+      tmp_bitmap = CreateBitmap(tmp_bitmap_xsize, tmp_bitmap_ysize,
+				DEFAULT_DEPTH);
+
+    sysCopyArea(src_bitmap, tmp_bitmap,
+		src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
+    sysCopyArea(tmp_bitmap, dst_bitmap,
+		dst_x, dst_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
+
+    return;
+  }
+#endif
+#endif
+
+  sysCopyArea(src_bitmap, dst_bitmap,
+	      src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
 }
 
-inline void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
-			  Pixel color)
+void FadeRectangle(Bitmap *bitmap_cross, int x, int y, int width, int height,
+		   int fade_mode, int fade_delay, int post_delay,
+		   void (*draw_border_function)(void))
+{
+#if defined(TARGET_SDL)
+  SDLFadeRectangle(bitmap_cross, x, y, width, height,
+		   fade_mode, fade_delay, post_delay, draw_border_function);
+#else
+  X11FadeRectangle(bitmap_cross, x, y, width, height,
+		   fade_mode, fade_delay, post_delay, draw_border_function);
+#endif
+}
+
+void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
+		   Pixel color)
 {
   if (DrawingDeactivated(x, y, width, height))
     return;
@@ -463,13 +571,13 @@ inline void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
   sysFillRectangle(bitmap, x, y, width, height, color);
 }
 
-inline void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
+void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
 {
   FillRectangle(bitmap, x, y, width, height, BLACK_PIXEL);
 }
 
-inline void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
-				       int width, int height)
+void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
+				int width, int height)
 {
   if (DrawingOnBackground(x, y))
     BlitBitmap(gfx.background_bitmap, bitmap, x, y, width, height, x, y);
@@ -477,13 +585,7 @@ inline void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
     ClearRectangle(bitmap, x, y, width, height);
 }
 
-#if 0
-#ifndef TARGET_SDL
-static GC last_clip_gc = 0;	/* needed for XCopyArea() through clip mask */
-#endif
-#endif
-
-inline void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
+void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
 {
 #if defined(TARGET_X11)
   if (clip_gc)
@@ -491,13 +593,10 @@ inline void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
     bitmap->clip_gc = clip_gc;
     XSetClipMask(display, bitmap->clip_gc, clip_pixmap);
   }
-#if 0
-  last_clip_gc = clip_gc;
-#endif
 #endif
 }
 
-inline void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
+void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
 {
 #if defined(TARGET_X11)
   if (clip_gc)
@@ -505,16 +604,12 @@ inline void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
     bitmap->clip_gc = clip_gc;
     XSetClipOrigin(display, bitmap->clip_gc, clip_x, clip_y);
   }
-#if 0
-  last_clip_gc = clip_gc;
-#endif
 #endif
 }
 
-inline void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
-			     int src_x, int src_y,
-			     int width, int height,
-			     int dst_x, int dst_y)
+void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+		      int src_x, int src_y, int width, int height,
+		      int dst_x, int dst_y)
 {
   if (DrawingDeactivated(dst_x, dst_y, width, height))
     return;
@@ -523,10 +618,9 @@ inline void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 	      dst_x, dst_y, BLIT_MASKED);
 }
 
-inline void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
-				   int src_x, int src_y,
-				   int width, int height,
-				   int dst_x, int dst_y)
+void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+			    int src_x, int src_y, int width, int height,
+			    int dst_x, int dst_y)
 {
   if (DrawingOnBackground(dst_x, dst_y))
   {
@@ -545,8 +639,18 @@ inline void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 	       dst_x, dst_y);
 }
 
-inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
-				int to_x, int to_y)
+void DrawSimpleBlackLine(Bitmap *bitmap, int from_x, int from_y,
+			 int to_x, int to_y)
+{
+#if defined(TARGET_SDL)
+  SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, BLACK_PIXEL);
+#else
+  X11DrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, BLACK_PIXEL);
+#endif
+}
+
+void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
+			 int to_x, int to_y)
 {
 #if defined(TARGET_SDL)
   SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL);
@@ -556,8 +660,8 @@ inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
 }
 
 #if !defined(TARGET_X11_NATIVE)
-inline void DrawLine(Bitmap *bitmap, int from_x, int from_y,
-		     int to_x, int to_y, Pixel pixel, int line_width)
+void DrawLine(Bitmap *bitmap, int from_x, int from_y,
+	      int to_x, int to_y, Pixel pixel, int line_width)
 {
   int x, y;
 
@@ -586,8 +690,7 @@ inline void DrawLine(Bitmap *bitmap, int from_x, int from_y,
 }
 #endif
 
-inline void DrawLines(Bitmap *bitmap, struct XY *points, int num_points,
-		      Pixel pixel)
+void DrawLines(Bitmap *bitmap, struct XY *points, int num_points, Pixel pixel)
 {
 #if !defined(TARGET_X11_NATIVE)
   int line_width = 4;
@@ -607,7 +710,7 @@ inline void DrawLines(Bitmap *bitmap, struct XY *points, int num_points,
 #endif
 }
 
-inline Pixel GetPixel(Bitmap *bitmap, int x, int y)
+Pixel GetPixel(Bitmap *bitmap, int x, int y)
 {
   if (x < 0 || x >= bitmap->width ||
       y < 0 || y >= bitmap->height)
@@ -622,8 +725,8 @@ inline Pixel GetPixel(Bitmap *bitmap, int x, int y)
 #endif
 }
 
-inline Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
-			     unsigned int color_g, unsigned int color_b)
+Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
+		      unsigned int color_g, unsigned int color_b)
 {
 #if defined(TARGET_SDL)
   return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
@@ -634,7 +737,7 @@ inline Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
 #endif
 }
 
-inline Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
+Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
 {
   unsigned int color_r = (color >> 16) & 0xff;
   unsigned int color_g = (color >>  8) & 0xff;
@@ -644,7 +747,7 @@ inline Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
 }
 
 /* execute all pending screen drawing operations */
-inline void FlushDisplay(void)
+void FlushDisplay(void)
 {
 #ifndef TARGET_SDL
   XFlush(display);
@@ -652,14 +755,14 @@ inline void FlushDisplay(void)
 }
 
 /* execute and wait for all pending screen drawing operations */
-inline void SyncDisplay(void)
+void SyncDisplay(void)
 {
 #ifndef TARGET_SDL
   XSync(display, FALSE);
 #endif
 }
 
-inline void KeyboardAutoRepeatOn(void)
+void KeyboardAutoRepeatOn(void)
 {
 #if defined(TARGET_SDL)
   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY / 2,
@@ -671,7 +774,7 @@ inline void KeyboardAutoRepeatOn(void)
 #endif
 }
 
-inline void KeyboardAutoRepeatOff(void)
+void KeyboardAutoRepeatOff(void)
 {
 #if defined(TARGET_SDL)
   SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
@@ -682,7 +785,7 @@ inline void KeyboardAutoRepeatOff(void)
 #endif
 }
 
-inline boolean PointerInWindow(DrawWindow *window)
+boolean PointerInWindow(DrawWindow *window)
 {
 #if defined(TARGET_SDL)
   return TRUE;
@@ -699,7 +802,7 @@ inline boolean PointerInWindow(DrawWindow *window)
 #endif
 }
 
-inline boolean SetVideoMode(boolean fullscreen)
+boolean SetVideoMode(boolean fullscreen)
 {
 #if defined(TARGET_SDL)
   return SDLSetVideoMode(&backbuffer, fullscreen);
@@ -720,7 +823,7 @@ inline boolean SetVideoMode(boolean fullscreen)
 #endif
 }
 
-inline boolean ChangeVideoModeIfNeeded(boolean fullscreen)
+boolean ChangeVideoModeIfNeeded(boolean fullscreen)
 {
 #if defined(TARGET_SDL)
   if ((fullscreen && !video.fullscreen_enabled && video.fullscreen_available)||
@@ -772,7 +875,7 @@ void ReloadCustomImage(Bitmap *bitmap, char *basename)
     return;
   }
 
-  if (strcmp(filename, bitmap->source_filename) == 0)
+  if (strEqual(filename, bitmap->source_filename))
   {
     /* The old and new image are the same (have the same filename and path).
        This usually means that this image does not exist in this graphic set
@@ -813,19 +916,28 @@ Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
   return dst_bitmap;
 }
 
-void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
+static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
+				boolean create_small_bitmaps)
 {
   Bitmap swap_bitmap;
-  Bitmap *new_bitmap, *tmp_bitmap_1, *tmp_bitmap_2, *tmp_bitmap_8;
-  int width_1, height_1, width_2, height_2, width_8, height_8;
+  Bitmap *new_bitmap;
+  Bitmap *tmp_bitmap_1;
+  Bitmap *tmp_bitmap_2;
+  Bitmap *tmp_bitmap_4;
+  Bitmap *tmp_bitmap_8;
+  Bitmap *tmp_bitmap_16;
+  Bitmap *tmp_bitmap_32;
+  int width_1, height_1;
+  int width_2, height_2;
+  int width_4, height_4;
+  int width_8, height_8;
+  int width_16, height_16;
+  int width_32, height_32;
   int new_width, new_height;
 
+  /* calculate new image dimensions for normal sized image */
   width_1  = old_bitmap->width  * zoom_factor;
   height_1 = old_bitmap->height * zoom_factor;
-  width_2  = width_1  / 2;
-  height_2 = height_1 / 2;
-  width_8  = width_1  / 8;
-  height_8 = height_1 / 8;
 
   /* get image with normal size (this might require scaling up) */
   if (zoom_factor != 1)
@@ -833,18 +945,71 @@ void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
   else
     tmp_bitmap_1 = old_bitmap;
 
-  /* get image with 1/2 of normal size (for use in the level editor) */
-  if (zoom_factor != 2)
-    tmp_bitmap_2 = ZoomBitmap(tmp_bitmap_1, width_1 / 2, height_1 / 2);
-  else
-    tmp_bitmap_2 = old_bitmap;
+  /* this is only needed to make compilers happy */
+  tmp_bitmap_2 = NULL;
+  tmp_bitmap_4 = NULL;
+  tmp_bitmap_8 = NULL;
+  tmp_bitmap_16 = NULL;
+  tmp_bitmap_32 = NULL;
 
-  /* get image with 1/8 of normal size (for use on the preview screen) */
-  if (zoom_factor != 8)
-    tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_1, width_1 / 8, height_1 / 8);
-  else
-    tmp_bitmap_8 = old_bitmap;
+  if (create_small_bitmaps)
+  {
+    /* calculate new image dimensions for small images */
+    width_2  = width_1  / 2;
+    height_2 = height_1 / 2;
+    width_4  = width_1  / 4;
+    height_4 = height_1 / 4;
+    width_8  = width_1  / 8;
+    height_8 = height_1 / 8;
+    width_16  = width_1  / 16;
+    height_16 = height_1 / 16;
+    width_32  = width_1  / 32;
+    height_32 = height_1 / 32;
+
+    UPDATE_BUSY_STATE();
+
+    /* get image with 1/2 of normal size (for use in the level editor) */
+    if (zoom_factor != 2)
+      tmp_bitmap_2 = ZoomBitmap(tmp_bitmap_1, width_1 / 2, height_1 / 2);
+    else
+      tmp_bitmap_2 = old_bitmap;
+
+    UPDATE_BUSY_STATE();
+
+    /* get image with 1/4 of normal size (for use in the level editor) */
+    if (zoom_factor != 4)
+      tmp_bitmap_4 = ZoomBitmap(tmp_bitmap_2, width_2 / 2, height_2 / 2);
+    else
+      tmp_bitmap_4 = old_bitmap;
+
+    UPDATE_BUSY_STATE();
+
+    /* get image with 1/8 of normal size (for use on the preview screen) */
+    if (zoom_factor != 8)
+      tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_4, width_4 / 2, height_4 / 2);
+    else
+      tmp_bitmap_8 = old_bitmap;
 
+    UPDATE_BUSY_STATE();
+
+    /* get image with 1/16 of normal size (for use on the preview screen) */
+    if (zoom_factor != 16)
+      tmp_bitmap_16 = ZoomBitmap(tmp_bitmap_8, width_8 / 2, height_8 / 2);
+    else
+      tmp_bitmap_16 = old_bitmap;
+
+    UPDATE_BUSY_STATE();
+
+    /* get image with 1/32 of normal size (for use on the preview screen) */
+    if (zoom_factor != 32)
+      tmp_bitmap_32 = ZoomBitmap(tmp_bitmap_16, width_16 / 2, height_16 / 2);
+    else
+      tmp_bitmap_32 = old_bitmap;
+
+    UPDATE_BUSY_STATE();
+  }
+
+#if 0
   /* if image was scaled up, create new clipmask for normal size image */
   if (zoom_factor != 1)
   {
@@ -869,42 +1034,60 @@ void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
     SDL_SetColorKey(tmp_surface_1, 0, 0);	/* reset transparent pixel */
 #endif
   }
+#endif
 
-  new_width  = width_1;
-  new_height = height_1 + (height_1 + 1) / 2;     /* prevent odd height */
-
-  new_bitmap = CreateBitmap(new_width, new_height, DEFAULT_DEPTH);
+  if (create_small_bitmaps)
+  {
+    new_width  = width_1;
+    new_height = height_1 + (height_1 + 1) / 2;     /* prevent odd height */
+
+    new_bitmap = CreateBitmap(new_width, new_height, DEFAULT_DEPTH);
+
+    BlitBitmap(tmp_bitmap_1, new_bitmap, 0, 0, width_1, height_1, 0, 0);
+    BlitBitmap(tmp_bitmap_2, new_bitmap, 0, 0, width_1 / 2, height_1 / 2,
+	       0, height_1);
+    BlitBitmap(tmp_bitmap_4, new_bitmap, 0, 0, width_1 / 4, height_1 / 4,
+	       width_1 / 2, height_1);
+    BlitBitmap(tmp_bitmap_8, new_bitmap, 0, 0, width_1 / 8, height_1 / 8,
+	       3 * width_1 / 4, height_1);
+    BlitBitmap(tmp_bitmap_16, new_bitmap, 0, 0, width_1 / 16, height_1 / 16,
+	       7 * width_1 / 8, height_1);
+    BlitBitmap(tmp_bitmap_32, new_bitmap, 0, 0, width_1 / 32, height_1 / 32,
+	       15 * width_1 / 16, height_1);
+
+    UPDATE_BUSY_STATE();
+  }
+  else
+  {
+    new_width  = width_1;
+    new_height = height_1;
 
-  BlitBitmap(tmp_bitmap_1, new_bitmap, 0, 0, width_1, height_1, 0, 0);
-  BlitBitmap(tmp_bitmap_2, new_bitmap, 0, 0, width_1 / 2, height_1 / 2,
-	     0, height_1);
-  BlitBitmap(tmp_bitmap_8, new_bitmap, 0, 0, width_1 / 8, height_1 / 8,
-	     3 * width_1 / 4, height_1);
+    new_bitmap = tmp_bitmap_1;	/* directly use tmp_bitmap_1 as new bitmap */
+  }
 
-  if (zoom_factor != 1)
-    FreeBitmap(tmp_bitmap_1);
+  if (create_small_bitmaps)
+  {
+    /* if no small bitmaps created, tmp_bitmap_1 is used as new bitmap now */
+    if (zoom_factor != 1)
+      FreeBitmap(tmp_bitmap_1);
 
-  if (zoom_factor != 2)
-    FreeBitmap(tmp_bitmap_2);
+    if (zoom_factor != 2)
+      FreeBitmap(tmp_bitmap_2);
 
-  if (zoom_factor != 8)
-    FreeBitmap(tmp_bitmap_8);
+    if (zoom_factor != 4)
+      FreeBitmap(tmp_bitmap_4);
 
-#if 0
+    if (zoom_factor != 8)
+      FreeBitmap(tmp_bitmap_8);
 
-#if defined(TARGET_SDL)
-  /* !!! what about the old old_bitmap->surface ??? FIX ME !!! */
-  old_bitmap->surface = new_bitmap->surface;
-  new_bitmap->surface = NULL;
-#else
-  /* !!! see above !!! */
-  old_bitmap->drawable = new_bitmap->drawable;
-  new_bitmap->drawable = None;
-#endif
+    if (zoom_factor != 16)
+      FreeBitmap(tmp_bitmap_16);
 
-#else
+    if (zoom_factor != 32)
+      FreeBitmap(tmp_bitmap_32);
+  }
 
-  /* replace image with extended image (containing normal, 1/2 and 1/8 size) */
+  /* replace image with extended image (containing 1/1, 1/2, 1/4, 1/8 size) */
 #if defined(TARGET_SDL)
   swap_bitmap.surface = old_bitmap->surface;
   old_bitmap->surface = new_bitmap->surface;
@@ -913,14 +1096,50 @@ void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
   swap_bitmap.drawable = old_bitmap->drawable;
   old_bitmap->drawable = new_bitmap->drawable;
   new_bitmap->drawable = swap_bitmap.drawable;
-#endif
-
 #endif
 
   old_bitmap->width  = new_bitmap->width;
   old_bitmap->height = new_bitmap->height;
 
-  FreeBitmap(new_bitmap);
+#if 1
+  /* this replaces all blit masks created when loading -- maybe optimize this */
+  {
+#if defined(TARGET_X11)
+    if (old_bitmap->clip_mask)
+      XFreePixmap(display, old_bitmap->clip_mask);
+
+    old_bitmap->clip_mask =
+      Pixmap_to_Mask(old_bitmap->drawable, new_width, new_height);
+
+    XSetClipMask(display, old_bitmap->stored_clip_gc, old_bitmap->clip_mask);
+#else
+    SDL_Surface *old_surface = old_bitmap->surface;
+
+    if (old_bitmap->surface_masked)
+      SDL_FreeSurface(old_bitmap->surface_masked);
+
+    SDL_SetColorKey(old_surface, SDL_SRCCOLORKEY,
+		    SDL_MapRGB(old_surface->format, 0x00, 0x00, 0x00));
+    if ((old_bitmap->surface_masked = SDL_DisplayFormat(old_surface)) ==NULL)
+      Error(ERR_EXIT, "SDL_DisplayFormat() failed");
+    SDL_SetColorKey(old_surface, 0, 0);		/* reset transparent pixel */
+#endif
+  }
+#endif
+
+  UPDATE_BUSY_STATE();
+
+  FreeBitmap(new_bitmap);	/* this actually frees the _old_ bitmap now */
+}
+
+void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
+{
+  CreateScaledBitmaps(old_bitmap, zoom_factor, TRUE);
+}
+
+void ScaleBitmap(Bitmap *old_bitmap, int zoom_factor)
+{
+  CreateScaledBitmaps(old_bitmap, zoom_factor, FALSE);
 }
 
 
@@ -929,8 +1148,9 @@ void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
 /* ------------------------------------------------------------------------- */
 
 #if !defined(PLATFORM_MSDOS)
-/* XPM */
-static const char *cursor_image_playfield[] =
+#define USE_ONE_PIXEL_PLAYFIELD_MOUSEPOINTER		0
+/* XPM image definitions */
+static const char *cursor_image_none[] =
 {
   /* width height num_colors chars_per_pixel */
   "    16    16        3            1",
@@ -940,10 +1160,6 @@ static const char *cursor_image_playfield[] =
   ". c #ffffff",
   "  c None",
 
-#if 1
-  /* some people complained about a "white dot" on the screen and thought it
-     was a graphical error... OK, let's just remove the whole pointer :-) */
-
   /* pixels */
   "                ",
   "                ",
@@ -964,7 +1180,18 @@ static const char *cursor_image_playfield[] =
 
   /* hot spot */
   "0,0"
-#else
+};
+#if USE_ONE_PIXEL_PLAYFIELD_MOUSEPOINTER
+static const char *cursor_image_dot[] =
+{
+  /* width height num_colors chars_per_pixel */
+  "    16    16        3            1",
+
+  /* colors */
+  "X c #000000",
+  ". c #ffffff",
+  "  c None",
+
   /* pixels */
   " X              ",
   "X.X             ",
@@ -985,8 +1212,13 @@ static const char *cursor_image_playfield[] =
 
   /* hot spot */
   "1,1"
-#endif
 };
+static const char **cursor_image_playfield = cursor_image_dot;
+#else
+/* some people complained about a "white dot" on the screen and thought it
+   was a graphical error... OK, let's just remove the whole pointer :-) */
+static const char **cursor_image_playfield = cursor_image_none;
+#endif
 
 #if defined(TARGET_SDL)
 static const int cursor_bit_order = BIT_ORDER_MSB;
@@ -1045,15 +1277,24 @@ static struct MouseCursorInfo *get_cursor_from_image(const char **image)
 void SetMouseCursor(int mode)
 {
 #if !defined(PLATFORM_MSDOS)
+  static struct MouseCursorInfo *cursor_none = NULL;
   static struct MouseCursorInfo *cursor_playfield = NULL;
+  struct MouseCursorInfo *cursor_new;
+
+  if (cursor_none == NULL)
+    cursor_none = get_cursor_from_image(cursor_image_none);
 
   if (cursor_playfield == NULL)
     cursor_playfield = get_cursor_from_image(cursor_image_playfield);
 
+  cursor_new = (mode == CURSOR_DEFAULT   ? NULL :
+		mode == CURSOR_NONE      ? cursor_none :
+		mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL);
+
 #if defined(TARGET_SDL)
-  SDLSetMouseCursor(mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL);
+  SDLSetMouseCursor(cursor_new);
 #elif defined(TARGET_X11_NATIVE)
-  X11SetMouseCursor(mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL);
+  X11SetMouseCursor(cursor_new);
 #endif
 #endif
 }
@@ -1063,7 +1304,7 @@ void SetMouseCursor(int mode)
 /* audio functions                                                           */
 /* ========================================================================= */
 
-inline void OpenAudio(void)
+void OpenAudio(void)
 {
   /* always start with reliable default values */
   audio.sound_available = FALSE;
@@ -1091,7 +1332,7 @@ inline void OpenAudio(void)
 #endif
 }
 
-inline void CloseAudio(void)
+void CloseAudio(void)
 {
 #if defined(TARGET_SDL)
   SDLCloseAudio();
@@ -1104,7 +1345,7 @@ inline void CloseAudio(void)
   audio.sound_enabled = FALSE;
 }
 
-inline void SetAudioMode(boolean enabled)
+void SetAudioMode(boolean enabled)
 {
   if (!audio.sound_available)
     return;
@@ -1117,7 +1358,7 @@ inline void SetAudioMode(boolean enabled)
 /* event functions                                                           */
 /* ========================================================================= */
 
-inline void InitEventFilter(EventFilter filter_function)
+void InitEventFilter(EventFilter filter_function)
 {
 #if defined(TARGET_SDL)
   /* set event filter to filter out certain events */
@@ -1125,7 +1366,7 @@ inline void InitEventFilter(EventFilter filter_function)
 #endif
 }
 
-inline boolean PendingEvent(void)
+boolean PendingEvent(void)
 {
 #if defined(TARGET_SDL)
   return (SDL_PollEvent(NULL) ? TRUE : FALSE);
@@ -1134,7 +1375,7 @@ inline boolean PendingEvent(void)
 #endif
 }
 
-inline void NextEvent(Event *event)
+void NextEvent(Event *event)
 {
 #if defined(TARGET_SDL)
   SDLNextEvent(event);
@@ -1143,9 +1384,19 @@ inline void NextEvent(Event *event)
 #endif
 }
 
-inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
+void PeekEvent(Event *event)
+{
+#if defined(TARGET_SDL)
+  SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_ALLEVENTS);
+#else
+  XPeekEvent(display, event);
+#endif
+}
+
+Key GetEventKey(KeyEvent *event, boolean with_modifiers)
 {
 #if defined(TARGET_SDL)
+
 #if 0
   printf("unicode == '%d', sym == '%d', mod == '0x%04x'\n",
 	 (int)event->keysym.unicode,
@@ -1159,7 +1410,9 @@ inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
     return event->keysym.unicode;
   else
     return event->keysym.sym;
+
 #else
+
 #if 0
   printf("with modifiers == '0x%04x', without modifiers == '0x%04x'\n",
 	 (int)XLookupKeysym(event, event->state),
@@ -1173,11 +1426,10 @@ inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
 #endif
 }
 
-inline KeyMod HandleKeyModState(Key key, int key_status)
+KeyMod HandleKeyModState(Key key, int key_status)
 {
   static KeyMod current_modifiers = KMOD_None;
 
-#if !defined(TARGET_SDL)
   if (key != KSYM_UNDEFINED)	/* new key => check for modifier key change */
   {
     KeyMod new_modifier = KMOD_None;
@@ -1217,12 +1469,11 @@ inline KeyMod HandleKeyModState(Key key, int key_status)
     else
       current_modifiers &= ~new_modifier;
   }
-#endif
 
   return current_modifiers;
 }
 
-inline KeyMod GetKeyModState()
+KeyMod GetKeyModState()
 {
 #if defined(TARGET_SDL)
   return (KeyMod)SDL_GetModState();
@@ -1231,7 +1482,18 @@ inline KeyMod GetKeyModState()
 #endif
 }
 
-inline boolean CheckCloseWindowEvent(ClientMessageEvent *event)
+KeyMod GetKeyModStateFromEvents()
+{
+  /* always use key modifier state as tracked from key events (this is needed
+     if the modifier key event was injected into the event queue, but the key
+     was not really pressed on keyboard -- SDL_GetModState() seems to directly
+     query the keys as held pressed on the keyboard) -- this case is currently
+     only used to filter out clipboard insert events from "True X-Mouse" tool */
+
+  return HandleKeyModState(KSYM_UNDEFINED, 0);
+}
+
+boolean CheckCloseWindowEvent(ClientMessageEvent *event)
 {
   if (event->type != EVENT_CLIENTMESSAGE)
     return FALSE;
@@ -1252,7 +1514,7 @@ inline boolean CheckCloseWindowEvent(ClientMessageEvent *event)
 /* joystick functions                                                        */
 /* ========================================================================= */
 
-inline void InitJoysticks()
+void InitJoysticks()
 {
   int i;
 
@@ -1272,9 +1534,14 @@ inline void InitJoysticks()
 #elif defined(PLATFORM_MSDOS)
   MSDOSInitJoysticks();
 #endif
+
+#if 0
+  for (i = 0; i < MAX_PLAYERS; i++)
+    printf("::: Joystick for player %d: %d\n", i, joystick.fd[i]);
+#endif
 }
 
-inline boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
+boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
 {
 #if defined(TARGET_SDL)
   return SDLReadJoystick(nr, x, y, b1, b2);