+struct ProgramInfo program;
+struct OptionInfo options;
+struct VideoSystemInfo video;
+struct AudioSystemInfo audio;
+struct GfxInfo gfx;
+struct OverlayInfo overlay;
+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;
+
+struct LevelStats level_stats[MAX_LEVELS];
+
+DrawWindow *window = NULL;
+DrawBuffer *backbuffer = NULL;
+DrawBuffer *drawto = NULL;
+
+int button_status = MB_NOT_PRESSED;
+boolean motion_status = FALSE;
+int wheel_steps = DEFAULT_WHEEL_STEPS;
+#if defined(TARGET_SDL2)
+boolean keyrepeat_status = TRUE;
+#endif
+
+int redraw_mask = REDRAW_NONE;
+
+int FrameCounter = 0;
+
+
+/* ========================================================================= */
+/* init/close functions */
+/* ========================================================================= */
+
+void InitProgramInfo(char *argv0, char *config_filename, char *userdata_subdir,
+ char *program_title, char *icon_title,
+ char *icon_filename, char *cookie_prefix,
+ int program_version)
+{
+ program.command_basepath = getBasePath(argv0);
+ program.command_basename = getBaseName(argv0);
+
+ program.config_filename = config_filename;
+
+ program.userdata_subdir = userdata_subdir;
+ program.userdata_path = getUserGameDataDir();
+
+ program.program_title = program_title;
+ program.window_title = "(undefined)";
+ program.icon_title = icon_title;
+
+ program.icon_filename = icon_filename;
+
+ program.cookie_prefix = cookie_prefix;
+
+ program.version_major = VERSION_MAJOR(program_version);
+ program.version_minor = VERSION_MINOR(program_version);
+ program.version_patch = VERSION_PATCH(program_version);
+ program.version_build = VERSION_BUILD(program_version);
+ program.version_ident = program_version;
+
+ program.log_filename[LOG_OUT_ID] = getLogFilename(LOG_OUT_BASENAME);
+ program.log_filename[LOG_ERR_ID] = getLogFilename(LOG_ERR_BASENAME);
+ program.log_file[LOG_OUT_ID] = program.log_file_default[LOG_OUT_ID] = stdout;
+ program.log_file[LOG_ERR_ID] = program.log_file_default[LOG_ERR_ID] = stderr;
+
+ program.headless = FALSE;
+}
+
+void InitScoresInfo()
+{
+ char *global_scores_dir = getPath2(getCommonDataDir(), SCORES_DIRECTORY);
+
+ program.global_scores = directoryExists(global_scores_dir);
+ program.many_scores_per_name = !program.global_scores;
+
+ free(global_scores_dir);
+}
+
+void SetWindowTitle()
+{
+ program.window_title = program.window_title_function();
+
+ SDLSetWindowTitle();
+}
+
+void InitWindowTitleFunction(char *(*window_title_function)(void))
+{
+ program.window_title_function = window_title_function;
+}
+
+void InitExitMessageFunction(void (*exit_message_function)(char *, va_list))
+{
+ program.exit_message_function = exit_message_function;
+}
+
+void InitExitFunction(void (*exit_function)(int))
+{
+ program.exit_function = exit_function;
+
+ /* set signal handlers to custom exit function */
+ // signal(SIGINT, exit_function);
+ signal(SIGTERM, exit_function);
+
+ /* set exit function to automatically cleanup SDL stuff after exit() */
+ atexit(SDL_Quit);
+}
+
+void InitPlatformDependentStuff(void)
+{
+ // this is initialized in GetOptions(), but may already be used before
+ options.verbose = TRUE;
+
+ OpenLogFiles();
+
+#if defined(TARGET_SDL2)
+ int sdl_init_flags = SDL_INIT_EVENTS | SDL_INIT_NOPARACHUTE;
+#else
+ int sdl_init_flags = SDL_INIT_EVENTTHREAD | SDL_INIT_NOPARACHUTE;
+#endif
+
+ if (SDL_Init(sdl_init_flags) < 0)
+ Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
+
+ SDLNet_Init();
+}
+
+void ClosePlatformDependentStuff(void)
+{
+ CloseLogFiles();
+}
+
+void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
+ int real_sx, int real_sy,
+ int full_sxsize, int full_sysize,
+ Bitmap *field_save_buffer)
+{
+ gfx.sx = sx;
+ gfx.sy = sy;
+ gfx.sxsize = sxsize;
+ gfx.sysize = sysize;
+ gfx.real_sx = real_sx;
+ gfx.real_sy = real_sy;
+ gfx.full_sxsize = full_sxsize;
+ gfx.full_sysize = full_sysize;
+
+ gfx.field_save_buffer = field_save_buffer;
+
+ SetDrawDeactivationMask(REDRAW_NONE); /* do not deactivate drawing */
+ SetDrawBackgroundMask(REDRAW_NONE); /* deactivate masked drawing */
+}
+
+void InitGfxTileSizeInfo(int game_tile_size, int standard_tile_size)
+{
+ gfx.game_tile_size = game_tile_size;
+ gfx.standard_tile_size = standard_tile_size;
+}
+
+void InitGfxDoor1Info(int dx, int dy, int dxsize, int dysize)
+{
+ gfx.dx = dx;
+ gfx.dy = dy;
+ gfx.dxsize = dxsize;
+ gfx.dysize = dysize;
+}
+
+void InitGfxDoor2Info(int vx, int vy, int vxsize, int vysize)
+{
+ gfx.vx = vx;
+ gfx.vy = vy;
+ gfx.vxsize = vxsize;
+ gfx.vysize = vysize;
+}
+
+void InitGfxDoor3Info(int ex, int ey, int exsize, int eysize)
+{
+ gfx.ex = ex;
+ gfx.ey = ey;
+ gfx.exsize = exsize;
+ gfx.eysize = eysize;
+}
+
+void InitGfxWindowInfo(int win_xsize, int win_ysize)
+{
+ if (win_xsize != gfx.win_xsize || win_ysize != gfx.win_ysize)
+ {
+ ReCreateBitmap(&gfx.background_bitmap, win_xsize, win_ysize);
+
+#if defined(TARGET_SDL2)
+ ReCreateBitmap(&gfx.final_screen_bitmap, win_xsize, win_ysize);
+#endif
+
+ ReCreateBitmap(&gfx.fade_bitmap_backup, win_xsize, win_ysize);
+ ReCreateBitmap(&gfx.fade_bitmap_source, win_xsize, win_ysize);
+ ReCreateBitmap(&gfx.fade_bitmap_target, win_xsize, win_ysize);
+ ReCreateBitmap(&gfx.fade_bitmap_black, win_xsize, win_ysize);
+
+ ClearRectangle(gfx.fade_bitmap_black, 0, 0, win_xsize, win_ysize);
+ }
+
+ gfx.win_xsize = win_xsize;
+ gfx.win_ysize = win_ysize;
+
+ gfx.background_bitmap_mask = REDRAW_NONE;
+}
+
+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 InitGfxClipRegion(boolean enabled, int x, int y, int width, int height)
+{
+ gfx.clipping_enabled = enabled;
+ gfx.clip_x = x;
+ gfx.clip_y = y;
+ gfx.clip_width = width;
+ gfx.clip_height = height;
+}
+
+void InitGfxDrawBusyAnimFunction(void (*draw_busy_anim_function)(void))
+{
+ gfx.draw_busy_anim_function = draw_busy_anim_function;
+}
+
+void InitGfxDrawGlobalAnimFunction(void (*draw_global_anim_function)(int, int))
+{
+ gfx.draw_global_anim_function = draw_global_anim_function;
+}
+
+void InitGfxDrawGlobalBorderFunction(void (*draw_global_border_function)(int))
+{
+ gfx.draw_global_border_function = draw_global_border_function;
+}
+
+void InitGfxCustomArtworkInfo()
+{
+ gfx.override_level_graphics = FALSE;
+ gfx.override_level_sounds = FALSE;
+ gfx.override_level_music = FALSE;
+
+ gfx.draw_init_text = TRUE;
+}
+
+void InitGfxOtherSettings()
+{
+ gfx.cursor_mode = CURSOR_DEFAULT;
+}
+
+void InitOverlayInfo()
+{
+ overlay.active = FALSE;
+}
+
+void SetOverlayActive(boolean active)
+{
+ overlay.active = active;
+}
+
+boolean GetOverlayActive()
+{
+ return overlay.active;
+}
+
+void SetDrawDeactivationMask(int draw_deactivation_mask)
+{
+ gfx.draw_deactivation_mask = draw_deactivation_mask;
+}
+
+void SetDrawBackgroundMask(int draw_background_mask)
+{
+ gfx.draw_background_mask = draw_background_mask;
+}
+
+void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
+{
+ if (background_bitmap_tile != NULL)
+ gfx.background_bitmap_mask |= mask;
+ else
+ gfx.background_bitmap_mask &= ~mask;
+
+ if (background_bitmap_tile == NULL) /* empty background requested */
+ return;
+
+ if (mask == REDRAW_ALL)
+ BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
+ 0, 0, video.width, video.height);
+ else if (mask == REDRAW_FIELD)
+ BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
+ gfx.real_sx, gfx.real_sy, gfx.full_sxsize, gfx.full_sysize);
+ else if (mask == REDRAW_DOOR_1)
+ BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
+ 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);
+}
+
+
+/* ========================================================================= */
+/* video functions */
+/* ========================================================================= */
+
+inline static int GetRealDepth(int depth)
+{
+ return (depth == DEFAULT_DEPTH ? video.default_depth : depth);
+}
+
+inline static void sysFillRectangle(Bitmap *bitmap, int x, int y,
+ int width, int height, Pixel color)
+{
+ SDLFillRectangle(bitmap, x, y, width, height, color);
+
+ if (bitmap == backbuffer)
+ SetRedrawMaskFromArea(x, y, width, height);
+}
+
+inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y, int mask_mode)
+{
+ SDLCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+ dst_x, dst_y, mask_mode);
+
+ if (dst_bitmap == backbuffer)
+ SetRedrawMaskFromArea(dst_x, dst_y, width, height);
+}
+
+void LimitScreenUpdates(boolean enable)
+{
+ SDLLimitScreenUpdates(enable);
+}
+
+void InitVideoDisplay(void)
+{
+ if (program.headless)
+ return;
+
+ SDLInitVideoDisplay();
+#if defined(TARGET_SDL2)
+ SDLSetDisplaySize();
+#endif
+}
+
+void CloseVideoDisplay(void)
+{
+ KeyboardAutoRepeatOn();
+
+ SDL_QuitSubSystem(SDL_INIT_VIDEO);
+}
+
+void InitVideoBuffer(int width, int height, int depth, boolean fullscreen)
+{
+ video.width = width;
+ video.height = height;
+ video.depth = GetRealDepth(depth);
+
+ video.screen_width = width;
+ video.screen_height = height;
+ video.screen_xoffset = 0;
+ video.screen_yoffset = 0;
+
+ video.fullscreen_available = FULLSCREEN_STATUS;
+ video.fullscreen_enabled = FALSE;
+
+ video.window_scaling_available = WINDOW_SCALING_STATUS;
+
+ video.frame_delay = 0;
+ video.frame_delay_value = GAME_FRAME_DELAY;
+
+ video.shifted_up = FALSE;
+ video.shifted_up_pos = 0;
+ video.shifted_up_pos_last = 0;
+ video.shifted_up_delay = 0;
+ video.shifted_up_delay_value = ONE_SECOND_DELAY / 4;
+
+ SDLInitVideoBuffer(fullscreen);
+
+ video.initialized = TRUE;
+
+ drawto = backbuffer;
+}
+
+inline static void FreeBitmapPointers(Bitmap *bitmap)
+{
+ if (bitmap == NULL)
+ return;
+
+ SDLFreeBitmapPointers(bitmap);
+
+ checked_free(bitmap->source_filename);
+ bitmap->source_filename = NULL;
+}
+
+inline static void TransferBitmapPointers(Bitmap *src_bitmap,
+ Bitmap *dst_bitmap)
+{
+ if (src_bitmap == NULL || dst_bitmap == NULL)
+ return;
+
+ FreeBitmapPointers(dst_bitmap);
+
+ *dst_bitmap = *src_bitmap;
+}
+
+void FreeBitmap(Bitmap *bitmap)
+{
+ if (bitmap == NULL)
+ return;
+
+ FreeBitmapPointers(bitmap);
+
+ free(bitmap);
+}
+
+Bitmap *CreateBitmapStruct(void)
+{
+ return checked_calloc(sizeof(Bitmap));
+}
+
+Bitmap *CreateBitmap(int width, int height, int depth)
+{
+ Bitmap *new_bitmap = CreateBitmapStruct();
+ 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);
+
+ SDLCreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
+
+ new_bitmap->width = real_width;
+ new_bitmap->height = real_height;
+
+ return new_bitmap;
+}
+
+void ReCreateBitmap(Bitmap **bitmap, int width, int height)
+{
+ Bitmap *new_bitmap = CreateBitmap(width, height, DEFAULT_DEPTH);
+
+ if (*bitmap == NULL)
+ {
+ *bitmap = new_bitmap;
+ }
+ else
+ {
+ TransferBitmapPointers(new_bitmap, *bitmap);
+ free(new_bitmap);
+ }
+}
+
+void CloseWindow(DrawWindow *window)
+{
+}
+
+void SetRedrawMaskFromArea(int x, int y, int width, int height)
+{
+ int x1 = x;
+ int y1 = y;
+ int x2 = x + width - 1;
+ int y2 = y + height - 1;
+
+ if (width == 0 || height == 0)
+ return;
+
+ if (IN_GFX_FIELD_FULL(x1, y1) && IN_GFX_FIELD_FULL(x2, y2))
+ redraw_mask |= REDRAW_FIELD;
+ else if (IN_GFX_DOOR_1(x1, y1) && IN_GFX_DOOR_1(x2, y2))
+ redraw_mask |= REDRAW_DOOR_1;
+ else if (IN_GFX_DOOR_2(x1, y1) && IN_GFX_DOOR_2(x2, y2))
+ redraw_mask |= REDRAW_DOOR_2;
+ else if (IN_GFX_DOOR_3(x1, y1) && IN_GFX_DOOR_3(x2, y2))
+ redraw_mask |= REDRAW_DOOR_3;
+ else
+ redraw_mask = REDRAW_ALL;
+}
+
+inline static boolean CheckDrawingArea(int x, int y, int width, int height,
+ int draw_mask)
+{
+ if (draw_mask == REDRAW_NONE)
+ return FALSE;
+
+ if (draw_mask & REDRAW_ALL)
+ return TRUE;
+
+ if ((draw_mask & REDRAW_FIELD) && IN_GFX_FIELD_FULL(x, y))
+ return TRUE;
+
+ if ((draw_mask & REDRAW_DOOR_1) && IN_GFX_DOOR_1(x, y))
+ return TRUE;
+
+ if ((draw_mask & REDRAW_DOOR_2) && IN_GFX_DOOR_2(x, y))
+ return TRUE;
+
+ if ((draw_mask & REDRAW_DOOR_3) && IN_GFX_DOOR_3(x, y))
+ return TRUE;
+
+ return FALSE;
+}
+
+boolean DrawingDeactivated(int x, int y, int width, int height)
+{
+ return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
+}
+
+boolean DrawingOnBackground(int x, int y)
+{
+ return (CheckDrawingArea(x, y, 1, 1, gfx.background_bitmap_mask) &&
+ CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
+}
+
+static boolean InClippedRectangle(Bitmap *bitmap, int *x, int *y,
+ int *width, int *height, boolean is_dest)
+{
+ int clip_x, clip_y, clip_width, clip_height;
+
+ if (gfx.clipping_enabled && is_dest) /* only clip destination bitmap */
+ {
+ clip_x = MIN(MAX(0, gfx.clip_x), bitmap->width);
+ clip_y = MIN(MAX(0, gfx.clip_y), bitmap->height);
+ clip_width = MIN(MAX(0, gfx.clip_width), bitmap->width - clip_x);
+ clip_height = MIN(MAX(0, gfx.clip_height), bitmap->height - clip_y);
+ }
+ else
+ {
+ clip_x = 0;
+ clip_y = 0;
+ clip_width = bitmap->width;
+ clip_height = bitmap->height;
+ }
+
+ /* skip if rectangle completely outside bitmap */
+
+ if (*x + *width <= clip_x ||
+ *y + *height <= clip_y ||
+ *x >= clip_x + clip_width ||
+ *y >= clip_y + clip_height)
+ return FALSE;
+
+ /* clip if rectangle overlaps bitmap */
+
+ if (*x < clip_x)
+ {
+ *width -= clip_x - *x;
+ *x = clip_x;
+ }
+ else if (*x + *width > clip_x + clip_width)
+ {
+ *width = clip_x + clip_width - *x;
+ }
+
+ if (*y < clip_y)
+ {
+ *height -= clip_y - *y;
+ *y = clip_y;
+ }
+ else if (*y + *height > clip_y + clip_height)
+ {
+ *height = clip_y + clip_height - *y;
+ }
+
+ return TRUE;
+}
+
+void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int width, int height,
+ int dst_x, int dst_y)
+{
+ int dst_x_unclipped = dst_x;
+ int dst_y_unclipped = dst_y;
+
+ if (program.headless)
+ return;
+
+ if (src_bitmap == NULL || dst_bitmap == NULL)
+ return;
+
+ if (DrawingDeactivated(dst_x, dst_y, width, height))
+ return;
+
+ if (!InClippedRectangle(src_bitmap, &src_x, &src_y, &width, &height, FALSE) ||
+ !InClippedRectangle(dst_bitmap, &dst_x, &dst_y, &width, &height, TRUE))
+ return;
+
+ /* source x/y might need adjustment if destination x/y was clipped top/left */
+ src_x += dst_x - dst_x_unclipped;
+ src_y += dst_y - dst_y_unclipped;
+
+#if defined(TARGET_SDL2)
+ /* !!! 2013-12-11: An "old friend" is back. Same bug in SDL2 2.0.1 !!! */
+ /* !!! 2009-03-30: Fixed by using self-compiled, patched SDL.dll !!! */
+ /* (This bug still exists in the actual (as of 2009-06-15) version 1.2.13,
+ but is already fixed in SVN and should therefore finally be fixed with
+ the next official SDL release, which is probably version 1.2.14.) */
+ /* !!! 2009-03-24: It seems that this problem still exists in 1.2.12 !!! */
+
+ if (src_bitmap == dst_bitmap)
+ {
+ /* 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
+
+ sysCopyArea(src_bitmap, dst_bitmap,
+ src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
+}
+
+void BlitBitmapTiled(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+ int src_x, int src_y, int src_width, int src_height,
+ int dst_x, int dst_y, int dst_width, int dst_height)
+{
+ int src_xsize = (src_width == 0 ? src_bitmap->width : src_width);
+ int src_ysize = (src_height == 0 ? src_bitmap->height : src_height);
+ int dst_xsize = dst_width;
+ int dst_ysize = dst_height;
+ int src_xsteps = (dst_xsize + src_xsize - 1) / src_xsize;
+ int src_ysteps = (dst_ysize + src_ysize - 1) / src_ysize;
+ int x, y;
+
+ for (y = 0; y < src_ysteps; y++)
+ {
+ for (x = 0; x < src_xsteps; x++)
+ {
+ int draw_x = dst_x + x * src_xsize;
+ int draw_y = dst_y + y * src_ysize;
+ int draw_xsize = MIN(src_xsize, dst_xsize - x * src_xsize);
+ int draw_ysize = MIN(src_ysize, dst_ysize - y * src_ysize);
+
+ BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, draw_xsize, draw_ysize,
+ draw_x, draw_y);
+ }
+ }
+}
+
+void FadeRectangle(int x, int y, int width, int height,
+ int fade_mode, int fade_delay, int post_delay,
+ void (*draw_border_function)(void))
+{
+ /* (use destination bitmap "backbuffer" -- "bitmap_cross" may be undefined) */
+ if (!InClippedRectangle(backbuffer, &x, &y, &width, &height, TRUE))
+ return;
+
+ SDLFadeRectangle(x, y, width, height,
+ fade_mode, fade_delay, post_delay, draw_border_function);
+}
+
+void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
+ Pixel color)
+{
+ if (DrawingDeactivated(x, y, width, height))
+ return;
+
+ if (!InClippedRectangle(bitmap, &x, &y, &width, &height, TRUE))
+ return;
+
+ sysFillRectangle(bitmap, x, y, width, height, color);
+}
+
+void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
+{
+ FillRectangle(bitmap, x, y, width, height, BLACK_PIXEL);
+}
+
+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);
+ else
+ ClearRectangle(bitmap, x, y, width, height);
+}
+
+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;
+
+ sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+ dst_x, dst_y, BLIT_MASKED);
+}
+
+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))
+ {
+ /* draw background */
+ BlitBitmap(gfx.background_bitmap, dst_bitmap, dst_x, dst_y, width, height,
+ dst_x, dst_y);