rnd-20040611-1-src
[rocksndiamonds.git] / src / libgame / msdos.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 * msdos.c                                                  *
12 ***********************************************************/
13
14 #include "system.h"
15
16
17 #if defined(PLATFORM_MSDOS)
18
19 #include "sound.h"
20 #include "joystick.h"
21 #include "misc.h"
22 #include "setup.h"
23 #include "pcx.h"
24
25 #define AllegroDefaultScreen() (display->screens[display->default_screen])
26
27 /* allegro driver declarations */
28 DECLARE_GFX_DRIVER_LIST(GFX_DRIVER_VBEAF GFX_DRIVER_VESA2L GFX_DRIVER_VESA1)
29 DECLARE_COLOR_DEPTH_LIST(COLOR_DEPTH_8)
30 DECLARE_DIGI_DRIVER_LIST(DIGI_DRIVER_SB)
31 DECLARE_MIDI_DRIVER_LIST()
32 DECLARE_JOYSTICK_DRIVER_LIST(JOYSTICK_DRIVER_STANDARD)
33
34 /* allegro global variables */
35 extern volatile int key_shifts;
36 extern int num_joysticks;
37 extern JOYSTICK_INFO joy[];
38 extern int i_love_bill;
39
40 /* internal variables of msdos.c */
41 static boolean keyboard_auto_repeat = TRUE;
42 static int key_press_state[MAX_SCANCODES];
43 static XEvent event_buffer[MAX_EVENT_BUFFER];
44 static int pending_events;
45 static boolean joystick_event;
46 static boolean mouse_installed = FALSE;
47 static int last_mouse_pos;
48 static int last_mouse_b;
49 static int last_joystick_state;
50 static BITMAP* video_bitmap;
51
52 static RGB global_colormap[MAX_COLORS];
53 static int global_colormap_entries_used = 0;
54
55 boolean wait_for_vsync;
56
57 static BITMAP *Read_PCX_to_AllegroBitmap(char *);
58
59 static void allegro_init_drivers()
60 {
61   int i;
62
63   for (i = 0; i < MAX_EVENT_BUFFER; i++)
64     event_buffer[i].type = 0;
65
66   for (i = 0; i < MAX_SCANCODES; i++)
67     key_press_state[i] = KeyReleaseMask;
68
69   last_mouse_pos = mouse_pos;
70   last_mouse_b = 0;
71
72   pending_events = 0;
73   clear_keybuf();
74
75   /* enable Windows friendly timer mode (already default under Windows) */
76   i_love_bill = TRUE;
77
78   install_keyboard();
79   install_timer();
80   if (install_mouse() > 0)
81     mouse_installed = TRUE;
82
83   last_joystick_state = 0;
84   joystick_event = FALSE;
85 }
86
87 static boolean allegro_init_audio()
88 {
89   reserve_voices(NUM_MIXER_CHANNELS, 0);
90
91   if (install_sound(DIGI_AUTODETECT, MIDI_NONE, NULL) == -1)
92     if (install_sound(DIGI_SB, MIDI_NONE, NULL) == -1)
93       return FALSE;
94
95   return TRUE;
96 }
97
98 static boolean hide_mouse(Display *display, int x, int y,
99                           unsigned int width, unsigned int height)
100 {
101   if (mouse_x + display->mouse_ptr->w < x || mouse_x > x + width)
102     return FALSE;
103   if (mouse_y + display->mouse_ptr->h < y || mouse_y > y + height)
104     return FALSE;
105
106   show_mouse(NULL);
107
108   return TRUE;
109 }
110
111 static void unhide_mouse(Display *display)
112 {
113   if (mouse_installed)
114     show_mouse(video_bitmap);
115 }
116
117 static KeySym ScancodeToKeySym(byte scancode)
118 {
119   switch(scancode)
120   {
121     case KEY_ESC:               return XK_Escape;
122     case KEY_1:                 return XK_1;
123     case KEY_2:                 return XK_2;
124     case KEY_3:                 return XK_3;
125     case KEY_4:                 return XK_4;
126     case KEY_5:                 return XK_5;
127     case KEY_6:                 return XK_6;
128     case KEY_7:                 return XK_7;
129     case KEY_8:                 return XK_8;
130     case KEY_9:                 return XK_9;
131     case KEY_0:                 return XK_0;
132     case KEY_MINUS:             return XK_minus;
133     case KEY_EQUALS:            return XK_equal;
134     case KEY_BACKSPACE:         return XK_BackSpace;
135     case KEY_TAB:               return XK_Tab;
136     case KEY_Q:                 return XK_q;
137     case KEY_W:                 return XK_w;
138     case KEY_E:                 return XK_e;
139     case KEY_R:                 return XK_r;
140     case KEY_T:                 return XK_t;
141     case KEY_Y:                 return XK_y;
142     case KEY_U:                 return XK_u;
143     case KEY_I:                 return XK_i;
144     case KEY_O:                 return XK_o;
145     case KEY_P:                 return XK_p;
146     case KEY_OPENBRACE:         return XK_braceleft;
147     case KEY_CLOSEBRACE:        return XK_braceright;
148     case KEY_ENTER:             return XK_Return;
149     case KEY_LCONTROL:          return XK_Control_L;
150     case KEY_A:                 return XK_a;
151     case KEY_S:                 return XK_s;
152     case KEY_D:                 return XK_d;
153     case KEY_F:                 return XK_f;
154     case KEY_G:                 return XK_g;
155     case KEY_H:                 return XK_h;
156     case KEY_J:                 return XK_j;
157     case KEY_K:                 return XK_k;
158     case KEY_L:                 return XK_l;
159     case KEY_COLON:             return XK_colon;
160     case KEY_QUOTE:             return XK_apostrophe;
161     case KEY_TILDE:             return XK_asciitilde;
162     case KEY_LSHIFT:            return XK_Shift_L;
163     case KEY_BACKSLASH:         return XK_backslash;
164     case KEY_Z:                 return XK_z;
165     case KEY_X:                 return XK_x;
166     case KEY_C:                 return XK_c;
167     case KEY_V:                 return XK_v;
168     case KEY_B:                 return XK_b;
169     case KEY_N:                 return XK_n;
170     case KEY_M:                 return XK_m;
171     case KEY_COMMA:             return XK_comma;
172     case KEY_STOP:              return XK_period;
173     case KEY_SLASH:             return XK_slash;
174     case KEY_RSHIFT:            return XK_Shift_R;
175     case KEY_ASTERISK:          return XK_KP_Multiply;
176     case KEY_ALT:               return XK_Alt_L;
177     case KEY_SPACE:             return XK_space;
178     case KEY_CAPSLOCK:          return XK_Caps_Lock;
179     case KEY_F1:                return XK_F1;
180     case KEY_F2:                return XK_F2;
181     case KEY_F3:                return XK_F3;
182     case KEY_F4:                return XK_F4;
183     case KEY_F5:                return XK_F5;
184     case KEY_F6:                return XK_F6;
185     case KEY_F7:                return XK_F7;
186     case KEY_F8:                return XK_F8;
187     case KEY_F9:                return XK_F9;
188     case KEY_F10:               return XK_F10;
189     case KEY_NUMLOCK:           return XK_Num_Lock;
190     case KEY_SCRLOCK:           return XK_Scroll_Lock;
191     case KEY_HOME:              return XK_Home;
192     case KEY_UP:                return XK_Up;
193     case KEY_PGUP:              return XK_Page_Up;
194     case KEY_MINUS_PAD:         return XK_KP_Subtract;
195     case KEY_LEFT:              return XK_Left;
196     case KEY_5_PAD:             return XK_KP_5;
197     case KEY_RIGHT:             return XK_Right;
198     case KEY_PLUS_PAD:          return XK_KP_Add;
199     case KEY_END:               return XK_End;
200     case KEY_DOWN:              return XK_Down;
201     case KEY_PGDN:              return XK_Page_Down;
202     case KEY_INSERT:            return XK_Insert;
203     case KEY_DEL:               return XK_Delete;
204     case KEY_PRTSCR:            return XK_Print;
205     case KEY_F11:               return XK_F11;
206     case KEY_F12:               return XK_F12;
207     case KEY_LWIN:              return XK_Meta_L;
208     case KEY_RWIN:              return XK_Meta_R;
209     case KEY_MENU:              return XK_Menu;
210     case KEY_PAD:               return XK_VoidSymbol;
211     case KEY_RCONTROL:          return XK_Control_R;
212     case KEY_ALTGR:             return XK_Alt_R;
213     case KEY_SLASH2:            return XK_KP_Divide;
214     case KEY_PAUSE:             return XK_Pause;
215
216     case NEW_KEY_BACKSLASH:     return XK_backslash;
217     case NEW_KEY_1_PAD:         return XK_KP_1;
218     case NEW_KEY_2_PAD:         return XK_KP_2;
219     case NEW_KEY_3_PAD:         return XK_KP_3;
220     case NEW_KEY_4_PAD:         return XK_KP_4;
221     case NEW_KEY_5_PAD:         return XK_KP_5;
222     case NEW_KEY_6_PAD:         return XK_KP_6;
223     case NEW_KEY_7_PAD:         return XK_KP_7;
224     case NEW_KEY_8_PAD:         return XK_KP_8;
225     case NEW_KEY_9_PAD:         return XK_KP_9;
226     case NEW_KEY_0_PAD:         return XK_KP_0;
227     case NEW_KEY_STOP_PAD:      return XK_KP_Separator;
228     case NEW_KEY_EQUALS_PAD:    return XK_KP_Equal;
229     case NEW_KEY_SLASH_PAD:     return XK_KP_Divide;
230     case NEW_KEY_ASTERISK_PAD:  return XK_KP_Multiply;
231     case NEW_KEY_ENTER_PAD:     return XK_KP_Enter;
232
233     default:                    return XK_VoidSymbol;
234   }
235 }
236
237 Pixel AllegroAllocColorCell(int r, int g, int b)
238 {
239   byte pixel_mapping = 0;
240   int i;
241
242   r >>= 10;
243   g >>= 10;
244   b >>= 10;
245
246   /* try to use existing colors from the global colormap */
247   for (i = 0; i < global_colormap_entries_used; i++)
248   {
249     if (r == global_colormap[i].r &&
250         g == global_colormap[i].g &&
251         b == global_colormap[i].b)              /* color found */
252     {
253       pixel_mapping = i;
254       break;
255     }
256   }
257
258   if (i == global_colormap_entries_used)        /* color not found */
259   {
260     if (global_colormap_entries_used < MAX_COLORS)
261       global_colormap_entries_used++;
262
263     i = global_colormap_entries_used - 1;
264
265     global_colormap[i].r = r;
266     global_colormap[i].g = g;
267     global_colormap[i].b = b;
268
269     set_palette(global_colormap);
270
271     pixel_mapping = i;
272   }
273
274   return pixel_mapping;
275 }
276
277 void XMapWindow(Display *display, Window window)
278 {
279   int x, y;
280   unsigned int width, height;
281   boolean mouse_off;
282
283   x = AllegroDefaultScreen().x;
284   y = AllegroDefaultScreen().y;
285   width = AllegroDefaultScreen().width;
286   height = AllegroDefaultScreen().height;
287
288   mouse_off = hide_mouse(display, x, y, width, height);
289   blit((BITMAP *)window, video_bitmap, 0, 0, x, y, width, height);
290
291   if (mouse_off)
292     unhide_mouse(display);
293 }
294
295 Display *XOpenDisplay(char *display_name)
296 {
297   Screen *screen;
298   Display *display;
299   BITMAP *mouse_bitmap = NULL;
300   char *mouse_filename = getCustomImageFilename(program.msdos_cursor_filename);
301
302   if ((mouse_bitmap = Read_PCX_to_AllegroBitmap(mouse_filename)) == NULL)
303     return NULL;
304
305   screen = malloc(sizeof(Screen));
306   display = malloc(sizeof(Display));
307
308   screen[0].cmap = 0;
309   screen[0].root = 0;
310   screen[0].white_pixel = AllegroAllocColorCell(0xFFFF, 0xFFFF, 0xFFFF);
311   screen[0].black_pixel = AllegroAllocColorCell(0x0000, 0x0000, 0x0000);
312   screen[0].video_bitmap = NULL;
313
314   display->default_screen = 0;
315   display->screens = screen;
316   display->mouse_ptr = mouse_bitmap;
317
318   allegro_init();
319   allegro_init_drivers();
320   set_color_depth(8);
321
322   /* force Windows 95 to switch to fullscreen mode */
323   set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
324   rest(200);
325   set_gfx_mode(GFX_AUTODETECT, XRES, YRES, 0, 0);
326
327   return display;
328 }
329
330 Window XCreateSimpleWindow(Display *display, Window parent, int x, int y,
331                            unsigned int width, unsigned int height,
332                            unsigned int border_width, unsigned long border,
333                            unsigned long background)
334 {
335   video_bitmap = create_video_bitmap(XRES, YRES);
336   clear_to_color(video_bitmap, background);
337
338   AllegroDefaultScreen().video_bitmap = video_bitmap;
339   AllegroDefaultScreen().x = x;
340   AllegroDefaultScreen().y = y;
341   AllegroDefaultScreen().width = XRES;
342   AllegroDefaultScreen().height = YRES;
343
344   set_mouse_sprite(display->mouse_ptr);
345
346 #if 0
347   set_mouse_sprite_focus(1, 1);
348 #endif
349
350   set_mouse_speed(1, 1);
351   set_mouse_range(AllegroDefaultScreen().x + 1,
352                   AllegroDefaultScreen().y + 1,
353                   AllegroDefaultScreen().x + video.width + 1,
354                   AllegroDefaultScreen().y + video.height + 1);
355
356   show_video_bitmap(video_bitmap);
357
358   return (Window)video_bitmap;
359 }
360
361 Status XStringListToTextProperty(char **list, int count,
362                                  XTextProperty *text_prop_return)
363 {
364   char *string;
365
366   if (count >= 1)
367   {
368     string = malloc(strlen(list[0] + 1));
369     strcpy(string, list[0]);
370     text_prop_return->value = (unsigned char *)string;
371     return 1;
372   }
373   else
374     text_prop_return = NULL;
375
376   return 0;
377 }
378
379 void XFree(void *data)
380 {
381   checked_free(data);
382 }
383
384 GC XCreateGC(Display *display, Drawable d, unsigned long value_mask,
385              XGCValues *values)
386 {
387   XGCValues *gcv;
388   gcv = malloc(sizeof(XGCValues));
389   gcv->foreground = values->foreground;
390   gcv->background = values->background;
391   gcv->graphics_exposures = values->graphics_exposures;
392   gcv->clip_mask = values->clip_mask;
393   gcv->clip_x_origin = values->clip_x_origin;
394   gcv->clip_y_origin = values->clip_y_origin;
395   gcv->value_mask = value_mask;
396   return (GC)gcv;
397 }
398
399 void XSetClipMask(Display *display, GC gc, Pixmap pixmap)
400 {
401   XGCValues *gcv = (XGCValues *)gc;
402
403   gcv->clip_mask = pixmap;
404   gcv->value_mask |= GCClipMask;
405 }
406
407 void XSetClipOrigin(Display *display, GC gc, int x, int y)
408 {
409   XGCValues *gcv = (XGCValues *)gc;
410
411   gcv->clip_x_origin = x;
412   gcv->clip_x_origin = y;
413 }
414
415 void XFillRectangle(Display *display, Drawable d, GC gc, int x, int y,
416                     unsigned int width, unsigned int height)
417 {
418   boolean mouse_off = FALSE;
419
420   if ((BITMAP *)d == video_bitmap)
421   {
422     x += AllegroDefaultScreen().x;
423     y += AllegroDefaultScreen().y;
424     freeze_mouse_flag = TRUE;
425     mouse_off = hide_mouse(display, x, y, width, height);
426   }
427
428   rectfill((BITMAP *)d, x, y, x + width - 1, y + height - 1,
429            ((XGCValues *)gc)->foreground);
430
431   if (mouse_off)
432     unhide_mouse(display);
433
434   freeze_mouse_flag = FALSE;
435 }
436
437 Pixmap XCreatePixmap(Display *display, Drawable d, unsigned int width,
438                      unsigned int height, unsigned int depth)
439 {
440   BITMAP *bitmap = NULL;
441
442   if (gfx_capabilities & GFX_HW_VRAM_BLIT &&
443       width  == gfx.scrollbuffer_width && height == gfx.scrollbuffer_height)
444     bitmap = create_video_bitmap(width, height);
445
446   if (bitmap == NULL)
447     bitmap = create_bitmap(width, height);
448
449   return (Pixmap)bitmap;
450 }
451
452 void XSync(Display *display, Bool discard_events)
453 {
454   wait_for_vsync = TRUE;
455 }
456
457 inline void XCopyArea(Display *display, Drawable src, Drawable dest, GC gc,
458                       int src_x, int src_y,
459                       unsigned int width, unsigned int height,
460                       int dest_x, int dest_y)
461 {
462   boolean mouse_off = FALSE;
463
464   if ((BITMAP *)src == video_bitmap)
465   {
466     src_x += AllegroDefaultScreen().x;
467     src_y += AllegroDefaultScreen().y;
468   }
469
470   if ((BITMAP *)dest == video_bitmap)
471   {
472     dest_x += AllegroDefaultScreen().x;
473     dest_y += AllegroDefaultScreen().y;
474     freeze_mouse_flag = TRUE;
475     mouse_off = hide_mouse(display, dest_x, dest_y, width, height);
476   }
477
478   if (wait_for_vsync)
479   {
480     wait_for_vsync = FALSE;
481     vsync();
482   }
483
484   if (((XGCValues *)gc)->value_mask & GCClipMask)
485     masked_blit((BITMAP *)src, (BITMAP *)dest, src_x, src_y, dest_x, dest_y,
486                 width, height);
487   else
488     blit((BITMAP *)src, (BITMAP *)dest, src_x, src_y, dest_x, dest_y,
489          width, height);
490
491   if (mouse_off)
492     unhide_mouse(display);
493
494   freeze_mouse_flag = FALSE;
495 }
496
497 static BITMAP *Image_to_AllegroBitmap(Image *image)
498 {
499   BITMAP *bitmap;
500   byte *src_ptr = image->data;
501   byte pixel_mapping[MAX_COLORS];
502   unsigned int depth = 8;
503   int i, x, y;
504
505   if (image->type == IMAGETYPE_TRUECOLOR && depth == 8)
506     Error(ERR_EXIT, "cannot handle true-color images on 8-bit display");
507
508   /* allocate new allegro bitmap structure */
509   if ((bitmap = create_bitmap_ex(depth, image->width, image->height)) == NULL)
510   {
511     errno_pcx = PCX_NoMemory;
512     return NULL;
513   }
514
515   clear(bitmap);
516
517   /* try to use existing colors from the global colormap */
518   for (i = 0; i < MAX_COLORS; i++)
519   {
520     if (!image->rgb.color_used[i])
521       continue;
522
523     pixel_mapping[i] = AllegroAllocColorCell(image->rgb.red[i],
524                                              image->rgb.green[i],
525                                              image->rgb.blue[i]);
526   }
527
528   /* copy bitmap data */
529   for (y = 0; y < image->height; y++)
530     for (x = 0; x < image->width; x++)
531       putpixel(bitmap, x, y, pixel_mapping[*src_ptr++]);
532
533   return bitmap;
534 }
535
536 static BITMAP *Read_PCX_to_AllegroBitmap(char *filename)
537 {
538   BITMAP *bitmap;
539   Image *image;
540
541   /* read the graphic file in PCX format to internal image structure */
542   if ((image = Read_PCX_to_Image(filename)) == NULL)
543     return NULL;
544
545   /* convert internal image structure to allegro bitmap structure */
546   if ((bitmap = Image_to_AllegroBitmap(image)) == NULL)
547     return NULL;
548
549   set_palette(global_colormap);
550
551   return bitmap;
552 }
553
554 int Read_PCX_to_Pixmap(Display *display, Window window, GC gc, char *filename,
555                        Pixmap *pixmap, Pixmap *pixmap_mask)
556 {
557   BITMAP *bitmap;
558
559   if ((bitmap = Read_PCX_to_AllegroBitmap(filename)) == NULL)
560     return errno_pcx;
561
562   *pixmap = (Pixmap)bitmap;
563
564   /* pixmap_mask will never be used in Allegro (which uses masked_blit()),
565      so use non-NULL dummy pointer to empty Pixmap */
566   *pixmap_mask = (Pixmap)DUMMY_MASK;
567
568   return PCX_Success;
569 }
570
571 int XReadBitmapFile(Display *display, Drawable d, char *filename,
572                     unsigned int *width_return, unsigned int *height_return,
573                     Pixmap *bitmap_return,
574                     int *x_hot_return, int *y_hot_return)
575 {
576   BITMAP *bitmap;
577
578   if ((bitmap = Read_PCX_to_AllegroBitmap(filename)) == NULL)
579     return BitmapOpenFailed;
580
581   *width_return = bitmap->w;
582   *height_return = bitmap->h;
583   *x_hot_return = -1;
584   *y_hot_return = -1;
585   *bitmap_return = (Pixmap)bitmap;
586
587   return BitmapSuccess;
588 }
589
590 void XFreePixmap(Display *display, Pixmap pixmap)
591 {
592   if (pixmap != DUMMY_MASK &&
593       (is_memory_bitmap((BITMAP *)pixmap) ||
594        is_screen_bitmap((BITMAP *)pixmap)))
595     destroy_bitmap((BITMAP *)pixmap);
596 }
597
598 void XFreeGC(Display *display, GC gc)
599 {
600   XGCValues *gcv = (XGCValues *)gc;
601
602   checked_free(gcv);
603 }
604
605 void XUnmapWindow(Display *display, Window window)
606 {
607 }
608
609 void XCloseDisplay(Display *display)
610 {
611   BITMAP *bitmap = video_bitmap;
612
613   if (is_screen_bitmap(bitmap))
614     destroy_bitmap(bitmap);
615
616   checked_free(display->screens);
617   checked_free(display);
618
619   /* return to text mode (or DOS box on Windows screen) */
620   set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
621 }
622
623 void XNextEvent(Display *display, XEvent *event_return)
624 {
625   while (!pending_events)
626     XPending(display);
627
628   memcpy(event_return, &event_buffer[pending_events], sizeof(XEvent));
629   pending_events--;
630 }
631
632 static void NewKeyEvent(int key_press_state, KeySym keysym)
633 {
634   XKeyEvent *xkey;
635
636   if (pending_events >= MAX_EVENT_BUFFER)
637     return;
638
639   pending_events++;
640   xkey = (XKeyEvent *)&event_buffer[pending_events];
641   xkey->type = key_press_state;
642   xkey->state = (unsigned int)keysym;
643 }
644
645 #define HANDLE_RAW_KB_ALL_KEYS                  0
646 #define HANDLE_RAW_KB_MODIFIER_KEYS_ONLY        1
647
648 static int modifier_scancode[] =
649 {
650   KEY_LSHIFT,
651   KEY_RSHIFT,
652   KEY_LCONTROL,
653   KEY_RCONTROL,
654   KEY_ALT,
655   KEY_ALTGR,
656   KEY_LWIN,
657   KEY_RWIN,
658   KEY_CAPSLOCK,
659   KEY_NUMLOCK,
660   KEY_SCRLOCK,
661   -1
662 };
663
664 static void HandleKeyboardRaw(int mode)
665 {
666   int i;
667
668   for (i = 0; i < MAX_SCANCODES; i++)
669   {
670     int scancode, new_state, event_type;
671     char key_pressed;
672
673     if (mode == HANDLE_RAW_KB_MODIFIER_KEYS_ONLY)
674     {
675       if ((scancode = modifier_scancode[i]) == -1)
676         return;
677     }
678     else
679       scancode = i;
680
681     key_pressed = key[scancode];
682     new_state = (key_pressed ? KeyPressMask : KeyReleaseMask);
683     event_type = (key_pressed ? KeyPress : KeyRelease);
684
685     if (key_press_state[i] == new_state)        /* state not changed */
686       continue;
687
688     key_press_state[i] = new_state;
689
690     NewKeyEvent(event_type, ScancodeToKeySym(scancode));
691   }
692 }
693
694 static void HandleKeyboardEvent()
695 {
696   if (keypressed())
697   {
698     int key_info = readkey();
699     int scancode = (key_info >> 8);
700     int ascii = (key_info & 0xff);
701     KeySym keysym = ScancodeToKeySym(scancode);
702
703     if (scancode == KEY_PAD)
704     {
705       /* keys on the numeric keypad return just scancode 'KEY_PAD'
706          for some reason, so we must handle them separately */
707
708       if (ascii >= '0' && ascii <= '9')
709         keysym = XK_KP_0 + (KeySym)(ascii - '0');
710       else if (ascii == '.')
711         keysym = XK_KP_Separator;
712     }
713     else if (ascii >= ' ' && ascii <= 'Z')
714       keysym = XK_space + (KeySym)(ascii - ' ');
715     else if (ascii == '^')
716       keysym = XK_asciicircum;
717     else if (ascii == '_')
718       keysym = XK_underscore;
719     else if (ascii == 'Ä')
720       keysym = XK_Adiaeresis;
721     else if (ascii == 'Ö')
722       keysym = XK_Odiaeresis;
723     else if (ascii == 'Ãœ')
724       keysym = XK_Udiaeresis;
725     else if (ascii == 'ä')
726       keysym = XK_adiaeresis;
727     else if (ascii == 'ö')
728       keysym = XK_odiaeresis;
729     else if (ascii == 'ü')
730       keysym = XK_udiaeresis;
731     else if (ascii == 'ß')
732       keysym = XK_ssharp;
733
734     NewKeyEvent(KeyPress, keysym);
735   }
736   else if (key_shifts & (KB_SHIFT_FLAG | KB_CTRL_FLAG | KB_ALT_FLAG))
737   {
738     /* the allegro function keypressed() does not give us single pressed
739        modifier keys, so we must detect them with the internal global
740        allegro variable 'key_shifts' and then handle them separately */
741
742     HandleKeyboardRaw(HANDLE_RAW_KB_MODIFIER_KEYS_ONLY);
743   }
744 }
745
746 int XPending(Display *display)
747 {
748   XButtonEvent *xbutton;
749   XMotionEvent *xmotion;
750   int i;
751
752   /* When using 'HandleKeyboardRaw()', keyboard input is also stored in
753      the allegro keyboard input buffer and would be available a second
754      time by calling 'HandleKeyboardEvent()'. To avoid double keyboard
755      events, the allegro function 'clear_keybuf()' must be called each
756      time when switching from calling 'HandleKeyboardRaw()' to calling
757      'HandleKeyboardEvent()' to get keyboard input, which is actually
758      done by 'XAutoRepeatOn()' which sets keyboard_auto_repeat to TRUE. */
759
760   /* keyboard event */
761   if (keyboard_auto_repeat)
762     HandleKeyboardEvent();
763   else
764     HandleKeyboardRaw(HANDLE_RAW_KB_ALL_KEYS);
765
766   /* mouse motion event */
767   if (mouse_pos != last_mouse_pos)
768   {
769     last_mouse_pos = mouse_pos;
770     pending_events++;
771     xmotion = (XMotionEvent *)&event_buffer[pending_events];
772     xmotion->type = MotionNotify;
773     xmotion->x = mouse_x - AllegroDefaultScreen().x;
774     xmotion->y = mouse_y - AllegroDefaultScreen().y;
775   }
776
777   /* mouse button event */
778   if (mouse_b != last_mouse_b)
779   {
780     for (i = 0; i < 3; i++)     /* check all three mouse buttons */
781     {
782       int bitmask = (1 << i);
783
784       if ((last_mouse_b & bitmask) != (mouse_b & bitmask))
785       {
786         int mapping[3] = { 1, 3, 2 };
787
788         pending_events++;
789         xbutton = (XButtonEvent *)&event_buffer[pending_events];
790         xbutton->type = (mouse_b & bitmask ? ButtonPress : ButtonRelease);
791         xbutton->button = mapping[i];
792         xbutton->x = mouse_x - AllegroDefaultScreen().x;
793         xbutton->y = mouse_y - AllegroDefaultScreen().y;
794       }
795     }
796     last_mouse_b = mouse_b;
797   }
798
799   return pending_events;
800 }
801
802 KeySym XLookupKeysym(XKeyEvent *key_event, int index)
803 {
804   return key_event->state;
805 }
806
807 int XLookupString(XKeyEvent *key_event, char *buffer, int buffer_size,
808                   KeySym *key, XComposeStatus *compose)
809 {
810   *key = key_event->state;
811   return 0;
812 }
813
814 void XSetForeground(Display *display, GC gc, unsigned long pixel)
815 {
816   XGCValues *gcv = (XGCValues *)gc;
817
818   gcv->foreground = pixel;
819 }
820
821 void XDrawLine(Display *display, Drawable d, GC gc,
822                int x1, int y1, int x2, int y2)
823 {
824   XGCValues *gcv = (XGCValues *)gc;
825   boolean mouse_off = FALSE;
826
827   if ((BITMAP *)d == video_bitmap)
828   {
829     x1 += AllegroDefaultScreen().x;
830     y1 += AllegroDefaultScreen().y;
831     x2 += AllegroDefaultScreen().x;
832     y2 += AllegroDefaultScreen().y;
833     freeze_mouse_flag = TRUE;
834     mouse_off = hide_mouse(display, MIN(x1, x2), MIN(y1, y2),
835                            MAX(x1, x2) - MIN(x1, x2),
836                            MAX(y1, y2) - MIN(y1, y2));
837   }
838
839   line((BITMAP *)d, x1, y1, x2, y2, gcv->foreground);
840
841   if (mouse_off)
842     unhide_mouse(display);
843
844   freeze_mouse_flag = FALSE;
845 }
846
847 void XDestroyImage(XImage *ximage)
848 {
849 }
850
851 void XDestroyWindow(Display *display, Window window)
852 {
853 }
854
855 Bool XQueryPointer(Display *display, Window window,
856                    Window *root, Window *child, int *root_x, int *root_y,
857                    int *win_x, int *win_y, unsigned int *mask)
858 {
859   *win_x = mouse_x - AllegroDefaultScreen().x;
860   *win_y = mouse_y - AllegroDefaultScreen().y;
861
862   return True;
863 }
864
865 void XAutoRepeatOn(Display *display)
866 {
867   keyboard_auto_repeat = TRUE;
868   clear_keybuf();
869 }
870
871 void XAutoRepeatOff(Display *display)
872 {
873   keyboard_auto_repeat = FALSE;
874 }
875
876 void AllegroDrawLine(Drawable d, int from_x, int from_y, int to_x, int to_y,
877                      Pixel color)
878 {
879   boolean mouse_off = FALSE;
880
881   if ((BITMAP *)d == video_bitmap)
882   {
883     int dx = AllegroDefaultScreen().x;
884     int dy = AllegroDefaultScreen().y;
885     int x1, y1, x2, y2;
886
887     from_x += dx;
888     from_y += dy;
889     to_x += dx;
890     to_y += dy;
891
892     x1 = (from_x < to_x ? from_x : to_x);
893     y1 = (from_y < to_y ? from_y : to_y);
894     x2 = (from_x < to_x ? to_x : from_x);
895     y2 = (from_y < to_y ? to_y : from_y);
896
897     freeze_mouse_flag = TRUE;
898     mouse_off = hide_mouse(display, x1, y1, x2 - x1 + 1, y2 - y1 + 1);
899   }
900
901   line((BITMAP *)d, from_x, from_y, to_x, to_y, color);
902
903   if (mouse_off)
904     unhide_mouse(display);
905
906   freeze_mouse_flag = FALSE;
907 }
908
909 Pixel AllegroGetPixel(Drawable d, int x, int y)
910 {
911   return getpixel((BITMAP *)d, x, y);
912 }
913
914 void AllegroZoomBitmap(Drawable src, Drawable dst,
915                        int src_width, int src_height,
916                        int dst_width, int dst_height)
917 {
918   stretch_blit((BITMAP *)src, (BITMAP *)dst,
919                0, 0, src_width, src_height, 0, 0, dst_width, dst_height);
920 }
921
922 void MSDOSOpenAudio(void)
923 {
924   if (allegro_init_audio())
925   {
926     audio.sound_available = TRUE;
927     audio.music_available = TRUE;
928     audio.loops_available = TRUE;
929     audio.sound_enabled = TRUE;
930
931     audio.num_channels = NUM_MIXER_CHANNELS;
932     audio.music_channel = MUSIC_CHANNEL;
933     audio.first_sound_channel = FIRST_SOUND_CHANNEL;
934
935     Mixer_InitChannels();
936   }
937 }
938
939 void MSDOSCloseAudio(void)
940 {
941   /* nothing to be done here */
942 }
943
944 void NetworkServer(int port, int serveronly)
945 {
946   Error(ERR_WARN, "networking not supported in DOS version");
947 }
948
949
950 /* ========================================================================= */
951 /* joystick functions                                                        */
952 /* ========================================================================= */
953
954 void MSDOSInitJoysticks()
955 {
956   int i;
957
958   /* start from scratch */
959   remove_joystick();
960
961   /* try to access two joysticks; if that fails, try to access just one */
962   if (install_joystick(JOY_TYPE_2PADS) == 0 ||
963       install_joystick(JOY_TYPE_AUTODETECT) == 0)
964     joystick.status = JOYSTICK_ACTIVATED;
965
966   for (i = 0; i < MAX_PLAYERS; i++)
967   {
968     char *device_name = setup.input[i].joy.device_name;
969     int joystick_nr = getJoystickNrFromDeviceName(device_name);
970
971     if (joystick_nr >= num_joysticks)
972       joystick_nr = -1;
973
974     /* misuse joystick file descriptor variable to store joystick number */
975     joystick.fd[i] = joystick_nr;
976   }
977 }
978
979 boolean MSDOSReadJoystick(int nr, int *x, int *y, boolean *b1, boolean *b2)
980 {
981   /* the allegro global variable 'num_joysticks' contains the number
982      of joysticks found at initialization under MS-DOS / Windows */
983
984   if (nr < 0 || nr >= num_joysticks)
985     return FALSE;
986
987   poll_joystick();
988
989   if (x != NULL)
990     *x = joy[nr].stick[0].axis[0].pos;
991   if (y != NULL)
992     *y = joy[nr].stick[0].axis[1].pos;
993
994   if (b1 != NULL)
995     *b1 = joy[nr].button[0].b;
996   if (b2 != NULL)
997     *b2 = joy[nr].button[1].b;
998
999   return TRUE;
1000 }
1001
1002 #endif /* PLATFORM_MSDOS */