src/libgame/system.c

   1 // ============================================================================
   2 // Artsoft Retro-Game Library
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2014 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // system.c
  10 // ============================================================================
  11
  12 #include <string.h>
  13 #include <signal.h>
  14
  15 #include "platform.h"
  16
  17 #include "system.h"
  18 #include "image.h"
  19 #include "sound.h"
  20 #include "setup.h"
  21 #include "joystick.h"
  22 #include "misc.h"
  23
  24 #define ENABLE_UNUSED_CODE      0       /* currently unused functions */
  25
  26
  27 /* ========================================================================= */
  28 /* exported variables                                                        */
  29 /* ========================================================================= */
  30
  31 struct ProgramInfo      program;
  32 struct OptionInfo       options;
  33 struct VideoSystemInfo  video;
  34 struct AudioSystemInfo  audio;
  35 struct GfxInfo          gfx;
  36 struct OverlayInfo      overlay;
  37 struct ArtworkInfo      artwork;
  38 struct JoystickInfo     joystick;
  39 struct SetupInfo        setup;
  40
  41 LevelDirTree           *leveldir_first_all = NULL;
  42 LevelDirTree           *leveldir_first = NULL;
  43 LevelDirTree           *leveldir_current = NULL;
  44 int                     level_nr;
  45
  46 struct LevelStats       level_stats[MAX_LEVELS];
  47
  48 DrawWindow             *window = NULL;
  49 DrawBuffer             *backbuffer = NULL;
  50 DrawBuffer             *drawto = NULL;
  51
  52 int                     button_status = MB_NOT_PRESSED;
  53 boolean                 motion_status = FALSE;
  54 int                     wheel_steps = DEFAULT_WHEEL_STEPS;
  55 #if defined(TARGET_SDL2)
  56 boolean                 keyrepeat_status = TRUE;
  57 #endif
  58
  59 int                     redraw_mask = REDRAW_NONE;
  60
  61 int                     FrameCounter = 0;
  62
  63
  64 /* ========================================================================= */
  65 /* init/close functions                                                      */
  66 /* ========================================================================= */
  67
  68 void InitProgramInfo(char *argv0, char *config_filename, char *userdata_subdir,
  69                      char *program_title, char *icon_title,
  70                      char *icon_filename, char *cookie_prefix,
  71                      char *program_version_string, int program_version)
  72 {
  73   program.command_basepath = getBasePath(argv0);
  74   program.command_basename = getBaseName(argv0);
  75
  76   program.config_filename = config_filename;
  77
  78   program.userdata_subdir = userdata_subdir;
  79   program.userdata_path = getUserGameDataDir();
  80
  81   program.program_title = program_title;
  82   program.window_title = "(undefined)";
  83   program.icon_title = icon_title;
  84
  85   program.icon_filename = icon_filename;
  86
  87   program.cookie_prefix = cookie_prefix;
  88
  89   program.version_major = VERSION_MAJOR(program_version);
  90   program.version_minor = VERSION_MINOR(program_version);
  91   program.version_patch = VERSION_PATCH(program_version);
  92   program.version_build = VERSION_BUILD(program_version);
  93   program.version_ident = program_version;
  94
  95   program.version_string = program_version_string;
  96
  97   program.log_filename[LOG_OUT_ID] = getLogFilename(LOG_OUT_BASENAME);
  98   program.log_filename[LOG_ERR_ID] = getLogFilename(LOG_ERR_BASENAME);
  99   program.log_file[LOG_OUT_ID] = program.log_file_default[LOG_OUT_ID] = stdout;
 100   program.log_file[LOG_ERR_ID] = program.log_file_default[LOG_ERR_ID] = stderr;
 101
 102   program.headless = FALSE;
 103 }
 104
 105 void InitScoresInfo()
 106 {
 107   char *global_scores_dir = getPath2(getCommonDataDir(), SCORES_DIRECTORY);
 108
 109   program.global_scores = directoryExists(global_scores_dir);
 110   program.many_scores_per_name = !program.global_scores;
 111
 112   if (options.debug)
 113   {
 114     if (program.global_scores)
 115     {
 116       Error(ERR_DEBUG, "Using global, multi-user scores directory '%s'.",
 117             global_scores_dir);
 118       Error(ERR_DEBUG, "Remove to enable single-user scores directory.");
 119       Error(ERR_DEBUG, "(This enables multipe score entries per user.)");
 120     }
 121     else
 122     {
 123       Error(ERR_DEBUG, "Using private, single-user scores directory.");
 124     }
 125   }
 126
 127   free(global_scores_dir);
 128 }
 129
 130 void SetWindowTitle()
 131 {
 132   program.window_title = program.window_title_function();
 133
 134   SDLSetWindowTitle();
 135 }
 136
 137 void InitWindowTitleFunction(char *(*window_title_function)(void))
 138 {
 139   program.window_title_function = window_title_function;
 140 }
 141
 142 void InitExitMessageFunction(void (*exit_message_function)(char *, va_list))
 143 {
 144   program.exit_message_function = exit_message_function;
 145 }
 146
 147 void InitExitFunction(void (*exit_function)(int))
 148 {
 149   program.exit_function = exit_function;
 150
 151   /* set signal handlers to custom exit function */
 152   // signal(SIGINT, exit_function);
 153   signal(SIGTERM, exit_function);
 154
 155   /* set exit function to automatically cleanup SDL stuff after exit() */
 156   atexit(SDL_Quit);
 157 }
 158
 159 void InitPlatformDependentStuff(void)
 160 {
 161   // this is initialized in GetOptions(), but may already be used before
 162   options.verbose = TRUE;
 163
 164   OpenLogFiles();
 165
 166 #if defined(TARGET_SDL2)
 167   int sdl_init_flags = SDL_INIT_EVENTS      | SDL_INIT_NOPARACHUTE;
 168 #else
 169   int sdl_init_flags = SDL_INIT_EVENTTHREAD | SDL_INIT_NOPARACHUTE;
 170 #endif
 171
 172   if (SDL_Init(sdl_init_flags) < 0)
 173     Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
 174
 175   SDLNet_Init();
 176 }
 177
 178 void ClosePlatformDependentStuff(void)
 179 {
 180   CloseLogFiles();
 181 }
 182
 183 void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
 184                       int real_sx, int real_sy,
 185                       int full_sxsize, int full_sysize,
 186                       Bitmap *field_save_buffer)
 187 {
 188   gfx.sx = sx;
 189   gfx.sy = sy;
 190   gfx.sxsize = sxsize;
 191   gfx.sysize = sysize;
 192   gfx.real_sx = real_sx;
 193   gfx.real_sy = real_sy;
 194   gfx.full_sxsize = full_sxsize;
 195   gfx.full_sysize = full_sysize;
 196
 197   gfx.field_save_buffer = field_save_buffer;
 198
 199   SetDrawDeactivationMask(REDRAW_NONE);         /* do not deactivate drawing */
 200   SetDrawBackgroundMask(REDRAW_NONE);           /* deactivate masked drawing */
 201 }
 202
 203 void InitGfxTileSizeInfo(int game_tile_size, int standard_tile_size)
 204 {
 205   gfx.game_tile_size = game_tile_size;
 206   gfx.standard_tile_size = standard_tile_size;
 207 }
 208
 209 void InitGfxDoor1Info(int dx, int dy, int dxsize, int dysize)
 210 {
 211   gfx.dx = dx;
 212   gfx.dy = dy;
 213   gfx.dxsize = dxsize;
 214   gfx.dysize = dysize;
 215 }
 216
 217 void InitGfxDoor2Info(int vx, int vy, int vxsize, int vysize)
 218 {
 219   gfx.vx = vx;
 220   gfx.vy = vy;
 221   gfx.vxsize = vxsize;
 222   gfx.vysize = vysize;
 223 }
 224
 225 void InitGfxDoor3Info(int ex, int ey, int exsize, int eysize)
 226 {
 227   gfx.ex = ex;
 228   gfx.ey = ey;
 229   gfx.exsize = exsize;
 230   gfx.eysize = eysize;
 231 }
 232
 233 void InitGfxWindowInfo(int win_xsize, int win_ysize)
 234 {
 235   if (win_xsize != gfx.win_xsize || win_ysize != gfx.win_ysize)
 236   {
 237     ReCreateBitmap(&gfx.background_bitmap, win_xsize, win_ysize);
 238
 239 #if defined(TARGET_SDL2)
 240     ReCreateBitmap(&gfx.final_screen_bitmap, win_xsize, win_ysize);
 241 #endif
 242
 243     ReCreateBitmap(&gfx.fade_bitmap_backup, win_xsize, win_ysize);
 244     ReCreateBitmap(&gfx.fade_bitmap_source, win_xsize, win_ysize);
 245     ReCreateBitmap(&gfx.fade_bitmap_target, win_xsize, win_ysize);
 246     ReCreateBitmap(&gfx.fade_bitmap_black,  win_xsize, win_ysize);
 247
 248     ClearRectangle(gfx.fade_bitmap_black, 0, 0, win_xsize, win_ysize);
 249   }
 250
 251   gfx.win_xsize = win_xsize;
 252   gfx.win_ysize = win_ysize;
 253
 254   gfx.background_bitmap_mask = REDRAW_NONE;
 255 }
 256
 257 void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height)
 258 {
 259   /* currently only used by MSDOS code to alloc VRAM buffer, if available */
 260   /* 2009-03-24: also (temporarily?) used for overlapping blit workaround */
 261   gfx.scrollbuffer_width = scrollbuffer_width;
 262   gfx.scrollbuffer_height = scrollbuffer_height;
 263 }
 264
 265 void InitGfxClipRegion(boolean enabled, int x, int y, int width, int height)
 266 {
 267   gfx.clipping_enabled = enabled;
 268   gfx.clip_x = x;
 269   gfx.clip_y = y;
 270   gfx.clip_width = width;
 271   gfx.clip_height = height;
 272 }
 273
 274 void InitGfxDrawBusyAnimFunction(void (*draw_busy_anim_function)(void))
 275 {
 276   gfx.draw_busy_anim_function = draw_busy_anim_function;
 277 }
 278
 279 void InitGfxDrawGlobalAnimFunction(void (*draw_global_anim_function)(int, int))
 280 {
 281   gfx.draw_global_anim_function = draw_global_anim_function;
 282 }
 283
 284 void InitGfxDrawGlobalBorderFunction(void (*draw_global_border_function)(int))
 285 {
 286   gfx.draw_global_border_function = draw_global_border_function;
 287 }
 288
 289 void InitGfxCustomArtworkInfo()
 290 {
 291   gfx.override_level_graphics = FALSE;
 292   gfx.override_level_sounds = FALSE;
 293   gfx.override_level_music = FALSE;
 294
 295   gfx.draw_init_text = TRUE;
 296 }
 297
 298 void InitGfxOtherSettings()
 299 {
 300   gfx.cursor_mode = CURSOR_DEFAULT;
 301 }
 302
 303 void InitOverlayInfo()
 304 {
 305   overlay.enabled = FALSE;
 306   overlay.active = FALSE;
 307
 308 #if defined(PLATFORM_ANDROID)
 309   if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
 310     overlay.enabled = TRUE;
 311 #endif
 312 }
 313
 314 void SetOverlayEnabled(boolean enabled)
 315 {
 316   overlay.enabled = enabled;
 317 }
 318
 319 void SetOverlayActive(boolean active)
 320 {
 321   overlay.active = active;
 322 }
 323
 324 boolean GetOverlayActive()
 325 {
 326   return overlay.active;
 327 }
 328
 329 void SetDrawDeactivationMask(int draw_deactivation_mask)
 330 {
 331   gfx.draw_deactivation_mask = draw_deactivation_mask;
 332 }
 333
 334 int GetDrawDeactivationMask()
 335 {
 336   return gfx.draw_deactivation_mask;
 337 }
 338
 339 void SetDrawBackgroundMask(int draw_background_mask)
 340 {
 341   gfx.draw_background_mask = draw_background_mask;
 342 }
 343
 344 void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
 345 {
 346   if (background_bitmap_tile != NULL)
 347     gfx.background_bitmap_mask |= mask;
 348   else
 349     gfx.background_bitmap_mask &= ~mask;
 350
 351   if (background_bitmap_tile == NULL)   /* empty background requested */
 352     return;
 353
 354   if (mask == REDRAW_ALL)
 355     BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
 356                     0, 0, video.width, video.height);
 357   else if (mask == REDRAW_FIELD)
 358     BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
 359                     gfx.real_sx, gfx.real_sy, gfx.full_sxsize, gfx.full_sysize);
 360   else if (mask == REDRAW_DOOR_1)
 361     BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
 362                     gfx.dx, gfx.dy, gfx.dxsize, gfx.dysize);
 363 }
 364
 365 void SetWindowBackgroundBitmap(Bitmap *background_bitmap_tile)
 366 {
 367   /* remove every mask before setting mask for window */
 368   /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
 369   SetBackgroundBitmap(NULL, 0xffff);            /* !!! FIX THIS !!! */
 370   SetBackgroundBitmap(background_bitmap_tile, REDRAW_ALL);
 371 }
 372
 373 void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
 374 {
 375   /* remove window area mask before setting mask for main area */
 376   /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
 377   SetBackgroundBitmap(NULL, REDRAW_ALL);        /* !!! FIX THIS !!! */
 378   SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
 379 }
 380
 381 void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
 382 {
 383   /* remove window area mask before setting mask for door area */
 384   /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
 385   SetBackgroundBitmap(NULL, REDRAW_ALL);        /* !!! FIX THIS !!! */
 386   SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
 387 }
 388
 389
 390 /* ========================================================================= */
 391 /* video functions                                                           */
 392 /* ========================================================================= */
 393
 394 inline static int GetRealDepth(int depth)
 395 {
 396   return (depth == DEFAULT_DEPTH ? video.default_depth : depth);
 397 }
 398
 399 inline static void sysFillRectangle(Bitmap *bitmap, int x, int y,
 400                                     int width, int height, Pixel color)
 401 {
 402   SDLFillRectangle(bitmap, x, y, width, height, color);
 403
 404   if (bitmap == backbuffer)
 405     SetRedrawMaskFromArea(x, y, width, height);
 406 }
 407
 408 inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 409                                int src_x, int src_y, int width, int height,
 410                                int dst_x, int dst_y, int mask_mode)
 411 {
 412   SDLCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 413               dst_x, dst_y, mask_mode);
 414
 415   if (dst_bitmap == backbuffer)
 416     SetRedrawMaskFromArea(dst_x, dst_y, width, height);
 417 }
 418
 419 void LimitScreenUpdates(boolean enable)
 420 {
 421   SDLLimitScreenUpdates(enable);
 422 }
 423
 424 void InitVideoDisplay(void)
 425 {
 426   if (program.headless)
 427     return;
 428
 429   SDLInitVideoDisplay();
 430 #if defined(TARGET_SDL2)
 431   SDLSetDisplaySize();
 432 #endif
 433 }
 434
 435 void CloseVideoDisplay(void)
 436 {
 437   KeyboardAutoRepeatOn();
 438
 439   SDL_QuitSubSystem(SDL_INIT_VIDEO);
 440 }
 441
 442 void InitVideoBuffer(int width, int height, int depth, boolean fullscreen)
 443 {
 444   video.width = width;
 445   video.height = height;
 446   video.depth = GetRealDepth(depth);
 447
 448   video.screen_width = width;
 449   video.screen_height = height;
 450   video.screen_xoffset = 0;
 451   video.screen_yoffset = 0;
 452
 453   video.fullscreen_available = FULLSCREEN_STATUS;
 454   video.fullscreen_enabled = FALSE;
 455
 456   video.window_scaling_available = WINDOW_SCALING_STATUS;
 457
 458   video.frame_delay = 0;
 459   video.frame_delay_value = GAME_FRAME_DELAY;
 460
 461   video.shifted_up = FALSE;
 462   video.shifted_up_pos = 0;
 463   video.shifted_up_pos_last = 0;
 464   video.shifted_up_delay = 0;
 465   video.shifted_up_delay_value = ONE_SECOND_DELAY / 4;
 466
 467   SDLInitVideoBuffer(fullscreen);
 468
 469   video.initialized = TRUE;
 470
 471   drawto = backbuffer;
 472 }
 473
 474 inline static void FreeBitmapPointers(Bitmap *bitmap)
 475 {
 476   if (bitmap == NULL)
 477     return;
 478
 479   SDLFreeBitmapPointers(bitmap);
 480
 481   checked_free(bitmap->source_filename);
 482   bitmap->source_filename = NULL;
 483 }
 484
 485 inline static void TransferBitmapPointers(Bitmap *src_bitmap,
 486                                           Bitmap *dst_bitmap)
 487 {
 488   if (src_bitmap == NULL || dst_bitmap == NULL)
 489     return;
 490
 491   FreeBitmapPointers(dst_bitmap);
 492
 493   *dst_bitmap = *src_bitmap;
 494 }
 495
 496 void FreeBitmap(Bitmap *bitmap)
 497 {
 498   if (bitmap == NULL)
 499     return;
 500
 501   FreeBitmapPointers(bitmap);
 502
 503   free(bitmap);
 504 }
 505
 506 Bitmap *CreateBitmapStruct(void)
 507 {
 508   return checked_calloc(sizeof(Bitmap));
 509 }
 510
 511 Bitmap *CreateBitmap(int width, int height, int depth)
 512 {
 513   Bitmap *new_bitmap = CreateBitmapStruct();
 514   int real_width  = MAX(1, width);      /* prevent zero bitmap width */
 515   int real_height = MAX(1, height);     /* prevent zero bitmap height */
 516   int real_depth  = GetRealDepth(depth);
 517
 518   SDLCreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
 519
 520   new_bitmap->width  = real_width;
 521   new_bitmap->height = real_height;
 522
 523   return new_bitmap;
 524 }
 525
 526 void ReCreateBitmap(Bitmap **bitmap, int width, int height)
 527 {
 528   if (*bitmap != NULL)
 529   {
 530     /* if new bitmap size fits into old one, no need to re-create it */
 531     if (width  <= (*bitmap)->width &&
 532         height <= (*bitmap)->height)
 533       return;
 534
 535     /* else adjust size so that old and new bitmap size fit into it */
 536     width  = MAX(width,  (*bitmap)->width);
 537     height = MAX(height, (*bitmap)->height);
 538   }
 539
 540   Bitmap *new_bitmap = CreateBitmap(width, height, DEFAULT_DEPTH);
 541
 542   if (*bitmap == NULL)
 543   {
 544     *bitmap = new_bitmap;
 545   }
 546   else
 547   {
 548     TransferBitmapPointers(new_bitmap, *bitmap);
 549     free(new_bitmap);
 550   }
 551 }
 552
 553 void CloseWindow(DrawWindow *window)
 554 {
 555 }
 556
 557 void SetRedrawMaskFromArea(int x, int y, int width, int height)
 558 {
 559   int x1 = x;
 560   int y1 = y;
 561   int x2 = x + width - 1;
 562   int y2 = y + height - 1;
 563
 564   if (width == 0 || height == 0)
 565     return;
 566
 567   if (IN_GFX_FIELD_FULL(x1, y1) && IN_GFX_FIELD_FULL(x2, y2))
 568     redraw_mask |= REDRAW_FIELD;
 569   else if (IN_GFX_DOOR_1(x1, y1) && IN_GFX_DOOR_1(x2, y2))
 570     redraw_mask |= REDRAW_DOOR_1;
 571   else if (IN_GFX_DOOR_2(x1, y1) && IN_GFX_DOOR_2(x2, y2))
 572     redraw_mask |= REDRAW_DOOR_2;
 573   else if (IN_GFX_DOOR_3(x1, y1) && IN_GFX_DOOR_3(x2, y2))
 574     redraw_mask |= REDRAW_DOOR_3;
 575   else
 576     redraw_mask = REDRAW_ALL;
 577 }
 578
 579 inline static boolean CheckDrawingArea(int x, int y, int width, int height,
 580                                        int draw_mask)
 581 {
 582   if (draw_mask == REDRAW_NONE)
 583     return FALSE;
 584
 585   if (draw_mask & REDRAW_ALL)
 586     return TRUE;
 587
 588   if ((draw_mask & REDRAW_FIELD) && IN_GFX_FIELD_FULL(x, y))
 589     return TRUE;
 590
 591   if ((draw_mask & REDRAW_DOOR_1) && IN_GFX_DOOR_1(x, y))
 592     return TRUE;
 593
 594   if ((draw_mask & REDRAW_DOOR_2) && IN_GFX_DOOR_2(x, y))
 595     return TRUE;
 596
 597   if ((draw_mask & REDRAW_DOOR_3) && IN_GFX_DOOR_3(x, y))
 598     return TRUE;
 599
 600   return FALSE;
 601 }
 602
 603 boolean DrawingDeactivatedField()
 604 {
 605   if (program.headless)
 606     return TRUE;
 607
 608   if (gfx.draw_deactivation_mask & REDRAW_FIELD)
 609     return TRUE;
 610
 611   return FALSE;
 612 }
 613
 614 boolean DrawingDeactivated(int x, int y, int width, int height)
 615 {
 616   return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
 617 }
 618
 619 boolean DrawingOnBackground(int x, int y)
 620 {
 621   return (CheckDrawingArea(x, y, 1, 1, gfx.background_bitmap_mask) &&
 622           CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
 623 }
 624
 625 static boolean InClippedRectangle(Bitmap *bitmap, int *x, int *y,
 626                                   int *width, int *height, boolean is_dest)
 627 {
 628   int clip_x, clip_y, clip_width, clip_height;
 629
 630   if (gfx.clipping_enabled && is_dest)  /* only clip destination bitmap */
 631   {
 632     clip_x = MIN(MAX(0, gfx.clip_x), bitmap->width);
 633     clip_y = MIN(MAX(0, gfx.clip_y), bitmap->height);
 634     clip_width = MIN(MAX(0, gfx.clip_width), bitmap->width - clip_x);
 635     clip_height = MIN(MAX(0, gfx.clip_height), bitmap->height - clip_y);
 636   }
 637   else
 638   {
 639     clip_x = 0;
 640     clip_y = 0;
 641     clip_width = bitmap->width;
 642     clip_height = bitmap->height;
 643   }
 644
 645   /* skip if rectangle completely outside bitmap */
 646
 647   if (*x + *width  <= clip_x ||
 648       *y + *height <= clip_y ||
 649       *x >= clip_x + clip_width ||
 650       *y >= clip_y + clip_height)
 651     return FALSE;
 652
 653   /* clip if rectangle overlaps bitmap */
 654
 655   if (*x < clip_x)
 656   {
 657     *width -= clip_x - *x;
 658     *x = clip_x;
 659   }
 660   else if (*x + *width > clip_x + clip_width)
 661   {
 662     *width = clip_x + clip_width - *x;
 663   }
 664
 665   if (*y < clip_y)
 666   {
 667     *height -= clip_y - *y;
 668     *y = clip_y;
 669   }
 670   else if (*y + *height > clip_y + clip_height)
 671   {
 672     *height = clip_y + clip_height - *y;
 673   }
 674
 675   return TRUE;
 676 }
 677
 678 void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 679                 int src_x, int src_y, int width, int height,
 680                 int dst_x, int dst_y)
 681 {
 682   int dst_x_unclipped = dst_x;
 683   int dst_y_unclipped = dst_y;
 684
 685   if (program.headless)
 686     return;
 687
 688   if (src_bitmap == NULL || dst_bitmap == NULL)
 689     return;
 690
 691   if (DrawingDeactivated(dst_x, dst_y, width, height))
 692     return;
 693
 694   if (!InClippedRectangle(src_bitmap, &src_x, &src_y, &width, &height, FALSE) ||
 695       !InClippedRectangle(dst_bitmap, &dst_x, &dst_y, &width, &height, TRUE))
 696     return;
 697
 698   /* source x/y might need adjustment if destination x/y was clipped top/left */
 699   src_x += dst_x - dst_x_unclipped;
 700   src_y += dst_y - dst_y_unclipped;
 701
 702 #if defined(TARGET_SDL2)
 703   /* !!! 2013-12-11: An "old friend" is back. Same bug in SDL2 2.0.1 !!! */
 704   /* !!! 2009-03-30: Fixed by using self-compiled, patched SDL.dll !!! */
 705   /* (This bug still exists in the actual (as of 2009-06-15) version 1.2.13,
 706      but is already fixed in SVN and should therefore finally be fixed with
 707      the next official SDL release, which is probably version 1.2.14.) */
 708   /* !!! 2009-03-24: It seems that this problem still exists in 1.2.12 !!! */
 709
 710   if (src_bitmap == dst_bitmap)
 711   {
 712     /* needed when blitting directly to same bitmap -- should not be needed with
 713        recent SDL libraries, but apparently does not work in 1.2.11 directly */
 714
 715     static Bitmap *tmp_bitmap = NULL;
 716     static int tmp_bitmap_xsize = 0;
 717     static int tmp_bitmap_ysize = 0;
 718
 719     /* start with largest static bitmaps for initial bitmap size ... */
 720     if (tmp_bitmap_xsize == 0 && tmp_bitmap_ysize == 0)
 721     {
 722       tmp_bitmap_xsize = MAX(gfx.win_xsize, gfx.scrollbuffer_width);
 723       tmp_bitmap_ysize = MAX(gfx.win_ysize, gfx.scrollbuffer_height);
 724     }
 725
 726     /* ... and allow for later re-adjustments due to custom artwork bitmaps */
 727     if (src_bitmap->width > tmp_bitmap_xsize ||
 728         src_bitmap->height > tmp_bitmap_ysize)
 729     {
 730       tmp_bitmap_xsize = MAX(tmp_bitmap_xsize, src_bitmap->width);
 731       tmp_bitmap_ysize = MAX(tmp_bitmap_ysize, src_bitmap->height);
 732
 733       FreeBitmap(tmp_bitmap);
 734
 735       tmp_bitmap = NULL;
 736     }
 737
 738     if (tmp_bitmap == NULL)
 739       tmp_bitmap = CreateBitmap(tmp_bitmap_xsize, tmp_bitmap_ysize,
 740                                 DEFAULT_DEPTH);
 741
 742     sysCopyArea(src_bitmap, tmp_bitmap,
 743                 src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
 744     sysCopyArea(tmp_bitmap, dst_bitmap,
 745                 dst_x, dst_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
 746
 747     return;
 748   }
 749 #endif
 750
 751   sysCopyArea(src_bitmap, dst_bitmap,
 752               src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
 753 }
 754
 755 void BlitBitmapTiled(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 756                      int src_x, int src_y, int src_width, int src_height,
 757                      int dst_x, int dst_y, int dst_width, int dst_height)
 758 {
 759   int src_xsize = (src_width  == 0 ? src_bitmap->width  : src_width);
 760   int src_ysize = (src_height == 0 ? src_bitmap->height : src_height);
 761   int dst_xsize = dst_width;
 762   int dst_ysize = dst_height;
 763   int src_xsteps = (dst_xsize + src_xsize - 1) / src_xsize;
 764   int src_ysteps = (dst_ysize + src_ysize - 1) / src_ysize;
 765   int x, y;
 766
 767   for (y = 0; y < src_ysteps; y++)
 768   {
 769     for (x = 0; x < src_xsteps; x++)
 770     {
 771       int draw_x = dst_x + x * src_xsize;
 772       int draw_y = dst_y + y * src_ysize;
 773       int draw_xsize = MIN(src_xsize, dst_xsize - x * src_xsize);
 774       int draw_ysize = MIN(src_ysize, dst_ysize - y * src_ysize);
 775
 776       BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, draw_xsize, draw_ysize,
 777                  draw_x, draw_y);
 778     }
 779   }
 780 }
 781
 782 void FadeRectangle(int x, int y, int width, int height,
 783                    int fade_mode, int fade_delay, int post_delay,
 784                    void (*draw_border_function)(void))
 785 {
 786   /* (use destination bitmap "backbuffer" -- "bitmap_cross" may be undefined) */
 787   if (!InClippedRectangle(backbuffer, &x, &y, &width, &height, TRUE))
 788     return;
 789
 790   SDLFadeRectangle(x, y, width, height,
 791                    fade_mode, fade_delay, post_delay, draw_border_function);
 792 }
 793
 794 void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
 795                    Pixel color)
 796 {
 797   if (DrawingDeactivated(x, y, width, height))
 798     return;
 799
 800   if (!InClippedRectangle(bitmap, &x, &y, &width, &height, TRUE))
 801     return;
 802
 803   sysFillRectangle(bitmap, x, y, width, height, color);
 804 }
 805
 806 void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
 807 {
 808   FillRectangle(bitmap, x, y, width, height, BLACK_PIXEL);
 809 }
 810
 811 void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
 812                                 int width, int height)
 813 {
 814   if (DrawingOnBackground(x, y))
 815     BlitBitmap(gfx.background_bitmap, bitmap, x, y, width, height, x, y);
 816   else
 817     ClearRectangle(bitmap, x, y, width, height);
 818 }
 819
 820 void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 821                       int src_x, int src_y, int width, int height,
 822                       int dst_x, int dst_y)
 823 {
 824   if (DrawingDeactivated(dst_x, dst_y, width, height))
 825     return;
 826
 827   sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 828               dst_x, dst_y, BLIT_MASKED);
 829 }
 830
 831 void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 832                             int src_x, int src_y, int width, int height,
 833                             int dst_x, int dst_y)
 834 {
 835   if (DrawingOnBackground(dst_x, dst_y))
 836   {
 837     /* draw background */
 838     BlitBitmap(gfx.background_bitmap, dst_bitmap, dst_x, dst_y, width, height,
 839                dst_x, dst_y);
 840
 841     /* draw foreground */
 842     BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 843                      dst_x, dst_y);
 844   }
 845   else
 846     BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 847                dst_x, dst_y);
 848 }
 849
 850 void BlitTexture(Bitmap *bitmap,
 851                 int src_x, int src_y, int width, int height,
 852                 int dst_x, int dst_y)
 853 {
 854   if (bitmap == NULL)
 855     return;
 856
 857   SDLBlitTexture(bitmap, src_x, src_y, width, height, dst_x, dst_y,
 858                  BLIT_OPAQUE);
 859 }
 860
 861 void BlitTextureMasked(Bitmap *bitmap,
 862                        int src_x, int src_y, int width, int height,
 863                        int dst_x, int dst_y)
 864 {
 865   if (bitmap == NULL)
 866     return;
 867
 868   SDLBlitTexture(bitmap, src_x, src_y, width, height, dst_x, dst_y,
 869                  BLIT_MASKED);
 870 }
 871
 872 void BlitToScreen(Bitmap *bitmap,
 873                   int src_x, int src_y, int width, int height,
 874                   int dst_x, int dst_y)
 875 {
 876   if (bitmap == NULL)
 877     return;
 878
 879   if (video.screen_rendering_mode == SPECIAL_RENDERING_BITMAP)
 880     BlitBitmap(bitmap, gfx.final_screen_bitmap, src_x, src_y,
 881                width, height, dst_x, dst_y);
 882   else
 883     BlitTexture(bitmap, src_x, src_y, width, height, dst_x, dst_y);
 884 }
 885
 886 void BlitToScreenMasked(Bitmap *bitmap,
 887                         int src_x, int src_y, int width, int height,
 888                         int dst_x, int dst_y)
 889 {
 890   if (bitmap == NULL)
 891     return;
 892
 893   if (video.screen_rendering_mode == SPECIAL_RENDERING_BITMAP)
 894     BlitBitmapMasked(bitmap, gfx.final_screen_bitmap, src_x, src_y,
 895                      width, height, dst_x, dst_y);
 896   else
 897     BlitTextureMasked(bitmap, src_x, src_y, width, height, dst_x, dst_y);
 898 }
 899
 900 void DrawSimpleBlackLine(Bitmap *bitmap, int from_x, int from_y,
 901                          int to_x, int to_y)
 902 {
 903   SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, BLACK_PIXEL);
 904 }
 905
 906 void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
 907                          int to_x, int to_y)
 908 {
 909   SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL);
 910 }
 911
 912 void DrawLine(Bitmap *bitmap, int from_x, int from_y,
 913               int to_x, int to_y, Pixel pixel, int line_width)
 914 {
 915   int x, y;
 916
 917   for (x = 0; x < line_width; x++)
 918   {
 919     for (y = 0; y < line_width; y++)
 920     {
 921       int dx = x - line_width / 2;
 922       int dy = y - line_width / 2;
 923
 924       if ((x == 0 && y == 0) ||
 925           (x == 0 && y == line_width - 1) ||
 926           (x == line_width - 1 && y == 0) ||
 927           (x == line_width - 1 && y == line_width - 1))
 928         continue;
 929
 930       SDLDrawLine(bitmap,
 931                   from_x + dx, from_y + dy, to_x + dx, to_y + dy, pixel);
 932     }
 933   }
 934 }
 935
 936 void DrawLines(Bitmap *bitmap, struct XY *points, int num_points, Pixel pixel)
 937 {
 938   int line_width = 4;
 939   int i;
 940
 941   for (i = 0; i < num_points - 1; i++)
 942     DrawLine(bitmap, points[i].x, points[i].y,
 943              points[i + 1].x, points[i + 1].y, pixel, line_width);
 944
 945   /*
 946   SDLDrawLines(bitmap->surface, points, num_points, pixel);
 947   */
 948 }
 949
 950 Pixel GetPixel(Bitmap *bitmap, int x, int y)
 951 {
 952   if (x < 0 || x >= bitmap->width ||
 953       y < 0 || y >= bitmap->height)
 954     return BLACK_PIXEL;
 955
 956   return SDLGetPixel(bitmap, x, y);
 957 }
 958
 959 Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
 960                       unsigned int color_g, unsigned int color_b)
 961 {
 962   return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
 963 }
 964
 965 Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
 966 {
 967   unsigned int color_r = (color >> 16) & 0xff;
 968   unsigned int color_g = (color >>  8) & 0xff;
 969   unsigned int color_b = (color >>  0) & 0xff;
 970
 971   return GetPixelFromRGB(bitmap, color_r, color_g, color_b);
 972 }
 973
 974 void KeyboardAutoRepeatOn(void)
 975 {
 976 #if defined(TARGET_SDL2)
 977   keyrepeat_status = TRUE;
 978 #else
 979   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY / 2,
 980                       SDL_DEFAULT_REPEAT_INTERVAL / 2);
 981   SDL_EnableUNICODE(1);
 982 #endif
 983 }
 984
 985 void KeyboardAutoRepeatOff(void)
 986 {
 987 #if defined(TARGET_SDL2)
 988   keyrepeat_status = FALSE;
 989 #else
 990   SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
 991   SDL_EnableUNICODE(0);
 992 #endif
 993 }
 994
 995 boolean SetVideoMode(boolean fullscreen)
 996 {
 997   return SDLSetVideoMode(fullscreen);
 998 }
 999
1000 void SetVideoFrameDelay(unsigned int frame_delay_value)
1001 {
1002   video.frame_delay_value = frame_delay_value;
1003 }
1004
1005 unsigned int GetVideoFrameDelay()
1006 {
1007   return video.frame_delay_value;
1008 }
1009
1010 boolean ChangeVideoModeIfNeeded(boolean fullscreen)
1011 {
1012   if ((fullscreen && !video.fullscreen_enabled && video.fullscreen_available)||
1013       (!fullscreen && video.fullscreen_enabled))
1014     fullscreen = SetVideoMode(fullscreen);
1015
1016   return fullscreen;
1017 }
1018
1019 Bitmap *LoadImage(char *filename)
1020 {
1021   Bitmap *new_bitmap;
1022
1023   new_bitmap = SDLLoadImage(filename);
1024
1025   if (new_bitmap)
1026     new_bitmap->source_filename = getStringCopy(filename);
1027
1028   return new_bitmap;
1029 }
1030
1031 Bitmap *LoadCustomImage(char *basename)
1032 {
1033   char *filename = getCustomImageFilename(basename);
1034   Bitmap *new_bitmap;
1035
1036   if (filename == NULL)
1037     Error(ERR_EXIT, "LoadCustomImage(): cannot find file '%s'", basename);
1038
1039   if ((new_bitmap = LoadImage(filename)) == NULL)
1040     Error(ERR_EXIT, "LoadImage('%s') failed: %s", basename, GetError());
1041
1042   return new_bitmap;
1043 }
1044
1045 void ReloadCustomImage(Bitmap *bitmap, char *basename)
1046 {
1047   char *filename = getCustomImageFilename(basename);
1048   Bitmap *new_bitmap;
1049
1050   if (filename == NULL)         /* (should never happen) */
1051   {
1052     Error(ERR_WARN, "ReloadCustomImage(): cannot find file '%s'", basename);
1053     return;
1054   }
1055
1056   if (strEqual(filename, bitmap->source_filename))
1057   {
1058     /* The old and new image are the same (have the same filename and path).
1059        This usually means that this image does not exist in this graphic set
1060        and a fallback to the existing image is done. */
1061
1062     return;
1063   }
1064
1065   if ((new_bitmap = LoadImage(filename)) == NULL)
1066   {
1067     Error(ERR_WARN, "LoadImage('%s') failed: %s", basename, GetError());
1068     return;
1069   }
1070
1071   if (bitmap->width != new_bitmap->width ||
1072       bitmap->height != new_bitmap->height)
1073   {
1074     Error(ERR_WARN, "ReloadCustomImage: new image '%s' has wrong dimensions",
1075           filename);
1076     FreeBitmap(new_bitmap);
1077     return;
1078   }
1079
1080   TransferBitmapPointers(new_bitmap, bitmap);
1081   free(new_bitmap);
1082 }
1083
1084 static Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
1085 {
1086   return SDLZoomBitmap(src_bitmap, zoom_width, zoom_height);
1087 }
1088
1089 void ReCreateGameTileSizeBitmap(Bitmap **bitmaps)
1090 {
1091   if (bitmaps[IMG_BITMAP_CUSTOM])
1092   {
1093     FreeBitmap(bitmaps[IMG_BITMAP_CUSTOM]);
1094
1095     bitmaps[IMG_BITMAP_CUSTOM] = NULL;
1096   }
1097
1098   if (gfx.game_tile_size == gfx.standard_tile_size)
1099   {
1100     bitmaps[IMG_BITMAP_GAME] = bitmaps[IMG_BITMAP_STANDARD];
1101
1102     return;
1103   }
1104
1105   Bitmap *bitmap = bitmaps[IMG_BITMAP_STANDARD];
1106   int width  = bitmap->width  * gfx.game_tile_size / gfx.standard_tile_size;;
1107   int height = bitmap->height * gfx.game_tile_size / gfx.standard_tile_size;;
1108
1109   Bitmap *bitmap_new = ZoomBitmap(bitmap, width, height);
1110
1111   bitmaps[IMG_BITMAP_CUSTOM] = bitmap_new;
1112   bitmaps[IMG_BITMAP_GAME]   = bitmap_new;
1113 }
1114
1115 static void CreateScaledBitmaps(Bitmap **bitmaps, int zoom_factor,
1116                                 int tile_size, boolean create_small_bitmaps)
1117 {
1118   Bitmap *old_bitmap = bitmaps[IMG_BITMAP_STANDARD];
1119   Bitmap *tmp_bitmap_final = NULL;
1120   Bitmap *tmp_bitmap_0 = NULL;
1121   Bitmap *tmp_bitmap_1 = NULL;
1122   Bitmap *tmp_bitmap_2 = NULL;
1123   Bitmap *tmp_bitmap_4 = NULL;
1124   Bitmap *tmp_bitmap_8 = NULL;
1125   Bitmap *tmp_bitmap_16 = NULL;
1126   Bitmap *tmp_bitmap_32 = NULL;
1127   int width_final, height_final;
1128   int width_0, height_0;
1129   int width_1, height_1;
1130   int width_2, height_2;
1131   int width_4, height_4;
1132   int width_8, height_8;
1133   int width_16, height_16;
1134   int width_32, height_32;
1135   int old_width, old_height;
1136   int i;
1137
1138   print_timestamp_init("CreateScaledBitmaps");
1139
1140   old_width  = old_bitmap->width;
1141   old_height = old_bitmap->height;
1142
1143   /* calculate new image dimensions for final image size */
1144   width_final  = old_width  * zoom_factor;
1145   height_final = old_height * zoom_factor;
1146
1147   /* get image with final size (this might require scaling up) */
1148   /* ("final" size may result in non-standard tile size image) */
1149   if (zoom_factor != 1)
1150     tmp_bitmap_final = ZoomBitmap(old_bitmap, width_final, height_final);
1151   else
1152     tmp_bitmap_final = old_bitmap;
1153
1154   UPDATE_BUSY_STATE();
1155
1156   width_0  = width_1  = width_final;
1157   height_0 = height_1 = height_final;
1158
1159   tmp_bitmap_0 = tmp_bitmap_1 = tmp_bitmap_final;
1160
1161   if (create_small_bitmaps)
1162   {
1163     /* check if we have a non-gameplay tile size image */
1164     if (tile_size != gfx.game_tile_size)
1165     {
1166       /* get image with gameplay tile size */
1167       width_0  = width_final  * gfx.game_tile_size / tile_size;
1168       height_0 = height_final * gfx.game_tile_size / tile_size;
1169
1170       if (width_0 == old_width)
1171         tmp_bitmap_0 = old_bitmap;
1172       else if (width_0 == width_final)
1173         tmp_bitmap_0 = tmp_bitmap_final;
1174       else
1175         tmp_bitmap_0 = ZoomBitmap(old_bitmap, width_0, height_0);
1176
1177       UPDATE_BUSY_STATE();
1178     }
1179
1180     /* check if we have a non-standard tile size image */
1181     if (tile_size != gfx.standard_tile_size)
1182     {
1183       /* get image with standard tile size */
1184       width_1  = width_final  * gfx.standard_tile_size / tile_size;
1185       height_1 = height_final * gfx.standard_tile_size / tile_size;
1186
1187       if (width_1 == old_width)
1188         tmp_bitmap_1 = old_bitmap;
1189       else if (width_1 == width_final)
1190         tmp_bitmap_1 = tmp_bitmap_final;
1191       else if (width_1 == width_0)
1192         tmp_bitmap_1 = tmp_bitmap_0;
1193       else
1194         tmp_bitmap_1 = ZoomBitmap(old_bitmap, width_1, height_1);
1195
1196       UPDATE_BUSY_STATE();
1197     }
1198
1199     /* calculate new image dimensions for small images */
1200     width_2  = width_1  / 2;
1201     height_2 = height_1 / 2;
1202     width_4  = width_1  / 4;
1203     height_4 = height_1 / 4;
1204     width_8  = width_1  / 8;
1205     height_8 = height_1 / 8;
1206     width_16  = width_1  / 16;
1207     height_16 = height_1 / 16;
1208     width_32  = width_1  / 32;
1209     height_32 = height_1 / 32;
1210
1211     /* get image with 1/2 of normal size (for use in the level editor) */
1212     if (width_2 == old_width)
1213       tmp_bitmap_2 = old_bitmap;
1214     else
1215       tmp_bitmap_2 = ZoomBitmap(tmp_bitmap_1, width_2, height_2);
1216
1217     UPDATE_BUSY_STATE();
1218
1219     /* get image with 1/4 of normal size (for use in the level editor) */
1220     if (width_4 == old_width)
1221       tmp_bitmap_4 = old_bitmap;
1222     else
1223       tmp_bitmap_4 = ZoomBitmap(tmp_bitmap_2, width_4, height_4);
1224
1225     UPDATE_BUSY_STATE();
1226
1227     /* get image with 1/8 of normal size (for use on the preview screen) */
1228     if (width_8 == old_width)
1229       tmp_bitmap_8 = old_bitmap;
1230     else
1231       tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_4, width_8, height_8);
1232
1233     UPDATE_BUSY_STATE();
1234
1235     /* get image with 1/16 of normal size (for use on the preview screen) */
1236     if (width_16 == old_width)
1237       tmp_bitmap_16 = old_bitmap;
1238     else
1239       tmp_bitmap_16 = ZoomBitmap(tmp_bitmap_8, width_16, height_16);
1240
1241     UPDATE_BUSY_STATE();
1242
1243     /* get image with 1/32 of normal size (for use on the preview screen) */
1244     if (width_32 == old_width)
1245       tmp_bitmap_32 = old_bitmap;
1246     else
1247       tmp_bitmap_32 = ZoomBitmap(tmp_bitmap_16, width_32, height_32);
1248
1249     UPDATE_BUSY_STATE();
1250
1251     bitmaps[IMG_BITMAP_32x32] = tmp_bitmap_1;
1252     bitmaps[IMG_BITMAP_16x16] = tmp_bitmap_2;
1253     bitmaps[IMG_BITMAP_8x8]   = tmp_bitmap_4;
1254     bitmaps[IMG_BITMAP_4x4]   = tmp_bitmap_8;
1255     bitmaps[IMG_BITMAP_2x2]   = tmp_bitmap_16;
1256     bitmaps[IMG_BITMAP_1x1]   = tmp_bitmap_32;
1257
1258     if (width_0 != width_1)
1259       bitmaps[IMG_BITMAP_CUSTOM] = tmp_bitmap_0;
1260
1261     if (bitmaps[IMG_BITMAP_CUSTOM])
1262       bitmaps[IMG_BITMAP_GAME] = bitmaps[IMG_BITMAP_CUSTOM];
1263     else
1264       bitmaps[IMG_BITMAP_GAME] = bitmaps[IMG_BITMAP_STANDARD];
1265
1266     boolean free_old_bitmap = TRUE;
1267
1268     for (i = 0; i < NUM_IMG_BITMAPS; i++)
1269       if (bitmaps[i] == old_bitmap)
1270         free_old_bitmap = FALSE;
1271
1272     if (free_old_bitmap)
1273       FreeBitmap(old_bitmap);
1274   }
1275   else
1276   {
1277     bitmaps[IMG_BITMAP_32x32] = tmp_bitmap_1;
1278   }
1279
1280   UPDATE_BUSY_STATE();
1281
1282   print_timestamp_done("CreateScaledBitmaps");
1283 }
1284
1285 void CreateBitmapWithSmallBitmaps(Bitmap **bitmaps, int zoom_factor,
1286                                   int tile_size)
1287 {
1288   CreateScaledBitmaps(bitmaps, zoom_factor, tile_size, TRUE);
1289 }
1290
1291 void CreateBitmapTextures(Bitmap **bitmaps)
1292 {
1293   SDLCreateBitmapTextures(bitmaps[IMG_BITMAP_STANDARD]);
1294 }
1295
1296 void FreeBitmapTextures(Bitmap **bitmaps)
1297 {
1298   SDLFreeBitmapTextures(bitmaps[IMG_BITMAP_STANDARD]);
1299 }
1300
1301 void ScaleBitmap(Bitmap **bitmaps, int zoom_factor)
1302 {
1303   CreateScaledBitmaps(bitmaps, zoom_factor, 0, FALSE);
1304 }
1305
1306
1307 /* ------------------------------------------------------------------------- */
1308 /* mouse pointer functions                                                   */
1309 /* ------------------------------------------------------------------------- */
1310
1311 #define USE_ONE_PIXEL_PLAYFIELD_MOUSEPOINTER            0
1312
1313 /* XPM image definitions */
1314 static const char *cursor_image_none[] =
1315 {
1316   /* width height num_colors chars_per_pixel */
1317   "    16    16        3            1",
1318
1319   /* colors */
1320   "X c #000000",
1321   ". c #ffffff",
1322   "  c None",
1323
1324   /* pixels */
1325   "                ",
1326   "                ",
1327   "                ",
1328   "                ",
1329   "                ",
1330   "                ",
1331   "                ",
1332   "                ",
1333   "                ",
1334   "                ",
1335   "                ",
1336   "                ",
1337   "                ",
1338   "                ",
1339   "                ",
1340   "                ",
1341
1342   /* hot spot */
1343   "0,0"
1344 };
1345
1346 #if USE_ONE_PIXEL_PLAYFIELD_MOUSEPOINTER
1347 static const char *cursor_image_dot[] =
1348 {
1349   /* width height num_colors chars_per_pixel */
1350   "    16    16        3            1",
1351
1352   /* colors */
1353   "X c #000000",
1354   ". c #ffffff",
1355   "  c None",
1356
1357   /* pixels */
1358   " X              ",
1359   "X.X             ",
1360   " X              ",
1361   "                ",
1362   "                ",
1363   "                ",
1364   "                ",
1365   "                ",
1366   "                ",
1367   "                ",
1368   "                ",
1369   "                ",
1370   "                ",
1371   "                ",
1372   "                ",
1373   "                ",
1374
1375   /* hot spot */
1376   "1,1"
1377 };
1378 static const char **cursor_image_playfield = cursor_image_dot;
1379 #else
1380 /* some people complained about a "white dot" on the screen and thought it
1381    was a graphical error... OK, let's just remove the whole pointer :-) */
1382 static const char **cursor_image_playfield = cursor_image_none;
1383 #endif
1384
1385 static const int cursor_bit_order = BIT_ORDER_MSB;
1386
1387 static struct MouseCursorInfo *get_cursor_from_image(const char **image)
1388 {
1389   struct MouseCursorInfo *cursor;
1390   boolean bit_order_msb = (cursor_bit_order == BIT_ORDER_MSB);
1391   int header_lines = 4;
1392   int x, y, i;
1393
1394   cursor = checked_calloc(sizeof(struct MouseCursorInfo));
1395
1396   sscanf(image[0], " %d %d ", &cursor->width, &cursor->height);
1397
1398   i = -1;
1399   for (y = 0; y < cursor->width; y++)
1400   {
1401     for (x = 0; x < cursor->height; x++)
1402     {
1403       int bit_nr = x % 8;
1404       int bit_mask = 0x01 << (bit_order_msb ? 7 - bit_nr : bit_nr );
1405
1406       if (bit_nr == 0)
1407       {
1408         i++;
1409         cursor->data[i] = cursor->mask[i] = 0;
1410       }
1411
1412       switch (image[header_lines + y][x])
1413       {
1414         case 'X':
1415           cursor->data[i] |= bit_mask;
1416           cursor->mask[i] |= bit_mask;
1417           break;
1418
1419         case '.':
1420           cursor->mask[i] |= bit_mask;
1421           break;
1422
1423         case ' ':
1424           break;
1425       }
1426     }
1427   }
1428
1429   sscanf(image[header_lines + y], "%d,%d", &cursor->hot_x, &cursor->hot_y);
1430
1431   return cursor;
1432 }
1433
1434 void SetMouseCursor(int mode)
1435 {
1436   static struct MouseCursorInfo *cursor_none = NULL;
1437   static struct MouseCursorInfo *cursor_playfield = NULL;
1438   struct MouseCursorInfo *cursor_new;
1439
1440   if (cursor_none == NULL)
1441     cursor_none = get_cursor_from_image(cursor_image_none);
1442
1443   if (cursor_playfield == NULL)
1444     cursor_playfield = get_cursor_from_image(cursor_image_playfield);
1445
1446   cursor_new = (mode == CURSOR_DEFAULT   ? NULL :
1447                 mode == CURSOR_NONE      ? cursor_none :
1448                 mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL);
1449
1450   SDLSetMouseCursor(cursor_new);
1451
1452   gfx.cursor_mode = mode;
1453 }
1454
1455
1456 /* ========================================================================= */
1457 /* audio functions                                                           */
1458 /* ========================================================================= */
1459
1460 void OpenAudio(void)
1461 {
1462   /* always start with reliable default values */
1463   audio.sound_available = FALSE;
1464   audio.music_available = FALSE;
1465   audio.loops_available = FALSE;
1466
1467   audio.sound_enabled = FALSE;
1468   audio.sound_deactivated = FALSE;
1469
1470   audio.mixer_pipe[0] = audio.mixer_pipe[1] = 0;
1471   audio.mixer_pid = 0;
1472   audio.device_name = NULL;
1473   audio.device_fd = -1;
1474
1475   audio.num_channels = 0;
1476   audio.music_channel = 0;
1477   audio.first_sound_channel = 0;
1478
1479   SDLOpenAudio();
1480 }
1481
1482 void CloseAudio(void)
1483 {
1484   SDLCloseAudio();
1485
1486   audio.sound_enabled = FALSE;
1487 }
1488
1489 void SetAudioMode(boolean enabled)
1490 {
1491   if (!audio.sound_available)
1492     return;
1493
1494   audio.sound_enabled = enabled;
1495 }
1496
1497
1498 /* ========================================================================= */
1499 /* event functions                                                           */
1500 /* ========================================================================= */
1501
1502 boolean PendingEvent(void)
1503 {
1504   return (SDL_PollEvent(NULL) ? TRUE : FALSE);
1505 }
1506
1507 void WaitEvent(Event *event)
1508 {
1509   SDLWaitEvent(event);
1510 }
1511
1512 void PeekEvent(Event *event)
1513 {
1514 #if defined(TARGET_SDL2)
1515   SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT);
1516 #else
1517   SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_ALLEVENTS);
1518 #endif
1519 }
1520
1521 void CheckQuitEvent(void)
1522 {
1523   if (SDL_QuitRequested())
1524     program.exit_function(0);
1525 }
1526
1527 Key GetEventKey(KeyEvent *event, boolean with_modifiers)
1528 {
1529 #if defined(TARGET_SDL2)
1530   /* key up/down events in SDL2 do not return text characters anymore */
1531   return event->keysym.sym;
1532 #else
1533
1534 #if ENABLE_UNUSED_CODE
1535   printf("unicode == '%d', sym == '%d', mod == '0x%04x'\n",
1536          (int)event->keysym.unicode,
1537          (int)event->keysym.sym,
1538          (int)SDL_GetModState());
1539 #endif
1540
1541   if (with_modifiers &&
1542       event->keysym.unicode > 0x0000 &&
1543       event->keysym.unicode < 0x2000)
1544     return event->keysym.unicode;
1545   else
1546     return event->keysym.sym;
1547
1548 #endif
1549 }
1550
1551 KeyMod HandleKeyModState(Key key, int key_status)
1552 {
1553   static KeyMod current_modifiers = KMOD_None;
1554
1555   if (key != KSYM_UNDEFINED)    /* new key => check for modifier key change */
1556   {
1557     KeyMod new_modifier = KMOD_None;
1558
1559     switch(key)
1560     {
1561       case KSYM_Shift_L:
1562         new_modifier = KMOD_Shift_L;
1563         break;
1564       case KSYM_Shift_R:
1565         new_modifier = KMOD_Shift_R;
1566         break;
1567       case KSYM_Control_L:
1568         new_modifier = KMOD_Control_L;
1569         break;
1570       case KSYM_Control_R:
1571         new_modifier = KMOD_Control_R;
1572         break;
1573       case KSYM_Meta_L:
1574         new_modifier = KMOD_Meta_L;
1575         break;
1576       case KSYM_Meta_R:
1577         new_modifier = KMOD_Meta_R;
1578         break;
1579       case KSYM_Alt_L:
1580         new_modifier = KMOD_Alt_L;
1581         break;
1582       case KSYM_Alt_R:
1583         new_modifier = KMOD_Alt_R;
1584         break;
1585       default:
1586         break;
1587     }
1588
1589     if (key_status == KEY_PRESSED)
1590       current_modifiers |= new_modifier;
1591     else
1592       current_modifiers &= ~new_modifier;
1593   }
1594
1595   return current_modifiers;
1596 }
1597
1598 KeyMod GetKeyModState()
1599 {
1600   return (KeyMod)SDL_GetModState();
1601 }
1602
1603 KeyMod GetKeyModStateFromEvents()
1604 {
1605   /* always use key modifier state as tracked from key events (this is needed
1606      if the modifier key event was injected into the event queue, but the key
1607      was not really pressed on keyboard -- SDL_GetModState() seems to directly
1608      query the keys as held pressed on the keyboard) -- this case is currently
1609      only used to filter out clipboard insert events from "True X-Mouse" tool */
1610
1611   return HandleKeyModState(KSYM_UNDEFINED, 0);
1612 }
1613
1614 void StartTextInput(int x, int y, int width, int height)
1615 {
1616 #if defined(TARGET_SDL2)
1617 #if defined(HAS_SCREEN_KEYBOARD)
1618   SDL_StartTextInput();
1619
1620   if (y + height > SCREEN_KEYBOARD_POS(video.height))
1621   {
1622     video.shifted_up_pos = y + height - SCREEN_KEYBOARD_POS(video.height);
1623     video.shifted_up_delay = SDL_GetTicks();
1624     video.shifted_up = TRUE;
1625   }
1626 #endif
1627 #endif
1628 }
1629
1630 void StopTextInput()
1631 {
1632 #if defined(TARGET_SDL2)
1633 #if defined(HAS_SCREEN_KEYBOARD)
1634   SDL_StopTextInput();
1635
1636   if (video.shifted_up)
1637   {
1638     video.shifted_up_pos = 0;
1639     video.shifted_up_delay = SDL_GetTicks();
1640     video.shifted_up = FALSE;
1641   }
1642 #endif
1643 #endif
1644 }
1645
1646 boolean CheckCloseWindowEvent(ClientMessageEvent *event)
1647 {
1648   if (event->type != EVENT_CLIENTMESSAGE)
1649     return FALSE;
1650
1651   return TRUE;          /* the only possible message here is SDL_QUIT */
1652 }
1653
1654
1655 /* ========================================================================= */
1656 /* joystick functions                                                        */
1657 /* ========================================================================= */
1658
1659 void InitJoysticks()
1660 {
1661   int i;
1662
1663 #if defined(NO_JOYSTICK)
1664   return;       /* joysticks generally deactivated by compile-time directive */
1665 #endif
1666
1667   /* always start with reliable default values */
1668   joystick.status = JOYSTICK_NOT_AVAILABLE;
1669   for (i = 0; i < MAX_PLAYERS; i++)
1670     joystick.nr[i] = -1;                /* no joystick configured */
1671
1672   SDLInitJoysticks();
1673 }
1674
1675 boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
1676 {
1677   return SDLReadJoystick(nr, x, y, b1, b2);
1678 }
1679
1680 boolean CheckJoystickOpened(int nr)
1681 {
1682   return SDLCheckJoystickOpened(nr);
1683 }
1684
1685 void ClearJoystickState()
1686 {
1687   SDLClearJoystickState();
1688 }