fixed compiler warnings (after adding "-Wstrict-prototypes")
[rocksndiamonds.git] / src / screens.c
1 // ============================================================================
2 // Rocks'n'Diamonds - McDuffin Strikes Back!
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  http://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // screens.c
10 // ============================================================================
11
12 #include "libgame/libgame.h"
13
14 #include "screens.h"
15 #include "events.h"
16 #include "game.h"
17 #include "tools.h"
18 #include "editor.h"
19 #include "files.h"
20 #include "tape.h"
21 #include "anim.h"
22 #include "network.h"
23 #include "init.h"
24 #include "config.h"
25
26
27 #define DEBUG_JOYSTICKS         0
28
29
30 /* screens on the info screen */
31 #define INFO_MODE_MAIN                  0
32 #define INFO_MODE_TITLE                 1
33 #define INFO_MODE_ELEMENTS              2
34 #define INFO_MODE_MUSIC                 3
35 #define INFO_MODE_CREDITS               4
36 #define INFO_MODE_PROGRAM               5
37 #define INFO_MODE_VERSION               6
38 #define INFO_MODE_LEVELSET              7
39
40 #define MAX_INFO_MODES                  8
41
42 /* screens on the setup screen */
43 /* (must match GFX_SPECIAL_ARG_SETUP_* values as defined in src/main.h) */
44 /* (should also match corresponding entries in src/conf_gfx.c) */
45 #define SETUP_MODE_MAIN                 0
46 #define SETUP_MODE_GAME                 1
47 #define SETUP_MODE_EDITOR               2
48 #define SETUP_MODE_GRAPHICS             3
49 #define SETUP_MODE_SOUND                4
50 #define SETUP_MODE_ARTWORK              5
51 #define SETUP_MODE_INPUT                6
52 #define SETUP_MODE_TOUCH                7
53 #define SETUP_MODE_SHORTCUTS            8
54 #define SETUP_MODE_SHORTCUTS_1          9
55 #define SETUP_MODE_SHORTCUTS_2          10
56 #define SETUP_MODE_SHORTCUTS_3          11
57 #define SETUP_MODE_SHORTCUTS_4          12
58 #define SETUP_MODE_SHORTCUTS_5          13
59
60 /* sub-screens on the setup screen (generic) */
61 #define SETUP_MODE_CHOOSE_ARTWORK       14
62 #define SETUP_MODE_CHOOSE_OTHER         15
63
64 /* sub-screens on the setup screen (specific) */
65 #define SETUP_MODE_CHOOSE_GAME_SPEED    16
66 #define SETUP_MODE_CHOOSE_SCROLL_DELAY  17
67 #define SETUP_MODE_CHOOSE_SNAPSHOT_MODE 18
68 #define SETUP_MODE_CHOOSE_WINDOW_SIZE   19
69 #define SETUP_MODE_CHOOSE_SCALING_TYPE  20
70 #define SETUP_MODE_CHOOSE_RENDERING     21
71 #define SETUP_MODE_CHOOSE_GRAPHICS      22
72 #define SETUP_MODE_CHOOSE_SOUNDS        23
73 #define SETUP_MODE_CHOOSE_MUSIC         24
74 #define SETUP_MODE_CHOOSE_VOLUME_SIMPLE 25
75 #define SETUP_MODE_CHOOSE_VOLUME_LOOPS  26
76 #define SETUP_MODE_CHOOSE_VOLUME_MUSIC  27
77 #define SETUP_MODE_CHOOSE_TOUCH_CONTROL 28
78 #define SETUP_MODE_CHOOSE_MOVE_DISTANCE 29
79 #define SETUP_MODE_CHOOSE_DROP_DISTANCE 30
80 #define SETUP_MODE_CHOOSE_TRANSPARENCY  31
81 #define SETUP_MODE_CHOOSE_GRID_XSIZE_0  32
82 #define SETUP_MODE_CHOOSE_GRID_YSIZE_0  33
83 #define SETUP_MODE_CHOOSE_GRID_XSIZE_1  34
84 #define SETUP_MODE_CHOOSE_GRID_YSIZE_1  35
85 #define SETUP_MODE_CONFIG_VIRT_BUTTONS  36
86
87 #define MAX_SETUP_MODES                 37
88
89 #define MAX_MENU_MODES                  MAX(MAX_INFO_MODES, MAX_SETUP_MODES)
90
91 /* setup screen titles */
92 #define STR_SETUP_MAIN                  "Setup"
93 #define STR_SETUP_GAME                  "Game & Menu"
94 #define STR_SETUP_EDITOR                "Editor"
95 #define STR_SETUP_GRAPHICS              "Graphics"
96 #define STR_SETUP_SOUND                 "Sound & Music"
97 #define STR_SETUP_ARTWORK               "Custom Artwork"
98 #define STR_SETUP_INPUT                 "Input Devices"
99 #define STR_SETUP_TOUCH                 "Touch Controls"
100 #define STR_SETUP_SHORTCUTS             "Key Shortcuts"
101 #define STR_SETUP_EXIT                  "Exit"
102 #define STR_SETUP_SAVE_AND_EXIT         "Save and Exit"
103
104 #define STR_SETUP_CHOOSE_GAME_SPEED     "Game Speed"
105 #define STR_SETUP_CHOOSE_SCROLL_DELAY   "Scroll Delay"
106 #define STR_SETUP_CHOOSE_SNAPSHOT_MODE  "Snapshot Mode"
107 #define STR_SETUP_CHOOSE_WINDOW_SIZE    "Window Scaling"
108 #define STR_SETUP_CHOOSE_SCALING_TYPE   "Anti-Aliasing"
109 #define STR_SETUP_CHOOSE_RENDERING      "Rendering Mode"
110 #define STR_SETUP_CHOOSE_VOLUME_SIMPLE  "Sound Volume"
111 #define STR_SETUP_CHOOSE_VOLUME_LOOPS   "Loops Volume"
112 #define STR_SETUP_CHOOSE_VOLUME_MUSIC   "Music Volume"
113 #define STR_SETUP_CHOOSE_TOUCH_CONTROL  "Control Type"
114 #define STR_SETUP_CHOOSE_MOVE_DISTANCE  "Move Distance"
115 #define STR_SETUP_CHOOSE_DROP_DISTANCE  "Drop Distance"
116 #define STR_SETUP_CHOOSE_TRANSPARENCY   "Transparency"
117 #define STR_SETUP_CHOOSE_GRID_XSIZE_0   "Horiz. Buttons"
118 #define STR_SETUP_CHOOSE_GRID_YSIZE_0   "Vert. Buttons"
119 #define STR_SETUP_CHOOSE_GRID_XSIZE_1   "Horiz. Buttons"
120 #define STR_SETUP_CHOOSE_GRID_YSIZE_1   "Vert. Buttons"
121
122 /* for input setup functions */
123 #define SETUPINPUT_SCREEN_POS_START     0
124 #define SETUPINPUT_SCREEN_POS_EMPTY1    3
125 #define SETUPINPUT_SCREEN_POS_EMPTY2    12
126 #define SETUPINPUT_SCREEN_POS_END       13
127
128 #define MENU_SETUP_FONT_TITLE           FONT_TEXT_1
129 #define MENU_SETUP_FONT_TEXT            FONT_TITLE_2
130
131 /* for various menu stuff  */
132 #define MENU_SCREEN_START_XPOS          1
133 #define MENU_SCREEN_START_YPOS          2
134 #define MENU_SCREEN_VALUE_XPOS          (SCR_FIELDX - 3)
135 #define MENU_SCREEN_MAX_XPOS            (SCR_FIELDX - 1)
136 #define MENU_TITLE1_YPOS                8
137 #define MENU_TITLE2_YPOS                46
138 #define MENU_INFO_FONT_TITLE            FONT_TEXT_1
139 #define MENU_INFO_FONT_HEAD             FONT_TEXT_2
140 #define MENU_INFO_FONT_TEXT             FONT_TEXT_3
141 #define MENU_INFO_FONT_FOOT             FONT_TEXT_4
142 #define MENU_INFO_SPACE_HEAD            (menu.headline2_spacing_info[info_mode])
143 #define MENU_SCREEN_INFO_SPACE_LEFT     (menu.left_spacing_info[info_mode])
144 #define MENU_SCREEN_INFO_SPACE_RIGHT    (menu.right_spacing_info[info_mode])
145 #define MENU_SCREEN_INFO_SPACE_TOP      (menu.top_spacing_info[info_mode])
146 #define MENU_SCREEN_INFO_SPACE_BOTTOM   (menu.bottom_spacing_info[info_mode])
147 #define MENU_SCREEN_INFO_YSTART1        MENU_SCREEN_INFO_SPACE_TOP
148 #define MENU_SCREEN_INFO_YSTART2        (MENU_SCREEN_INFO_YSTART1 +            \
149                                          getMenuTextStep(MENU_INFO_SPACE_HEAD, \
150                                                          MENU_INFO_FONT_TITLE))
151 #define MENU_SCREEN_INFO_YSTEP          (TILEY + 4)
152 #define MENU_SCREEN_INFO_YBOTTOM        (SYSIZE - MENU_SCREEN_INFO_SPACE_BOTTOM)
153 #define MENU_SCREEN_INFO_YSIZE          (MENU_SCREEN_INFO_YBOTTOM -     \
154                                          MENU_SCREEN_INFO_YSTART2 -     \
155                                          TILEY / 2)
156 #define MAX_INFO_ELEMENTS_ON_SCREEN     128
157 #define STD_INFO_ELEMENTS_ON_SCREEN     (MENU_SCREEN_INFO_YSIZE /       \
158                                          MENU_SCREEN_INFO_YSTEP)
159 #define NUM_INFO_ELEMENTS_FROM_CONF     \
160   (menu.list_size_info[GFX_SPECIAL_ARG_INFO_ELEMENTS] > 0 ?             \
161    menu.list_size_info[GFX_SPECIAL_ARG_INFO_ELEMENTS] :                 \
162    MAX_MENU_ENTRIES_ON_SCREEN)
163 #define NUM_INFO_ELEMENTS_ON_SCREEN     MIN(MIN(STD_INFO_ELEMENTS_ON_SCREEN, \
164                                                 MAX_INFO_ELEMENTS_ON_SCREEN), \
165                                             NUM_INFO_ELEMENTS_FROM_CONF)
166 #define MAX_MENU_ENTRIES_ON_SCREEN      (SCR_FIELDY - MENU_SCREEN_START_YPOS)
167 #define MAX_MENU_TEXT_LENGTH_BIG        13
168 #define MAX_MENU_TEXT_LENGTH_MEDIUM     (MAX_MENU_TEXT_LENGTH_BIG * 2)
169
170 /* buttons and scrollbars identifiers */
171 #define SCREEN_CTRL_ID_PREV_LEVEL       0
172 #define SCREEN_CTRL_ID_NEXT_LEVEL       1
173 #define SCREEN_CTRL_ID_PREV_PLAYER      2
174 #define SCREEN_CTRL_ID_NEXT_PLAYER      3
175 #define SCREEN_CTRL_ID_INSERT_SOLUTION  4
176 #define SCREEN_CTRL_ID_PLAY_SOLUTION    5
177 #define SCREEN_CTRL_ID_SCROLL_UP        6
178 #define SCREEN_CTRL_ID_SCROLL_DOWN      7
179 #define SCREEN_CTRL_ID_SCROLL_VERTICAL  8
180
181 #define NUM_SCREEN_GADGETS              9
182
183 #define NUM_SCREEN_MENUBUTTONS          6
184 #define NUM_SCREEN_SCROLLBUTTONS        2
185 #define NUM_SCREEN_SCROLLBARS           1
186
187 #define SCREEN_MASK_MAIN                (1 << 0)
188 #define SCREEN_MASK_MAIN_HAS_SOLUTION   (1 << 1)
189 #define SCREEN_MASK_INPUT               (1 << 2)
190
191 /* graphic position and size values for buttons and scrollbars */
192 #define SC_MENUBUTTON_XSIZE             TILEX
193 #define SC_MENUBUTTON_YSIZE             TILEY
194
195 #define SC_SCROLLBUTTON_XSIZE           TILEX
196 #define SC_SCROLLBUTTON_YSIZE           TILEY
197
198 #define SC_SCROLLBAR_XPOS               (SXSIZE - SC_SCROLLBUTTON_XSIZE)
199
200 #define SC_SCROLL_VERTICAL_XSIZE        SC_SCROLLBUTTON_XSIZE
201 #define SC_SCROLL_VERTICAL_YSIZE        ((MAX_MENU_ENTRIES_ON_SCREEN - 2) * \
202                                          SC_SCROLLBUTTON_YSIZE)
203
204 #define SC_SCROLL_UP_XPOS               SC_SCROLLBAR_XPOS
205 #define SC_SCROLL_UP_YPOS               (2 * SC_SCROLLBUTTON_YSIZE)
206
207 #define SC_SCROLL_VERTICAL_XPOS         SC_SCROLLBAR_XPOS
208 #define SC_SCROLL_VERTICAL_YPOS         (SC_SCROLL_UP_YPOS + \
209                                          SC_SCROLLBUTTON_YSIZE)
210
211 #define SC_SCROLL_DOWN_XPOS             SC_SCROLLBAR_XPOS
212 #define SC_SCROLL_DOWN_YPOS             (SC_SCROLL_VERTICAL_YPOS + \
213                                          SC_SCROLL_VERTICAL_YSIZE)
214
215 #define SC_BORDER_SIZE                  14
216
217
218 /* forward declarations of internal functions */
219 static void HandleScreenGadgets(struct GadgetInfo *);
220 static void HandleSetupScreen_Generic(int, int, int, int, int);
221 static void HandleSetupScreen_Input(int, int, int, int, int);
222 static void CustomizeKeyboard(int);
223 static void ConfigureJoystick(int);
224 static void ConfigureVirtualButtons(void);
225 static void execSetupGame(void);
226 static void execSetupGraphics(void);
227 static void execSetupSound(void);
228 static void execSetupTouch(void);
229 static void execSetupArtwork(void);
230 static void HandleChooseTree(int, int, int, int, int, TreeInfo **);
231
232 static void DrawChooseLevelSet(void);
233 static void DrawChooseLevelNr(void);
234 static void DrawInfoScreen(void);
235 static void DrawSetupScreen(void);
236
237 static void DrawInfoScreen_NotAvailable(char *, char *);
238 static void DrawInfoScreen_HelpAnim(int, int, boolean);
239 static void DrawInfoScreen_HelpText(int, int, int, int);
240 static void HandleInfoScreen_Main(int, int, int, int, int);
241 static void HandleInfoScreen_TitleScreen(int);
242 static void HandleInfoScreen_Elements(int);
243 static void HandleInfoScreen_Music(int);
244 static void HandleInfoScreen_Credits(int);
245 static void HandleInfoScreen_Program(int);
246 static void HandleInfoScreen_Version(int);
247
248 static void MapScreenMenuGadgets(int);
249 static void MapScreenGadgets(int);
250 static void MapScreenTreeGadgets(TreeInfo *);
251
252 static void UpdateScreenMenuGadgets(int, boolean);
253
254 static struct GadgetInfo *screen_gadget[NUM_SCREEN_GADGETS];
255
256 static int info_mode = INFO_MODE_MAIN;
257 static int setup_mode = SETUP_MODE_MAIN;
258
259 static TreeInfo *window_sizes = NULL;
260 static TreeInfo *window_size_current = NULL;
261
262 static TreeInfo *scaling_types = NULL;
263 static TreeInfo *scaling_type_current = NULL;
264
265 static TreeInfo *rendering_modes = NULL;
266 static TreeInfo *rendering_mode_current = NULL;
267
268 static TreeInfo *scroll_delays = NULL;
269 static TreeInfo *scroll_delay_current = NULL;
270
271 static TreeInfo *snapshot_modes = NULL;
272 static TreeInfo *snapshot_mode_current = NULL;
273
274 static TreeInfo *game_speeds = NULL;
275 static TreeInfo *game_speed_current = NULL;
276
277 static TreeInfo *volumes_simple = NULL;
278 static TreeInfo *volume_simple_current = NULL;
279
280 static TreeInfo *volumes_loops = NULL;
281 static TreeInfo *volume_loops_current = NULL;
282
283 static TreeInfo *volumes_music = NULL;
284 static TreeInfo *volume_music_current = NULL;
285
286 static TreeInfo *touch_controls = NULL;
287 static TreeInfo *touch_control_current = NULL;
288
289 static TreeInfo *move_distances = NULL;
290 static TreeInfo *move_distance_current = NULL;
291
292 static TreeInfo *drop_distances = NULL;
293 static TreeInfo *drop_distance_current = NULL;
294
295 static TreeInfo *transparencies = NULL;
296 static TreeInfo *transparency_current = NULL;
297
298 static TreeInfo *grid_sizes[2][2] = { { NULL, NULL }, { NULL, NULL } };
299 static TreeInfo *grid_size_current[2][2] = { { NULL, NULL }, { NULL, NULL } };
300
301 static TreeInfo *level_number = NULL;
302 static TreeInfo *level_number_current = NULL;
303
304 static struct
305 {
306   int value;
307   char *text;
308 } window_sizes_list[] =
309 {
310   {     50,     "50 %"                          },
311   {     80,     "80 %"                          },
312   {     90,     "90 %"                          },
313   {     100,    "100 % (Default)"               },
314   {     110,    "110 %"                         },
315   {     120,    "120 %"                         },
316   {     130,    "130 %"                         },
317   {     140,    "140 %"                         },
318   {     150,    "150 %"                         },
319   {     200,    "200 %"                         },
320   {     250,    "250 %"                         },
321   {     300,    "300 %"                         },
322
323   {     -1,     NULL                            },
324 };
325
326 static struct
327 {
328   char *value;
329   char *text;
330 } scaling_types_list[] =
331 {
332   {     SCALING_QUALITY_NEAREST, "Off"          },
333   {     SCALING_QUALITY_LINEAR,  "Linear"       },
334   {     SCALING_QUALITY_BEST,    "Anisotropic"  },
335
336   {     NULL,                    NULL           },
337 };
338
339 static struct
340 {
341   char *value;
342   char *text;
343 } rendering_modes_list[] =
344 {
345   {     STR_SPECIAL_RENDERING_OFF,      "Off (May show artifacts, fast)" },
346   {     STR_SPECIAL_RENDERING_BITMAP,   "Bitmap/Texture mode (slower)"   },
347 #if DEBUG
348   // this mode may work under certain conditions, but does not work on Windows
349   {     STR_SPECIAL_RENDERING_TARGET,   "Target Texture mode (slower)"   },
350 #endif
351   {     STR_SPECIAL_RENDERING_DOUBLE,   "Double Texture mode (slower)"   },
352
353   {     NULL,                            NULL                            },
354 };
355
356 static struct
357 {
358   int value;
359   char *text;
360 } game_speeds_list[] =
361 {
362 #if 1
363   {     30,     "Very Slow"                     },
364   {     25,     "Slow"                          },
365   {     20,     "Normal"                        },
366   {     15,     "Fast"                          },
367   {     10,     "Very Fast"                     },
368 #else
369   {     1000,   "1/1s (Extremely Slow)"         },
370   {     500,    "1/2s"                          },
371   {     200,    "1/5s"                          },
372   {     100,    "1/10s"                         },
373   {     50,     "1/20s"                         },
374   {     29,     "1/35s (Original Supaplex)"     },
375   {     25,     "1/40s"                         },
376   {     20,     "1/50s (Normal Speed)"          },
377   {     14,     "1/70s (Maximum Supaplex)"      },
378   {     10,     "1/100s"                        },
379   {     5,      "1/200s"                        },
380   {     2,      "1/500s"                        },
381   {     1,      "1/1000s (Extremely Fast)"      },
382 #endif
383
384   {     -1,     NULL                            },
385 };
386
387 static struct
388 {
389   int value;
390   char *text;
391 } scroll_delays_list[] =
392 {
393   {     0,      "0 Tiles (No Scroll Delay)"     },
394   {     1,      "1 Tile"                        },
395   {     2,      "2 Tiles"                       },
396   {     3,      "3 Tiles (Default)"             },
397   {     4,      "4 Tiles"                       },
398   {     5,      "5 Tiles"                       },
399   {     6,      "6 Tiles"                       },
400   {     7,      "7 Tiles"                       },
401   {     8,      "8 Tiles (Maximum Scroll Delay)"},
402
403   {     -1,     NULL                            },
404 };
405
406 static struct
407 {
408   char *value;
409   char *text;
410 } snapshot_modes_list[] =
411 {
412   {     STR_SNAPSHOT_MODE_OFF,                  "Off"           },
413   {     STR_SNAPSHOT_MODE_EVERY_STEP,           "Every Step"    },
414   {     STR_SNAPSHOT_MODE_EVERY_MOVE,           "Every Move"    },
415   {     STR_SNAPSHOT_MODE_EVERY_COLLECT,        "Every Collect" },
416
417   {     NULL,                                   NULL            },
418 };
419
420 static struct
421 {
422   int value;
423   char *text;
424 } volumes_list[] =
425 {
426   {     0,      "0 %"                           },
427   {     1,      "1 %"                           },
428   {     2,      "2 %"                           },
429   {     5,      "5 %"                           },
430   {     10,     "10 %"                          },
431   {     20,     "20 %"                          },
432   {     30,     "30 %"                          },
433   {     40,     "40 %"                          },
434   {     50,     "50 %"                          },
435   {     60,     "60 %"                          },
436   {     70,     "70 %"                          },
437   {     80,     "80 %"                          },
438   {     90,     "90 %"                          },
439   {     100,    "100 %"                         },
440
441   {     -1,     NULL                            },
442 };
443
444 static struct
445 {
446   char *value;
447   char *text;
448 } touch_controls_list[] =
449 {
450   {     TOUCH_CONTROL_OFF,              "Off"                   },
451   {     TOUCH_CONTROL_VIRTUAL_BUTTONS,  "Virtual Buttons"       },
452   {     TOUCH_CONTROL_WIPE_GESTURES,    "Wipe Gestures"         },
453   {     TOUCH_CONTROL_FOLLOW_FINGER,    "Follow Finger"         },
454
455   {     NULL,                           NULL                    },
456 };
457
458 static struct
459 {
460   int value;
461   char *text;
462 } distances_list[] =
463 {
464   {     1,      "1 %"                           },
465   {     2,      "2 %"                           },
466   {     3,      "3 %"                           },
467   {     4,      "4 %"                           },
468   {     5,      "5 %"                           },
469   {     10,     "10 %"                          },
470   {     15,     "15 %"                          },
471   {     20,     "20 %"                          },
472   {     25,     "25 %"                          },
473
474   {     -1,     NULL                            },
475 };
476
477 static struct
478 {
479   int value;
480   char *text;
481 } transparencies_list[] =
482 {
483   {     0,      "0 % (Opaque)"                  },
484   {     10,     "10 %"                          },
485   {     20,     "20 %"                          },
486   {     30,     "30 %"                          },
487   {     40,     "40 %"                          },
488   {     50,     "50 %"                          },
489   {     60,     "60 %"                          },
490   {     70,     "70 %"                          },
491   {     80,     "80 %"                          },
492   {     90,     "90 %"                          },
493   {     100,    "100 % (Invisible)"             },
494
495   {     -1,     NULL                            },
496 };
497
498 static struct
499 {
500   int value;
501   char *text;
502 } grid_sizes_list[] =
503 {
504   {     3,      "3"                             },
505   {     4,      "4"                             },
506   {     5,      "5"                             },
507   {     6,      "6"                             },
508   {     7,      "7"                             },
509   {     8,      "8"                             },
510   {     9,      "9"                             },
511   {     10,     "10"                            },
512   {     11,     "11"                            },
513   {     12,     "12"                            },
514   {     13,     "13"                            },
515   {     14,     "14"                            },
516   {     15,     "15"                            },
517   {     16,     "16"                            },
518   {     17,     "17"                            },
519   {     18,     "18"                            },
520   {     19,     "19"                            },
521   {     20,     "20"                            },
522   {     21,     "21"                            },
523   {     22,     "22"                            },
524   {     23,     "23"                            },
525   {     24,     "24"                            },
526   {     25,     "25"                            },
527   {     26,     "26"                            },
528   {     27,     "27"                            },
529   {     28,     "28"                            },
530   {     29,     "29"                            },
531   {     30,     "30"                            },
532   {     31,     "31"                            },
533   {     32,     "32"                            },
534
535   {     -1,     NULL                            },
536 };
537
538 #define DRAW_MODE(s)            ((s) >= GAME_MODE_MAIN &&               \
539                                  (s) <= GAME_MODE_SETUP ? (s) :         \
540                                  (s) == GAME_MODE_PSEUDO_TYPENAME ?     \
541                                  GAME_MODE_MAIN : GAME_MODE_DEFAULT)
542
543 /* (there are no draw offset definitions needed for INFO_MODE_TITLE) */
544 #define DRAW_MODE_INFO(i)       ((i) >= INFO_MODE_TITLE &&              \
545                                  (i) <= INFO_MODE_LEVELSET ? (i) :      \
546                                  INFO_MODE_MAIN)
547
548 #define DRAW_MODE_SETUP(i)      ((i) >= SETUP_MODE_MAIN &&              \
549                                  (i) <= SETUP_MODE_SHORTCUTS_5 ? (i) :  \
550                                  (i) >= SETUP_MODE_CHOOSE_GRAPHICS &&   \
551                                  (i) <= SETUP_MODE_CHOOSE_MUSIC ?       \
552                                  SETUP_MODE_CHOOSE_ARTWORK :            \
553                                  SETUP_MODE_CHOOSE_OTHER)
554
555 #define DRAW_XOFFSET_INFO(i)    (DRAW_MODE_INFO(i) == INFO_MODE_MAIN ?  \
556                                  menu.draw_xoffset[GAME_MODE_INFO] :    \
557                                  menu.draw_xoffset_info[DRAW_MODE_INFO(i)])
558 #define DRAW_YOFFSET_INFO(i)    (DRAW_MODE_INFO(i) == INFO_MODE_MAIN ?  \
559                                  menu.draw_yoffset[GAME_MODE_INFO] :    \
560                                  menu.draw_yoffset_info[DRAW_MODE_INFO(i)])
561 #define EXTRA_SPACING_INFO(i)   (DRAW_MODE_INFO(i) == INFO_MODE_MAIN ? \
562                                  menu.extra_spacing[GAME_MODE_INFO] :   \
563                                  menu.extra_spacing_info[DRAW_MODE_INFO(i)])
564
565 #define DRAW_XOFFSET_SETUP(i)   (DRAW_MODE_SETUP(i) == SETUP_MODE_MAIN ? \
566                                  menu.draw_xoffset[GAME_MODE_SETUP] :   \
567                                  menu.draw_xoffset_setup[DRAW_MODE_SETUP(i)])
568 #define DRAW_YOFFSET_SETUP(i)   (DRAW_MODE_SETUP(i) == SETUP_MODE_MAIN ? \
569                                  menu.draw_yoffset[GAME_MODE_SETUP] :   \
570                                  menu.draw_yoffset_setup[DRAW_MODE_SETUP(i)])
571 #define EXTRA_SPACING_SETUP(i)  (DRAW_MODE_SETUP(i) == SETUP_MODE_MAIN ? \
572                                  menu.extra_spacing[GAME_MODE_SETUP] :  \
573                                  menu.extra_spacing_setup[DRAW_MODE_SETUP(i)])
574
575 #define DRAW_XOFFSET(s)         ((s) == GAME_MODE_INFO ?                \
576                                  DRAW_XOFFSET_INFO(info_mode) :         \
577                                  (s) == GAME_MODE_SETUP ?               \
578                                  DRAW_XOFFSET_SETUP(setup_mode) :       \
579                                  menu.draw_xoffset[DRAW_MODE(s)])
580 #define DRAW_YOFFSET(s)         ((s) == GAME_MODE_INFO ?                \
581                                  DRAW_YOFFSET_INFO(info_mode) :         \
582                                  (s) == GAME_MODE_SETUP ?               \
583                                  DRAW_YOFFSET_SETUP(setup_mode) :       \
584                                  menu.draw_yoffset[DRAW_MODE(s)])
585 #define EXTRA_SPACING(s)        ((s) == GAME_MODE_INFO ?                \
586                                  EXTRA_SPACING_INFO(info_mode) :        \
587                                  (s) == GAME_MODE_SETUP ?               \
588                                  EXTRA_SPACING_SETUP(setup_mode) :      \
589                                  menu.extra_spacing[DRAW_MODE(s)])
590
591 #define mSX                     (SX + DRAW_XOFFSET(game_status))
592 #define mSY                     (SY + DRAW_YOFFSET(game_status))
593
594 #define NUM_MENU_ENTRIES_ON_SCREEN (menu.list_size[game_status] > 2 ?   \
595                                     menu.list_size[game_status] :       \
596                                     MAX_MENU_ENTRIES_ON_SCREEN)
597
598 #define IN_VIS_MENU(x, y)       IN_FIELD(x, y, SCR_FIELDX,              \
599                                          NUM_MENU_ENTRIES_ON_SCREEN)
600
601
602 /* title display and control definitions */
603
604 #define MAX_NUM_TITLE_SCREENS   (2 * MAX_NUM_TITLE_IMAGES +             \
605                                  2 * MAX_NUM_TITLE_MESSAGES)
606
607 #define NO_DIRECT_LEVEL_SELECT  (-1)
608
609
610 static int num_title_screens = 0;
611
612 struct TitleControlInfo
613 {
614   boolean is_image;
615   boolean initial;
616   boolean first;
617   int local_nr;
618   int sort_priority;
619 };
620
621 struct TitleControlInfo title_controls[MAX_NUM_TITLE_SCREENS];
622
623 /* main menu display and control definitions */
624
625 #define MAIN_CONTROL_NAME                       0
626 #define MAIN_CONTROL_LEVELS                     1
627 #define MAIN_CONTROL_SCORES                     2
628 #define MAIN_CONTROL_EDITOR                     3
629 #define MAIN_CONTROL_INFO                       4
630 #define MAIN_CONTROL_GAME                       5
631 #define MAIN_CONTROL_SETUP                      6
632 #define MAIN_CONTROL_QUIT                       7
633 #define MAIN_CONTROL_PREV_LEVEL                 8
634 #define MAIN_CONTROL_NEXT_LEVEL                 9
635 #define MAIN_CONTROL_FIRST_LEVEL                10
636 #define MAIN_CONTROL_LAST_LEVEL                 11
637 #define MAIN_CONTROL_LEVEL_NUMBER               12
638 #define MAIN_CONTROL_LEVEL_INFO_1               13
639 #define MAIN_CONTROL_LEVEL_INFO_2               14
640 #define MAIN_CONTROL_LEVEL_NAME                 15
641 #define MAIN_CONTROL_LEVEL_AUTHOR               16
642 #define MAIN_CONTROL_LEVEL_YEAR                 17
643 #define MAIN_CONTROL_LEVEL_IMPORTED_FROM        18
644 #define MAIN_CONTROL_LEVEL_IMPORTED_BY          19
645 #define MAIN_CONTROL_LEVEL_TESTED_BY            20
646 #define MAIN_CONTROL_TITLE_1                    21
647 #define MAIN_CONTROL_TITLE_2                    22
648 #define MAIN_CONTROL_TITLE_3                    23
649
650 static char str_main_text_name[10];
651 static char str_main_text_first_level[10];
652 static char str_main_text_last_level[10];
653 static char str_main_text_level_number[10];
654
655 static char *main_text_name                     = str_main_text_name;
656 static char *main_text_first_level              = str_main_text_first_level;
657 static char *main_text_last_level               = str_main_text_last_level;
658 static char *main_text_level_number             = str_main_text_level_number;
659 static char *main_text_levels                   = "Levelset";
660 static char *main_text_scores                   = "Hall Of Fame";
661 static char *main_text_editor                   = "Level Creator";
662 static char *main_text_info                     = "Info Screen";
663 static char *main_text_game                     = "Start Game";
664 static char *main_text_setup                    = "Setup";
665 static char *main_text_quit                     = "Quit";
666 static char *main_text_level_name               = level.name;
667 static char *main_text_level_author             = level.author;
668 static char *main_text_level_year               = NULL;
669 static char *main_text_level_imported_from      = NULL;
670 static char *main_text_level_imported_by        = NULL;
671 static char *main_text_level_tested_by          = NULL;
672 static char *main_text_title_1                  = NULL;
673 static char *main_text_title_2                  = NULL;
674 static char *main_text_title_3                  = NULL;
675
676 struct MainControlInfo
677 {
678   int nr;
679
680   struct MenuPosInfo *pos_button;
681   int button_graphic;
682
683   struct TextPosInfo *pos_text;
684   char **text;
685
686   struct TextPosInfo *pos_input;
687   char **input;
688 };
689
690 static struct MainControlInfo main_controls[] =
691 {
692   {
693     MAIN_CONTROL_NAME,
694     &menu.main.button.name,             IMG_MENU_BUTTON_NAME,
695     &menu.main.text.name,               &main_text_name,
696     &menu.main.input.name,              &setup.player_name,
697   },
698   {
699     MAIN_CONTROL_LEVELS,
700     &menu.main.button.levels,           IMG_MENU_BUTTON_LEVELS,
701     &menu.main.text.levels,             &main_text_levels,
702     NULL,                               NULL,
703   },
704   {
705     MAIN_CONTROL_SCORES,
706     &menu.main.button.scores,           IMG_MENU_BUTTON_SCORES,
707     &menu.main.text.scores,             &main_text_scores,
708     NULL,                               NULL,
709   },
710   {
711     MAIN_CONTROL_EDITOR,
712     &menu.main.button.editor,           IMG_MENU_BUTTON_EDITOR,
713     &menu.main.text.editor,             &main_text_editor,
714     NULL,                               NULL,
715   },
716   {
717     MAIN_CONTROL_INFO,
718     &menu.main.button.info,             IMG_MENU_BUTTON_INFO,
719     &menu.main.text.info,               &main_text_info,
720     NULL,                               NULL,
721   },
722   {
723     MAIN_CONTROL_GAME,
724     &menu.main.button.game,             IMG_MENU_BUTTON_GAME,
725     &menu.main.text.game,               &main_text_game,
726     NULL,                               NULL,
727   },
728   {
729     MAIN_CONTROL_SETUP,
730     &menu.main.button.setup,            IMG_MENU_BUTTON_SETUP,
731     &menu.main.text.setup,              &main_text_setup,
732     NULL,                               NULL,
733   },
734   {
735     MAIN_CONTROL_QUIT,
736     &menu.main.button.quit,             IMG_MENU_BUTTON_QUIT,
737     &menu.main.text.quit,               &main_text_quit,
738     NULL,                               NULL,
739   },
740 #if 0
741   /* (these two buttons are real gadgets) */
742   {
743     MAIN_CONTROL_PREV_LEVEL,
744     &menu.main.button.prev_level,       IMG_MENU_BUTTON_PREV_LEVEL,
745     NULL,                               NULL,
746     NULL,                               NULL,
747   },
748   {
749     MAIN_CONTROL_NEXT_LEVEL,
750     &menu.main.button.next_level,       IMG_MENU_BUTTON_NEXT_LEVEL,
751     NULL,                               NULL,
752     NULL,                               NULL,
753   },
754 #endif
755   {
756     MAIN_CONTROL_FIRST_LEVEL,
757     &menu.main.button.first_level,      IMG_MENU_BUTTON_FIRST_LEVEL,
758     &menu.main.text.first_level,        &main_text_first_level,
759     NULL,                               NULL,
760   },
761   {
762     MAIN_CONTROL_LAST_LEVEL,
763     &menu.main.button.last_level,       IMG_MENU_BUTTON_LAST_LEVEL,
764     &menu.main.text.last_level,         &main_text_last_level,
765     NULL,                               NULL,
766   },
767   {
768     MAIN_CONTROL_LEVEL_NUMBER,
769     &menu.main.button.level_number,     IMG_MENU_BUTTON_LEVEL_NUMBER,
770     &menu.main.text.level_number,       &main_text_level_number,
771     NULL,                               NULL,
772   },
773   {
774     MAIN_CONTROL_LEVEL_INFO_1,
775     NULL,                               -1,
776     &menu.main.text.level_info_1,       NULL,
777     NULL,                               NULL,
778   },
779   {
780     MAIN_CONTROL_LEVEL_INFO_2,
781     NULL,                               -1,
782     &menu.main.text.level_info_2,       NULL,
783     NULL,                               NULL,
784   },
785   {
786     MAIN_CONTROL_LEVEL_NAME,
787     NULL,                               -1,
788     &menu.main.text.level_name,         &main_text_level_name,
789     NULL,                               NULL,
790   },
791   {
792     MAIN_CONTROL_LEVEL_AUTHOR,
793     NULL,                               -1,
794     &menu.main.text.level_author,       &main_text_level_author,
795     NULL,                               NULL,
796   },
797   {
798     MAIN_CONTROL_LEVEL_YEAR,
799     NULL,                               -1,
800     &menu.main.text.level_year,         &main_text_level_year,
801     NULL,                               NULL,
802   },
803   {
804     MAIN_CONTROL_LEVEL_IMPORTED_FROM,
805     NULL,                               -1,
806     &menu.main.text.level_imported_from, &main_text_level_imported_from,
807     NULL,                               NULL,
808   },
809   {
810     MAIN_CONTROL_LEVEL_IMPORTED_BY,
811     NULL,                               -1,
812     &menu.main.text.level_imported_by,  &main_text_level_imported_by,
813     NULL,                               NULL,
814   },
815   {
816     MAIN_CONTROL_LEVEL_TESTED_BY,
817     NULL,                               -1,
818     &menu.main.text.level_tested_by,    &main_text_level_tested_by,
819     NULL,                               NULL,
820   },
821   {
822     MAIN_CONTROL_TITLE_1,
823     NULL,                               -1,
824     &menu.main.text.title_1,            &main_text_title_1,
825     NULL,                               NULL,
826   },
827   {
828     MAIN_CONTROL_TITLE_2,
829     NULL,                               -1,
830     &menu.main.text.title_2,            &main_text_title_2,
831     NULL,                               NULL,
832   },
833   {
834     MAIN_CONTROL_TITLE_3,
835     NULL,                               -1,
836     &menu.main.text.title_3,            &main_text_title_3,
837     NULL,                               NULL,
838   },
839
840   {
841     -1,
842     NULL,                               -1,
843     NULL,                               NULL,
844     NULL,                               NULL,
845   }
846 };
847
848
849 static int getTitleScreenGraphic(int nr, boolean initial)
850 {
851   return (initial ? IMG_TITLESCREEN_INITIAL_1 : IMG_TITLESCREEN_1) + nr;
852 }
853
854 static struct TitleMessageInfo *getTitleMessageInfo(int nr, boolean initial)
855 {
856   return (initial ? &titlemessage_initial[nr] : &titlemessage[nr]);
857 }
858
859 #if 0
860 static int getTitleScreenGameMode(boolean initial)
861 {
862   return (initial ? GAME_MODE_TITLE_INITIAL : GAME_MODE_TITLE);
863 }
864 #endif
865
866 static int getTitleMessageGameMode(boolean initial)
867 {
868   return (initial ? GAME_MODE_TITLE_INITIAL : GAME_MODE_TITLE);
869 }
870
871 static int getTitleAnimMode(struct TitleControlInfo *tci)
872 {
873   int base = (tci->initial ? GAME_MODE_TITLE_INITIAL_1 : GAME_MODE_TITLE_1);
874
875   return base + tci->local_nr;
876 }
877
878 #if 0
879 static int getTitleScreenBackground(boolean initial)
880 {
881   return (initial ? IMG_BACKGROUND_TITLE_INITIAL : IMG_BACKGROUND_TITLE);
882 }
883 #endif
884
885 #if 0
886 static int getTitleMessageBackground(int nr, boolean initial)
887 {
888   return (initial ? IMG_BACKGROUND_TITLE_INITIAL : IMG_BACKGROUND_TITLE);
889 }
890 #endif
891
892 static int getTitleBackground(int nr, boolean initial, boolean is_image)
893 {
894   int base = (is_image ?
895               (initial ? IMG_BACKGROUND_TITLESCREEN_INITIAL_1 :
896                          IMG_BACKGROUND_TITLESCREEN_1) :
897               (initial ? IMG_BACKGROUND_TITLEMESSAGE_INITIAL_1 :
898                          IMG_BACKGROUND_TITLEMESSAGE_1));
899   int graphic_global = (initial ? IMG_BACKGROUND_TITLE_INITIAL :
900                                   IMG_BACKGROUND_TITLE);
901   int graphic_local = base + nr;
902
903   if (graphic_info[graphic_local].bitmap != NULL)
904     return graphic_local;
905
906   if (graphic_info[graphic_global].bitmap != NULL)
907     return graphic_global;
908
909   return IMG_UNDEFINED;
910 }
911
912 static int getTitleSound(struct TitleControlInfo *tci)
913 {
914   boolean is_image = tci->is_image;
915   int initial = tci->initial;
916   int nr = tci->local_nr;
917   int mode = (initial ? GAME_MODE_TITLE_INITIAL : GAME_MODE_TITLE);
918   int base = (is_image ?
919               (initial ? SND_BACKGROUND_TITLESCREEN_INITIAL_1 :
920                          SND_BACKGROUND_TITLESCREEN_1) :
921               (initial ? SND_BACKGROUND_TITLEMESSAGE_INITIAL_1 :
922                          SND_BACKGROUND_TITLEMESSAGE_1));
923   int sound_global = menu.sound[mode];
924   int sound_local = base + nr;
925
926 #if 0
927   printf("::: %d, %d, %d: %d ['%s'], %d ['%s']\n",
928          nr, initial, is_image,
929          sound_global, getSoundListEntry(sound_global)->filename,
930          sound_local, getSoundListEntry(sound_local)->filename);
931 #endif
932
933   if (!strEqual(getSoundListEntry(sound_local)->filename, UNDEFINED_FILENAME))
934     return sound_local;
935
936   if (!strEqual(getSoundListEntry(sound_global)->filename, UNDEFINED_FILENAME))
937     return sound_global;
938
939   return SND_UNDEFINED;
940 }
941
942 static int getTitleMusic(struct TitleControlInfo *tci)
943 {
944   boolean is_image = tci->is_image;
945   int initial = tci->initial;
946   int nr = tci->local_nr;
947   int mode = (initial ? GAME_MODE_TITLE_INITIAL : GAME_MODE_TITLE);
948   int base = (is_image ?
949               (initial ? MUS_BACKGROUND_TITLESCREEN_INITIAL_1 :
950                          MUS_BACKGROUND_TITLESCREEN_1) :
951               (initial ? MUS_BACKGROUND_TITLEMESSAGE_INITIAL_1 :
952                          MUS_BACKGROUND_TITLEMESSAGE_1));
953   int music_global = menu.music[mode];
954   int music_local = base + nr;
955
956 #if 0
957   printf("::: %d, %d, %d: %d ['%s'], %d ['%s']\n",
958          nr, initial, is_image,
959          music_global, getMusicListEntry(music_global)->filename,
960          music_local, getMusicListEntry(music_local)->filename);
961 #endif
962
963   if (!strEqual(getMusicListEntry(music_local)->filename, UNDEFINED_FILENAME))
964     return music_local;
965
966   if (!strEqual(getMusicListEntry(music_global)->filename, UNDEFINED_FILENAME))
967     return music_global;
968
969   return MUS_UNDEFINED;
970 }
971
972 static struct TitleFadingInfo getTitleFading(struct TitleControlInfo *tci)
973 {
974   boolean is_image = tci->is_image;
975   boolean initial = tci->initial;
976   boolean first = tci->first;
977   int nr = tci->local_nr;
978   struct TitleMessageInfo tmi;
979   struct TitleFadingInfo ti;
980
981   tmi = (is_image ? (initial ? (first ?
982                                 titlescreen_initial_first[nr] :
983                                 titlescreen_initial[nr])
984                              : (first ?
985                                 titlescreen_first[nr] :
986                                 titlescreen[nr]))
987                   : (initial ? (first ?
988                                 titlemessage_initial_first[nr] :
989                                 titlemessage_initial[nr])
990                              : (first ?
991                                 titlemessage_first[nr] :
992                                 titlemessage[nr])));
993
994   ti.fade_mode  = tmi.fade_mode;
995   ti.fade_delay = tmi.fade_delay;
996   ti.post_delay = tmi.post_delay;
997   ti.auto_delay = tmi.auto_delay;
998
999   return ti;
1000 }
1001
1002 static int compareTitleControlInfo(const void *object1, const void *object2)
1003 {
1004   const struct TitleControlInfo *tci1 = (struct TitleControlInfo *)object1;
1005   const struct TitleControlInfo *tci2 = (struct TitleControlInfo *)object2;
1006   int compare_result;
1007
1008   if (tci1->initial != tci2->initial)
1009     compare_result = (tci1->initial ? -1 : +1);
1010   else if (tci1->sort_priority != tci2->sort_priority)
1011     compare_result = tci1->sort_priority - tci2->sort_priority;
1012   else if (tci1->is_image != tci2->is_image)
1013     compare_result = (tci1->is_image ? -1 : +1);
1014   else
1015     compare_result = tci1->local_nr - tci2->local_nr;
1016
1017   return compare_result;
1018 }
1019
1020 static void InitializeTitleControlsExt_AddTitleInfo(boolean is_image,
1021                                                     boolean initial,
1022                                                     int nr, int sort_priority)
1023 {
1024   title_controls[num_title_screens].is_image = is_image;
1025   title_controls[num_title_screens].initial = initial;
1026   title_controls[num_title_screens].local_nr = nr;
1027   title_controls[num_title_screens].sort_priority = sort_priority;
1028
1029   title_controls[num_title_screens].first = FALSE;      /* will be set later */
1030
1031   num_title_screens++;
1032 }
1033
1034 static void InitializeTitleControls_CheckTitleInfo(boolean initial)
1035 {
1036   int i;
1037
1038   for (i = 0; i < MAX_NUM_TITLE_IMAGES; i++)
1039   {
1040     int graphic = getTitleScreenGraphic(i, initial);
1041     Bitmap *bitmap = graphic_info[graphic].bitmap;
1042     int sort_priority = graphic_info[graphic].sort_priority;
1043
1044     if (bitmap != NULL)
1045       InitializeTitleControlsExt_AddTitleInfo(TRUE, initial, i, sort_priority);
1046   }
1047
1048   for (i = 0; i < MAX_NUM_TITLE_MESSAGES; i++)
1049   {
1050     struct TitleMessageInfo *tmi = getTitleMessageInfo(i, initial);
1051     char *filename = getLevelSetTitleMessageFilename(i, initial);
1052     int sort_priority = tmi->sort_priority;
1053
1054     if (filename != NULL)
1055       InitializeTitleControlsExt_AddTitleInfo(FALSE, initial, i, sort_priority);
1056   }
1057 }
1058
1059 static void InitializeTitleControls(boolean show_title_initial)
1060 {
1061   num_title_screens = 0;
1062
1063   /* 1st step: initialize title screens for game start (only when starting) */
1064   if (show_title_initial)
1065     InitializeTitleControls_CheckTitleInfo(TRUE);
1066
1067   /* 2nd step: initialize title screens for current level set */
1068   InitializeTitleControls_CheckTitleInfo(FALSE);
1069
1070   /* sort title screens according to sort_priority and title number */
1071   qsort(title_controls, num_title_screens, sizeof(struct TitleControlInfo),
1072         compareTitleControlInfo);
1073
1074   /* mark first title screen */
1075   title_controls[0].first = TRUE;
1076 }
1077
1078 static boolean visibleMenuPos(struct MenuPosInfo *pos)
1079 {
1080   return (pos != NULL && pos->x != -1 && pos->y != -1);
1081 }
1082
1083 static boolean visibleTextPos(struct TextPosInfo *pos)
1084 {
1085   return (pos != NULL && pos->x != -1 && pos->y != -1);
1086 }
1087
1088 static void InitializeMainControls(void)
1089 {
1090   boolean local_team_mode = (!network.enabled && setup.team_mode);
1091   int i;
1092
1093   /* set main control text values to dynamically determined values */
1094   sprintf(main_text_name,         "%s",   local_team_mode ? "Team:" : "Name:");
1095
1096   strcpy(main_text_first_level,  int2str(leveldir_current->first_level,
1097                                          menu.main.text.first_level.size));
1098   strcpy(main_text_last_level,   int2str(leveldir_current->last_level,
1099                                          menu.main.text.last_level.size));
1100   strcpy(main_text_level_number, int2str(level_nr,
1101                                          menu.main.text.level_number.size));
1102
1103   main_text_level_year          = leveldir_current->year;
1104   main_text_level_imported_from = leveldir_current->imported_from;
1105   main_text_level_imported_by   = leveldir_current->imported_by;
1106   main_text_level_tested_by     = leveldir_current->tested_by;
1107
1108   main_text_title_1 = getConfigProgramTitleString();
1109   main_text_title_2 = getConfigProgramCopyrightString();
1110   main_text_title_3 = getConfigProgramCompanyString();
1111
1112   /* set main control screen positions to dynamically determined values */
1113   for (i = 0; main_controls[i].nr != -1; i++)
1114   {
1115     struct MainControlInfo *mci = &main_controls[i];
1116     int nr                         = mci->nr;
1117     struct MenuPosInfo *pos_button = mci->pos_button;
1118     struct TextPosInfo *pos_text   = mci->pos_text;
1119     struct TextPosInfo *pos_input  = mci->pos_input;
1120     char *text                     = (mci->text  ? *mci->text  : NULL);
1121     char *input                    = (mci->input ? *mci->input : NULL);
1122     int button_graphic             = mci->button_graphic;
1123     int font_text                  = (pos_text  ? pos_text->font  : -1);
1124     int font_input                 = (pos_input ? pos_input->font : -1);
1125
1126     int font_text_width   = (font_text  != -1 ? getFontWidth(font_text)   : 0);
1127     int font_text_height  = (font_text  != -1 ? getFontHeight(font_text)  : 0);
1128     int font_input_width  = (font_input != -1 ? getFontWidth(font_input)  : 0);
1129     int font_input_height = (font_input != -1 ? getFontHeight(font_input) : 0);
1130     int text_chars  = (text  != NULL ? strlen(text)  : 0);
1131     int input_chars = (input != NULL ? strlen(input) : 0);
1132
1133     int button_width =
1134       (button_graphic != -1 ? graphic_info[button_graphic].width  : 0);
1135     int button_height =
1136       (button_graphic != -1 ? graphic_info[button_graphic].height : 0);
1137     int text_width   = font_text_width * text_chars;
1138     int text_height  = font_text_height;
1139     int input_width  = font_input_width * input_chars;
1140     int input_height = font_input_height;
1141
1142     if (nr == MAIN_CONTROL_NAME)
1143     {
1144       menu.main.input.name.width  = input_width;
1145       menu.main.input.name.height = input_height;
1146     }
1147
1148     if (pos_button != NULL)             /* (x/y may be -1/-1 here) */
1149     {
1150       pos_button->width  = button_width;
1151       pos_button->height = button_height;
1152     }
1153
1154     if (pos_text != NULL)               /* (x/y may be -1/-1 here) */
1155     {
1156       /* calculate text size -- needed for text alignment */
1157       boolean calculate_text_size = (text != NULL);
1158
1159       if (pos_text->width == -1 || calculate_text_size)
1160         pos_text->width = text_width;
1161       if (pos_text->height == -1 || calculate_text_size)
1162         pos_text->height = text_height;
1163
1164       if (visibleMenuPos(pos_button))
1165       {
1166         if (pos_text->x == -1)
1167           pos_text->x = pos_button->x + pos_button->width;
1168         if (pos_text->y == -1)
1169           pos_text->y =
1170             pos_button->y + (pos_button->height - pos_text->height) / 2;
1171       }
1172     }
1173
1174     if (pos_input != NULL)              /* (x/y may be -1/-1 here) */
1175     {
1176       if (visibleTextPos(pos_text))
1177       {
1178         if (pos_input->x == -1)
1179           pos_input->x = pos_text->x + pos_text->width;
1180         if (pos_input->y == -1)
1181           pos_input->y = pos_text->y;
1182       }
1183
1184       if (pos_input->width == -1)
1185         pos_input->width = input_width;
1186       if (pos_input->height == -1)
1187         pos_input->height = input_height;
1188     }
1189   }
1190 }
1191
1192 static void DrawPressedGraphicThruMask(int dst_x, int dst_y,
1193                                        int graphic, boolean pressed)
1194 {
1195   struct GraphicInfo *g = &graphic_info[graphic];
1196   Bitmap *src_bitmap;
1197   int src_x, src_y;
1198   int xoffset = (pressed ? g->pressed_xoffset : 0);
1199   int yoffset = (pressed ? g->pressed_yoffset : 0);
1200
1201   getFixedGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
1202
1203   BlitBitmapMasked(src_bitmap, drawto, src_x + xoffset, src_y + yoffset,
1204                    g->width, g->height, dst_x, dst_y);
1205 }
1206
1207 static void DrawCursorAndText_Main_Ext(int nr, boolean active_text,
1208                                        boolean active_input,
1209                                        boolean pressed_button)
1210 {
1211   int i;
1212
1213   for (i = 0; main_controls[i].nr != -1; i++)
1214   {
1215     struct MainControlInfo *mci = &main_controls[i];
1216
1217     if (mci->nr == nr || nr == -1)
1218     {
1219       struct MenuPosInfo *pos_button = mci->pos_button;
1220       struct TextPosInfo *pos_text   = mci->pos_text;
1221       struct TextPosInfo *pos_input  = mci->pos_input;
1222       char *text                     = (mci->text  ? *mci->text  : NULL);
1223       char *input                    = (mci->input ? *mci->input : NULL);
1224       int button_graphic             = mci->button_graphic;
1225       int font_text                  = (pos_text  ? pos_text->font  : -1);
1226       int font_input                 = (pos_input ? pos_input->font : -1);
1227
1228       if (active_text)
1229       {
1230         button_graphic = BUTTON_ACTIVE(button_graphic);
1231         font_text = FONT_ACTIVE(font_text);
1232       }
1233
1234       if (active_input)
1235       {
1236         font_input = FONT_ACTIVE(font_input);
1237       }
1238
1239       if (visibleMenuPos(pos_button))
1240       {
1241         struct MenuPosInfo *pos = pos_button;
1242         int x = mSX + pos->x;
1243         int y = mSY + pos->y;
1244
1245         DrawBackgroundForGraphic(x, y, pos->width, pos->height, button_graphic);
1246         DrawPressedGraphicThruMask(x, y, button_graphic, pressed_button);
1247       }
1248
1249       if (visibleTextPos(pos_text) && text != NULL)
1250       {
1251         struct TextPosInfo *pos = pos_text;
1252         int x = mSX + ALIGNED_TEXT_XPOS(pos);
1253         int y = mSY + ALIGNED_TEXT_YPOS(pos);
1254
1255 #if 1
1256         /* (check why/if this is needed) */
1257         DrawBackgroundForFont(x, y, pos->width, pos->height, font_text);
1258 #endif
1259         DrawText(x, y, text, font_text);
1260       }
1261
1262       if (visibleTextPos(pos_input) && input != NULL)
1263       {
1264         struct TextPosInfo *pos = pos_input;
1265         int x = mSX + ALIGNED_TEXT_XPOS(pos);
1266         int y = mSY + ALIGNED_TEXT_YPOS(pos);
1267
1268 #if 1
1269         /* (check why/if this is needed) */
1270         DrawBackgroundForFont(x, y, pos->width, pos->height, font_input);
1271 #endif
1272         DrawText(x, y, input, font_input);
1273       }
1274     }
1275   }
1276 }
1277
1278 static void DrawCursorAndText_Main(int nr, boolean active_text,
1279                                    boolean pressed_button)
1280 {
1281   DrawCursorAndText_Main_Ext(nr, active_text, FALSE, pressed_button);
1282 }
1283
1284 #if 0
1285 static void DrawCursorAndText_Main_Input(int nr, boolean active_text,
1286                                          boolean pressed_button)
1287 {
1288   DrawCursorAndText_Main_Ext(nr, active_text, TRUE, pressed_button);
1289 }
1290 #endif
1291
1292 static struct MainControlInfo *getMainControlInfo(int nr)
1293 {
1294   int i;
1295
1296   for (i = 0; main_controls[i].nr != -1; i++)
1297     if (main_controls[i].nr == nr)
1298       return &main_controls[i];
1299
1300   return NULL;
1301 }
1302
1303 static boolean insideMenuPosRect(struct MenuPosInfo *rect, int x, int y)
1304 {
1305   if (rect == NULL)
1306     return FALSE;
1307
1308   int rect_x = ALIGNED_TEXT_XPOS(rect);
1309   int rect_y = ALIGNED_TEXT_YPOS(rect);
1310
1311   return (x >= rect_x && x < rect_x + rect->width &&
1312           y >= rect_y && y < rect_y + rect->height);
1313 }
1314
1315 static boolean insideTextPosRect(struct TextPosInfo *rect, int x, int y)
1316 {
1317   if (rect == NULL)
1318     return FALSE;
1319
1320   int rect_x = ALIGNED_TEXT_XPOS(rect);
1321   int rect_y = ALIGNED_TEXT_YPOS(rect);
1322
1323 #if 0
1324   printf("::: insideTextPosRect: (%d, %d), (%d, %d) [%d, %d] (%d, %d) => %d\n",
1325          x, y, rect_x, rect_y, rect->x, rect->y, rect->width, rect->height,
1326          (x >= rect_x && x < rect_x + rect->width &&
1327           y >= rect_y && y < rect_y + rect->height));
1328 #endif
1329
1330   return (x >= rect_x && x < rect_x + rect->width &&
1331           y >= rect_y && y < rect_y + rect->height);
1332 }
1333
1334 static boolean insidePreviewRect(struct PreviewInfo *preview, int x, int y)
1335 {
1336   int rect_width  = preview->xsize * preview->tile_size;
1337   int rect_height = preview->ysize * preview->tile_size;
1338   int rect_x = ALIGNED_XPOS(preview->x, rect_width,  preview->align);
1339   int rect_y = ALIGNED_YPOS(preview->y, rect_height, preview->valign);
1340
1341   return (x >= rect_x && x < rect_x + rect_width &&
1342           y >= rect_y && y < rect_y + rect_height);
1343 }
1344
1345 static void AdjustScrollbar(int id, int items_max, int items_visible,
1346                             int item_position)
1347 {
1348   struct GadgetInfo *gi = screen_gadget[id];
1349
1350   if (item_position > items_max - items_visible)
1351     item_position = items_max - items_visible;
1352
1353   ModifyGadget(gi, GDI_SCROLLBAR_ITEMS_MAX, items_max,
1354                GDI_SCROLLBAR_ITEMS_VISIBLE, items_visible,
1355                GDI_SCROLLBAR_ITEM_POSITION, item_position, GDI_END);
1356 }
1357
1358 static void AdjustChooseTreeScrollbar(int id, int first_entry, TreeInfo *ti)
1359 {
1360   AdjustScrollbar(id, numTreeInfoInGroup(ti), NUM_MENU_ENTRIES_ON_SCREEN,
1361                   first_entry);
1362 }
1363
1364 static void clearMenuListArea(void)
1365 {
1366   int scrollbar_xpos = mSX + SC_SCROLLBAR_XPOS + menu.scrollbar_xoffset;
1367
1368   /* correct scrollbar position if placed outside menu (playfield) area */
1369   if (scrollbar_xpos > SX + SC_SCROLLBAR_XPOS)
1370     scrollbar_xpos = SX + SC_SCROLLBAR_XPOS;
1371
1372   /* clear menu list area, but not title or scrollbar */
1373   DrawBackground(mSX, mSY + MENU_SCREEN_START_YPOS * 32,
1374                  scrollbar_xpos - mSX, NUM_MENU_ENTRIES_ON_SCREEN * 32);
1375 }
1376
1377 static void drawCursorExt(int xpos, int ypos, boolean active, int graphic)
1378 {
1379   static int cursor_array[MAX_LEV_FIELDY];
1380   int x = mSX + TILEX * xpos;
1381   int y = mSY + TILEY * (MENU_SCREEN_START_YPOS + ypos);
1382
1383   if (xpos == 0)
1384   {
1385     if (graphic != -1)
1386       cursor_array[ypos] = graphic;
1387     else
1388       graphic = cursor_array[ypos];
1389   }
1390
1391   if (active)
1392     graphic = BUTTON_ACTIVE(graphic);
1393
1394   DrawBackgroundForGraphic(x, y, TILEX, TILEY, graphic);
1395   DrawFixedGraphicThruMaskExt(drawto, x, y, graphic, 0);
1396 }
1397
1398 static void initCursor(int ypos, int graphic)
1399 {
1400   drawCursorExt(0, ypos, FALSE, graphic);
1401 }
1402
1403 static void drawCursor(int ypos, boolean active)
1404 {
1405   drawCursorExt(0, ypos, active, -1);
1406 }
1407
1408 static void drawCursorXY(int xpos, int ypos, int graphic)
1409 {
1410   drawCursorExt(xpos, ypos, FALSE, graphic);
1411 }
1412
1413 static void drawChooseTreeCursor(int ypos, boolean active)
1414 {
1415   drawCursorExt(0, ypos, active, -1);
1416 }
1417
1418 void DrawHeadline(void)
1419 {
1420   DrawTextSCentered(MENU_TITLE1_YPOS, FONT_TITLE_1, main_text_title_1);
1421   DrawTextSCentered(MENU_TITLE2_YPOS, FONT_TITLE_2, main_text_title_2);
1422 }
1423
1424 void DrawTitleScreenImage(int nr, boolean initial)
1425 {
1426   int graphic = getTitleScreenGraphic(nr, initial);
1427   Bitmap *bitmap = graphic_info[graphic].bitmap;
1428   int width  = graphic_info[graphic].width;
1429   int height = graphic_info[graphic].height;
1430   int src_x = graphic_info[graphic].src_x;
1431   int src_y = graphic_info[graphic].src_y;
1432   int dst_x, dst_y;
1433
1434   if (bitmap == NULL)
1435     return;
1436
1437   if (width > WIN_XSIZE)
1438   {
1439     /* image width too large for window => center image horizontally */
1440     src_x = (width - WIN_XSIZE) / 2;
1441     width = WIN_XSIZE;
1442   }
1443
1444   if (height > WIN_YSIZE)
1445   {
1446     /* image height too large for window => center image vertically */
1447     src_y = (height - WIN_YSIZE) / 2;
1448     height = WIN_YSIZE;
1449   }
1450
1451   /* always display title screens centered */
1452   dst_x = (WIN_XSIZE - width) / 2;
1453   dst_y = (WIN_YSIZE - height) / 2;
1454
1455   SetDrawBackgroundMask(REDRAW_ALL);
1456   SetWindowBackgroundImage(getTitleBackground(nr, initial, TRUE));
1457
1458   ClearRectangleOnBackground(drawto, 0, 0, WIN_XSIZE, WIN_YSIZE);
1459
1460   if (DrawingOnBackground(dst_x, dst_y))
1461     BlitBitmapMasked(bitmap, drawto, src_x, src_y, width, height, dst_x, dst_y);
1462   else
1463     BlitBitmap(bitmap, drawto, src_x, src_y, width, height, dst_x, dst_y);
1464
1465   redraw_mask = REDRAW_ALL;
1466 }
1467
1468 void DrawTitleScreenMessage(int nr, boolean initial)
1469 {
1470   char *filename = getLevelSetTitleMessageFilename(nr, initial);
1471   struct TitleMessageInfo *tmi = getTitleMessageInfo(nr, initial);
1472
1473   if (filename == NULL)
1474     return;
1475
1476   /* force TITLE font on title message screen */
1477   SetFontStatus(getTitleMessageGameMode(initial));
1478
1479   /* if chars *and* width set to "-1", automatically determine width */
1480   if (tmi->chars == -1 && tmi->width == -1)
1481     tmi->width = viewport.window[game_status].width;
1482
1483   /* if lines *and* height set to "-1", automatically determine height */
1484   if (tmi->lines == -1 && tmi->height == -1)
1485     tmi->height = viewport.window[game_status].height;
1486
1487   /* if chars set to "-1", automatically determine by text and font width */
1488   if (tmi->chars == -1)
1489     tmi->chars = tmi->width / getFontWidth(tmi->font);
1490   else
1491     tmi->width = tmi->chars * getFontWidth(tmi->font);
1492
1493   /* if lines set to "-1", automatically determine by text and font height */
1494   if (tmi->lines == -1)
1495     tmi->lines = tmi->height / getFontHeight(tmi->font);
1496   else
1497     tmi->height = tmi->lines * getFontHeight(tmi->font);
1498
1499   /* if x set to "-1", automatically determine by width and alignment */
1500   if (tmi->x == -1)
1501     tmi->x = -1 * ALIGNED_XPOS(0, tmi->width, tmi->align);
1502
1503   /* if y set to "-1", automatically determine by height and alignment */
1504   if (tmi->y == -1)
1505     tmi->y = -1 * ALIGNED_YPOS(0, tmi->height, tmi->valign);
1506
1507   SetDrawBackgroundMask(REDRAW_ALL);
1508   SetWindowBackgroundImage(getTitleBackground(nr, initial, FALSE));
1509
1510   ClearRectangleOnBackground(drawto, 0, 0, WIN_XSIZE, WIN_YSIZE);
1511
1512   DrawTextFile(ALIGNED_TEXT_XPOS(tmi), ALIGNED_TEXT_YPOS(tmi),
1513                filename, tmi->font, tmi->chars, -1, tmi->lines, 0, -1,
1514                tmi->autowrap, tmi->centered, tmi->parse_comments);
1515
1516   ResetFontStatus();
1517 }
1518
1519 void DrawTitleScreen(void)
1520 {
1521   KeyboardAutoRepeatOff();
1522
1523   HandleTitleScreen(0, 0, 0, 0, MB_MENU_INITIALIZE);
1524 }
1525
1526 boolean CheckTitleScreen(boolean levelset_has_changed)
1527 {
1528   static boolean show_title_initial = TRUE;
1529   boolean show_titlescreen = FALSE;
1530
1531   /* needed to be able to skip title screen, if no image or message defined */
1532   InitializeTitleControls(show_title_initial);
1533
1534   if (setup.show_titlescreen && (show_title_initial || levelset_has_changed))
1535     show_titlescreen = TRUE;
1536
1537   /* show initial title images and messages only once at program start */
1538   show_title_initial = FALSE;
1539
1540   return (show_titlescreen && num_title_screens > 0);
1541 }
1542
1543 void DrawMainMenu(void)
1544 {
1545   static LevelDirTree *leveldir_last_valid = NULL;
1546   boolean levelset_has_changed = FALSE;
1547   int fade_mask = REDRAW_FIELD;
1548
1549   LimitScreenUpdates(FALSE);
1550
1551   FadeSetLeaveScreen();
1552
1553   /* do not fade out here -- function may continue and fade on editor screen */
1554
1555   UnmapAllGadgets();
1556   FadeMenuSoundsAndMusic();
1557
1558   ExpireSoundLoops(FALSE);
1559
1560   KeyboardAutoRepeatOn();
1561
1562   audio.sound_deactivated = FALSE;
1563
1564   GetPlayerConfig();
1565
1566   /* needed if last screen was the playing screen, invoked from level editor */
1567   if (level_editor_test_game)
1568   {
1569     CloseDoor(DOOR_CLOSE_ALL);
1570
1571     SetGameStatus(GAME_MODE_EDITOR);
1572
1573     DrawLevelEd();
1574
1575     return;
1576   }
1577
1578   /* needed if last screen was the setup screen and fullscreen state changed */
1579   // (moved to "execSetupGraphics()" to change fullscreen state directly)
1580   // ToggleFullscreenOrChangeWindowScalingIfNeeded();
1581
1582   /* leveldir_current may be invalid (level group, parent link) */
1583   if (!validLevelSeries(leveldir_current))
1584     leveldir_current = getFirstValidTreeInfoEntry(leveldir_last_valid);
1585
1586   if (leveldir_current != leveldir_last_valid)
1587     levelset_has_changed = TRUE;
1588
1589   /* store valid level series information */
1590   leveldir_last_valid = leveldir_current;
1591
1592   init_last = init;                     /* switch to new busy animation */
1593
1594   /* needed if last screen (level choice) changed graphics, sounds or music */
1595   ReloadCustomArtwork(0);
1596
1597   if (CheckTitleScreen(levelset_has_changed))
1598   {
1599     SetGameStatus(GAME_MODE_TITLE);
1600
1601     DrawTitleScreen();
1602
1603     return;
1604   }
1605
1606   if (redraw_mask & REDRAW_ALL)
1607     fade_mask = REDRAW_ALL;
1608
1609   if (CheckIfGlobalBorderOrPlayfieldViewportHasChanged())
1610     fade_mask = REDRAW_ALL;
1611
1612   FadeOut(fade_mask);
1613
1614   /* needed if different viewport properties defined for menues */
1615   ChangeViewportPropertiesIfNeeded();
1616
1617   SetDrawtoField(DRAW_TO_BACKBUFFER);
1618
1619   /* level_nr may have been set to value over handicap with level editor */
1620   if (setup.handicap && level_nr > leveldir_current->handicap_level)
1621     level_nr = leveldir_current->handicap_level;
1622
1623   LoadLevel(level_nr);
1624   LoadScore(level_nr);
1625
1626   SaveLevelSetup_SeriesInfo();
1627
1628   // set this after "ChangeViewportPropertiesIfNeeded()" (which may reset it)
1629   SetDrawDeactivationMask(REDRAW_NONE);
1630   SetDrawBackgroundMask(REDRAW_FIELD);
1631
1632   SetMainBackgroundImage(IMG_BACKGROUND_MAIN);
1633
1634 #if 0
1635   if (fade_mask == REDRAW_ALL)
1636     RedrawGlobalBorder();
1637 #endif
1638
1639   ClearField();
1640
1641   InitializeMainControls();
1642
1643   DrawCursorAndText_Main(-1, FALSE, FALSE);
1644   DrawPreviewLevelInitial();
1645   DrawNetworkPlayers();
1646
1647   HandleMainMenu(0, 0, 0, 0, MB_MENU_INITIALIZE);
1648
1649   TapeStop();
1650   if (TAPE_IS_EMPTY(tape))
1651     LoadTape(level_nr);
1652   DrawCompleteVideoDisplay();
1653
1654   PlayMenuSoundsAndMusic();
1655
1656   /* create gadgets for main menu screen */
1657   FreeScreenGadgets();
1658   CreateScreenGadgets();
1659
1660   /* may be required if audio buttons shown on tape and changed in setup menu */
1661   FreeGameButtons();
1662   CreateGameButtons();
1663
1664   /* map gadgets for main menu screen */
1665   MapTapeButtons();
1666   MapScreenMenuGadgets(SCREEN_MASK_MAIN);
1667   UpdateScreenMenuGadgets(SCREEN_MASK_MAIN_HAS_SOLUTION, hasSolutionTape());
1668
1669   /* copy actual game door content to door double buffer for OpenDoor() */
1670   BlitBitmap(drawto, bitmap_db_door_1, DX, DY, DXSIZE, DYSIZE, 0, 0);
1671   BlitBitmap(drawto, bitmap_db_door_2, VX, VY, VXSIZE, VYSIZE, 0, 0);
1672
1673   OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
1674
1675   DrawMaskedBorder(fade_mask);
1676
1677   FadeIn(fade_mask);
1678   FadeSetEnterMenu();
1679
1680   /* update screen area with special editor door */
1681   redraw_mask |= REDRAW_ALL;
1682   BackToFront();
1683
1684   SetMouseCursor(CURSOR_DEFAULT);
1685
1686   OpenDoor(DOOR_CLOSE_1 | DOOR_OPEN_2);
1687 }
1688
1689 static void gotoTopLevelDir(void)
1690 {
1691   /* move upwards until inside (but not above) top level directory */
1692   while (leveldir_current->node_parent &&
1693          !strEqual(leveldir_current->node_parent->subdir, STRING_TOP_DIRECTORY))
1694   {
1695     /* write a "path" into level tree for easy navigation to last level */
1696     if (leveldir_current->node_parent->node_group->cl_first == -1)
1697     {
1698       int num_leveldirs = numTreeInfoInGroup(leveldir_current);
1699       int leveldir_pos = posTreeInfo(leveldir_current);
1700       int num_page_entries;
1701       int cl_first, cl_cursor;
1702
1703       if (num_leveldirs <= NUM_MENU_ENTRIES_ON_SCREEN)
1704         num_page_entries = num_leveldirs;
1705       else
1706         num_page_entries = NUM_MENU_ENTRIES_ON_SCREEN;
1707
1708       cl_first = MAX(0, leveldir_pos - num_page_entries + 1);
1709       cl_cursor = leveldir_pos - cl_first;
1710
1711       leveldir_current->node_parent->node_group->cl_first = cl_first;
1712       leveldir_current->node_parent->node_group->cl_cursor = cl_cursor;
1713     }
1714
1715     leveldir_current = leveldir_current->node_parent;
1716   }
1717 }
1718
1719 void HandleTitleScreen(int mx, int my, int dx, int dy, int button)
1720 {
1721   static unsigned int title_delay = 0;
1722   static int title_screen_nr = 0;
1723   static int last_sound = -1, last_music = -1;
1724   boolean return_to_main_menu = FALSE;
1725   struct TitleControlInfo *tci;
1726   int sound, music;
1727
1728   if (button == MB_MENU_INITIALIZE)
1729   {
1730     title_delay = 0;
1731     title_screen_nr = 0;
1732     tci = &title_controls[title_screen_nr];
1733
1734     SetAnimStatus(getTitleAnimMode(tci));
1735
1736     last_sound = SND_UNDEFINED;
1737     last_music = MUS_UNDEFINED;
1738
1739     if (num_title_screens != 0)
1740     {
1741       FadeSetEnterScreen();
1742
1743       /* use individual title fading instead of global "enter screen" fading */
1744       fading = getTitleFading(tci);
1745     }
1746
1747     if (game_status_last_screen == GAME_MODE_INFO)
1748     {
1749       if (num_title_screens == 0)
1750       {
1751         /* switch game mode from title screen mode back to info screen mode */
1752         SetGameStatus(GAME_MODE_INFO);
1753
1754         /* store that last screen was info screen, not main menu screen */
1755         game_status_last_screen = GAME_MODE_INFO;
1756
1757         DrawInfoScreen_NotAvailable("Title screen information:",
1758                                     "No title screen for this level set.");
1759         return;
1760       }
1761
1762       FadeMenuSoundsAndMusic();
1763     }
1764
1765     FadeOut(REDRAW_ALL);
1766
1767     /* title screens may have different window size */
1768     ChangeViewportPropertiesIfNeeded();
1769
1770     /* only required to update logic for redrawing global border */
1771     ClearField();
1772
1773     if (tci->is_image)
1774       DrawTitleScreenImage(tci->local_nr, tci->initial);
1775     else
1776       DrawTitleScreenMessage(tci->local_nr, tci->initial);
1777
1778     sound = getTitleSound(tci);
1779     music = getTitleMusic(tci);
1780
1781     if (sound != last_sound)
1782       PlayMenuSoundExt(sound);
1783     if (music != last_music)
1784       PlayMenuMusicExt(music);
1785
1786     last_sound = sound;
1787     last_music = music;
1788
1789     SetMouseCursor(CURSOR_NONE);
1790
1791     FadeIn(REDRAW_ALL);
1792
1793     DelayReached(&title_delay, 0);      /* reset delay counter */
1794
1795     return;
1796   }
1797
1798   if (fading.auto_delay > 0 && DelayReached(&title_delay, fading.auto_delay))
1799     button = MB_MENU_CHOICE;
1800
1801   if (button == MB_MENU_LEAVE)
1802   {
1803     return_to_main_menu = TRUE;
1804   }
1805   else if (button == MB_MENU_CHOICE)
1806   {
1807     if (game_status_last_screen == GAME_MODE_INFO && num_title_screens == 0)
1808     {
1809       SetGameStatus(GAME_MODE_INFO);
1810
1811       info_mode = INFO_MODE_MAIN;
1812
1813       DrawInfoScreen();
1814
1815       return;
1816     }
1817
1818     title_screen_nr++;
1819
1820     if (title_screen_nr < num_title_screens)
1821     {
1822       tci = &title_controls[title_screen_nr];
1823
1824       SetAnimStatus(getTitleAnimMode(tci));
1825
1826       sound = getTitleSound(tci);
1827       music = getTitleMusic(tci);
1828
1829       if (last_sound != SND_UNDEFINED && sound != last_sound)
1830         FadeSound(last_sound);
1831       if (last_music != MUS_UNDEFINED && music != last_music)
1832         FadeMusic();
1833
1834       fading = getTitleFading(tci);
1835
1836       FadeOut(REDRAW_ALL);
1837
1838       if (tci->is_image)
1839         DrawTitleScreenImage(tci->local_nr, tci->initial);
1840       else
1841         DrawTitleScreenMessage(tci->local_nr, tci->initial);
1842
1843       sound = getTitleSound(tci);
1844       music = getTitleMusic(tci);
1845
1846       if (sound != last_sound)
1847         PlayMenuSoundExt(sound);
1848       if (music != last_music)
1849         PlayMenuMusicExt(music);
1850
1851       last_sound = sound;
1852       last_music = music;
1853
1854       FadeIn(REDRAW_ALL);
1855
1856       DelayReached(&title_delay, 0);    /* reset delay counter */
1857     }
1858     else
1859     {
1860       FadeMenuSoundsAndMusic();
1861
1862       return_to_main_menu = TRUE;
1863     }
1864   }
1865
1866   if (return_to_main_menu)
1867   {
1868     SetMouseCursor(CURSOR_DEFAULT);
1869
1870     /* force full menu screen redraw after displaying title screens */
1871     redraw_mask = REDRAW_ALL;
1872
1873     if (game_status_last_screen == GAME_MODE_INFO)
1874     {
1875       SetGameStatus(GAME_MODE_INFO);
1876
1877       info_mode = INFO_MODE_MAIN;
1878
1879       DrawInfoScreen();
1880     }
1881     else        /* default: return to main menu */
1882     {
1883       SetGameStatus(GAME_MODE_MAIN);
1884
1885       DrawMainMenu();
1886     }
1887   }
1888 }
1889
1890 void HandleMainMenu_SelectLevel(int step, int direction, int selected_level_nr)
1891 {
1892   int old_level_nr = level_nr;
1893   int new_level_nr;
1894
1895   if (selected_level_nr != NO_DIRECT_LEVEL_SELECT)
1896     new_level_nr = selected_level_nr;
1897   else
1898     new_level_nr = old_level_nr + step * direction;
1899
1900   if (new_level_nr < leveldir_current->first_level)
1901     new_level_nr = leveldir_current->first_level;
1902   if (new_level_nr > leveldir_current->last_level)
1903     new_level_nr = leveldir_current->last_level;
1904
1905   if (setup.handicap && new_level_nr > leveldir_current->handicap_level)
1906   {
1907     /* skipping levels is only allowed when trying to skip single level */
1908     if (setup.skip_levels && new_level_nr == old_level_nr + 1 &&
1909         Request("Level still unsolved! Skip despite handicap?", REQ_ASK))
1910     {
1911       leveldir_current->handicap_level++;
1912       SaveLevelSetup_SeriesInfo();
1913     }
1914
1915     new_level_nr = leveldir_current->handicap_level;
1916   }
1917
1918   if (new_level_nr != old_level_nr)
1919   {
1920     struct MainControlInfo *mci= getMainControlInfo(MAIN_CONTROL_LEVEL_NUMBER);
1921
1922     PlaySound(SND_MENU_ITEM_SELECTING);
1923
1924     level_nr = new_level_nr;
1925
1926     DrawText(mSX + mci->pos_text->x, mSY + mci->pos_text->y,
1927              int2str(level_nr, menu.main.text.level_number.size),
1928              mci->pos_text->font);
1929
1930     LoadLevel(level_nr);
1931     DrawPreviewLevelInitial();
1932
1933     TapeErase();
1934     LoadTape(level_nr);
1935     DrawCompleteVideoDisplay();
1936
1937     SaveLevelSetup_SeriesInfo();
1938
1939     UpdateScreenMenuGadgets(SCREEN_MASK_MAIN_HAS_SOLUTION, hasSolutionTape());
1940
1941     /* needed because DrawPreviewLevelInitial() takes some time */
1942     BackToFront();
1943     /* SyncDisplay(); */
1944   }
1945 }
1946
1947 void HandleMainMenu(int mx, int my, int dx, int dy, int button)
1948 {
1949   static int choice = MAIN_CONTROL_GAME;
1950   static boolean button_pressed_last = FALSE;
1951   boolean button_pressed = FALSE;
1952   int pos = choice;
1953   int i;
1954
1955   if (button == MB_MENU_INITIALIZE)
1956   {
1957     DrawCursorAndText_Main(choice, TRUE, FALSE);
1958
1959     return;
1960   }
1961
1962   if (mx || my)         /* mouse input */
1963   {
1964     pos = -1;
1965
1966     for (i = 0; main_controls[i].nr != -1; i++)
1967     {
1968       if (insideMenuPosRect(main_controls[i].pos_button, mx - mSX, my - mSY) ||
1969           insideTextPosRect(main_controls[i].pos_text,   mx - mSX, my - mSY) ||
1970           insideTextPosRect(main_controls[i].pos_input,  mx - mSX, my - mSY))
1971       {
1972         pos = main_controls[i].nr;
1973
1974         break;
1975       }
1976     }
1977
1978     /* check if level preview was clicked */
1979     if (insidePreviewRect(&preview, mx - SX, my - SY))
1980       pos = MAIN_CONTROL_GAME;
1981
1982     // handle pressed/unpressed state for active/inactive menu buttons
1983     // (if pos != -1, "i" contains index position corresponding to "pos")
1984     if (button &&
1985         pos >= MAIN_CONTROL_NAME && pos <= MAIN_CONTROL_QUIT &&
1986         insideMenuPosRect(main_controls[i].pos_button, mx - mSX, my - mSY))
1987       button_pressed = TRUE;
1988
1989     if (button_pressed != button_pressed_last)
1990     {
1991       DrawCursorAndText_Main(choice, TRUE, button_pressed);
1992
1993       if (button_pressed)
1994         PlaySound(SND_MENU_BUTTON_PRESSING);
1995       else
1996         PlaySound(SND_MENU_BUTTON_RELEASING);
1997     }
1998   }
1999   else if (dx || dy)    /* keyboard input */
2000   {
2001     if (dx > 0 && (choice == MAIN_CONTROL_INFO ||
2002                    choice == MAIN_CONTROL_SETUP))
2003       button = MB_MENU_CHOICE;
2004     else if (dy)
2005       pos = choice + dy;
2006   }
2007
2008   if (pos == MAIN_CONTROL_FIRST_LEVEL && !button)
2009   {
2010     HandleMainMenu_SelectLevel(MAX_LEVELS, -1, NO_DIRECT_LEVEL_SELECT);
2011   }
2012   else if (pos == MAIN_CONTROL_LAST_LEVEL && !button)
2013   {
2014     HandleMainMenu_SelectLevel(MAX_LEVELS, +1, NO_DIRECT_LEVEL_SELECT);
2015   }
2016   else if (pos == MAIN_CONTROL_LEVEL_NUMBER && !button)
2017   {
2018     CloseDoor(DOOR_CLOSE_2);
2019
2020     SetGameStatus(GAME_MODE_LEVELNR);
2021
2022     DrawChooseLevelNr();
2023   }
2024   else if (pos >= MAIN_CONTROL_NAME && pos <= MAIN_CONTROL_QUIT)
2025   {
2026     if (button)
2027     {
2028       if (pos != choice)
2029       {
2030         PlaySound(SND_MENU_ITEM_ACTIVATING);
2031
2032         DrawCursorAndText_Main(choice, FALSE, FALSE);
2033         DrawCursorAndText_Main(pos, TRUE, button_pressed);
2034
2035         choice = pos;
2036       }
2037       else if (dx != 0)
2038       {
2039         if (choice != MAIN_CONTROL_INFO &&
2040             choice != MAIN_CONTROL_SETUP)
2041           HandleMainMenu_SelectLevel(1, dx, NO_DIRECT_LEVEL_SELECT);
2042       }
2043     }
2044     else
2045     {
2046       PlaySound(SND_MENU_ITEM_SELECTING);
2047
2048       if (pos == MAIN_CONTROL_NAME)
2049       {
2050         SetGameStatus(GAME_MODE_PSEUDO_TYPENAME);
2051
2052         HandleTypeName(strlen(setup.player_name), 0);
2053       }
2054       else if (pos == MAIN_CONTROL_LEVELS)
2055       {
2056         if (leveldir_first)
2057         {
2058           CloseDoor(DOOR_CLOSE_2);
2059
2060           SetGameStatus(GAME_MODE_LEVELS);
2061
2062           SaveLevelSetup_LastSeries();
2063           SaveLevelSetup_SeriesInfo();
2064
2065           if (setup.internal.choose_from_top_leveldir)
2066             gotoTopLevelDir();
2067
2068           DrawChooseLevelSet();
2069         }
2070       }
2071       else if (pos == MAIN_CONTROL_SCORES)
2072       {
2073         CloseDoor(DOOR_CLOSE_2);
2074
2075         SetGameStatus(GAME_MODE_SCORES);
2076
2077         DrawHallOfFame(level_nr, -1);
2078       }
2079       else if (pos == MAIN_CONTROL_EDITOR)
2080       {
2081         if (leveldir_current->readonly &&
2082             !strEqual(setup.player_name, "Artsoft"))
2083           Request("This level is read only!", REQ_CONFIRM);
2084
2085         CloseDoor(DOOR_CLOSE_2);
2086
2087         SetGameStatus(GAME_MODE_EDITOR);
2088
2089         FadeSetEnterScreen();
2090
2091         DrawLevelEd();
2092       }
2093       else if (pos == MAIN_CONTROL_INFO)
2094       {
2095         CloseDoor(DOOR_CLOSE_2);
2096
2097         SetGameStatus(GAME_MODE_INFO);
2098
2099         info_mode = INFO_MODE_MAIN;
2100
2101         DrawInfoScreen();
2102       }
2103       else if (pos == MAIN_CONTROL_GAME)
2104       {
2105         StartGameActions(network.enabled, setup.autorecord, level.random_seed);
2106       }
2107       else if (pos == MAIN_CONTROL_SETUP)
2108       {
2109         CloseDoor(DOOR_CLOSE_2);
2110
2111         SetGameStatus(GAME_MODE_SETUP);
2112
2113         setup_mode = SETUP_MODE_MAIN;
2114
2115         DrawSetupScreen();
2116       }
2117       else if (pos == MAIN_CONTROL_QUIT)
2118       {
2119         SaveLevelSetup_LastSeries();
2120         SaveLevelSetup_SeriesInfo();
2121
2122         if (Request("Do you really want to quit?", REQ_ASK | REQ_STAY_CLOSED))
2123           SetGameStatus(GAME_MODE_QUIT);
2124       }
2125     }
2126   }
2127
2128   button_pressed_last = button_pressed;
2129 }
2130
2131
2132 /* ========================================================================= */
2133 /* info screen functions                                                     */
2134 /* ========================================================================= */
2135
2136 static struct TokenInfo *info_info;
2137 static int num_info_info;       /* number of info entries shown on screen */
2138 static int max_info_info;       /* total number of info entries in list */
2139
2140 static void execInfoTitleScreen(void)
2141 {
2142   info_mode = INFO_MODE_TITLE;
2143
2144   DrawInfoScreen();
2145 }
2146
2147 static void execInfoElements(void)
2148 {
2149   info_mode = INFO_MODE_ELEMENTS;
2150
2151   DrawInfoScreen();
2152 }
2153
2154 static void execInfoMusic(void)
2155 {
2156   info_mode = INFO_MODE_MUSIC;
2157
2158   DrawInfoScreen();
2159 }
2160
2161 static void execInfoCredits(void)
2162 {
2163   info_mode = INFO_MODE_CREDITS;
2164
2165   DrawInfoScreen();
2166 }
2167
2168 static void execInfoProgram(void)
2169 {
2170   info_mode = INFO_MODE_PROGRAM;
2171
2172   DrawInfoScreen();
2173 }
2174
2175 static void execInfoVersion(void)
2176 {
2177   info_mode = INFO_MODE_VERSION;
2178
2179   DrawInfoScreen();
2180 }
2181
2182 static void execInfoLevelSet(void)
2183 {
2184   info_mode = INFO_MODE_LEVELSET;
2185
2186   DrawInfoScreen();
2187 }
2188
2189 static void execExitInfo(void)
2190 {
2191   SetGameStatus(GAME_MODE_MAIN);
2192
2193   DrawMainMenu();
2194 }
2195
2196 static struct TokenInfo info_info_main[] =
2197 {
2198   { TYPE_ENTER_SCREEN,  execInfoTitleScreen,    "Title Screen"          },
2199   { TYPE_ENTER_SCREEN,  execInfoElements,       "Elements Info"         },
2200   { TYPE_ENTER_SCREEN,  execInfoMusic,          "Music Info"            },
2201   { TYPE_ENTER_SCREEN,  execInfoCredits,        "Credits"               },
2202   { TYPE_ENTER_SCREEN,  execInfoProgram,        "Program Info"          },
2203   { TYPE_ENTER_SCREEN,  execInfoVersion,        "Version Info"          },
2204   { TYPE_ENTER_SCREEN,  execInfoLevelSet,       "Level Set Info"        },
2205   { TYPE_EMPTY,         NULL,                   ""                      },
2206   { TYPE_LEAVE_MENU,    execExitInfo,           "Exit"                  },
2207
2208   { 0,                  NULL,                   NULL                    }
2209 };
2210
2211 static int getMenuTextFont(int type)
2212 {
2213   if (type & (TYPE_SWITCH       |
2214               TYPE_YES_NO       |
2215               TYPE_YES_NO_AUTO  |
2216               TYPE_STRING       |
2217               TYPE_PLAYER       |
2218               TYPE_ECS_AGA      |
2219               TYPE_KEYTEXT      |
2220               TYPE_ENTER_LIST))
2221     return FONT_MENU_2;
2222   else
2223     return FONT_MENU_1;
2224 }
2225
2226 static struct TokenInfo *setup_info;
2227 static struct TokenInfo setup_info_input[];
2228
2229 static struct TokenInfo *menu_info;
2230
2231 static void DrawCursorAndText_Menu_Ext(struct TokenInfo *token_info,
2232                                        int screen_pos, int menu_info_pos_raw,
2233                                        boolean active)
2234 {
2235   int pos = (menu_info_pos_raw < 0 ? screen_pos : menu_info_pos_raw);
2236   struct TokenInfo *ti = &token_info[pos];
2237   int xpos = MENU_SCREEN_START_XPOS;
2238   int ypos = MENU_SCREEN_START_YPOS + screen_pos;
2239   int font_nr = getMenuTextFont(ti->type);
2240
2241   if (setup_mode == SETUP_MODE_INPUT)
2242     font_nr = FONT_MENU_1;
2243
2244   if (active)
2245     font_nr = FONT_ACTIVE(font_nr);
2246
2247   DrawText(mSX + xpos * 32, mSY + ypos * 32, ti->text, font_nr);
2248
2249   if (ti->type & ~TYPE_SKIP_ENTRY)
2250     drawCursor(screen_pos, active);
2251 }
2252
2253 static void DrawCursorAndText_Menu(int screen_pos, int menu_info_pos_raw,
2254                                    boolean active)
2255 {
2256   DrawCursorAndText_Menu_Ext(menu_info, screen_pos, menu_info_pos_raw, active);
2257 }
2258
2259 static void DrawCursorAndText_Setup(int screen_pos, int menu_info_pos_raw,
2260                                     boolean active)
2261 {
2262   DrawCursorAndText_Menu_Ext(setup_info, screen_pos, menu_info_pos_raw, active);
2263 }
2264
2265 static char *window_size_text;
2266 static char *scaling_type_text;
2267
2268 static void drawSetupValue(int, int);
2269
2270 static void drawMenuInfoList(int first_entry, int num_page_entries,
2271                              int max_page_entries)
2272 {
2273   int i;
2274
2275   if (first_entry + num_page_entries > max_page_entries)
2276     first_entry = 0;
2277
2278   clearMenuListArea();
2279
2280   for (i = 0; i < num_page_entries; i++)
2281   {
2282     int menu_info_pos = first_entry + i;
2283     struct TokenInfo *si = &menu_info[menu_info_pos];
2284     void *value_ptr = si->value;
2285
2286     /* set some entries to "unchangeable" according to other variables */
2287     if ((value_ptr == &setup.sound_simple && !audio.sound_available) ||
2288         (value_ptr == &setup.sound_loops  && !audio.loops_available) ||
2289         (value_ptr == &setup.sound_music  && !audio.music_available) ||
2290         (value_ptr == &setup.fullscreen   && !video.fullscreen_available) ||
2291         (value_ptr == &window_size_text   && !video.window_scaling_available) ||
2292         (value_ptr == &scaling_type_text  && !video.window_scaling_available))
2293       si->type |= TYPE_GHOSTED;
2294
2295     if (si->type & (TYPE_ENTER_MENU|TYPE_ENTER_LIST))
2296       initCursor(i, IMG_MENU_BUTTON_ENTER_MENU);
2297     else if (si->type & (TYPE_LEAVE_MENU|TYPE_LEAVE_LIST))
2298       initCursor(i, IMG_MENU_BUTTON_LEAVE_MENU);
2299     else if (si->type & ~TYPE_SKIP_ENTRY)
2300       initCursor(i, IMG_MENU_BUTTON);
2301
2302     DrawCursorAndText_Menu(i, menu_info_pos, FALSE);
2303
2304     if (si->type & TYPE_VALUE &&
2305         menu_info == setup_info)
2306       drawSetupValue(i, menu_info_pos);
2307   }
2308 }
2309
2310 static void DrawInfoScreen_Main(void)
2311 {
2312   int fade_mask = REDRAW_FIELD;
2313   int i;
2314
2315   if (redraw_mask & REDRAW_ALL)
2316     fade_mask = REDRAW_ALL;
2317
2318   if (CheckIfGlobalBorderOrPlayfieldViewportHasChanged())
2319     fade_mask = REDRAW_ALL;
2320
2321   UnmapAllGadgets();
2322   FadeMenuSoundsAndMusic();
2323
2324   FreeScreenGadgets();
2325   CreateScreenGadgets();
2326
2327   /* (needed after displaying title screens which disable auto repeat) */
2328   KeyboardAutoRepeatOn();
2329
2330   FadeSetLeaveScreen();
2331
2332   FadeOut(fade_mask);
2333
2334   /* needed if different viewport properties defined for info screen */
2335   ChangeViewportPropertiesIfNeeded();
2336
2337   SetMainBackgroundImage(IMG_BACKGROUND_INFO);
2338
2339   ClearField();
2340
2341   OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
2342
2343   DrawTextSCentered(mSY - SY + 16, FONT_TITLE_1, "Info Screen");
2344
2345   info_info = info_info_main;
2346
2347   // determine maximal number of info entries that can be displayed on screen
2348   num_info_info = 0;
2349   for (i = 0; info_info[i].type != 0 && i < NUM_MENU_ENTRIES_ON_SCREEN; i++)
2350     num_info_info++;
2351
2352   // determine maximal number of info entries available for menu of info screen
2353   max_info_info = 0;
2354   for (i = 0; info_info[i].type != 0; i++)
2355     max_info_info++;
2356
2357   HandleInfoScreen_Main(0, 0, 0, 0, MB_MENU_INITIALIZE);
2358
2359   MapScreenGadgets(max_info_info);
2360
2361   PlayMenuSoundsAndMusic();
2362
2363   DrawMaskedBorder(fade_mask);
2364
2365   FadeIn(fade_mask);
2366 }
2367
2368 static void changeSetupValue(int, int, int);
2369
2370 void HandleMenuScreen(int mx, int my, int dx, int dy, int button,
2371                       int mode, int num_page_entries, int max_page_entries)
2372 {
2373   static int num_page_entries_all_last[NUM_SPECIAL_GFX_ARGS][MAX_MENU_MODES];
2374   static int choice_stores[NUM_SPECIAL_GFX_ARGS][MAX_MENU_MODES];
2375   static int first_entry_stores[NUM_SPECIAL_GFX_ARGS][MAX_MENU_MODES];
2376   int *num_page_entries_last = num_page_entries_all_last[game_status];
2377   int *choice_store = choice_stores[game_status];
2378   int *first_entry_store = first_entry_stores[game_status];
2379   int choice = choice_store[mode];              /* starts with 0 */
2380   int first_entry = first_entry_store[mode];    /* starts with 0 */
2381   int x = 0;
2382   int y = choice - first_entry;
2383   int y_old = y;
2384   boolean position_set_by_scrollbar = (dx == 999);
2385   int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
2386   int i;
2387
2388   if (button == MB_MENU_INITIALIZE)
2389   {
2390     // check if number of menu page entries has changed (may happen by change
2391     // of custom artwork definition value for 'list_size' for this menu screen)
2392     // (in this case, the last menu position most probably has to be corrected)
2393     if (num_page_entries != num_page_entries_last[mode])
2394     {
2395       choice_store[mode] = first_entry_store[mode] = 0;
2396
2397       choice = first_entry = 0;
2398       y = y_old = 0;
2399
2400       num_page_entries_last[mode] = num_page_entries;
2401     }
2402
2403     /* advance to first valid menu entry */
2404     while (choice < num_page_entries &&
2405            menu_info[choice].type & TYPE_SKIP_ENTRY)
2406       choice++;
2407
2408     if (position_set_by_scrollbar)
2409       first_entry = first_entry_store[mode] = dy;
2410     else
2411       AdjustScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL, max_page_entries,
2412                       NUM_MENU_ENTRIES_ON_SCREEN, first_entry);
2413
2414     drawMenuInfoList(first_entry, num_page_entries, max_page_entries);
2415
2416     if (choice < first_entry)
2417     {
2418       choice = first_entry;
2419
2420       if (menu_info[choice].type & TYPE_SKIP_ENTRY)
2421         choice++;
2422     }
2423     else if (choice > first_entry + num_page_entries - 1)
2424     {
2425       choice = first_entry + num_page_entries - 1;
2426
2427       if (menu_info[choice].type & TYPE_SKIP_ENTRY)
2428         choice--;
2429     }
2430
2431     choice_store[mode] = choice;
2432
2433     DrawCursorAndText_Menu(choice - first_entry, choice, TRUE);
2434
2435     return;
2436   }
2437   else if (button == MB_MENU_LEAVE)
2438   {
2439     PlaySound(SND_MENU_ITEM_SELECTING);
2440
2441     for (i = 0; i < max_page_entries; i++)
2442     {
2443       if (menu_info[i].type & TYPE_LEAVE_MENU)
2444       {
2445         void (*menu_callback_function)(void) = menu_info[i].value;
2446
2447         FadeSetLeaveMenu();
2448
2449         menu_callback_function();
2450
2451         break;  /* absolutely needed because function changes 'menu_info'! */
2452       }
2453     }
2454
2455     return;
2456   }
2457
2458   if (mx || my)         /* mouse input */
2459   {
2460     x = (mx - mSX) / 32;
2461     y = (my - mSY) / 32 - MENU_SCREEN_START_YPOS;
2462   }
2463   else if (dx || dy)    /* keyboard or scrollbar/scrollbutton input */
2464   {
2465     /* move cursor instead of scrolling when already at start/end of list */
2466     if (dy == -1 * SCROLL_LINE && first_entry == 0)
2467       dy = -1;
2468     else if (dy == +1 * SCROLL_LINE &&
2469              first_entry + num_page_entries == max_page_entries)
2470       dy = 1;
2471
2472     /* handle scrolling screen one line or page */
2473     if (y + dy < 0 ||
2474         y + dy > num_page_entries - 1)
2475     {
2476       boolean redraw = FALSE;
2477
2478       if (ABS(dy) == SCROLL_PAGE)
2479         step = num_page_entries - 1;
2480
2481       if (dy < 0 && first_entry > 0)
2482       {
2483         /* scroll page/line up */
2484
2485         first_entry -= step;
2486         if (first_entry < 0)
2487           first_entry = 0;
2488
2489         redraw = TRUE;
2490       }
2491       else if (dy > 0 && first_entry + num_page_entries < max_page_entries)
2492       {
2493         /* scroll page/line down */
2494
2495         first_entry += step;
2496         if (first_entry + num_page_entries > max_page_entries)
2497           first_entry = MAX(0, max_page_entries - num_page_entries);
2498
2499         redraw = TRUE;
2500       }
2501
2502       if (redraw)
2503       {
2504         choice += first_entry - first_entry_store[mode];
2505
2506         if (choice < first_entry)
2507         {
2508           choice = first_entry;
2509
2510           if (menu_info[choice].type & TYPE_SKIP_ENTRY)
2511             choice++;
2512         }
2513         else if (choice > first_entry + num_page_entries - 1)
2514         {
2515           choice = first_entry + num_page_entries - 1;
2516
2517           if (menu_info[choice].type & TYPE_SKIP_ENTRY)
2518             choice--;
2519         }
2520         else if (menu_info[choice].type & TYPE_SKIP_ENTRY)
2521         {
2522           choice += SIGN(dy);
2523
2524           if (choice < first_entry ||
2525               choice > first_entry + num_page_entries - 1)
2526           first_entry += SIGN(dy);
2527         }
2528
2529         first_entry_store[mode] = first_entry;
2530         choice_store[mode] = choice;
2531
2532         drawMenuInfoList(first_entry, num_page_entries, max_page_entries);
2533
2534         DrawCursorAndText_Menu(choice - first_entry, choice, TRUE);
2535
2536         AdjustScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL, max_page_entries,
2537                         NUM_MENU_ENTRIES_ON_SCREEN, first_entry);
2538       }
2539
2540       return;
2541     }
2542
2543     if (dx)
2544     {
2545       int menu_navigation_type = (dx < 0 ? TYPE_LEAVE : TYPE_ENTER);
2546
2547       if (menu_info[choice].type & menu_navigation_type ||
2548           menu_info[choice].type & TYPE_BOOLEAN_STYLE ||
2549           menu_info[choice].type & TYPE_YES_NO_AUTO ||
2550           menu_info[choice].type & TYPE_PLAYER)
2551         button = MB_MENU_CHOICE;
2552     }
2553     else if (dy)
2554       y += dy;
2555
2556     /* jump to next non-empty menu entry (up or down) */
2557     while (first_entry + y > 0 &&
2558            first_entry + y < max_page_entries - 1 &&
2559            menu_info[first_entry + y].type & TYPE_SKIP_ENTRY)
2560       y += dy;
2561
2562     if (!IN_VIS_MENU(x, y))
2563     {
2564       choice += y - y_old;
2565
2566       if (choice < first_entry)
2567         first_entry = choice;
2568       else if (choice > first_entry + num_page_entries - 1)
2569         first_entry = choice - num_page_entries + 1;
2570
2571       if (first_entry >= 0 &&
2572           first_entry + num_page_entries <= max_page_entries)
2573       {
2574         first_entry_store[mode] = first_entry;
2575
2576         if (choice < first_entry)
2577           choice = first_entry;
2578         else if (choice > first_entry + num_page_entries - 1)
2579           choice = first_entry + num_page_entries - 1;
2580
2581         choice_store[mode] = choice;
2582
2583         drawMenuInfoList(first_entry, num_page_entries, max_page_entries);
2584
2585         DrawCursorAndText_Menu(choice - first_entry, choice, TRUE);
2586
2587         AdjustScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL, max_page_entries,
2588                         NUM_MENU_ENTRIES_ON_SCREEN, first_entry);
2589       }
2590
2591       return;
2592     }
2593   }
2594
2595   if (!anyScrollbarGadgetActive() &&
2596       IN_VIS_MENU(x, y) &&
2597       mx < screen_gadget[SCREEN_CTRL_ID_SCROLL_VERTICAL]->x &&
2598       y >= 0 && y < num_page_entries)
2599   {
2600     if (button)
2601     {
2602       if (first_entry + y != choice &&
2603           menu_info[first_entry + y].type & ~TYPE_SKIP_ENTRY)
2604       {
2605         PlaySound(SND_MENU_ITEM_ACTIVATING);
2606
2607         DrawCursorAndText_Menu(choice - first_entry, choice, FALSE);
2608         DrawCursorAndText_Menu(y, first_entry + y, TRUE);
2609
2610         choice = choice_store[mode] = first_entry + y;
2611       }
2612       else if (dx < 0)
2613       {
2614         PlaySound(SND_MENU_ITEM_SELECTING);
2615
2616         for (i = 0; menu_info[i].type != 0; i++)
2617         {
2618           if (menu_info[i].type & TYPE_LEAVE_MENU)
2619           {
2620             void (*menu_callback_function)(void) = menu_info[i].value;
2621
2622             FadeSetLeaveMenu();
2623
2624             menu_callback_function();
2625
2626             /* absolutely needed because function changes 'menu_info'! */
2627             break;
2628           }
2629         }
2630
2631         return;
2632       }
2633     }
2634     else if (!(menu_info[first_entry + y].type & TYPE_GHOSTED))
2635     {
2636       PlaySound(SND_MENU_ITEM_SELECTING);
2637
2638       /* when selecting key headline, execute function for key value change */
2639       if (menu_info[first_entry + y].type & TYPE_KEYTEXT &&
2640           menu_info[first_entry + y + 1].type & TYPE_KEY)
2641         y++;
2642
2643       /* when selecting string value, execute function for list selection */
2644       if (menu_info[first_entry + y].type & TYPE_STRING && y > 0 &&
2645           menu_info[first_entry + y - 1].type & TYPE_ENTER_LIST)
2646         y--;
2647
2648       if (menu_info[first_entry + y].type & TYPE_ENTER_OR_LEAVE)
2649       {
2650         void (*menu_callback_function)(void) =
2651           menu_info[first_entry + y].value;
2652
2653         FadeSetFromType(menu_info[first_entry + y].type);
2654
2655         menu_callback_function();
2656       }
2657       else if (menu_info[first_entry + y].type & TYPE_VALUE &&
2658                menu_info == setup_info)
2659       {
2660         changeSetupValue(y, first_entry + y, dx);
2661       }
2662     }
2663   }
2664 }
2665
2666 void HandleInfoScreen_Main(int mx, int my, int dx, int dy, int button)
2667 {
2668   menu_info = info_info;
2669
2670   HandleMenuScreen(mx, my, dx, dy, button,
2671                    info_mode, num_info_info, max_info_info);
2672 }
2673
2674 static int getMenuFontSpacing(int spacing_height, int font_nr)
2675 {
2676   int font_spacing = getFontHeight(font_nr) + EXTRA_SPACING(game_status);
2677
2678   return (spacing_height < 0 ? ABS(spacing_height) * font_spacing :
2679           spacing_height);
2680 }
2681
2682 static int getMenuTextSpacing(int spacing_height, int font_nr)
2683 {
2684   return (getMenuFontSpacing(spacing_height, font_nr) +
2685           EXTRA_SPACING(game_status));
2686 }
2687
2688 static int getMenuTextStep(int spacing_height, int font_nr)
2689 {
2690   return getFontHeight(font_nr) + getMenuTextSpacing(spacing_height, font_nr);
2691 }
2692
2693 void DrawInfoScreen_NotAvailable(char *text_title, char *text_error)
2694 {
2695   int font_title = MENU_INFO_FONT_TITLE;
2696   int font_error = FONT_TEXT_2;
2697   int font_foot  = MENU_INFO_FONT_FOOT;
2698   int spacing_title = menu.headline1_spacing_info[info_mode];
2699   int ystep_title = getMenuTextStep(spacing_title, font_title);
2700   int ystart1 = mSY - SY + MENU_SCREEN_INFO_YSTART1;
2701   int ystart2 = ystart1 + ystep_title;
2702   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
2703
2704   SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO);
2705
2706   FadeOut(REDRAW_FIELD);
2707
2708   ClearField();
2709   DrawHeadline();
2710
2711   DrawTextSCentered(ystart1, font_title, text_title);
2712   DrawTextSCentered(ystart2, font_error, text_error);
2713
2714   DrawTextSCentered(ybottom, font_foot,
2715                     "Press any key or button for info menu");
2716
2717   FadeIn(REDRAW_FIELD);
2718 }
2719
2720 void DrawInfoScreen_HelpAnim(int start, int max_anims, boolean init)
2721 {
2722   static int infoscreen_step[MAX_INFO_ELEMENTS_ON_SCREEN];
2723   static int infoscreen_frame[MAX_INFO_ELEMENTS_ON_SCREEN];
2724   int font_title = MENU_INFO_FONT_TITLE;
2725   int font_foot  = MENU_INFO_FONT_FOOT;
2726   int xstart  = mSX + MENU_SCREEN_INFO_SPACE_LEFT;
2727   int ystart1 = mSY - SY + MENU_SCREEN_INFO_YSTART1;
2728   int ystart2 = mSY + MENU_SCREEN_INFO_YSTART2;
2729   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
2730   int ystep = MENU_SCREEN_INFO_YSTEP;
2731   int element, action, direction;
2732   int graphic;
2733   int delay;
2734   int sync_frame;
2735   int i, j;
2736
2737   if (init)
2738   {
2739     for (i = 0; i < NUM_INFO_ELEMENTS_ON_SCREEN; i++)
2740       infoscreen_step[i] = infoscreen_frame[i] = 0;
2741
2742     ClearField();
2743     DrawHeadline();
2744
2745     DrawTextSCentered(ystart1, font_title, "The Game Elements:");
2746
2747     DrawTextSCentered(ybottom, font_foot,
2748                       "Press any key or button for next page");
2749
2750     FrameCounter = 0;
2751   }
2752
2753   i = j = 0;
2754   while (helpanim_info[j].element != HELPANIM_LIST_END)
2755   {
2756     if (i >= start + NUM_INFO_ELEMENTS_ON_SCREEN ||
2757         i >= max_anims)
2758       break;
2759     else if (i < start)
2760     {
2761       while (helpanim_info[j].element != HELPANIM_LIST_NEXT)
2762         j++;
2763
2764       j++;
2765       i++;
2766
2767       continue;
2768     }
2769
2770     j += infoscreen_step[i - start];
2771
2772     element = helpanim_info[j].element;
2773     action = helpanim_info[j].action;
2774     direction = helpanim_info[j].direction;
2775
2776     if (element < 0)
2777       element = EL_UNKNOWN;
2778
2779     if (action != -1 && direction != -1)
2780       graphic = el_act_dir2img(element, action, direction);
2781     else if (action != -1)
2782       graphic = el_act2img(element, action);
2783     else if (direction != -1)
2784       graphic = el_dir2img(element, direction);
2785     else
2786       graphic = el2img(element);
2787
2788     delay = helpanim_info[j++].delay;
2789
2790     if (delay == -1)
2791       delay = 1000000;
2792
2793     if (infoscreen_frame[i - start] == 0)
2794     {
2795       sync_frame = 0;
2796       infoscreen_frame[i - start] = delay - 1;
2797     }
2798     else
2799     {
2800       sync_frame = delay - infoscreen_frame[i - start];
2801       infoscreen_frame[i - start]--;
2802     }
2803
2804     if (helpanim_info[j].element == HELPANIM_LIST_NEXT)
2805     {
2806       if (!infoscreen_frame[i - start])
2807         infoscreen_step[i - start] = 0;
2808     }
2809     else
2810     {
2811       if (!infoscreen_frame[i - start])
2812         infoscreen_step[i - start]++;
2813       while (helpanim_info[j].element != HELPANIM_LIST_NEXT)
2814         j++;
2815     }
2816
2817     j++;
2818
2819     ClearRectangleOnBackground(drawto, xstart, ystart2 + (i - start) * ystep,
2820                                TILEX, TILEY);
2821     DrawFixedGraphicAnimationExt(drawto, xstart, ystart2 + (i - start) * ystep,
2822                                  graphic, sync_frame, USE_MASKING);
2823
2824     if (init)
2825       DrawInfoScreen_HelpText(element, action, direction, i - start);
2826
2827     i++;
2828   }
2829
2830   redraw_mask |= REDRAW_FIELD;
2831
2832   FrameCounter++;
2833 }
2834
2835 static char *getHelpText(int element, int action, int direction)
2836 {
2837   char token[MAX_LINE_LEN];
2838
2839   strcpy(token, element_info[element].token_name);
2840
2841   if (action != -1)
2842     strcat(token, element_action_info[action].suffix);
2843
2844   if (direction != -1)
2845     strcat(token, element_direction_info[MV_DIR_TO_BIT(direction)].suffix);
2846
2847   return getHashEntry(helptext_info, token);
2848 }
2849
2850 void DrawInfoScreen_HelpText(int element, int action, int direction, int ypos)
2851 {
2852   int font_nr = FONT_INFO_ELEMENTS;
2853   int font_width = getFontWidth(font_nr);
2854   int font_height = getFontHeight(font_nr);
2855   int yoffset = (TILEX - 2 * font_height) / 2;
2856   int xstart = mSX + MENU_SCREEN_INFO_SPACE_LEFT + TILEX + MINI_TILEX;
2857   int ystart = mSY + MENU_SCREEN_INFO_YSTART2 + yoffset;
2858   int ystep = TILEY + 4;
2859   int pad_left = xstart - SX;
2860   int pad_right = MENU_SCREEN_INFO_SPACE_RIGHT;
2861   int max_chars_per_line = (SXSIZE - pad_left - pad_right) / font_width;
2862   int max_lines_per_text = 2;    
2863   char *text = NULL;
2864
2865   if (action != -1 && direction != -1)          /* element.action.direction */
2866     text = getHelpText(element, action, direction);
2867
2868   if (text == NULL && action != -1)             /* element.action */
2869     text = getHelpText(element, action, -1);
2870
2871   if (text == NULL && direction != -1)          /* element.direction */
2872     text = getHelpText(element, -1, direction);
2873
2874   if (text == NULL)                             /* base element */
2875     text = getHelpText(element, -1, -1);
2876
2877   if (text == NULL)                             /* not found */
2878     text = "No description available";
2879
2880   if (strlen(text) <= max_chars_per_line)       /* only one line of text */
2881     ystart += getFontHeight(font_nr) / 2;
2882
2883   DrawTextBuffer(xstart, ystart + ypos * ystep, text, font_nr,
2884                  max_chars_per_line, -1, max_lines_per_text, 0, -1,
2885                  TRUE, FALSE, FALSE);
2886 }
2887
2888 void DrawInfoScreen_TitleScreen(void)
2889 {
2890   SetGameStatus(GAME_MODE_TITLE);
2891
2892   DrawTitleScreen();
2893 }
2894
2895 void HandleInfoScreen_TitleScreen(int button)
2896 {
2897   HandleTitleScreen(0, 0, 0, 0, button);
2898 }
2899
2900 void DrawInfoScreen_Elements(void)
2901 {
2902   SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_ELEMENTS);
2903
2904   FadeOut(REDRAW_FIELD);
2905
2906   LoadHelpAnimInfo();
2907   LoadHelpTextInfo();
2908
2909   HandleInfoScreen_Elements(MB_MENU_INITIALIZE);
2910
2911   FadeIn(REDRAW_FIELD);
2912 }
2913
2914 void HandleInfoScreen_Elements(int button)
2915 {
2916   static unsigned int info_delay = 0;
2917   static int num_anims;
2918   static int num_pages;
2919   static int page;
2920   int anims_per_page = NUM_INFO_ELEMENTS_ON_SCREEN;
2921   int i;
2922
2923   if (button == MB_MENU_INITIALIZE)
2924   {
2925     boolean new_element = TRUE;
2926
2927     num_anims = 0;
2928
2929     for (i = 0; helpanim_info[i].element != HELPANIM_LIST_END; i++)
2930     {
2931       if (helpanim_info[i].element == HELPANIM_LIST_NEXT)
2932         new_element = TRUE;
2933       else if (new_element)
2934       {
2935         num_anims++;
2936         new_element = FALSE;
2937       }
2938     }
2939
2940     num_pages = (num_anims + anims_per_page - 1) / anims_per_page;
2941     page = 0;
2942   }
2943
2944   if (button == MB_MENU_LEAVE)
2945   {
2946     PlaySound(SND_MENU_ITEM_SELECTING);
2947
2948     info_mode = INFO_MODE_MAIN;
2949     DrawInfoScreen();
2950
2951     return;
2952   }
2953   else if (button == MB_MENU_CHOICE || button == MB_MENU_INITIALIZE)
2954   {
2955     if (button != MB_MENU_INITIALIZE)
2956     {
2957       PlaySound(SND_MENU_ITEM_SELECTING);
2958
2959       page++;
2960     }
2961
2962     if (page >= num_pages)
2963     {
2964       FadeMenuSoundsAndMusic();
2965
2966       info_mode = INFO_MODE_MAIN;
2967       DrawInfoScreen();
2968
2969       return;
2970     }
2971
2972     if (page > 0)
2973       FadeSetNextScreen();
2974
2975     if (button != MB_MENU_INITIALIZE)
2976       FadeOut(REDRAW_FIELD);
2977
2978     DrawInfoScreen_HelpAnim(page * anims_per_page, num_anims, TRUE);
2979
2980     if (button != MB_MENU_INITIALIZE)
2981       FadeIn(REDRAW_FIELD);
2982   }
2983   else
2984   {
2985     if (DelayReached(&info_delay, GameFrameDelay))
2986       if (page < num_pages)
2987         DrawInfoScreen_HelpAnim(page * anims_per_page, num_anims, FALSE);
2988
2989     PlayMenuSoundIfLoop();
2990   }
2991 }
2992
2993 void DrawInfoScreen_Music(void)
2994 {
2995   SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_MUSIC);
2996
2997   FadeOut(REDRAW_FIELD);
2998
2999   ClearField();
3000   DrawHeadline();
3001
3002   LoadMusicInfo();
3003
3004   HandleInfoScreen_Music(MB_MENU_INITIALIZE);
3005
3006   FadeIn(REDRAW_FIELD);
3007 }
3008
3009 void HandleInfoScreen_Music(int button)
3010 {
3011   static struct MusicFileInfo *list = NULL;
3012   int font_title = MENU_INFO_FONT_TITLE;
3013   int font_head  = MENU_INFO_FONT_HEAD;
3014   int font_text  = MENU_INFO_FONT_TEXT;
3015   int font_foot  = MENU_INFO_FONT_FOOT;
3016   int spacing_title = menu.headline1_spacing_info[info_mode];
3017   int spacing_head  = menu.headline2_spacing_info[info_mode];
3018   int ystep_title = getMenuTextStep(spacing_title, font_title);
3019   int ystep_head  = getMenuTextStep(spacing_head,  font_head);
3020   int ystart  = mSY - SY + MENU_SCREEN_INFO_YSTART1;
3021   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
3022
3023   if (button == MB_MENU_INITIALIZE)
3024   {
3025     list = music_file_info;
3026
3027     if (list == NULL)
3028     {
3029       FadeMenuSoundsAndMusic();
3030
3031       ClearField();
3032       DrawHeadline();
3033
3034       DrawTextSCentered(ystart, font_title,
3035                         "No music info for this level set.");
3036
3037       DrawTextSCentered(ybottom, font_foot,
3038                         "Press any key or button for info menu");
3039
3040       return;
3041     }
3042   }
3043
3044   if (button == MB_MENU_LEAVE)
3045   {
3046     PlaySound(SND_MENU_ITEM_SELECTING);
3047
3048     FadeMenuSoundsAndMusic();
3049
3050     info_mode = INFO_MODE_MAIN;
3051     DrawInfoScreen();
3052
3053     return;
3054   }
3055   else if (button == MB_MENU_CHOICE || button == MB_MENU_INITIALIZE)
3056   {
3057     if (button != MB_MENU_INITIALIZE)
3058     {
3059       PlaySound(SND_MENU_ITEM_SELECTING);
3060
3061       if (list != NULL)
3062         list = list->next;
3063     }
3064
3065     if (list == NULL)
3066     {
3067       FadeMenuSoundsAndMusic();
3068
3069       info_mode = INFO_MODE_MAIN;
3070       DrawInfoScreen();
3071
3072       return;
3073     }
3074
3075     FadeMenuSoundsAndMusic();
3076
3077     if (list != music_file_info)
3078       FadeSetNextScreen();
3079
3080     if (button != MB_MENU_INITIALIZE)
3081       FadeOut(REDRAW_FIELD);
3082
3083     ClearField();
3084     DrawHeadline();
3085
3086     if (list->is_sound)
3087     {
3088       int sound = list->music;
3089
3090       if (sound_info[sound].loop)
3091         PlaySoundLoop(sound);
3092       else
3093         PlaySound(sound);
3094
3095       DrawTextSCentered(ystart, font_title, "The Game Background Sounds:");
3096     }
3097     else
3098     {
3099       int music = list->music;
3100
3101       if (music_info[music].loop)
3102         PlayMusicLoop(music);
3103       else
3104         PlayMusic(music);
3105
3106       DrawTextSCentered(ystart, font_title, "The Game Background Music:");
3107     }
3108
3109     ystart += ystep_title;
3110
3111     if (!strEqual(list->title, UNKNOWN_NAME))
3112     {
3113       if (!strEqual(list->title_header, UNKNOWN_NAME))
3114       {
3115         DrawTextSCentered(ystart, font_head, list->title_header);
3116         ystart += ystep_head;
3117       }
3118
3119       DrawTextFCentered(ystart, font_text, "\"%s\"", list->title);
3120       ystart += ystep_head;
3121     }
3122
3123     if (!strEqual(list->artist, UNKNOWN_NAME))
3124     {
3125       if (!strEqual(list->artist_header, UNKNOWN_NAME))
3126         DrawTextSCentered(ystart, font_head, list->artist_header);
3127       else
3128         DrawTextSCentered(ystart, font_head, "by");
3129
3130       ystart += ystep_head;
3131
3132       DrawTextFCentered(ystart, font_text, "%s", list->artist);
3133       ystart += ystep_head;
3134     }
3135
3136     if (!strEqual(list->album, UNKNOWN_NAME))
3137     {
3138       if (!strEqual(list->album_header, UNKNOWN_NAME))
3139         DrawTextSCentered(ystart, font_head, list->album_header);
3140       else
3141         DrawTextSCentered(ystart, font_head, "from the album");
3142
3143       ystart += ystep_head;
3144
3145       DrawTextFCentered(ystart, font_text, "\"%s\"", list->album);
3146       ystart += ystep_head;
3147     }
3148
3149     if (!strEqual(list->year, UNKNOWN_NAME))
3150     {
3151       if (!strEqual(list->year_header, UNKNOWN_NAME))
3152         DrawTextSCentered(ystart, font_head, list->year_header);
3153       else
3154         DrawTextSCentered(ystart, font_head, "from the year");
3155
3156       ystart += ystep_head;
3157
3158       DrawTextFCentered(ystart, font_text, "%s", list->year);
3159       ystart += ystep_head;
3160     }
3161
3162     DrawTextSCentered(ybottom, FONT_TEXT_4,
3163                       "Press any key or button for next page");
3164
3165     if (button != MB_MENU_INITIALIZE)
3166       FadeIn(REDRAW_FIELD);
3167   }
3168
3169   if (list != NULL && list->is_sound && sound_info[list->music].loop)
3170     PlaySoundLoop(list->music);
3171 }
3172
3173 static void DrawInfoScreen_CreditsScreen(int screen_nr)
3174 {
3175   int font_title = MENU_INFO_FONT_TITLE;
3176   int font_head  = MENU_INFO_FONT_HEAD;
3177   int font_text  = MENU_INFO_FONT_TEXT;
3178   int font_foot  = MENU_INFO_FONT_FOOT;
3179   int spacing_title = menu.headline1_spacing_info[info_mode];
3180   int spacing_head  = menu.headline2_spacing_info[info_mode];
3181   int spacing_para  = menu.paragraph_spacing_info[info_mode];
3182   int spacing_line  = menu.line_spacing_info[info_mode];
3183   int ystep_title = getMenuTextStep(spacing_title, font_title);
3184   int ystep_head  = getMenuTextStep(spacing_head,  font_head);
3185   int ystep_para  = getMenuTextStep(spacing_para,  font_text);
3186   int ystep_line  = getMenuTextStep(spacing_line,  font_text);
3187   int ystart  = mSY - SY + MENU_SCREEN_INFO_YSTART1;
3188   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
3189
3190   ClearField();
3191   DrawHeadline();
3192
3193   DrawTextSCentered(ystart, font_title, "Credits:");
3194   ystart += ystep_title;
3195
3196   if (screen_nr == 0)
3197   {
3198     DrawTextSCentered(ystart, font_head,
3199                       "Special thanks to");
3200     ystart += ystep_head;
3201     DrawTextSCentered(ystart, font_text,
3202                       "Peter Liepa");
3203     ystart += ystep_head;
3204     DrawTextSCentered(ystart, font_head,
3205                       "for creating");
3206     ystart += ystep_head;
3207     DrawTextSCentered(ystart, font_text,
3208                       "\"Boulder Dash\"");
3209     ystart += ystep_head;
3210     DrawTextSCentered(ystart, font_head,
3211                       "in the year");
3212     ystart += ystep_head;
3213     DrawTextSCentered(ystart, font_text,
3214                       "1984");
3215     ystart += ystep_head;
3216     DrawTextSCentered(ystart, font_head,
3217                       "published by");
3218     ystart += ystep_head;
3219     DrawTextSCentered(ystart, font_text,
3220                       "First Star Software");
3221   }
3222   else if (screen_nr == 1)
3223   {
3224     DrawTextSCentered(ystart, font_head,
3225                       "Special thanks to");
3226     ystart += ystep_head;
3227     DrawTextSCentered(ystart, font_text,
3228                       "Klaus Heinz & Volker Wertich");
3229     ystart += ystep_head;
3230     DrawTextSCentered(ystart, font_head,
3231                       "for creating");
3232     ystart += ystep_head;
3233     DrawTextSCentered(ystart, font_text,
3234                       "\"Emerald Mine\"");
3235     ystart += ystep_head;
3236     DrawTextSCentered(ystart, font_head,
3237                       "in the year");
3238     ystart += ystep_head;
3239     DrawTextSCentered(ystart, font_text,
3240                       "1987");
3241     ystart += ystep_head;
3242     DrawTextSCentered(ystart, font_head,
3243                       "published by");
3244     ystart += ystep_head;
3245     DrawTextSCentered(ystart, font_text,
3246                       "Kingsoft");
3247   }
3248   else if (screen_nr == 2)
3249   {
3250     DrawTextSCentered(ystart, font_head,
3251                       "Special thanks to");
3252     ystart += ystep_head;
3253     DrawTextSCentered(ystart, font_text,
3254                       "Michael Stopp & Philip Jespersen");
3255     ystart += ystep_head;
3256     DrawTextSCentered(ystart, font_head,
3257                       "for creating");
3258     ystart += ystep_head;
3259     DrawTextSCentered(ystart, font_text,
3260                       "\"Supaplex\"");
3261     ystart += ystep_head;
3262     DrawTextSCentered(ystart, font_head,
3263                       "in the year");
3264     ystart += ystep_head;
3265     DrawTextSCentered(ystart, font_text,
3266                       "1991");
3267     ystart += ystep_head;
3268     DrawTextSCentered(ystart, font_head,
3269                       "published by");
3270     ystart += ystep_head;
3271     DrawTextSCentered(ystart, font_text,
3272                       "Digital Integration");
3273   }
3274   else if (screen_nr == 3)
3275   {
3276     DrawTextSCentered(ystart, font_head,
3277                       "Special thanks to");
3278     ystart += ystep_head;
3279     DrawTextSCentered(ystart, font_text,
3280                       "Hiroyuki Imabayashi");
3281     ystart += ystep_head;
3282     DrawTextSCentered(ystart, font_head,
3283                       "for creating");
3284     ystart += ystep_head;
3285     DrawTextSCentered(ystart, font_text,
3286                       "\"Sokoban\"");
3287     ystart += ystep_head;
3288     DrawTextSCentered(ystart, font_head,
3289                       "in the year");
3290     ystart += ystep_head;
3291     DrawTextSCentered(ystart, font_text,
3292                       "1982");
3293     ystart += ystep_head;
3294     DrawTextSCentered(ystart, font_head,
3295                       "published by");
3296     ystart += ystep_head;
3297     DrawTextSCentered(ystart, font_text,
3298                       "Thinking Rabbit");
3299   }
3300   else if (screen_nr == 4)
3301   {
3302     DrawTextSCentered(ystart, font_head,
3303                       "Special thanks to");
3304     ystart += ystep_head;
3305     DrawTextSCentered(ystart, font_text,
3306                       "Alan Bond");
3307     ystart += ystep_head;
3308     DrawTextSCentered(ystart, font_head,
3309                       "and");
3310     ystart += ystep_head;
3311     DrawTextSCentered(ystart, font_text,
3312                       "J\xfcrgen Bonhagen");
3313     ystart += ystep_head;
3314     DrawTextSCentered(ystart, font_head,
3315                       "for the continuous creation");
3316     ystart += ystep_line;
3317     DrawTextSCentered(ystart, font_head,
3318                       "of outstanding level sets");
3319   }
3320   else if (screen_nr == 5)
3321   {
3322     DrawTextSCentered(ystart, font_head,
3323                       "Thanks to");
3324     ystart += ystep_head;
3325     DrawTextSCentered(ystart, font_text,
3326                       "Peter Elzner");
3327     ystart += ystep_head;
3328     DrawTextSCentered(ystart, font_head,
3329                       "for ideas and inspiration by");
3330     ystart += ystep_head;
3331     DrawTextSCentered(ystart, font_text,
3332                       "Diamond Caves");
3333     ystart += ystep_para;
3334
3335     DrawTextSCentered(ystart, font_head,
3336                       "Thanks to");
3337     ystart += ystep_head;
3338     DrawTextSCentered(ystart, font_text,
3339                       "Steffest");
3340     ystart += ystep_head;
3341     DrawTextSCentered(ystart, font_head,
3342                       "for ideas and inspiration by");
3343     ystart += ystep_head;
3344     DrawTextSCentered(ystart, font_text,
3345                       "DX-Boulderdash");
3346   }
3347   else if (screen_nr == 6)
3348   {
3349     DrawTextSCentered(ystart, font_head,
3350                       "Thanks to");
3351     ystart += ystep_head;
3352     DrawTextSCentered(ystart, font_text,
3353                       "David Tritscher");
3354     ystart += ystep_head;
3355     DrawTextSCentered(ystart, font_head,
3356                       "for the code base used for the");
3357     ystart += ystep_line;
3358     DrawTextSCentered(ystart, font_head,
3359                       "native Emerald Mine engine");
3360   }
3361   else if (screen_nr == 7)
3362   {
3363     DrawTextSCentered(ystart, font_head,
3364                       "Thanks to");
3365     ystart += ystep_head;
3366     DrawTextSCentered(ystart, font_text,
3367                       "Guido Schulz");
3368     ystart += ystep_head;
3369     DrawTextSCentered(ystart, font_head,
3370                       "for the initial DOS port");
3371     ystart += ystep_para;
3372
3373     DrawTextSCentered(ystart, font_head,
3374                       "Thanks to");
3375     ystart += ystep_head;
3376     DrawTextSCentered(ystart, font_text,
3377                       "Karl H\xf6rnell");
3378     ystart += ystep_head;
3379     DrawTextSCentered(ystart, font_head,
3380                       "for some additional toons");
3381   }
3382   else if (screen_nr == 8)
3383   {
3384     DrawTextSCentered(ystart, font_head,
3385                       "And not to forget:");
3386     ystart += ystep_head;
3387     DrawTextSCentered(ystart, font_head,
3388                       "Many thanks to");
3389     ystart += ystep_head;
3390     DrawTextSCentered(ystart, font_text,
3391                       "All those who contributed");
3392     ystart += ystep_line;
3393     DrawTextSCentered(ystart, font_text,
3394                       "levels to this game");
3395     ystart += ystep_line;
3396     DrawTextSCentered(ystart, font_text,
3397                       "since 1995");
3398   }
3399
3400   DrawTextSCentered(ybottom, font_foot,
3401                     "Press any key or button for next page");
3402 }
3403
3404 void DrawInfoScreen_Credits(void)
3405 {
3406   SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_CREDITS);
3407
3408   FadeMenuSoundsAndMusic();
3409
3410   FadeOut(REDRAW_FIELD);
3411
3412   HandleInfoScreen_Credits(MB_MENU_INITIALIZE);
3413
3414   FadeIn(REDRAW_FIELD);
3415 }
3416
3417 void HandleInfoScreen_Credits(int button)
3418 {
3419   static int screen_nr = 0;
3420   int num_screens = 9;
3421
3422   if (button == MB_MENU_INITIALIZE)
3423   {
3424     screen_nr = 0;
3425
3426     // DrawInfoScreen_CreditsScreen(screen_nr);
3427   }
3428
3429   if (button == MB_MENU_LEAVE)
3430   {
3431     PlaySound(SND_MENU_ITEM_SELECTING);
3432
3433     info_mode = INFO_MODE_MAIN;
3434     DrawInfoScreen();
3435
3436     return;
3437   }
3438   else if (button == MB_MENU_CHOICE || button == MB_MENU_INITIALIZE)
3439   {
3440     if (button != MB_MENU_INITIALIZE)
3441     {
3442       PlaySound(SND_MENU_ITEM_SELECTING);
3443
3444       screen_nr++;
3445     }
3446
3447     if (screen_nr >= num_screens)
3448     {
3449       FadeMenuSoundsAndMusic();
3450
3451       info_mode = INFO_MODE_MAIN;
3452       DrawInfoScreen();
3453
3454       return;
3455     }
3456
3457     if (screen_nr > 0)
3458       FadeSetNextScreen();
3459
3460     if (button != MB_MENU_INITIALIZE)
3461       FadeOut(REDRAW_FIELD);
3462
3463     DrawInfoScreen_CreditsScreen(screen_nr);
3464
3465     if (button != MB_MENU_INITIALIZE)
3466       FadeIn(REDRAW_FIELD);
3467   }
3468   else
3469   {
3470     PlayMenuSoundIfLoop();
3471   }
3472 }
3473
3474 void DrawInfoScreen_Program(void)
3475 {
3476   int font_title = MENU_INFO_FONT_TITLE;
3477   int font_head  = MENU_INFO_FONT_HEAD;
3478   int font_text  = MENU_INFO_FONT_TEXT;
3479   int font_foot  = MENU_INFO_FONT_FOOT;
3480   int spacing_title = menu.headline1_spacing_info[info_mode];
3481   int spacing_head  = menu.headline2_spacing_info[info_mode];
3482   int spacing_para  = menu.paragraph_spacing_info[info_mode];
3483   int spacing_line  = menu.line_spacing_info[info_mode];
3484   int ystep_title = getMenuTextStep(spacing_title, font_title);
3485   int ystep_head  = getMenuTextStep(spacing_head,  font_head);
3486   int ystep_para  = getMenuTextStep(spacing_para,  font_text);
3487   int ystep_line  = getMenuTextStep(spacing_line,  font_text);
3488   int ystart  = mSY - SY + MENU_SCREEN_INFO_YSTART1;
3489   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
3490
3491   SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_PROGRAM);
3492
3493   FadeOut(REDRAW_FIELD);
3494
3495   ClearField();
3496   DrawHeadline();
3497
3498   DrawTextSCentered(ystart, font_title, "Program Information:");
3499   ystart += ystep_title;
3500
3501   DrawTextSCentered(ystart, font_head,
3502                     "This game is Freeware!");
3503   ystart += ystep_head;
3504   DrawTextSCentered(ystart, font_head,
3505                     "If you like it, send e-mail to:");
3506   ystart += ystep_head;
3507   DrawTextSCentered(ystart, font_text,
3508                     setup.internal.program_email);
3509   ystart += ystep_para;
3510
3511   DrawTextSCentered(ystart, font_head,
3512                     "More information and levels:");
3513   ystart += ystep_head;
3514   DrawTextSCentered(ystart, font_text,
3515                     setup.internal.program_website);
3516   ystart += ystep_para;
3517
3518   DrawTextSCentered(ystart, font_head,
3519                     "If you have created new levels,");
3520   ystart += ystep_line;
3521   DrawTextSCentered(ystart, font_head,
3522                     "send them to me to include them!");
3523   ystart += ystep_head;
3524   DrawTextSCentered(ystart, font_head,
3525                     ":-)");
3526
3527   DrawTextSCentered(ybottom, font_foot,
3528                     "Press any key or button for info menu");
3529
3530   FadeIn(REDRAW_FIELD);
3531 }
3532
3533 void HandleInfoScreen_Program(int button)
3534 {
3535   if (button == MB_MENU_LEAVE)
3536   {
3537     PlaySound(SND_MENU_ITEM_SELECTING);
3538
3539     info_mode = INFO_MODE_MAIN;
3540     DrawInfoScreen();
3541
3542     return;
3543   }
3544   else if (button == MB_MENU_CHOICE)
3545   {
3546     PlaySound(SND_MENU_ITEM_SELECTING);
3547
3548     FadeMenuSoundsAndMusic();
3549
3550     info_mode = INFO_MODE_MAIN;
3551     DrawInfoScreen();
3552   }
3553   else
3554   {
3555     PlayMenuSoundIfLoop();
3556   }
3557 }
3558
3559 void DrawInfoScreen_Version(void)
3560 {
3561   int font_title = MENU_INFO_FONT_TITLE;
3562   int font_head  = MENU_INFO_FONT_HEAD;
3563   int font_text  = MENU_INFO_FONT_TEXT;
3564   int font_foot  = MENU_INFO_FONT_FOOT;
3565   int spacing_title = menu.headline1_spacing_info[info_mode];
3566   int spacing_head  = menu.headline2_spacing_info[info_mode];
3567   int spacing_para  = menu.paragraph_spacing_info[info_mode];
3568   int spacing_line  = menu.line_spacing_info[info_mode];
3569   int xstep = getFontWidth(font_text);
3570   int ystep_title = getMenuTextStep(spacing_title, font_title);
3571   int ystep_head  = getMenuTextStep(spacing_head,  font_head);
3572   int ystep_para  = getMenuTextStep(spacing_para,  font_text);
3573   int ystep_line  = getMenuTextStep(spacing_line,  font_text);
3574   int ystart  = mSY - SY + MENU_SCREEN_INFO_YSTART1;
3575   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
3576   int xstart1 = mSX - SX + 2 * xstep;
3577   int xstart2 = mSX - SX + 18 * xstep;
3578   int xstart3 = mSX - SX + 28 * xstep;
3579   SDL_version sdl_version_compiled;
3580   const SDL_version *sdl_version_linked;
3581   int driver_name_len = 10;
3582 #if defined(TARGET_SDL2)
3583   SDL_version sdl_version_linked_ext;
3584   const char *driver_name = NULL;
3585 #else
3586   char driver_name[driver_name_len];
3587 #endif
3588
3589   SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_VERSION);
3590
3591   FadeOut(REDRAW_FIELD);
3592
3593   ClearField();
3594   DrawHeadline();
3595
3596   DrawTextSCentered(ystart, font_title, "Version Information:");
3597   ystart += ystep_title;
3598
3599   DrawTextF(xstart1, ystart, font_head, "Name");
3600   DrawTextF(xstart2, ystart, font_text, getProgramTitleString());
3601   ystart += ystep_line;
3602
3603   if (!strEqual(getProgramVersionString(), getProgramRealVersionString()))
3604   {
3605     DrawTextF(xstart1, ystart, font_head, "Version (fake)");
3606     DrawTextF(xstart2, ystart, font_text, getProgramVersionString());
3607     ystart += ystep_line;
3608
3609     DrawTextF(xstart1, ystart, font_head, "Version (real)");
3610     DrawTextF(xstart2, ystart, font_text, getProgramRealVersionString());
3611     ystart += ystep_line;
3612   }
3613   else
3614   {
3615     DrawTextF(xstart1, ystart, font_head, "Version");
3616     DrawTextF(xstart2, ystart, font_text, getProgramVersionString());
3617     ystart += ystep_line;
3618   }
3619
3620   DrawTextF(xstart1, ystart, font_head, "Platform");
3621   DrawTextF(xstart2, ystart, font_text, PLATFORM_STRING);
3622   ystart += ystep_line;
3623
3624   DrawTextF(xstart1, ystart, font_head, "Target");
3625   DrawTextF(xstart2, ystart, font_text, TARGET_STRING);
3626   ystart += ystep_line;
3627
3628   DrawTextF(xstart1, ystart, font_head, "Source date");
3629   DrawTextF(xstart2, ystart, font_text, getSourceDateString());
3630   ystart += ystep_para;
3631
3632   DrawTextF(xstart1, ystart, font_head, "Library");
3633   DrawTextF(xstart2, ystart, font_head, "compiled");
3634   DrawTextF(xstart3, ystart, font_head, "linked");
3635   ystart += ystep_head;
3636
3637   SDL_VERSION(&sdl_version_compiled);
3638 #if defined(TARGET_SDL2)
3639   SDL_GetVersion(&sdl_version_linked_ext);
3640   sdl_version_linked = &sdl_version_linked_ext;
3641 #else
3642   sdl_version_linked = SDL_Linked_Version();
3643 #endif
3644
3645   DrawTextF(xstart1, ystart, font_text, "SDL");
3646   DrawTextF(xstart2, ystart, font_text, "%d.%d.%d",
3647             sdl_version_compiled.major,
3648             sdl_version_compiled.minor,
3649             sdl_version_compiled.patch);
3650   DrawTextF(xstart3, ystart, font_text, "%d.%d.%d",
3651             sdl_version_linked->major,
3652             sdl_version_linked->minor,
3653             sdl_version_linked->patch);
3654   ystart += ystep_line;
3655
3656   SDL_IMAGE_VERSION(&sdl_version_compiled);
3657   sdl_version_linked = IMG_Linked_Version();
3658
3659   DrawTextF(xstart1, ystart, font_text, "SDL_image");
3660   DrawTextF(xstart2, ystart, font_text, "%d.%d.%d",
3661             sdl_version_compiled.major,
3662             sdl_version_compiled.minor,
3663             sdl_version_compiled.patch);
3664   DrawTextF(xstart3, ystart, font_text, "%d.%d.%d",
3665             sdl_version_linked->major,
3666             sdl_version_linked->minor,
3667             sdl_version_linked->patch);
3668   ystart += ystep_line;
3669
3670   SDL_MIXER_VERSION(&sdl_version_compiled);
3671   sdl_version_linked = Mix_Linked_Version();
3672
3673   DrawTextF(xstart1, ystart, font_text, "SDL_mixer");
3674   DrawTextF(xstart2, ystart, font_text, "%d.%d.%d",
3675             sdl_version_compiled.major,
3676             sdl_version_compiled.minor,
3677             sdl_version_compiled.patch);
3678   DrawTextF(xstart3, ystart, font_text, "%d.%d.%d",
3679             sdl_version_linked->major,
3680             sdl_version_linked->minor,
3681             sdl_version_linked->patch);
3682   ystart += ystep_line;
3683
3684   SDL_NET_VERSION(&sdl_version_compiled);
3685   sdl_version_linked = SDLNet_Linked_Version();
3686
3687   DrawTextF(xstart1, ystart, font_text, "SDL_net");
3688   DrawTextF(xstart2, ystart, font_text, "%d.%d.%d",
3689             sdl_version_compiled.major,
3690             sdl_version_compiled.minor,
3691             sdl_version_compiled.patch);
3692   DrawTextF(xstart3, ystart, font_text, "%d.%d.%d",
3693             sdl_version_linked->major,
3694             sdl_version_linked->minor,
3695             sdl_version_linked->patch);
3696   ystart += ystep_para;
3697
3698   DrawTextF(xstart1, ystart, font_head, "Driver");
3699   DrawTextF(xstart2, ystart, font_head, "Requested");
3700   DrawTextF(xstart3, ystart, font_head, "Used");
3701   ystart += ystep_head;
3702
3703 #if defined(TARGET_SDL2)
3704   driver_name = getStringCopyNStatic(SDL_GetVideoDriver(0), driver_name_len);
3705 #else
3706   SDL_VideoDriverName(driver_name, driver_name_len);
3707 #endif
3708
3709   DrawTextF(xstart1, ystart, font_text, "SDL_VideoDriver");
3710   DrawTextF(xstart2, ystart, font_text, "%s", setup.system.sdl_videodriver);
3711   DrawTextF(xstart3, ystart, font_text, "%s", driver_name);
3712   ystart += ystep_line;
3713
3714 #if defined(TARGET_SDL2)
3715   driver_name = getStringCopyNStatic(SDL_GetAudioDriver(0), driver_name_len);
3716 #else
3717   SDL_AudioDriverName(driver_name, driver_name_len);
3718 #endif
3719
3720   DrawTextF(xstart1, ystart, font_text, "SDL_AudioDriver");
3721   DrawTextF(xstart2, ystart, font_text, "%s", setup.system.sdl_audiodriver);
3722   DrawTextF(xstart3, ystart, font_text, "%s", driver_name);
3723
3724   DrawTextSCentered(ybottom, font_foot,
3725                     "Press any key or button for info menu");
3726
3727   FadeIn(REDRAW_FIELD);
3728 }
3729
3730 void HandleInfoScreen_Version(int button)
3731 {
3732   if (button == MB_MENU_LEAVE)
3733   {
3734     PlaySound(SND_MENU_ITEM_SELECTING);
3735
3736     info_mode = INFO_MODE_MAIN;
3737     DrawInfoScreen();
3738
3739     return;
3740   }
3741   else if (button == MB_MENU_CHOICE)
3742   {
3743     PlaySound(SND_MENU_ITEM_SELECTING);
3744
3745     FadeMenuSoundsAndMusic();
3746
3747     info_mode = INFO_MODE_MAIN;
3748     DrawInfoScreen();
3749   }
3750   else
3751   {
3752     PlayMenuSoundIfLoop();
3753   }
3754 }
3755
3756 void DrawInfoScreen_LevelSet(void)
3757 {
3758   struct TitleMessageInfo *tmi = &readme;
3759   char *filename = getLevelSetInfoFilename();
3760   char *title = "Level Set Information:";
3761   int ystart  = mSY - SY + MENU_SCREEN_INFO_YSTART1;
3762   int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
3763
3764   if (filename == NULL)