X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fsystem.c;h=264a3366832f24750ff3de0a2a9d3527ed2b9377;hp=656d97f90d732e5e988b65e7d1fe838786072b93;hb=c0c5862d9ee59c70412b1c35e558101b109a8ec9;hpb=0ae305660baec1a7568ac7df7f296b695904d59a

diff --git a/src/libgame/system.c b/src/libgame/system.c
index 656d97f9..264a3366 100644
--- a/src/libgame/system.c
+++ b/src/libgame/system.c
@@ -21,6 +21,7 @@
 #endif
 
 #include "system.h"
+#include "image.h"
 #include "sound.h"
 #include "setup.h"
 #include "joystick.h"
@@ -40,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;
@@ -67,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;
@@ -91,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))
@@ -111,17 +121,30 @@ 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)
   if (SDL_Init(SDL_INIT_EVENTTHREAD | SDL_INIT_NOPARACHUTE) < 0)
     Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
+
+  SDLNet_Init();
 #endif
 }
 
 void ClosePlatformDependentStuff(void)
 {
+#if defined(PLATFORM_WIN32) || defined(PLATFORM_MSDOS)
+  closeErrorFile();
+#endif
+
 #if defined(PLATFORM_MSDOS)
   dumpErrorFile();
 #endif
@@ -210,27 +233,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;
@@ -246,10 +249,12 @@ void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
     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 SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
@@ -295,7 +300,7 @@ inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 #endif
 }
 
-inline void InitVideoDisplay(void)
+void InitVideoDisplay(void)
 {
 #if defined(TARGET_SDL)
   SDLInitVideoDisplay();
@@ -304,7 +309,7 @@ inline void InitVideoDisplay(void)
 #endif
 }
 
-inline void CloseVideoDisplay(void)
+void CloseVideoDisplay(void)
 {
   KeyboardAutoRepeatOn();
 
@@ -316,15 +321,17 @@ inline void CloseVideoDisplay(void)
 #endif
 }
 
-inline void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
-			    int width, int height, int depth,
-			    boolean fullscreen)
+void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
+		     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);
@@ -333,7 +340,7 @@ inline void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
 #endif
 }
 
-inline Bitmap *CreateBitmapStruct(void)
+Bitmap *CreateBitmapStruct(void)
 {
 #if defined(TARGET_SDL)
   return checked_calloc(sizeof(struct SDLSurfaceInfo));
@@ -342,7 +349,7 @@ 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);
@@ -385,7 +392,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;
@@ -395,7 +402,7 @@ inline void FreeBitmap(Bitmap *bitmap)
   free(bitmap);
 }
 
-inline void CloseWindow(DrawWindow *window)
+void CloseWindow(DrawWindow *window)
 {
 #if defined(TARGET_X11)
   if (window->drawable)
@@ -408,7 +415,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)
@@ -429,20 +436,20 @@ static inline boolean CheckDrawingArea(int x, int y, int width, int height,
   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;
@@ -451,8 +458,20 @@ inline void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 	      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)
+{
+#if defined(TARGET_SDL)
+  SDLFadeRectangle(bitmap_cross, x, y, width, height,
+		   fade_mode, fade_delay, post_delay);
+#else
+  X11FadeRectangle(bitmap_cross, x, y, width, height,
+		   fade_mode, fade_delay, post_delay);
+#endif
+}
+
+void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
+		   Pixel color)
 {
   if (DrawingDeactivated(x, y, width, height))
     return;
@@ -460,13 +479,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);
@@ -474,13 +493,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)
@@ -488,13 +501,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)
@@ -502,16 +512,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;
@@ -520,10 +526,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))
   {
@@ -542,8 +547,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);
@@ -553,8 +568,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;
 
@@ -583,8 +598,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;
@@ -604,7 +618,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)
@@ -619,8 +633,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);
@@ -631,7 +645,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;
@@ -641,7 +655,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);
@@ -649,14 +663,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,
@@ -668,7 +682,7 @@ inline void KeyboardAutoRepeatOn(void)
 #endif
 }
 
-inline void KeyboardAutoRepeatOff(void)
+void KeyboardAutoRepeatOff(void)
 {
 #if defined(TARGET_SDL)
   SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
@@ -679,7 +693,7 @@ inline void KeyboardAutoRepeatOff(void)
 #endif
 }
 
-inline boolean PointerInWindow(DrawWindow *window)
+boolean PointerInWindow(DrawWindow *window)
 {
 #if defined(TARGET_SDL)
   return TRUE;
@@ -696,7 +710,7 @@ inline boolean PointerInWindow(DrawWindow *window)
 #endif
 }
 
-inline boolean SetVideoMode(boolean fullscreen)
+boolean SetVideoMode(boolean fullscreen)
 {
 #if defined(TARGET_SDL)
   return SDLSetVideoMode(&backbuffer, fullscreen);
@@ -717,7 +731,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)||
@@ -769,7 +783,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
@@ -810,45 +824,145 @@ Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
   return dst_bitmap;
 }
 
-void CreateBitmapWithSmallBitmaps(Bitmap *src_bitmap)
+static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
+				boolean create_small_bitmaps)
 {
-  Bitmap *tmp_bitmap, *tmp_bitmap_2, *tmp_bitmap_8;
-  int src_width, src_height;
-  int tmp_width, tmp_height;
+  Bitmap swap_bitmap;
+  Bitmap *new_bitmap, *tmp_bitmap_1, *tmp_bitmap_2, *tmp_bitmap_4,*tmp_bitmap_8;
+  int width_1, height_1, width_2, height_2, width_4, height_4, width_8,height_8;
+  int new_width, new_height;
 
-  src_width  = src_bitmap->width;
-  src_height = src_bitmap->height;
+  /* calculate new image dimensions for normal sized image */
+  width_1  = old_bitmap->width  * zoom_factor;
+  height_1 = old_bitmap->height * zoom_factor;
 
-  tmp_width  = src_width;
-  tmp_height = src_height + (src_height + 1) / 2;     /* prevent odd height */
+  /* get image with normal size (this might require scaling up) */
+  if (zoom_factor != 1)
+    tmp_bitmap_1 = ZoomBitmap(old_bitmap, width_1, height_1);
+  else
+    tmp_bitmap_1 = old_bitmap;
 
-  tmp_bitmap = CreateBitmap(tmp_width, tmp_height, DEFAULT_DEPTH);
+  /* this is only needed to make compilers happy */
+  tmp_bitmap_2 = tmp_bitmap_4 = tmp_bitmap_8 = NULL;
 
-  tmp_bitmap_2 = ZoomBitmap(src_bitmap, src_width / 2, src_height / 2);
-  tmp_bitmap_8 = ZoomBitmap(src_bitmap, src_width / 8, src_height / 8);
+  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;
+
+    /* 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;
 
-  BlitBitmap(src_bitmap, tmp_bitmap, 0, 0, src_width, src_height, 0, 0);
-  BlitBitmap(tmp_bitmap_2, tmp_bitmap, 0, 0, src_width / 2, src_height / 2,
-	     0, src_height);
-  BlitBitmap(tmp_bitmap_8, tmp_bitmap, 0, 0, src_width / 8, src_height / 8,
-	     3 * src_width / 4, src_height);
+    /* 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;
 
-  FreeBitmap(tmp_bitmap_2);
-  FreeBitmap(tmp_bitmap_8);
+    /* 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;
+  }
+
+  /* if image was scaled up, create new clipmask for normal size image */
+  if (zoom_factor != 1)
+  {
+#if defined(TARGET_X11)
+    if (old_bitmap->clip_mask)
+      XFreePixmap(display, old_bitmap->clip_mask);
+
+    old_bitmap->clip_mask =
+      Pixmap_to_Mask(tmp_bitmap_1->drawable, width_1, height_1);
+
+    XSetClipMask(display, old_bitmap->stored_clip_gc, old_bitmap->clip_mask);
+#else
+    SDL_Surface *tmp_surface_1 = tmp_bitmap_1->surface;
+
+    if (old_bitmap->surface_masked)
+      SDL_FreeSurface(old_bitmap->surface_masked);
+
+    SDL_SetColorKey(tmp_surface_1, SDL_SRCCOLORKEY,
+		    SDL_MapRGB(tmp_surface_1->format, 0x00, 0x00, 0x00));
+    if ((old_bitmap->surface_masked = SDL_DisplayFormat(tmp_surface_1)) ==NULL)
+      Error(ERR_EXIT, "SDL_DisplayFormat() failed");
+    SDL_SetColorKey(tmp_surface_1, 0, 0);	/* reset transparent pixel */
+#endif
+  }
+
+  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);
+  }
+  else
+  {
+    new_width  = width_1;
+    new_height = height_1;
+
+    new_bitmap = tmp_bitmap_1;	/* directly use tmp_bitmap_1 as new bitmap */
+  }
+
+  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 != 4)
+      FreeBitmap(tmp_bitmap_4);
+
+    if (zoom_factor != 8)
+      FreeBitmap(tmp_bitmap_8);
+  }
+
+  /* replace image with extended image (containing 1/1, 1/2, 1/4, 1/8 size) */
 #if defined(TARGET_SDL)
-  /* !!! what about the old src_bitmap->surface ??? FIX ME !!! */
-  src_bitmap->surface = tmp_bitmap->surface;
-  tmp_bitmap->surface = NULL;
+  swap_bitmap.surface = old_bitmap->surface;
+  old_bitmap->surface = new_bitmap->surface;
+  new_bitmap->surface = swap_bitmap.surface;
 #else
-  /* !!! see above !!! */
-  src_bitmap->drawable = tmp_bitmap->drawable;
-  tmp_bitmap->drawable = None;
+  swap_bitmap.drawable = old_bitmap->drawable;
+  old_bitmap->drawable = new_bitmap->drawable;
+  new_bitmap->drawable = swap_bitmap.drawable;
 #endif
 
-  src_bitmap->height = tmp_bitmap->height;
+  old_bitmap->width  = new_bitmap->width;
+  old_bitmap->height = new_bitmap->height;
 
-  FreeBitmap(tmp_bitmap);
+  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);
 }
 
 
@@ -892,7 +1006,9 @@ static const char *cursor_image_playfield[] =
 
   /* hot spot */
   "0,0"
+
 #else
+
   /* pixels */
   " X              ",
   "X.X             ",
@@ -991,7 +1107,7 @@ void SetMouseCursor(int mode)
 /* audio functions                                                           */
 /* ========================================================================= */
 
-inline void OpenAudio(void)
+void OpenAudio(void)
 {
   /* always start with reliable default values */
   audio.sound_available = FALSE;
@@ -1019,7 +1135,7 @@ inline void OpenAudio(void)
 #endif
 }
 
-inline void CloseAudio(void)
+void CloseAudio(void)
 {
 #if defined(TARGET_SDL)
   SDLCloseAudio();
@@ -1032,7 +1148,7 @@ inline void CloseAudio(void)
   audio.sound_enabled = FALSE;
 }
 
-inline void SetAudioMode(boolean enabled)
+void SetAudioMode(boolean enabled)
 {
   if (!audio.sound_available)
     return;
@@ -1045,7 +1161,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 */
@@ -1053,7 +1169,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);
@@ -1062,7 +1178,7 @@ inline boolean PendingEvent(void)
 #endif
 }
 
-inline void NextEvent(Event *event)
+void NextEvent(Event *event)
 {
 #if defined(TARGET_SDL)
   SDLNextEvent(event);
@@ -1071,9 +1187,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,
@@ -1087,7 +1213,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),
@@ -1101,11 +1229,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;
@@ -1145,12 +1272,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();
@@ -1159,7 +1285,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;
@@ -1180,7 +1317,7 @@ inline boolean CheckCloseWindowEvent(ClientMessageEvent *event)
 /* joystick functions                                                        */
 /* ========================================================================= */
 
-inline void InitJoysticks()
+void InitJoysticks()
 {
   int i;
 
@@ -1200,9 +1337,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);