src/libgame/system.c

   1 /***********************************************************
   2 * Artsoft Retro-Game Library                               *
   3 *----------------------------------------------------------*
   4 * (c) 1994-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * system.c                                                 *
  12 ***********************************************************/
  13
  14 #include <string.h>
  15 #include <signal.h>
  16
  17 #include "platform.h"
  18
  19 #if defined(PLATFORM_MSDOS)
  20 #include <fcntl.h>
  21 #endif
  22
  23 #include "system.h"
  24 #include "image.h"
  25 #include "sound.h"
  26 #include "setup.h"
  27 #include "joystick.h"
  28 #include "misc.h"
  29
  30
  31 /* ========================================================================= */
  32 /* exported variables                                                        */
  33 /* ========================================================================= */
  34
  35 struct ProgramInfo      program;
  36 struct OptionInfo       options;
  37 struct VideoSystemInfo  video;
  38 struct AudioSystemInfo  audio;
  39 struct GfxInfo          gfx;
  40 struct ArtworkInfo      artwork;
  41 struct JoystickInfo     joystick;
  42 struct SetupInfo        setup;
  43
  44 LevelDirTree           *leveldir_first_all = NULL;
  45 LevelDirTree           *leveldir_first = NULL;
  46 LevelDirTree           *leveldir_current = NULL;
  47 int                     level_nr;
  48
  49 Display                *display = NULL;
  50 Visual                 *visual = NULL;
  51 int                     screen = 0;
  52 Colormap                cmap = None;
  53
  54 DrawWindow             *window = NULL;
  55 DrawBuffer             *backbuffer = NULL;
  56 DrawBuffer             *drawto = NULL;
  57
  58 int                     button_status = MB_NOT_PRESSED;
  59 boolean                 motion_status = FALSE;
  60
  61 int                     redraw_mask = REDRAW_NONE;
  62 int                     redraw_tiles = 0;
  63
  64 int                     FrameCounter = 0;
  65
  66
  67 /* ========================================================================= */
  68 /* init/close functions                                                      */
  69 /* ========================================================================= */
  70
  71 void InitProgramInfo(char *argv0,
  72                      char *userdata_subdir, char *userdata_subdir_unix,
  73                      char *program_title, char *window_title, char *icon_title,
  74                      char *x11_icon_filename, char *x11_iconmask_filename,
  75                      char *msdos_cursor_filename,
  76                      char *cookie_prefix, char *filename_prefix,
  77                      int program_version)
  78 {
  79   program.command_basepath = getBasePath(argv0);
  80   program.command_basename = getBaseName(argv0);
  81
  82   program.userdata_subdir = userdata_subdir;
  83   program.userdata_subdir_unix = userdata_subdir_unix;
  84   program.userdata_path = getUserGameDataDir();
  85
  86   program.program_title = program_title;
  87   program.window_title = window_title;
  88   program.icon_title = icon_title;
  89
  90   program.x11_icon_filename = x11_icon_filename;
  91   program.x11_iconmask_filename = x11_iconmask_filename;
  92   program.msdos_cursor_filename = msdos_cursor_filename;
  93
  94   program.cookie_prefix = cookie_prefix;
  95   program.filename_prefix = filename_prefix;
  96
  97   program.version_major = VERSION_MAJOR(program_version);
  98   program.version_minor = VERSION_MINOR(program_version);
  99   program.version_patch = VERSION_PATCH(program_version);
 100
 101   program.error_filename = getErrorFilename(ERROR_BASENAME);
 102   program.error_file = stderr;
 103 }
 104
 105 void InitExitFunction(void (*exit_function)(int))
 106 {
 107   program.exit_function = exit_function;
 108
 109   /* set signal handlers to custom exit function */
 110   signal(SIGINT, exit_function);
 111   signal(SIGTERM, exit_function);
 112
 113 #if defined(TARGET_SDL)
 114   /* set exit function to automatically cleanup SDL stuff after exit() */
 115   atexit(SDL_Quit);
 116 #endif
 117 }
 118
 119 void InitPlatformDependentStuff(void)
 120 {
 121 #if defined(PLATFORM_MSDOS)
 122   _fmode = O_BINARY;
 123 #endif
 124
 125 #if defined(PLATFORM_MACOSX)
 126   fixUserGameDataDir();
 127 #endif
 128
 129 #if !defined(PLATFORM_UNIX) || defined(PLATFORM_MACOSX)
 130   openErrorFile();
 131 #endif
 132
 133 #if defined(TARGET_SDL)
 134   if (SDL_Init(SDL_INIT_EVENTTHREAD | SDL_INIT_NOPARACHUTE) < 0)
 135     Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
 136
 137   SDLNet_Init();
 138 #endif
 139 }
 140
 141 void ClosePlatformDependentStuff(void)
 142 {
 143 #if defined(PLATFORM_WIN32) || defined(PLATFORM_MSDOS)
 144   closeErrorFile();
 145 #endif
 146
 147 #if defined(PLATFORM_MSDOS)
 148   dumpErrorFile();
 149 #endif
 150 }
 151
 152 void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
 153                       int real_sx, int real_sy,
 154                       int full_sxsize, int full_sysize,
 155                       Bitmap *field_save_buffer)
 156 {
 157   gfx.sx = sx;
 158   gfx.sy = sy;
 159   gfx.sxsize = sxsize;
 160   gfx.sysize = sysize;
 161   gfx.real_sx = real_sx;
 162   gfx.real_sy = real_sy;
 163   gfx.full_sxsize = full_sxsize;
 164   gfx.full_sysize = full_sysize;
 165
 166   gfx.field_save_buffer = field_save_buffer;
 167
 168   gfx.background_bitmap = NULL;
 169   gfx.background_bitmap_mask = REDRAW_NONE;
 170
 171   SetDrawDeactivationMask(REDRAW_NONE);         /* do not deactivate drawing */
 172   SetDrawBackgroundMask(REDRAW_NONE);           /* deactivate masked drawing */
 173 }
 174
 175 void InitGfxDoor1Info(int dx, int dy, int dxsize, int dysize)
 176 {
 177   gfx.dx = dx;
 178   gfx.dy = dy;
 179   gfx.dxsize = dxsize;
 180   gfx.dysize = dysize;
 181 }
 182
 183 void InitGfxDoor2Info(int vx, int vy, int vxsize, int vysize)
 184 {
 185   gfx.vx = vx;
 186   gfx.vy = vy;
 187   gfx.vxsize = vxsize;
 188   gfx.vysize = vysize;
 189 }
 190
 191 void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height)
 192 {
 193   /* currently only used by MSDOS code to alloc VRAM buffer, if available */
 194   gfx.scrollbuffer_width = scrollbuffer_width;
 195   gfx.scrollbuffer_height = scrollbuffer_height;
 196 }
 197
 198 void SetDrawDeactivationMask(int draw_deactivation_mask)
 199 {
 200   gfx.draw_deactivation_mask = draw_deactivation_mask;
 201 }
 202
 203 void SetDrawBackgroundMask(int draw_background_mask)
 204 {
 205   gfx.draw_background_mask = draw_background_mask;
 206 }
 207
 208 static void DrawBitmapFromTile(Bitmap *bitmap, Bitmap *tile,
 209                                int dest_x, int dest_y, int width, int height)
 210 {
 211   int bitmap_xsize = width;
 212   int bitmap_ysize = height;
 213   int tile_xsize = tile->width;
 214   int tile_ysize = tile->height;
 215   int tile_xsteps = (bitmap_xsize + tile_xsize - 1) / tile_xsize;
 216   int tile_ysteps = (bitmap_ysize + tile_ysize - 1) / tile_ysize;
 217   int x, y;
 218
 219   for (y = 0; y < tile_ysteps; y++)
 220   {
 221     for (x = 0; x < tile_xsteps; x++)
 222     {
 223       int draw_x = dest_x + x * tile_xsize;
 224       int draw_y = dest_y + y * tile_ysize;
 225       int draw_xsize = MIN(tile_xsize, bitmap_xsize - x * tile_xsize);
 226       int draw_ysize = MIN(tile_ysize, bitmap_ysize - y * tile_ysize);
 227
 228       BlitBitmap(tile, bitmap, 0, 0, draw_xsize, draw_ysize, draw_x, draw_y);
 229     }
 230   }
 231 }
 232
 233 void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
 234 {
 235   if (background_bitmap_tile != NULL)
 236     gfx.background_bitmap_mask |= mask;
 237   else
 238     gfx.background_bitmap_mask &= ~mask;
 239
 240   if (gfx.background_bitmap == NULL)
 241     gfx.background_bitmap = CreateBitmap(video.width, video.height,
 242                                          DEFAULT_DEPTH);
 243
 244   if (background_bitmap_tile == NULL)   /* empty background requested */
 245     return;
 246
 247   if (mask == REDRAW_FIELD)
 248     DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
 249                        gfx.real_sx, gfx.real_sy,
 250                        gfx.full_sxsize, gfx.full_sysize);
 251   else if (mask == REDRAW_DOOR_1)
 252   {
 253     DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
 254                        gfx.dx, gfx.dy,
 255                        gfx.dxsize, gfx.dysize);
 256   }
 257 }
 258
 259 void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
 260 {
 261   SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
 262 }
 263
 264 void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
 265 {
 266   SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
 267 }
 268
 269
 270 /* ========================================================================= */
 271 /* video functions                                                           */
 272 /* ========================================================================= */
 273
 274 inline static int GetRealDepth(int depth)
 275 {
 276   return (depth == DEFAULT_DEPTH ? video.default_depth : depth);
 277 }
 278
 279 inline static void sysFillRectangle(Bitmap *bitmap, int x, int y,
 280                                int width, int height, Pixel color)
 281 {
 282 #if defined(TARGET_SDL)
 283   SDLFillRectangle(bitmap, x, y, width, height, color);
 284 #else
 285   X11FillRectangle(bitmap, x, y, width, height, color);
 286 #endif
 287 }
 288
 289 inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 290                                int src_x, int src_y, int width, int height,
 291                                int dst_x, int dst_y, int mask_mode)
 292 {
 293 #if defined(TARGET_SDL)
 294   SDLCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 295               dst_x, dst_y, mask_mode);
 296 #else
 297   X11CopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 298               dst_x, dst_y, mask_mode);
 299 #endif
 300 }
 301
 302 void InitVideoDisplay(void)
 303 {
 304 #if defined(TARGET_SDL)
 305   SDLInitVideoDisplay();
 306 #else
 307   X11InitVideoDisplay();
 308 #endif
 309 }
 310
 311 void CloseVideoDisplay(void)
 312 {
 313   KeyboardAutoRepeatOn();
 314
 315 #if defined(TARGET_SDL)
 316   SDL_QuitSubSystem(SDL_INIT_VIDEO);
 317 #else
 318   if (display)
 319     XCloseDisplay(display);
 320 #endif
 321 }
 322
 323 void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
 324                      int width, int height, int depth, boolean fullscreen)
 325 {
 326   video.width = width;
 327   video.height = height;
 328   video.depth = GetRealDepth(depth);
 329   video.fullscreen_available = FULLSCREEN_STATUS;
 330   video.fullscreen_enabled = FALSE;
 331
 332 #if defined(TARGET_SDL)
 333   SDLInitVideoBuffer(backbuffer, window, fullscreen);
 334 #else
 335   X11InitVideoBuffer(backbuffer, window);
 336 #endif
 337 }
 338
 339 Bitmap *CreateBitmapStruct(void)
 340 {
 341 #if defined(TARGET_SDL)
 342   return checked_calloc(sizeof(struct SDLSurfaceInfo));
 343 #else
 344   return checked_calloc(sizeof(struct X11DrawableInfo));
 345 #endif
 346 }
 347
 348 Bitmap *CreateBitmap(int width, int height, int depth)
 349 {
 350   Bitmap *new_bitmap = CreateBitmapStruct();
 351   int real_depth = GetRealDepth(depth);
 352
 353 #if defined(TARGET_SDL)
 354   SDLCreateBitmapContent(new_bitmap, width, height, real_depth);
 355 #else
 356   X11CreateBitmapContent(new_bitmap, width, height, real_depth);
 357 #endif
 358
 359   new_bitmap->width = width;
 360   new_bitmap->height = height;
 361
 362   return new_bitmap;
 363 }
 364
 365 inline static void FreeBitmapPointers(Bitmap *bitmap)
 366 {
 367   if (bitmap == NULL)
 368     return;
 369
 370 #if defined(TARGET_SDL)
 371   SDLFreeBitmapPointers(bitmap);
 372 #else
 373   X11FreeBitmapPointers(bitmap);
 374 #endif
 375
 376   checked_free(bitmap->source_filename);
 377   bitmap->source_filename = NULL;
 378 }
 379
 380 inline static void TransferBitmapPointers(Bitmap *src_bitmap,
 381                                           Bitmap *dst_bitmap)
 382 {
 383   if (src_bitmap == NULL || dst_bitmap == NULL)
 384     return;
 385
 386   FreeBitmapPointers(dst_bitmap);
 387
 388   *dst_bitmap = *src_bitmap;
 389 }
 390
 391 void FreeBitmap(Bitmap *bitmap)
 392 {
 393   if (bitmap == NULL)
 394     return;
 395
 396   FreeBitmapPointers(bitmap);
 397
 398   free(bitmap);
 399 }
 400
 401 void CloseWindow(DrawWindow *window)
 402 {
 403 #if defined(TARGET_X11)
 404   if (window->drawable)
 405   {
 406     XUnmapWindow(display, window->drawable);
 407     XDestroyWindow(display, window->drawable);
 408   }
 409   if (window->gc)
 410     XFreeGC(display, window->gc);
 411 #endif
 412 }
 413
 414 inline static boolean CheckDrawingArea(int x, int y, int width, int height,
 415                                        int draw_mask)
 416 {
 417   if (draw_mask == REDRAW_NONE)
 418     return FALSE;
 419
 420   if (draw_mask & REDRAW_ALL)
 421     return TRUE;
 422
 423   if ((draw_mask & REDRAW_FIELD) && x < gfx.real_sx + gfx.full_sxsize)
 424     return TRUE;
 425
 426   if ((draw_mask & REDRAW_DOOR_1) && x >= gfx.dx && y < gfx.dy + gfx.dysize)
 427     return TRUE;
 428
 429   if ((draw_mask & REDRAW_DOOR_2) && x >= gfx.dx && y >= gfx.vy)
 430     return TRUE;
 431
 432   return FALSE;
 433 }
 434
 435 boolean DrawingDeactivated(int x, int y, int width, int height)
 436 {
 437   return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
 438 }
 439
 440 boolean DrawingOnBackground(int x, int y)
 441 {
 442   return (CheckDrawingArea(x, y, 1, 1, gfx.background_bitmap_mask) &&
 443           CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
 444 }
 445
 446 void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 447                 int src_x, int src_y, int width, int height,
 448                 int dst_x, int dst_y)
 449 {
 450   if (DrawingDeactivated(dst_x, dst_y, width, height))
 451     return;
 452
 453   sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 454               dst_x, dst_y, BLIT_OPAQUE);
 455 }
 456
 457 void FadeScreen(Bitmap *bitmap_cross, int fade_mode, int fade_delay,
 458                 int post_delay)
 459 {
 460 #if defined(TARGET_SDL)
 461   SDLFadeScreen(bitmap_cross, fade_mode, fade_delay, post_delay);
 462 #else
 463   X11FadeScreen(bitmap_cross, fade_mode, fade_delay, post_delay);
 464 #endif
 465 }
 466
 467 void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
 468                    Pixel color)
 469 {
 470   if (DrawingDeactivated(x, y, width, height))
 471     return;
 472
 473   sysFillRectangle(bitmap, x, y, width, height, color);
 474 }
 475
 476 void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
 477 {
 478   FillRectangle(bitmap, x, y, width, height, BLACK_PIXEL);
 479 }
 480
 481 void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
 482                                 int width, int height)
 483 {
 484   if (DrawingOnBackground(x, y))
 485     BlitBitmap(gfx.background_bitmap, bitmap, x, y, width, height, x, y);
 486   else
 487     ClearRectangle(bitmap, x, y, width, height);
 488 }
 489
 490 void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
 491 {
 492 #if defined(TARGET_X11)
 493   if (clip_gc)
 494   {
 495     bitmap->clip_gc = clip_gc;
 496     XSetClipMask(display, bitmap->clip_gc, clip_pixmap);
 497   }
 498 #endif
 499 }
 500
 501 void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
 502 {
 503 #if defined(TARGET_X11)
 504   if (clip_gc)
 505   {
 506     bitmap->clip_gc = clip_gc;
 507     XSetClipOrigin(display, bitmap->clip_gc, clip_x, clip_y);
 508   }
 509 #endif
 510 }
 511
 512 void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 513                       int src_x, int src_y, int width, int height,
 514                       int dst_x, int dst_y)
 515 {
 516   if (DrawingDeactivated(dst_x, dst_y, width, height))
 517     return;
 518
 519   sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 520               dst_x, dst_y, BLIT_MASKED);
 521 }
 522
 523 void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 524                             int src_x, int src_y, int width, int height,
 525                             int dst_x, int dst_y)
 526 {
 527   if (DrawingOnBackground(dst_x, dst_y))
 528   {
 529     /* draw background */
 530     BlitBitmap(gfx.background_bitmap, dst_bitmap, dst_x, dst_y, width, height,
 531                dst_x, dst_y);
 532
 533     /* draw foreground */
 534     SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc,
 535                   dst_x - src_x, dst_y - src_y);
 536     BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 537                      dst_x, dst_y);
 538   }
 539   else
 540     BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, width, height,
 541                dst_x, dst_y);
 542 }
 543
 544 void DrawSimpleBlackLine(Bitmap *bitmap, int from_x, int from_y,
 545                          int to_x, int to_y)
 546 {
 547 #if defined(TARGET_SDL)
 548   SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, BLACK_PIXEL);
 549 #else
 550   X11DrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, BLACK_PIXEL);
 551 #endif
 552 }
 553
 554 void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
 555                          int to_x, int to_y)
 556 {
 557 #if defined(TARGET_SDL)
 558   SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL);
 559 #else
 560   X11DrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, WHITE_PIXEL);
 561 #endif
 562 }
 563
 564 #if !defined(TARGET_X11_NATIVE)
 565 void DrawLine(Bitmap *bitmap, int from_x, int from_y,
 566               int to_x, int to_y, Pixel pixel, int line_width)
 567 {
 568   int x, y;
 569
 570   for (x = 0; x < line_width; x++)
 571   {
 572     for (y = 0; y < line_width; y++)
 573     {
 574       int dx = x - line_width / 2;
 575       int dy = y - line_width / 2;
 576
 577       if ((x == 0 && y == 0) ||
 578           (x == 0 && y == line_width - 1) ||
 579           (x == line_width - 1 && y == 0) ||
 580           (x == line_width - 1 && y == line_width - 1))
 581         continue;
 582
 583 #if defined(TARGET_SDL)
 584       SDLDrawLine(bitmap,
 585                   from_x + dx, from_y + dy, to_x + dx, to_y + dy, pixel);
 586 #elif defined(TARGET_ALLEGRO)
 587       AllegroDrawLine(bitmap->drawable, from_x + dx, from_y + dy,
 588                       to_x + dx, to_y + dy, pixel);
 589 #endif
 590     }
 591   }
 592 }
 593 #endif
 594
 595 void DrawLines(Bitmap *bitmap, struct XY *points, int num_points, Pixel pixel)
 596 {
 597 #if !defined(TARGET_X11_NATIVE)
 598   int line_width = 4;
 599   int i;
 600
 601   for (i = 0; i < num_points - 1; i++)
 602     DrawLine(bitmap, points[i].x, points[i].y,
 603              points[i + 1].x, points[i + 1].y, pixel, line_width);
 604
 605   /*
 606   SDLDrawLines(bitmap->surface, points, num_points, pixel);
 607   */
 608 #else
 609   XSetForeground(display, bitmap->line_gc[1], pixel);
 610   XDrawLines(display, bitmap->drawable, bitmap->line_gc[1],
 611              (XPoint *)points, num_points, CoordModeOrigin);
 612 #endif
 613 }
 614
 615 Pixel GetPixel(Bitmap *bitmap, int x, int y)
 616 {
 617   if (x < 0 || x >= bitmap->width ||
 618       y < 0 || y >= bitmap->height)
 619     return BLACK_PIXEL;
 620
 621 #if defined(TARGET_SDL)
 622   return SDLGetPixel(bitmap, x, y);
 623 #elif defined(TARGET_ALLEGRO)
 624   return AllegroGetPixel(bitmap->drawable, x, y);
 625 #else
 626   return X11GetPixel(bitmap, x, y);
 627 #endif
 628 }
 629
 630 Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
 631                       unsigned int color_g, unsigned int color_b)
 632 {
 633 #if defined(TARGET_SDL)
 634   return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
 635 #elif defined(TARGET_ALLEGRO)
 636   return AllegroAllocColorCell(color_r << 8, color_g << 8, color_b << 8);
 637 #else
 638   return X11GetPixelFromRGB(color_r, color_g, color_b);
 639 #endif
 640 }
 641
 642 Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
 643 {
 644   unsigned int color_r = (color >> 16) & 0xff;
 645   unsigned int color_g = (color >>  8) & 0xff;
 646   unsigned int color_b = (color >>  0) & 0xff;
 647
 648   return GetPixelFromRGB(bitmap, color_r, color_g, color_b);
 649 }
 650
 651 /* execute all pending screen drawing operations */
 652 void FlushDisplay(void)
 653 {
 654 #ifndef TARGET_SDL
 655   XFlush(display);
 656 #endif
 657 }
 658
 659 /* execute and wait for all pending screen drawing operations */
 660 void SyncDisplay(void)
 661 {
 662 #ifndef TARGET_SDL
 663   XSync(display, FALSE);
 664 #endif
 665 }
 666
 667 void KeyboardAutoRepeatOn(void)
 668 {
 669 #if defined(TARGET_SDL)
 670   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY / 2,
 671                       SDL_DEFAULT_REPEAT_INTERVAL / 2);
 672   SDL_EnableUNICODE(1);
 673 #else
 674   if (display)
 675     XAutoRepeatOn(display);
 676 #endif
 677 }
 678
 679 void KeyboardAutoRepeatOff(void)
 680 {
 681 #if defined(TARGET_SDL)
 682   SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
 683   SDL_EnableUNICODE(0);
 684 #else
 685   if (display)
 686     XAutoRepeatOff(display);
 687 #endif
 688 }
 689
 690 boolean PointerInWindow(DrawWindow *window)
 691 {
 692 #if defined(TARGET_SDL)
 693   return TRUE;
 694 #else
 695   Window root, child;
 696   int root_x, root_y;
 697   unsigned int mask;
 698   int win_x, win_y;
 699
 700   /* if XQueryPointer() returns False, the pointer
 701      is not on the same screen as the specified window */
 702   return XQueryPointer(display, window->drawable, &root, &child,
 703                        &root_x, &root_y, &win_x, &win_y, &mask);
 704 #endif
 705 }
 706
 707 boolean SetVideoMode(boolean fullscreen)
 708 {
 709 #if defined(TARGET_SDL)
 710   return SDLSetVideoMode(&backbuffer, fullscreen);
 711 #else
 712   boolean success = TRUE;
 713
 714   if (fullscreen && video.fullscreen_available)
 715   {
 716     Error(ERR_WARN, "fullscreen not available in X11 version");
 717
 718     /* display error message only once */
 719     video.fullscreen_available = FALSE;
 720
 721     success = FALSE;
 722   }
 723
 724   return success;
 725 #endif
 726 }
 727
 728 boolean ChangeVideoModeIfNeeded(boolean fullscreen)
 729 {
 730 #if defined(TARGET_SDL)
 731   if ((fullscreen && !video.fullscreen_enabled && video.fullscreen_available)||
 732       (!fullscreen && video.fullscreen_enabled))
 733     fullscreen = SetVideoMode(fullscreen);
 734 #endif
 735
 736   return fullscreen;
 737 }
 738
 739 Bitmap *LoadImage(char *filename)
 740 {
 741   Bitmap *new_bitmap;
 742
 743 #if defined(TARGET_SDL)
 744   new_bitmap = SDLLoadImage(filename);
 745 #else
 746   new_bitmap = X11LoadImage(filename);
 747 #endif
 748
 749   if (new_bitmap)
 750     new_bitmap->source_filename = getStringCopy(filename);
 751
 752   return new_bitmap;
 753 }
 754
 755 Bitmap *LoadCustomImage(char *basename)
 756 {
 757   char *filename = getCustomImageFilename(basename);
 758   Bitmap *new_bitmap;
 759
 760   if (filename == NULL)
 761     Error(ERR_EXIT, "LoadCustomImage(): cannot find file '%s'", basename);
 762
 763   if ((new_bitmap = LoadImage(filename)) == NULL)
 764     Error(ERR_EXIT, "LoadImage() failed: %s", GetError());
 765
 766   return new_bitmap;
 767 }
 768
 769 void ReloadCustomImage(Bitmap *bitmap, char *basename)
 770 {
 771   char *filename = getCustomImageFilename(basename);
 772   Bitmap *new_bitmap;
 773
 774   if (filename == NULL)         /* (should never happen) */
 775   {
 776     Error(ERR_WARN, "ReloadCustomImage(): cannot find file '%s'", basename);
 777     return;
 778   }
 779
 780   if (strEqual(filename, bitmap->source_filename))
 781   {
 782     /* The old and new image are the same (have the same filename and path).
 783        This usually means that this image does not exist in this graphic set
 784        and a fallback to the existing image is done. */
 785
 786     return;
 787   }
 788
 789   if ((new_bitmap = LoadImage(filename)) == NULL)
 790   {
 791     Error(ERR_WARN, "LoadImage() failed: %s", GetError());
 792     return;
 793   }
 794
 795   if (bitmap->width != new_bitmap->width ||
 796       bitmap->height != new_bitmap->height)
 797   {
 798     Error(ERR_WARN, "ReloadCustomImage: new image '%s' has wrong dimensions",
 799           filename);
 800     FreeBitmap(new_bitmap);
 801     return;
 802   }
 803
 804   TransferBitmapPointers(new_bitmap, bitmap);
 805   free(new_bitmap);
 806 }
 807
 808 Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
 809 {
 810   Bitmap *dst_bitmap = CreateBitmap(zoom_width, zoom_height, DEFAULT_DEPTH);
 811
 812 #if defined(TARGET_SDL)
 813   SDLZoomBitmap(src_bitmap, dst_bitmap);
 814 #else
 815   X11ZoomBitmap(src_bitmap, dst_bitmap);
 816 #endif
 817
 818   return dst_bitmap;
 819 }
 820
 821 static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
 822                                 boolean create_small_bitmaps)
 823 {
 824   Bitmap swap_bitmap;
 825   Bitmap *new_bitmap, *tmp_bitmap_1, *tmp_bitmap_2, *tmp_bitmap_4,*tmp_bitmap_8;
 826   int width_1, height_1, width_2, height_2, width_4, height_4, width_8,height_8;
 827   int new_width, new_height;
 828
 829   /* calculate new image dimensions for normal sized image */
 830   width_1  = old_bitmap->width  * zoom_factor;
 831   height_1 = old_bitmap->height * zoom_factor;
 832
 833   /* get image with normal size (this might require scaling up) */
 834   if (zoom_factor != 1)
 835     tmp_bitmap_1 = ZoomBitmap(old_bitmap, width_1, height_1);
 836   else
 837     tmp_bitmap_1 = old_bitmap;
 838
 839   /* this is only needed to make compilers happy */
 840   tmp_bitmap_2 = tmp_bitmap_4 = tmp_bitmap_8 = NULL;
 841
 842   if (create_small_bitmaps)
 843   {
 844     /* calculate new image dimensions for small images */
 845     width_2  = width_1  / 2;
 846     height_2 = height_1 / 2;
 847     width_4  = width_1  / 4;
 848     height_4 = height_1 / 4;
 849     width_8  = width_1  / 8;
 850     height_8 = height_1 / 8;
 851
 852     /* get image with 1/2 of normal size (for use in the level editor) */
 853     if (zoom_factor != 2)
 854       tmp_bitmap_2 = ZoomBitmap(tmp_bitmap_1, width_1 / 2, height_1 / 2);
 855     else
 856       tmp_bitmap_2 = old_bitmap;
 857
 858     /* get image with 1/4 of normal size (for use in the level editor) */
 859     if (zoom_factor != 4)
 860       tmp_bitmap_4 = ZoomBitmap(tmp_bitmap_2, width_2 / 2, height_2 / 2);
 861     else
 862       tmp_bitmap_4 = old_bitmap;
 863
 864     /* get image with 1/8 of normal size (for use on the preview screen) */
 865     if (zoom_factor != 8)
 866       tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_4, width_4 / 2, height_4 / 2);
 867     else
 868       tmp_bitmap_8 = old_bitmap;
 869   }
 870
 871   /* if image was scaled up, create new clipmask for normal size image */
 872   if (zoom_factor != 1)
 873   {
 874 #if defined(TARGET_X11)
 875     if (old_bitmap->clip_mask)
 876       XFreePixmap(display, old_bitmap->clip_mask);
 877
 878     old_bitmap->clip_mask =
 879       Pixmap_to_Mask(tmp_bitmap_1->drawable, width_1, height_1);
 880
 881     XSetClipMask(display, old_bitmap->stored_clip_gc, old_bitmap->clip_mask);
 882 #else
 883     SDL_Surface *tmp_surface_1 = tmp_bitmap_1->surface;
 884
 885     if (old_bitmap->surface_masked)
 886       SDL_FreeSurface(old_bitmap->surface_masked);
 887
 888     SDL_SetColorKey(tmp_surface_1, SDL_SRCCOLORKEY,
 889                     SDL_MapRGB(tmp_surface_1->format, 0x00, 0x00, 0x00));
 890     if ((old_bitmap->surface_masked = SDL_DisplayFormat(tmp_surface_1)) ==NULL)
 891       Error(ERR_EXIT, "SDL_DisplayFormat() failed");
 892     SDL_SetColorKey(tmp_surface_1, 0, 0);       /* reset transparent pixel */
 893 #endif
 894   }
 895
 896   if (create_small_bitmaps)
 897   {
 898     new_width  = width_1;
 899     new_height = height_1 + (height_1 + 1) / 2;     /* prevent odd height */
 900
 901     new_bitmap = CreateBitmap(new_width, new_height, DEFAULT_DEPTH);
 902
 903     BlitBitmap(tmp_bitmap_1, new_bitmap, 0, 0, width_1, height_1, 0, 0);
 904     BlitBitmap(tmp_bitmap_2, new_bitmap, 0, 0, width_1 / 2, height_1 / 2,
 905                0, height_1);
 906     BlitBitmap(tmp_bitmap_4, new_bitmap, 0, 0, width_1 / 4, height_1 / 4,
 907                width_1 / 2, height_1);
 908     BlitBitmap(tmp_bitmap_8, new_bitmap, 0, 0, width_1 / 8, height_1 / 8,
 909                3 * width_1 / 4, height_1);
 910   }
 911   else
 912   {
 913     new_width  = width_1;
 914     new_height = height_1;
 915
 916     new_bitmap = tmp_bitmap_1;  /* directly use tmp_bitmap_1 as new bitmap */
 917   }
 918
 919   if (create_small_bitmaps)
 920   {
 921     /* if no small bitmaps created, tmp_bitmap_1 is used as new bitmap now */
 922     if (zoom_factor != 1)
 923       FreeBitmap(tmp_bitmap_1);
 924
 925     if (zoom_factor != 2)
 926       FreeBitmap(tmp_bitmap_2);
 927
 928     if (zoom_factor != 4)
 929       FreeBitmap(tmp_bitmap_4);
 930
 931     if (zoom_factor != 8)
 932       FreeBitmap(tmp_bitmap_8);
 933   }
 934
 935   /* replace image with extended image (containing 1/1, 1/2, 1/4, 1/8 size) */
 936 #if defined(TARGET_SDL)
 937   swap_bitmap.surface = old_bitmap->surface;
 938   old_bitmap->surface = new_bitmap->surface;
 939   new_bitmap->surface = swap_bitmap.surface;
 940 #else
 941   swap_bitmap.drawable = old_bitmap->drawable;
 942   old_bitmap->drawable = new_bitmap->drawable;
 943   new_bitmap->drawable = swap_bitmap.drawable;
 944 #endif
 945
 946   old_bitmap->width  = new_bitmap->width;
 947   old_bitmap->height = new_bitmap->height;
 948
 949   FreeBitmap(new_bitmap);       /* this actually frees the _old_ bitmap now */
 950 }
 951
 952 void CreateBitmapWithSmallBitmaps(Bitmap *old_bitmap, int zoom_factor)
 953 {
 954   CreateScaledBitmaps(old_bitmap, zoom_factor, TRUE);
 955 }
 956
 957 void ScaleBitmap(Bitmap *old_bitmap, int zoom_factor)
 958 {
 959   CreateScaledBitmaps(old_bitmap, zoom_factor, FALSE);
 960 }
 961
 962
 963 /* ------------------------------------------------------------------------- */
 964 /* mouse pointer functions                                                   */
 965 /* ------------------------------------------------------------------------- */
 966
 967 #if !defined(PLATFORM_MSDOS)
 968 /* XPM */
 969 static const char *cursor_image_playfield[] =
 970 {
 971   /* width height num_colors chars_per_pixel */
 972   "    16    16        3            1",
 973
 974   /* colors */
 975   "X c #000000",
 976   ". c #ffffff",
 977   "  c None",
 978
 979 #if 1
 980   /* some people complained about a "white dot" on the screen and thought it
 981      was a graphical error... OK, let's just remove the whole pointer :-) */
 982
 983   /* pixels */
 984   "                ",
 985   "                ",
 986   "                ",
 987   "                ",
 988   "                ",
 989   "                ",
 990   "                ",
 991   "                ",
 992   "                ",
 993   "                ",
 994   "                ",
 995   "                ",
 996   "                ",
 997   "                ",
 998   "                ",
 999   "                ",
1000
1001   /* hot spot */
1002   "0,0"
1003
1004 #else
1005
1006   /* pixels */
1007   " X              ",
1008   "X.X             ",
1009   " X              ",
1010   "                ",
1011   "                ",
1012   "                ",
1013   "                ",
1014   "                ",
1015   "                ",
1016   "                ",
1017   "                ",
1018   "                ",
1019   "                ",
1020   "                ",
1021   "                ",
1022   "                ",
1023
1024   /* hot spot */
1025   "1,1"
1026 #endif
1027 };
1028
1029 #if defined(TARGET_SDL)
1030 static const int cursor_bit_order = BIT_ORDER_MSB;
1031 #elif defined(TARGET_X11_NATIVE)
1032 static const int cursor_bit_order = BIT_ORDER_LSB;
1033 #endif
1034
1035 static struct MouseCursorInfo *get_cursor_from_image(const char **image)
1036 {
1037   struct MouseCursorInfo *cursor;
1038   boolean bit_order_msb = (cursor_bit_order == BIT_ORDER_MSB);
1039   int header_lines = 4;
1040   int x, y, i;
1041
1042   cursor = checked_calloc(sizeof(struct MouseCursorInfo));
1043
1044   sscanf(image[0], " %d %d ", &cursor->width, &cursor->height);
1045
1046   i = -1;
1047   for (y = 0; y < cursor->width; y++)
1048   {
1049     for (x = 0; x < cursor->height; x++)
1050     {
1051       int bit_nr = x % 8;
1052       int bit_mask = 0x01 << (bit_order_msb ? 7 - bit_nr : bit_nr );
1053
1054       if (bit_nr == 0)
1055       {
1056         i++;
1057         cursor->data[i] = cursor->mask[i] = 0;
1058       }
1059
1060       switch (image[header_lines + y][x])
1061       {
1062         case 'X':
1063           cursor->data[i] |= bit_mask;
1064           cursor->mask[i] |= bit_mask;
1065           break;
1066
1067         case '.':
1068           cursor->mask[i] |= bit_mask;
1069           break;
1070
1071         case ' ':
1072           break;
1073       }
1074     }
1075   }
1076
1077   sscanf(image[header_lines + y], "%d,%d", &cursor->hot_x, &cursor->hot_y);
1078
1079   return cursor;
1080 }
1081 #endif  /* !PLATFORM_MSDOS */
1082
1083 void SetMouseCursor(int mode)
1084 {
1085 #if !defined(PLATFORM_MSDOS)
1086   static struct MouseCursorInfo *cursor_playfield = NULL;
1087
1088   if (cursor_playfield == NULL)
1089     cursor_playfield = get_cursor_from_image(cursor_image_playfield);
1090
1091 #if defined(TARGET_SDL)
1092   SDLSetMouseCursor(mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL);
1093 #elif defined(TARGET_X11_NATIVE)
1094   X11SetMouseCursor(mode == CURSOR_PLAYFIELD ? cursor_playfield : NULL);
1095 #endif
1096 #endif
1097 }
1098
1099
1100 /* ========================================================================= */
1101 /* audio functions                                                           */
1102 /* ========================================================================= */
1103
1104 void OpenAudio(void)
1105 {
1106   /* always start with reliable default values */
1107   audio.sound_available = FALSE;
1108   audio.music_available = FALSE;
1109   audio.loops_available = FALSE;
1110
1111   audio.sound_enabled = FALSE;
1112   audio.sound_deactivated = FALSE;
1113
1114   audio.mixer_pipe[0] = audio.mixer_pipe[1] = 0;
1115   audio.mixer_pid = 0;
1116   audio.device_name = NULL;
1117   audio.device_fd = -1;
1118
1119   audio.num_channels = 0;
1120   audio.music_channel = 0;
1121   audio.first_sound_channel = 0;
1122
1123 #if defined(TARGET_SDL)
1124   SDLOpenAudio();
1125 #elif defined(PLATFORM_UNIX)
1126   UnixOpenAudio();
1127 #elif defined(PLATFORM_MSDOS)
1128   MSDOSOpenAudio();
1129 #endif
1130 }
1131
1132 void CloseAudio(void)
1133 {
1134 #if defined(TARGET_SDL)
1135   SDLCloseAudio();
1136 #elif defined(PLATFORM_UNIX)
1137   UnixCloseAudio();
1138 #elif defined(PLATFORM_MSDOS)
1139   MSDOSCloseAudio();
1140 #endif
1141
1142   audio.sound_enabled = FALSE;
1143 }
1144
1145 void SetAudioMode(boolean enabled)
1146 {
1147   if (!audio.sound_available)
1148     return;
1149
1150   audio.sound_enabled = enabled;
1151 }
1152
1153
1154 /* ========================================================================= */
1155 /* event functions                                                           */
1156 /* ========================================================================= */
1157
1158 void InitEventFilter(EventFilter filter_function)
1159 {
1160 #if defined(TARGET_SDL)
1161   /* set event filter to filter out certain events */
1162   SDL_SetEventFilter(filter_function);
1163 #endif
1164 }
1165
1166 boolean PendingEvent(void)
1167 {
1168 #if defined(TARGET_SDL)
1169   return (SDL_PollEvent(NULL) ? TRUE : FALSE);
1170 #else
1171   return (XPending(display) ? TRUE : FALSE);
1172 #endif
1173 }
1174
1175 void NextEvent(Event *event)
1176 {
1177 #if defined(TARGET_SDL)
1178   SDLNextEvent(event);
1179 #else
1180   XNextEvent(display, event);
1181 #endif
1182 }
1183
1184 void PeekEvent(Event *event)
1185 {
1186 #if defined(TARGET_SDL)
1187   SDL_PeepEvents(event, 1, SDL_PEEKEVENT, SDL_ALLEVENTS);
1188 #else
1189   XPeekEvent(display, event);
1190 #endif
1191 }
1192
1193 Key GetEventKey(KeyEvent *event, boolean with_modifiers)
1194 {
1195 #if defined(TARGET_SDL)
1196
1197 #if 0
1198   printf("unicode == '%d', sym == '%d', mod == '0x%04x'\n",
1199          (int)event->keysym.unicode,
1200          (int)event->keysym.sym,
1201          (int)SDL_GetModState());
1202 #endif
1203
1204   if (with_modifiers &&
1205       event->keysym.unicode > 0x0000 &&
1206       event->keysym.unicode < 0x2000)
1207     return event->keysym.unicode;
1208   else
1209     return event->keysym.sym;
1210
1211 #else
1212
1213 #if 0
1214   printf("with modifiers == '0x%04x', without modifiers == '0x%04x'\n",
1215          (int)XLookupKeysym(event, event->state),
1216          (int)XLookupKeysym(event, 0));
1217 #endif
1218
1219   if (with_modifiers)
1220     return XLookupKeysym(event, event->state);
1221   else
1222     return XLookupKeysym(event, 0);
1223 #endif
1224 }
1225
1226 KeyMod HandleKeyModState(Key key, int key_status)
1227 {
1228   static KeyMod current_modifiers = KMOD_None;
1229
1230 #if !defined(TARGET_SDL)
1231   if (key != KSYM_UNDEFINED)    /* new key => check for modifier key change */
1232   {
1233     KeyMod new_modifier = KMOD_None;
1234
1235     switch(key)
1236     {
1237       case KSYM_Shift_L:
1238         new_modifier = KMOD_Shift_L;
1239         break;
1240       case KSYM_Shift_R:
1241         new_modifier = KMOD_Shift_R;
1242         break;
1243       case KSYM_Control_L:
1244         new_modifier = KMOD_Control_L;
1245         break;
1246       case KSYM_Control_R:
1247         new_modifier = KMOD_Control_R;
1248         break;
1249       case KSYM_Meta_L:
1250         new_modifier = KMOD_Meta_L;
1251         break;
1252       case KSYM_Meta_R:
1253         new_modifier = KMOD_Meta_R;
1254         break;
1255       case KSYM_Alt_L:
1256         new_modifier = KMOD_Alt_L;
1257         break;
1258       case KSYM_Alt_R:
1259         new_modifier = KMOD_Alt_R;
1260         break;
1261       default:
1262         break;
1263     }
1264
1265     if (key_status == KEY_PRESSED)
1266       current_modifiers |= new_modifier;
1267     else
1268       current_modifiers &= ~new_modifier;
1269   }
1270 #endif
1271
1272   return current_modifiers;
1273 }
1274
1275 KeyMod GetKeyModState()
1276 {
1277 #if defined(TARGET_SDL)
1278   return (KeyMod)SDL_GetModState();
1279 #else
1280   return HandleKeyModState(KSYM_UNDEFINED, 0);
1281 #endif
1282 }
1283
1284 boolean CheckCloseWindowEvent(ClientMessageEvent *event)
1285 {
1286   if (event->type != EVENT_CLIENTMESSAGE)
1287     return FALSE;
1288
1289 #if defined(TARGET_SDL)
1290   return TRUE;          /* the only possible message here is SDL_QUIT */
1291 #elif defined(PLATFORM_UNIX)
1292   if ((event->window == window->drawable) &&
1293       (event->data.l[0] == XInternAtom(display, "WM_DELETE_WINDOW", FALSE)))
1294     return TRUE;
1295 #endif
1296
1297   return FALSE;
1298 }
1299
1300
1301 /* ========================================================================= */
1302 /* joystick functions                                                        */
1303 /* ========================================================================= */
1304
1305 void InitJoysticks()
1306 {
1307   int i;
1308
1309 #if defined(NO_JOYSTICK)
1310   return;       /* joysticks generally deactivated by compile-time directive */
1311 #endif
1312
1313   /* always start with reliable default values */
1314   joystick.status = JOYSTICK_NOT_AVAILABLE;
1315   for (i = 0; i < MAX_PLAYERS; i++)
1316     joystick.fd[i] = -1;                /* joystick device closed */
1317
1318 #if defined(TARGET_SDL)
1319   SDLInitJoysticks();
1320 #elif defined(PLATFORM_UNIX)
1321   UnixInitJoysticks();
1322 #elif defined(PLATFORM_MSDOS)
1323   MSDOSInitJoysticks();
1324 #endif
1325
1326 #if 0
1327   for (i = 0; i < MAX_PLAYERS; i++)
1328     printf("::: Joystick for player %d: %d\n", i, joystick.fd[i]);
1329 #endif
1330 }
1331
1332 boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
1333 {
1334 #if defined(TARGET_SDL)
1335   return SDLReadJoystick(nr, x, y, b1, b2);
1336 #elif defined(PLATFORM_UNIX)
1337   return UnixReadJoystick(nr, x, y, b1, b2);
1338 #elif defined(PLATFORM_MSDOS)
1339   return MSDOSReadJoystick(nr, x, y, b1, b2);
1340 #endif
1341 }