src/libgame/system.c

   1 /***********************************************************
   2 * Artsoft Retro-Game Library                               *
   3 *----------------------------------------------------------*
   4 * (c) 1994-2001 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 "sound.h"
  25 #include "setup.h"
  26 #include "joystick.h"
  27 #include "misc.h"
  28
  29
  30 /* ========================================================================= */
  31 /* exported variables                                                        */
  32 /* ========================================================================= */
  33
  34 struct ProgramInfo      program;
  35 struct OptionInfo       options;
  36 struct VideoSystemInfo  video;
  37 struct AudioSystemInfo  audio;
  38 struct GfxInfo          gfx;
  39 struct ArtworkInfo      artwork;
  40 struct JoystickInfo     joystick;
  41 struct SetupInfo        setup;
  42
  43 struct LevelDirInfo    *leveldir_first = NULL;
  44 struct LevelDirInfo    *leveldir_current = NULL;
  45 int                     level_nr;
  46
  47 Display                *display = NULL;
  48 Visual                 *visual = NULL;
  49 int                     screen = 0;
  50 Colormap                cmap = None;
  51
  52 DrawWindow             *window = NULL;
  53 DrawBuffer             *backbuffer = NULL;
  54 DrawBuffer             *drawto = NULL;
  55
  56 int                     button_status = MB_NOT_PRESSED;
  57 boolean                 motion_status = FALSE;
  58
  59 int                     redraw_mask = REDRAW_NONE;
  60 int                     redraw_tiles = 0;
  61
  62 int                     FrameCounter = 0;
  63
  64
  65 /* ========================================================================= */
  66 /* init/close functions                                                      */
  67 /* ========================================================================= */
  68
  69 void InitCommandName(char *argv0)
  70 {
  71   program.command_basename =
  72     (strrchr(argv0, '/') ? strrchr(argv0, '/') + 1 : argv0);
  73 }
  74
  75 void InitExitFunction(void (*exit_function)(int))
  76 {
  77   program.exit_function = exit_function;
  78
  79   /* set signal handlers to custom exit function */
  80   signal(SIGINT, exit_function);
  81   signal(SIGTERM, exit_function);
  82
  83 #if defined(TARGET_SDL)
  84   /* set exit function to automatically cleanup SDL stuff after exit() */
  85   atexit(SDL_Quit);
  86 #endif
  87 }
  88
  89 void InitPlatformDependantStuff(void)
  90 {
  91 #if defined(PLATFORM_MSDOS)
  92   _fmode = O_BINARY;
  93 #endif
  94
  95 #if !defined(PLATFORM_UNIX)
  96   program.userdata_directory = "userdata";
  97   initErrorFile();
  98 #endif
  99
 100 #if defined(TARGET_SDL)
 101   if (SDL_Init(SDL_INIT_EVENTTHREAD | SDL_INIT_NOPARACHUTE) < 0)
 102     Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
 103 #endif
 104 }
 105
 106 void ClosePlatformDependantStuff(void)
 107 {
 108 #if !defined(PLATFORM_UNIX)
 109   dumpErrorFile();
 110 #endif
 111 }
 112
 113 void InitProgramInfo(char *unix_userdata_directory, char *program_title,
 114                      char *window_title, char *icon_title,
 115                      char *x11_icon_basename, char *x11_iconmask_basename,
 116                      char *msdos_pointer_basename,
 117                      char *cookie_prefix, char *filename_prefix,
 118                      int program_version)
 119 {
 120   char *x11_icon_filename =
 121     getPath2(options.graphics_directory, x11_icon_basename);
 122   char *x11_iconmask_filename =
 123     getPath2(options.graphics_directory, x11_iconmask_basename);
 124   char *msdos_pointer_filename =
 125     getPath2(options.graphics_directory, msdos_pointer_basename);
 126
 127 #if defined(PLATFORM_UNIX)
 128   program.userdata_directory = unix_userdata_directory;
 129 #else
 130   program.userdata_directory = "userdata";
 131 #endif
 132
 133   program.program_title = program_title;
 134   program.window_title = window_title;
 135   program.icon_title = icon_title;
 136   program.x11_icon_filename = x11_icon_filename;
 137   program.x11_iconmask_filename = x11_iconmask_filename;
 138   program.msdos_pointer_filename = msdos_pointer_filename;
 139
 140   program.cookie_prefix = cookie_prefix;
 141   program.filename_prefix = filename_prefix;
 142
 143   program.version_major = VERSION_MAJOR(program_version);
 144   program.version_minor = VERSION_MINOR(program_version);
 145   program.version_patch = VERSION_PATCH(program_version);
 146 }
 147
 148 void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
 149                       int real_sx, int real_sy,
 150                       int full_sxsize, int full_sysize)
 151 {
 152   gfx.sx = sx;
 153   gfx.sy = sy;
 154   gfx.sxsize = sxsize;
 155   gfx.sysize = sysize;
 156   gfx.real_sx = real_sx;
 157   gfx.real_sy = real_sy;
 158   gfx.full_sxsize = full_sxsize;
 159   gfx.full_sysize = full_sysize;
 160 }
 161
 162 void InitGfxDoor1Info(int dx, int dy, int dxsize, int dysize)
 163 {
 164   gfx.dx = dx;
 165   gfx.dy = dy;
 166   gfx.dxsize = dxsize;
 167   gfx.dysize = dysize;
 168 }
 169
 170 void InitGfxDoor2Info(int vx, int vy, int vxsize, int vysize)
 171 {
 172   gfx.vx = vx;
 173   gfx.vy = vy;
 174   gfx.vxsize = vxsize;
 175   gfx.vysize = vysize;
 176 }
 177
 178 void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height)
 179 {
 180   /* currently only used by MSDOS code to alloc VRAM buffer, if available */
 181   gfx.scrollbuffer_width = scrollbuffer_width;
 182   gfx.scrollbuffer_height = scrollbuffer_height;
 183 }
 184
 185
 186 /* ========================================================================= */
 187 /* video functions                                                           */
 188 /* ========================================================================= */
 189
 190 inline static int GetRealDepth(int depth)
 191 {
 192   return (depth == DEFAULT_DEPTH ? video.default_depth : depth);
 193 }
 194
 195 inline void InitVideoDisplay(void)
 196 {
 197 #if defined(TARGET_SDL)
 198   SDLInitVideoDisplay();
 199 #else
 200   X11InitVideoDisplay();
 201 #endif
 202 }
 203
 204 inline void CloseVideoDisplay(void)
 205 {
 206   KeyboardAutoRepeatOn();
 207
 208 #if defined(TARGET_SDL)
 209   SDL_QuitSubSystem(SDL_INIT_VIDEO);
 210 #else
 211   if (display)
 212     XCloseDisplay(display);
 213 #endif
 214 }
 215
 216 inline void InitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
 217                             int width, int height, int depth,
 218                             boolean fullscreen)
 219 {
 220   video.width = width;
 221   video.height = height;
 222   video.depth = GetRealDepth(depth);
 223   video.fullscreen_available = FULLSCREEN_STATUS;
 224   video.fullscreen_enabled = FALSE;
 225
 226 #ifdef TARGET_SDL
 227   SDLInitVideoBuffer(backbuffer, window, fullscreen);
 228 #else
 229   X11InitVideoBuffer(backbuffer, window);
 230 #endif
 231 }
 232
 233 inline Bitmap *CreateBitmapStruct(void)
 234 {
 235 #ifdef TARGET_SDL
 236   return checked_calloc(sizeof(struct SDLSurfaceInfo));
 237 #else
 238   return checked_calloc(sizeof(struct X11DrawableInfo));
 239 #endif
 240 }
 241
 242 inline Bitmap *CreateBitmap(int width, int height, int depth)
 243 {
 244   Bitmap *new_bitmap = CreateBitmapStruct();
 245   int real_depth = GetRealDepth(depth);
 246
 247 #ifdef TARGET_SDL
 248   SDL_Surface *surface_tmp, *surface_native;
 249
 250   if ((surface_tmp = SDL_CreateRGBSurface(SURFACE_FLAGS, width, height,
 251                                           real_depth, 0, 0, 0, 0))
 252       == NULL)
 253     Error(ERR_EXIT, "SDL_CreateRGBSurface() failed: %s", SDL_GetError());
 254
 255   if ((surface_native = SDL_DisplayFormat(surface_tmp)) == NULL)
 256     Error(ERR_EXIT, "SDL_DisplayFormat() failed: %s", SDL_GetError());
 257
 258   SDL_FreeSurface(surface_tmp);
 259
 260   new_bitmap->surface = surface_native;
 261 #else
 262   Pixmap pixmap;
 263
 264   if ((pixmap = XCreatePixmap(display, window->drawable,
 265                               width, height, real_depth))
 266       == None)
 267     Error(ERR_EXIT, "cannot create pixmap");
 268
 269   new_bitmap->drawable = pixmap;
 270
 271   if (window == NULL)
 272     Error(ERR_EXIT, "Window GC needed for Bitmap -- create Window first");
 273
 274   new_bitmap->gc = window->gc;
 275
 276   new_bitmap->line_gc[0] = window->line_gc[0];
 277   new_bitmap->line_gc[1] = window->line_gc[1];
 278 #endif
 279
 280   return new_bitmap;
 281 }
 282
 283 inline void FreeBitmap(Bitmap *bitmap)
 284 {
 285   if (bitmap == NULL)
 286     return;
 287
 288 #ifdef TARGET_SDL
 289   if (bitmap->surface)
 290     SDL_FreeSurface(bitmap->surface);
 291   if (bitmap->surface_masked)
 292     SDL_FreeSurface(bitmap->surface_masked);
 293 #else
 294   if (bitmap->drawable)
 295     XFreePixmap(display, bitmap->drawable);
 296   if (bitmap->clip_mask)
 297     XFreePixmap(display, bitmap->clip_mask);
 298   if (bitmap->stored_clip_gc)
 299     XFreeGC(display, bitmap->stored_clip_gc);
 300 #endif
 301
 302   free(bitmap);
 303 }
 304
 305 inline void CloseWindow(DrawWindow *window)
 306 {
 307 #ifdef TARGET_X11
 308   if (window->drawable)
 309   {
 310     XUnmapWindow(display, window->drawable);
 311     XDestroyWindow(display, window->drawable);
 312   }
 313   if (window->gc)
 314     XFreeGC(display, window->gc);
 315 #endif
 316 }
 317
 318 inline void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 319                        int src_x, int src_y,
 320                        int width, int height,
 321                        int dst_x, int dst_y)
 322 {
 323 #ifdef TARGET_SDL
 324   SDLCopyArea(src_bitmap, dst_bitmap,
 325               src_x, src_y, width, height, dst_x, dst_y, SDLCOPYAREA_OPAQUE);
 326 #else
 327   XCopyArea(display, src_bitmap->drawable, dst_bitmap->drawable,
 328             dst_bitmap->gc, src_x, src_y, width, height, dst_x, dst_y);
 329 #endif
 330 }
 331
 332 inline void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
 333 {
 334 #ifdef TARGET_SDL
 335   SDLFillRectangle(bitmap, x, y, width, height, 0x000000);
 336 #else
 337   XFillRectangle(display, bitmap->drawable, bitmap->gc, x, y, width, height);
 338 #endif
 339 }
 340
 341 #if 0
 342 #ifndef TARGET_SDL
 343 static GC last_clip_gc = 0;     /* needed for XCopyArea() through clip mask */
 344 #endif
 345 #endif
 346
 347 inline void SetClipMask(Bitmap *bitmap, GC clip_gc, Pixmap clip_pixmap)
 348 {
 349 #ifdef TARGET_X11
 350   if (clip_gc)
 351   {
 352     bitmap->clip_gc = clip_gc;
 353     XSetClipMask(display, bitmap->clip_gc, clip_pixmap);
 354   }
 355 #if 0
 356   last_clip_gc = clip_gc;
 357 #endif
 358 #endif
 359 }
 360
 361 inline void SetClipOrigin(Bitmap *bitmap, GC clip_gc, int clip_x, int clip_y)
 362 {
 363 #ifdef TARGET_X11
 364   if (clip_gc)
 365   {
 366     bitmap->clip_gc = clip_gc;
 367     XSetClipOrigin(display, bitmap->clip_gc, clip_x, clip_y);
 368   }
 369 #if 0
 370   last_clip_gc = clip_gc;
 371 #endif
 372 #endif
 373 }
 374
 375 inline void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 376                              int src_x, int src_y,
 377                              int width, int height,
 378                              int dst_x, int dst_y)
 379 {
 380 #ifdef TARGET_SDL
 381   SDLCopyArea(src_bitmap, dst_bitmap,
 382               src_x, src_y, width, height, dst_x, dst_y, SDLCOPYAREA_MASKED);
 383 #else
 384   XCopyArea(display, src_bitmap->drawable, dst_bitmap->drawable,
 385             src_bitmap->clip_gc, src_x, src_y, width, height, dst_x, dst_y);
 386 #endif
 387 }
 388
 389 inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
 390                                 int to_x, int to_y)
 391 {
 392 #ifdef TARGET_SDL
 393   SDLDrawSimpleLine(bitmap, from_x, from_y, to_x, to_y, 0xffffff);
 394 #else
 395   XSetForeground(display, bitmap->gc, WhitePixel(display, screen));
 396   XDrawLine(display, bitmap->drawable, bitmap->gc, from_x, from_y, to_x, to_y);
 397   XSetForeground(display, bitmap->gc, BlackPixel(display, screen));
 398 #endif
 399 }
 400
 401 #if !defined(TARGET_X11_NATIVE)
 402 inline void DrawLine(Bitmap *bitmap, int from_x, int from_y,
 403                      int to_x, int to_y, Pixel pixel, int line_width)
 404 {
 405   int x, y;
 406
 407   for (x=0; x<line_width; x++)
 408   {
 409     for (y=0; y<line_width; y++)
 410     {
 411       int dx = x - line_width / 2;
 412       int dy = y - line_width / 2;
 413
 414       if ((x == 0 && y == 0) ||
 415           (x == 0 && y == line_width - 1) ||
 416           (x == line_width - 1 && y == 0) ||
 417           (x == line_width - 1 && y == line_width - 1))
 418         continue;
 419
 420 #if defined(TARGET_SDL)
 421       SDLDrawLine(bitmap,
 422                   from_x + dx, from_y + dy, to_x + dx, to_y + dy, pixel);
 423 #elif defined(TARGET_ALLEGRO)
 424       AllegroDrawLine(bitmap->drawable, from_x + dx, from_y + dy,
 425                       to_x + dx, to_y + dy, pixel);
 426 #endif
 427     }
 428   }
 429 }
 430 #endif
 431
 432 inline void DrawLines(Bitmap *bitmap, struct XY *points, int num_points,
 433                       Pixel pixel)
 434 {
 435 #if !defined(TARGET_X11_NATIVE)
 436   int line_width = 4;
 437   int i;
 438
 439   for (i=0; i<num_points - 1; i++)
 440     DrawLine(bitmap, points[i].x, points[i].y,
 441              points[i + 1].x, points[i + 1].y, pixel, line_width);
 442
 443   /*
 444   SDLDrawLines(bitmap->surface, points, num_points, pixel);
 445   */
 446 #else
 447   XSetForeground(display, bitmap->line_gc[1], pixel);
 448   XDrawLines(display, bitmap->drawable, bitmap->line_gc[1],
 449              (XPoint *)points, num_points, CoordModeOrigin);
 450   /*
 451   XSetForeground(display, gc, BlackPixel(display, screen));
 452   */
 453 #endif
 454 }
 455
 456 inline Pixel GetPixel(Bitmap *bitmap, int x, int y)
 457 {
 458 #if defined(TARGET_SDL)
 459   return SDLGetPixel(bitmap, x, y);
 460 #elif defined(TARGET_ALLEGRO)
 461   return AllegroGetPixel(bitmap->drawable, x, y);
 462 #else
 463   unsigned long pixel_value;
 464   XImage *pixel_image;
 465
 466   pixel_image = XGetImage(display, bitmap->drawable, x, y, 1, 1,
 467                           AllPlanes, ZPixmap);
 468   pixel_value = XGetPixel(pixel_image, 0, 0);
 469
 470   XDestroyImage(pixel_image);
 471
 472   return pixel_value;
 473 #endif
 474 }
 475
 476 inline Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
 477                              unsigned int color_g, unsigned int color_b)
 478 {
 479   Pixel pixel;
 480
 481 #if defined(TARGET_SDL)
 482   pixel = SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
 483 #elif defined(TARGET_ALLEGRO)
 484   pixel = AllegroAllocColorCell(color_r << 8, color_g << 8, color_b << 8);
 485 #elif defined(TARGET_X11_NATIVE)
 486   XColor xcolor;
 487
 488   xcolor.flags = DoRed | DoGreen | DoBlue;
 489   xcolor.red = (color_r << 8);
 490   xcolor.green = (color_g << 8);
 491   xcolor.blue = (color_b << 8);
 492   XAllocColor(display, cmap, &xcolor);
 493   pixel = xcolor.pixel;
 494 #endif
 495
 496   return pixel;
 497 }
 498
 499 inline Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
 500 {
 501   unsigned int color_r = (color >> 16) & 0xff;
 502   unsigned int color_g = (color >>  8) & 0xff;
 503   unsigned int color_b = (color >>  0) & 0xff;
 504
 505   return GetPixelFromRGB(bitmap, color_r, color_g, color_b);
 506 }
 507
 508 /* execute all pending screen drawing operations */
 509 inline void FlushDisplay(void)
 510 {
 511 #ifndef TARGET_SDL
 512   XFlush(display);
 513 #endif
 514 }
 515
 516 /* execute and wait for all pending screen drawing operations */
 517 inline void SyncDisplay(void)
 518 {
 519 #ifndef TARGET_SDL
 520   XSync(display, FALSE);
 521 #endif
 522 }
 523
 524 inline void KeyboardAutoRepeatOn(void)
 525 {
 526 #ifdef TARGET_SDL
 527   SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY / 2,
 528                       SDL_DEFAULT_REPEAT_INTERVAL / 2);
 529   SDL_EnableUNICODE(1);
 530 #else
 531   if (display)
 532     XAutoRepeatOn(display);
 533 #endif
 534 }
 535
 536 inline void KeyboardAutoRepeatOff(void)
 537 {
 538 #ifdef TARGET_SDL
 539   SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
 540   SDL_EnableUNICODE(0);
 541 #else
 542   if (display)
 543     XAutoRepeatOff(display);
 544 #endif
 545 }
 546
 547 inline boolean PointerInWindow(DrawWindow *window)
 548 {
 549 #ifdef TARGET_SDL
 550   return TRUE;
 551 #else
 552   Window root, child;
 553   int root_x, root_y;
 554   unsigned int mask;
 555   int win_x, win_y;
 556
 557   /* if XQueryPointer() returns False, the pointer
 558      is not on the same screen as the specified window */
 559   return XQueryPointer(display, window->drawable, &root, &child,
 560                        &root_x, &root_y, &win_x, &win_y, &mask);
 561 #endif
 562 }
 563
 564 inline boolean SetVideoMode(boolean fullscreen)
 565 {
 566 #ifdef TARGET_SDL
 567   return SDLSetVideoMode(&backbuffer, fullscreen);
 568 #else
 569   boolean success = TRUE;
 570
 571   if (fullscreen && video.fullscreen_available)
 572   {
 573     Error(ERR_WARN, "fullscreen not available in X11 version");
 574
 575     /* display error message only once */
 576     video.fullscreen_available = FALSE;
 577
 578     success = FALSE;
 579   }
 580
 581   return success;
 582 #endif
 583 }
 584
 585 inline boolean ChangeVideoModeIfNeeded(boolean fullscreen)
 586 {
 587 #ifdef TARGET_SDL
 588   if ((fullscreen && !video.fullscreen_enabled && video.fullscreen_available)||
 589       (!fullscreen && video.fullscreen_enabled))
 590     fullscreen = SetVideoMode(fullscreen);
 591 #endif
 592
 593   return fullscreen;
 594 }
 595
 596 Bitmap *LoadImage(char *filename)
 597 {
 598   Bitmap *new_bitmap;
 599
 600 #if defined(TARGET_SDL)
 601   new_bitmap = SDLLoadImage(filename);
 602 #else
 603   new_bitmap = X11LoadImage(filename);
 604 #endif
 605
 606   return new_bitmap;
 607 }
 608
 609
 610 /* ========================================================================= */
 611 /* audio functions                                                           */
 612 /* ========================================================================= */
 613
 614 inline void OpenAudio(void)
 615 {
 616   /* always start with reliable default values */
 617   audio.sound_available = FALSE;
 618   audio.music_available = FALSE;
 619   audio.loops_available = FALSE;
 620   audio.mods_available = FALSE;
 621   audio.sound_enabled = FALSE;
 622
 623   audio.soundserver_pipe[0] = audio.soundserver_pipe[1] = 0;
 624   audio.soundserver_pid = 0;
 625   audio.device_name = NULL;
 626   audio.device_fd = 0;
 627
 628   audio.channels = 0;
 629   audio.music_channel = 0;
 630   audio.music_nr = 0;
 631
 632 #if defined(TARGET_SDL)
 633   SDLOpenAudio();
 634 #elif defined(PLATFORM_UNIX)
 635   UnixOpenAudio();
 636 #elif defined(PLATFORM_MSDOS)
 637   MSDOSOpenAudio();
 638 #endif
 639 }
 640
 641 inline void CloseAudio(void)
 642 {
 643 #if defined(TARGET_SDL)
 644   SDLCloseAudio();
 645 #elif defined(PLATFORM_UNIX)
 646   UnixCloseAudio();
 647 #elif defined(PLATFORM_MSDOS)
 648   MSDOSCloseAudio();
 649 #endif
 650
 651   audio.sound_enabled = FALSE;
 652 }
 653
 654 inline void SetAudioMode(boolean enabled)
 655 {
 656   if (!audio.sound_available)
 657     return;
 658
 659   audio.sound_enabled = enabled;
 660 }
 661
 662
 663 /* ========================================================================= */
 664 /* event functions                                                           */
 665 /* ========================================================================= */
 666
 667 inline void InitEventFilter(EventFilter filter_function)
 668 {
 669 #ifdef TARGET_SDL
 670   /* set event filter to filter out certain events */
 671   SDL_SetEventFilter(filter_function);
 672 #endif
 673 }
 674
 675 inline boolean PendingEvent(void)
 676 {
 677 #ifdef TARGET_SDL
 678   return (SDL_PollEvent(NULL) ? TRUE : FALSE);
 679 #else
 680   return (XPending(display) ? TRUE : FALSE);
 681 #endif
 682 }
 683
 684 inline void NextEvent(Event *event)
 685 {
 686 #ifdef TARGET_SDL
 687   SDLNextEvent(event);
 688 #else
 689   XNextEvent(display, event);
 690 #endif
 691 }
 692
 693 inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
 694 {
 695 #ifdef TARGET_SDL
 696 #if 0
 697   printf("unicode == '%d', sym == '%d', mod == '0x%04x'\n",
 698          (int)event->keysym.unicode,
 699          (int)event->keysym.sym,
 700          (int)SDL_GetModState());
 701 #endif
 702
 703   if (with_modifiers && event->keysym.unicode != 0)
 704     return event->keysym.unicode;
 705   else
 706     return event->keysym.sym;
 707 #else
 708 #if 0
 709   printf("with modifiers == '0x%04x', without modifiers == '0x%04x'\n",
 710          (int)XLookupKeysym(event, event->state),
 711          (int)XLookupKeysym(event, 0));
 712 #endif
 713
 714   if (with_modifiers)
 715     return XLookupKeysym(event, event->state);
 716   else
 717     return XLookupKeysym(event, 0);
 718 #endif
 719 }
 720
 721 inline boolean CheckCloseWindowEvent(ClientMessageEvent *event)
 722 {
 723   if (event->type != EVENT_CLIENTMESSAGE)
 724     return FALSE;
 725
 726 #if defined(TARGET_SDL)
 727   return TRUE;          /* the only possible message here is SDL_QUIT */
 728 #elif defined(PLATFORM_UNIX)
 729   if ((event->window == window->drawable) &&
 730       (event->data.l[0] == XInternAtom(display, "WM_DELETE_WINDOW", FALSE)))
 731     return TRUE;
 732 #endif
 733
 734   return FALSE;
 735 }
 736
 737
 738 /* ========================================================================= */
 739 /* joystick functions                                                        */
 740 /* ========================================================================= */
 741
 742 inline void InitJoysticks()
 743 {
 744   int i;
 745
 746 #ifdef NO_JOYSTICK
 747   return;       /* joysticks generally deactivated by compile-time directive */
 748 #endif
 749
 750   /* always start with reliable default values */
 751   joystick.status = JOYSTICK_NOT_AVAILABLE;
 752   for (i=0; i<MAX_PLAYERS; i++)
 753     joystick.fd[i] = -1;                /* joystick device closed */
 754
 755 #if defined(TARGET_SDL)
 756   SDLInitJoysticks();
 757 #elif defined(PLATFORM_UNIX)
 758   UnixInitJoysticks();
 759 #elif defined(PLATFORM_MSDOS)
 760   MSDOSInitJoysticks();
 761 #endif
 762 }
 763
 764 inline boolean ReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
 765 {
 766 #if defined(TARGET_SDL)
 767   return SDLReadJoystick(nr, x, y, b1, b2);
 768 #elif defined(PLATFORM_UNIX)
 769   return UnixReadJoystick(nr, x, y, b1, b2);
 770 #elif defined(PLATFORM_MSDOS)
 771   return MSDOSReadJoystick(nr, x, y, b1, b2);
 772 #endif
 773 }