+void DrawInfoScreen_HelpAnim(int start, int max_anims, boolean init)
+{
+ static int infoscreen_step[MAX_INFO_ELEMENTS_ON_SCREEN];
+ static int infoscreen_frame[MAX_INFO_ELEMENTS_ON_SCREEN];
+ int xstart = mSX + MENU_SCREEN_INFO_XSTART;
+ int ystart1 = mSY - SY + MENU_SCREEN_INFO_YSTART1;
+ int ystart2 = mSY + MENU_SCREEN_INFO_YSTART2;
+ int ybottom = mSY - SY + MENU_SCREEN_INFO_YBOTTOM;
+ int ystep = MENU_SCREEN_INFO_YSTEP;
+ int element, action, direction;
+ int graphic;
+ int delay;
+ int sync_frame;
+ int i, j;
+
+ if (init)
+ {
+ for (i = 0; i < NUM_INFO_ELEMENTS_ON_SCREEN; i++)
+ infoscreen_step[i] = infoscreen_frame[i] = 0;
+
+ ClearField();
+ DrawHeadline();
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, "The Game Elements:");
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for next page");
+
+ FrameCounter = 0;
+ }
+
+ i = j = 0;
+ while (helpanim_info[j].element != HELPANIM_LIST_END)
+ {
+ if (i >= start + NUM_INFO_ELEMENTS_ON_SCREEN ||
+ i >= max_anims)
+ break;
+ else if (i < start)
+ {
+ while (helpanim_info[j].element != HELPANIM_LIST_NEXT)
+ j++;
+
+ j++;
+ i++;
+
+ continue;
+ }
+
+ j += infoscreen_step[i - start];
+
+ element = helpanim_info[j].element;
+ action = helpanim_info[j].action;
+ direction = helpanim_info[j].direction;
+
+ if (element < 0)
+ element = EL_UNKNOWN;
+
+ if (action != -1 && direction != -1)
+ graphic = el_act_dir2img(element, action, direction);
+ else if (action != -1)
+ graphic = el_act2img(element, action);
+ else if (direction != -1)
+ graphic = el_dir2img(element, direction);
+ else
+ graphic = el2img(element);
+
+ delay = helpanim_info[j++].delay;
+
+ if (delay == -1)
+ delay = 1000000;
+
+ if (infoscreen_frame[i - start] == 0)
+ {
+ sync_frame = 0;
+ infoscreen_frame[i - start] = delay - 1;
+ }
+ else
+ {
+ sync_frame = delay - infoscreen_frame[i - start];
+ infoscreen_frame[i - start]--;
+ }
+
+ if (helpanim_info[j].element == HELPANIM_LIST_NEXT)
+ {
+ if (!infoscreen_frame[i - start])
+ infoscreen_step[i - start] = 0;
+ }
+ else
+ {
+ if (!infoscreen_frame[i - start])
+ infoscreen_step[i - start]++;
+ while (helpanim_info[j].element != HELPANIM_LIST_NEXT)
+ j++;
+ }
+
+ j++;
+
+ ClearRectangleOnBackground(drawto, xstart, ystart2 + (i - start) * ystep,
+ TILEX, TILEY);
+ DrawFixedGraphicAnimationExt(drawto, xstart, ystart2 + (i - start) * ystep,
+ graphic, sync_frame, USE_MASKING);
+
+ if (init)
+ DrawInfoScreen_HelpText(element, action, direction, i - start);
+
+ i++;
+ }
+
+ redraw_mask |= REDRAW_FIELD;
+
+ FrameCounter++;
+}
+
+static char *getHelpText(int element, int action, int direction)
+{
+ char token[MAX_LINE_LEN];
+
+ strcpy(token, element_info[element].token_name);
+
+ if (action != -1)
+ strcat(token, element_action_info[action].suffix);
+
+ if (direction != -1)
+ strcat(token, element_direction_info[MV_DIR_TO_BIT(direction)].suffix);
+
+ return getHashEntry(helptext_info, token);
+}
+
+void DrawInfoScreen_HelpText(int element, int action, int direction, int ypos)
+{
+ int font_nr = FONT_INFO_ELEMENTS;
+ int font_width = getFontWidth(font_nr);
+ int sx = mSX + MINI_TILEX + TILEX + MINI_TILEX;
+ int sy = mSY + 65 + 2 * 32 + 1;
+ int ystep = TILEY + 4;
+ int pad_x = sx - SX;
+ int max_chars_per_line = (SXSIZE - pad_x - MINI_TILEX) / font_width;
+ int max_lines_per_text = 2;
+ char *text = NULL;
+
+ if (action != -1 && direction != -1) /* element.action.direction */
+ text = getHelpText(element, action, direction);
+
+ if (text == NULL && action != -1) /* element.action */
+ text = getHelpText(element, action, -1);
+
+ if (text == NULL && direction != -1) /* element.direction */
+ text = getHelpText(element, -1, direction);
+
+ if (text == NULL) /* base element */
+ text = getHelpText(element, -1, -1);
+
+ if (text == NULL) /* not found */
+ text = "No description available";
+
+ if (strlen(text) <= max_chars_per_line) /* only one line of text */
+ sy += getFontHeight(font_nr) / 2;
+
+ DrawTextBuffer(sx, sy + ypos * ystep, text, font_nr,
+ max_chars_per_line, -1, max_lines_per_text, 0, -1,
+ TRUE, FALSE, FALSE);
+}
+
+void DrawInfoScreen_TitleScreen()
+{
+ game_status_last_screen = GAME_MODE_INFO;
+
+ SetGameStatus(GAME_MODE_TITLE);
+
+ DrawTitleScreen();
+}
+
+void HandleInfoScreen_TitleScreen(int button)
+{
+ HandleTitleScreen(0, 0, 0, 0, button);
+}
+
+void DrawInfoScreen_Elements()
+{
+ SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_ELEMENTS);
+
+ FadeOut(REDRAW_FIELD);
+
+ LoadHelpAnimInfo();
+ LoadHelpTextInfo();
+
+ HandleInfoScreen_Elements(MB_MENU_INITIALIZE);
+
+ FadeIn(REDRAW_FIELD);
+
+ InitAnimation();
+}
+
+void HandleInfoScreen_Elements(int button)
+{
+ static unsigned int info_delay = 0;
+ static int num_anims;
+ static int num_pages;
+ static int page;
+ int anims_per_page = NUM_INFO_ELEMENTS_ON_SCREEN;
+ int i;
+
+ if (button == MB_MENU_INITIALIZE)
+ {
+ boolean new_element = TRUE;
+
+ num_anims = 0;
+
+ for (i = 0; helpanim_info[i].element != HELPANIM_LIST_END; i++)
+ {
+ if (helpanim_info[i].element == HELPANIM_LIST_NEXT)
+ new_element = TRUE;
+ else if (new_element)
+ {
+ num_anims++;
+ new_element = FALSE;
+ }
+ }
+
+ num_pages = (num_anims + anims_per_page - 1) / anims_per_page;
+ page = 0;
+ }
+
+ if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+ else if (button == MB_MENU_CHOICE || button == MB_MENU_INITIALIZE)
+ {
+ if (button != MB_MENU_INITIALIZE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ page++;
+ }
+
+ if (page >= num_pages)
+ {
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+
+ if (page > 0)
+ FadeSetNextScreen();
+
+ if (button != MB_MENU_INITIALIZE)
+ FadeOut(REDRAW_FIELD);
+
+ DrawInfoScreen_HelpAnim(page * anims_per_page, num_anims, TRUE);
+
+ if (button != MB_MENU_INITIALIZE)
+ FadeIn(REDRAW_FIELD);
+ }
+ else
+ {
+ if (DelayReached(&info_delay, GameFrameDelay))
+ if (page < num_pages)
+ DrawInfoScreen_HelpAnim(page * anims_per_page, num_anims, FALSE);
+
+ PlayMenuSoundIfLoop();
+ }
+}
+
+void DrawInfoScreen_Music()
+{
+ SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_MUSIC);
+
+ FadeOut(REDRAW_FIELD);
+
+ ClearField();
+ DrawHeadline();
+
+ LoadMusicInfo();
+
+ HandleInfoScreen_Music(MB_MENU_INITIALIZE);
+
+ FadeIn(REDRAW_FIELD);
+}
+
+void HandleInfoScreen_Music(int button)
+{
+ static struct MusicFileInfo *list = NULL;
+ int ystart1 = mSY - SY + 100;
+ int ystart2 = mSY - SY + 150;
+ int ybottom = mSY - SY + SYSIZE - 20;
+ int dy = 30;
+
+ if (button == MB_MENU_INITIALIZE)
+ {
+ list = music_file_info;
+
+ if (list == NULL)
+ {
+ FadeSoundsAndMusic();
+
+ ClearField();
+ DrawHeadline();
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1,
+ "No music info for this level set.");
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for info menu");
+
+ return;
+ }
+ }
+
+ if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+ else if (button == MB_MENU_CHOICE || button == MB_MENU_INITIALIZE)
+ {
+ int y = 0;
+
+ if (button != MB_MENU_INITIALIZE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ if (list != NULL)
+ list = list->next;
+ }
+
+ if (list == NULL)
+ {
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+
+ FadeSoundsAndMusic();
+
+ if (list != music_file_info)
+ FadeSetNextScreen();
+
+ if (button != MB_MENU_INITIALIZE)
+ FadeOut(REDRAW_FIELD);
+
+ ClearField();
+ DrawHeadline();
+
+ if (list->is_sound)
+ {
+ int sound = list->music;
+
+ if (sound_info[sound].loop)
+ PlaySoundLoop(sound);
+ else
+ PlaySound(sound);
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, "The Game Background Sounds:");
+ }
+ else
+ {
+ PlayMusic(list->music);
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, "The Game Background Music:");
+ }
+
+ if (!strEqual(list->title, UNKNOWN_NAME))
+ {
+ if (!strEqual(list->title_header, UNKNOWN_NAME))
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, list->title_header);
+
+ DrawTextFCentered(ystart2 + y++ * dy, FONT_TEXT_3, "\"%s\"", list->title);
+ }
+
+ if (!strEqual(list->artist, UNKNOWN_NAME))
+ {
+ if (!strEqual(list->artist_header, UNKNOWN_NAME))
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, list->artist_header);
+ else
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, "by");
+
+ DrawTextFCentered(ystart2 + y++ * dy, FONT_TEXT_3, "%s", list->artist);
+ }
+
+ if (!strEqual(list->album, UNKNOWN_NAME))
+ {
+ if (!strEqual(list->album_header, UNKNOWN_NAME))
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, list->album_header);
+ else
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, "from the album");
+
+ DrawTextFCentered(ystart2 + y++ * dy, FONT_TEXT_3, "\"%s\"", list->album);
+ }
+
+ if (!strEqual(list->year, UNKNOWN_NAME))
+ {
+ if (!strEqual(list->year_header, UNKNOWN_NAME))
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, list->year_header);
+ else
+ DrawTextSCentered(ystart2 + y++ * dy, FONT_TEXT_2, "from the year");
+
+ DrawTextFCentered(ystart2 + y++ * dy, FONT_TEXT_3, "%s", list->year);
+ }
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for next page");
+
+ if (button != MB_MENU_INITIALIZE)
+ FadeIn(REDRAW_FIELD);
+ }
+
+ if (list != NULL && list->is_sound && sound_info[list->music].loop)
+ PlaySoundLoop(list->music);
+}
+
+static void DrawInfoScreen_CreditsScreen(int screen_nr)
+{
+ int ystart1 = mSY - SY + 100;
+ int ystart2 = mSY - SY + 150;
+ int ybottom = mSY - SY + SYSIZE - 20;
+ int ystep = 30;
+
+ ClearField();
+ DrawHeadline();
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, "Credits:");
+
+ if (screen_nr == 0)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Special thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Peter Liepa");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for creating");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "\"Boulder Dash\"");
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "in the year");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_3,
+ "1984");
+ DrawTextSCentered(ystart2 + 6 * ystep, FONT_TEXT_2,
+ "published by");
+ DrawTextSCentered(ystart2 + 7 * ystep, FONT_TEXT_3,
+ "First Star Software");
+ }
+ else if (screen_nr == 1)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Special thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Klaus Heinz & Volker Wertich");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for creating");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "\"Emerald Mine\"");
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "in the year");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_3,
+ "1987");
+ DrawTextSCentered(ystart2 + 6 * ystep, FONT_TEXT_2,
+ "published by");
+ DrawTextSCentered(ystart2 + 7 * ystep, FONT_TEXT_3,
+ "Kingsoft");
+ }
+ else if (screen_nr == 2)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Special thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Michael Stopp & Philip Jespersen");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for creating");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "\"Supaplex\"");
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "in the year");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_3,
+ "1991");
+ DrawTextSCentered(ystart2 + 6 * ystep, FONT_TEXT_2,
+ "published by");
+ DrawTextSCentered(ystart2 + 7 * ystep, FONT_TEXT_3,
+ "Digital Integration");
+ }
+ else if (screen_nr == 3)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Special thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Hiroyuki Imabayashi");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for creating");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "\"Sokoban\"");
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "in the year");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_3,
+ "1982");
+ DrawTextSCentered(ystart2 + 6 * ystep, FONT_TEXT_2,
+ "published by");
+ DrawTextSCentered(ystart2 + 7 * ystep, FONT_TEXT_3,
+ "Thinking Rabbit");
+ }
+ else if (screen_nr == 4)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Special thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Alan Bond");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "and");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "J\xfcrgen Bonhagen");
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "for the continuous creation");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_2,
+ "of outstanding level sets");
+ }
+ else if (screen_nr == 5)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Peter Elzner");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for ideas and inspiration by");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "Diamond Caves");
+
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_2,
+ "Thanks to");
+ DrawTextSCentered(ystart2 + 6 * ystep, FONT_TEXT_3,
+ "Steffest");
+ DrawTextSCentered(ystart2 + 7 * ystep, FONT_TEXT_2,
+ "for ideas and inspiration by");
+ DrawTextSCentered(ystart2 + 8 * ystep, FONT_TEXT_3,
+ "DX-Boulderdash");
+ }
+ else if (screen_nr == 6)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "David Tritscher");
+#if 1
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for the code base used for the");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_2,
+ "native Emerald Mine engine");
+#else
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for the new Emerald Mine engine");
+#endif
+ }
+ else if (screen_nr == 7)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "Thanks to");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_3,
+ "Guido Schulz");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_2,
+ "for the initial DOS port");
+
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "Thanks to");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_3,
+ "Karl H\xf6rnell");
+ DrawTextSCentered(ystart2 + 6 * ystep, FONT_TEXT_2,
+ "for some additional toons");
+ }
+ else if (screen_nr == 8)
+ {
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "And not to forget:");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_2,
+ "Many thanks to");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_3,
+ "All those who contributed");
+ DrawTextSCentered(ystart2 + 3 * ystep, FONT_TEXT_3,
+ "levels to this game");
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_3,
+ "since 1995");
+ }
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for next page");
+}
+
+void DrawInfoScreen_Credits()
+{
+ SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_CREDITS);
+
+ FadeSoundsAndMusic();
+
+ FadeOut(REDRAW_FIELD);
+
+ HandleInfoScreen_Credits(MB_MENU_INITIALIZE);
+
+ FadeIn(REDRAW_FIELD);
+}
+
+void HandleInfoScreen_Credits(int button)
+{
+ static int screen_nr = 0;
+ int num_screens = 9;
+
+ if (button == MB_MENU_INITIALIZE)
+ {
+ screen_nr = 0;
+
+ // DrawInfoScreen_CreditsScreen(screen_nr);
+ }
+
+ if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+ else if (button == MB_MENU_CHOICE || button == MB_MENU_INITIALIZE)
+ {
+ if (button != MB_MENU_INITIALIZE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ screen_nr++;
+ }
+
+ if (screen_nr >= num_screens)
+ {
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+
+ if (screen_nr > 0)
+ FadeSetNextScreen();
+
+ if (button != MB_MENU_INITIALIZE)
+ FadeOut(REDRAW_FIELD);
+
+ DrawInfoScreen_CreditsScreen(screen_nr);
+
+ if (button != MB_MENU_INITIALIZE)
+ FadeIn(REDRAW_FIELD);
+ }
+ else
+ {
+ PlayMenuSoundIfLoop();
+ }
+}
+
+void DrawInfoScreen_Program()
+{
+ int ystart1 = mSY - SY + 100;
+ int ystart2 = mSY - SY + 150;
+ int ybottom = mSY - SY + SYSIZE - 20;
+ int ystep = 30;
+
+ SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_PROGRAM);
+
+ FadeOut(REDRAW_FIELD);
+
+ ClearField();
+ DrawHeadline();
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, "Program Information:");
+
+ DrawTextSCentered(ystart2 + 0 * ystep, FONT_TEXT_2,
+ "This game is Freeware!");
+ DrawTextSCentered(ystart2 + 1 * ystep, FONT_TEXT_2,
+ "If you like it, send e-mail to:");
+ DrawTextSCentered(ystart2 + 2 * ystep, FONT_TEXT_3,
+ setup.internal.program_email);
+ DrawTextSCentered(ystart2 + 4 * ystep, FONT_TEXT_2,
+ "More information and levels:");
+ DrawTextSCentered(ystart2 + 5 * ystep, FONT_TEXT_3,
+ setup.internal.program_website);
+ DrawTextSCentered(ystart2 + 7 * ystep, FONT_TEXT_2,
+ "If you have created new levels,");
+ DrawTextSCentered(ystart2 + 8 * ystep, FONT_TEXT_2,
+ "send them to me to include them!");
+ DrawTextSCentered(ystart2 + 9 * ystep, FONT_TEXT_2,
+ ":-)");
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for info menu");
+
+ FadeIn(REDRAW_FIELD);
+}
+
+void HandleInfoScreen_Program(int button)
+{
+ if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+ else if (button == MB_MENU_CHOICE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+ }
+ else
+ {
+ PlayMenuSoundIfLoop();
+ }
+}
+
+void DrawInfoScreen_Version()
+{
+ int font_header = FONT_TEXT_3;
+ int font_text = FONT_TEXT_2;
+ int xstep = getFontWidth(font_text);
+ int ystep = getFontHeight(font_text);
+ int ystart1 = mSY - SY + 100;
+ int ystart2 = mSY - SY + 150;
+ int ybottom = mSY - SY + SYSIZE - 20;
+ int xstart1 = mSX - SX + 2 * xstep;
+ int xstart2 = mSX - SX + 18 * xstep;
+ int xstart3 = mSX - SX + 28 * xstep;
+ SDL_version sdl_version_compiled;
+ const SDL_version *sdl_version_linked;
+ int driver_name_len = 10;
+#if defined(TARGET_SDL2)
+ SDL_version sdl_version_linked_ext;
+ const char *driver_name = NULL;
+#else
+ char driver_name[driver_name_len];
+#endif
+
+ SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_VERSION);
+
+ FadeOut(REDRAW_FIELD);
+
+ ClearField();
+ DrawHeadline();
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, "Version Information:");
+
+ DrawTextF(xstart1, ystart2, font_header, "Name");
+ DrawTextF(xstart2, ystart2, font_text, getProgramTitleString());
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_header, "Version");
+ DrawTextF(xstart2, ystart2, font_text, getProgramVersionString());
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_header, "Platform");
+ DrawTextF(xstart2, ystart2, font_text, PLATFORM_STRING);
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_header, "Target");
+ DrawTextF(xstart2, ystart2, font_text, TARGET_STRING);
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_header, "Compile time");
+ DrawTextF(xstart2, ystart2, font_text, getCompileDateString());
+
+ ystart2 += 3 * ystep;
+ DrawTextF(xstart1, ystart2, font_header, "Library");
+ DrawTextF(xstart2, ystart2, font_header, "compiled");
+ DrawTextF(xstart3, ystart2, font_header, "linked");
+
+ SDL_VERSION(&sdl_version_compiled);
+#if defined(TARGET_SDL2)
+ SDL_GetVersion(&sdl_version_linked_ext);
+ sdl_version_linked = &sdl_version_linked_ext;
+#else
+ sdl_version_linked = SDL_Linked_Version();
+#endif
+
+ ystart2 += 2 * ystep;
+ DrawTextF(xstart1, ystart2, font_text, "SDL");
+ DrawTextF(xstart2, ystart2, font_text, "%d.%d.%d",
+ sdl_version_compiled.major,
+ sdl_version_compiled.minor,
+ sdl_version_compiled.patch);
+ DrawTextF(xstart3, ystart2, font_text, "%d.%d.%d",
+ sdl_version_linked->major,
+ sdl_version_linked->minor,
+ sdl_version_linked->patch);
+
+ SDL_IMAGE_VERSION(&sdl_version_compiled);
+ sdl_version_linked = IMG_Linked_Version();
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_text, "SDL_image");
+ DrawTextF(xstart2, ystart2, font_text, "%d.%d.%d",
+ sdl_version_compiled.major,
+ sdl_version_compiled.minor,
+ sdl_version_compiled.patch);
+ DrawTextF(xstart3, ystart2, font_text, "%d.%d.%d",
+ sdl_version_linked->major,
+ sdl_version_linked->minor,
+ sdl_version_linked->patch);
+
+ SDL_MIXER_VERSION(&sdl_version_compiled);
+ sdl_version_linked = Mix_Linked_Version();
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_text, "SDL_mixer");
+ DrawTextF(xstart2, ystart2, font_text, "%d.%d.%d",
+ sdl_version_compiled.major,
+ sdl_version_compiled.minor,
+ sdl_version_compiled.patch);
+ DrawTextF(xstart3, ystart2, font_text, "%d.%d.%d",
+ sdl_version_linked->major,
+ sdl_version_linked->minor,
+ sdl_version_linked->patch);
+
+ SDL_NET_VERSION(&sdl_version_compiled);
+ sdl_version_linked = SDLNet_Linked_Version();
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_text, "SDL_net");
+ DrawTextF(xstart2, ystart2, font_text, "%d.%d.%d",
+ sdl_version_compiled.major,
+ sdl_version_compiled.minor,
+ sdl_version_compiled.patch);
+ DrawTextF(xstart3, ystart2, font_text, "%d.%d.%d",
+ sdl_version_linked->major,
+ sdl_version_linked->minor,
+ sdl_version_linked->patch);
+
+ ystart2 += 3 * ystep;
+ DrawTextF(xstart1, ystart2, font_header, "Driver");
+ DrawTextF(xstart2, ystart2, font_header, "Requested");
+ DrawTextF(xstart3, ystart2, font_header, "Used");
+
+#if defined(TARGET_SDL2)
+ driver_name = getStringCopyNStatic(SDL_GetVideoDriver(0), driver_name_len);
+#else
+ SDL_VideoDriverName(driver_name, driver_name_len);
+#endif
+
+ ystart2 += 2 * ystep;
+ DrawTextF(xstart1, ystart2, font_text, "SDL_VideoDriver");
+ DrawTextF(xstart2, ystart2, font_text, "%s", setup.system.sdl_videodriver);
+ DrawTextF(xstart3, ystart2, font_text, "%s", driver_name);
+
+#if defined(TARGET_SDL2)
+ driver_name = getStringCopyNStatic(SDL_GetAudioDriver(0), driver_name_len);
+#else
+ SDL_AudioDriverName(driver_name, driver_name_len);
+#endif
+
+ ystart2 += ystep;
+ DrawTextF(xstart1, ystart2, font_text, "SDL_AudioDriver");
+ DrawTextF(xstart2, ystart2, font_text, "%s", setup.system.sdl_audiodriver);
+ DrawTextF(xstart3, ystart2, font_text, "%s", driver_name);
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for info menu");
+
+ FadeIn(REDRAW_FIELD);
+}
+
+void HandleInfoScreen_Version(int button)
+{
+ if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+ else if (button == MB_MENU_CHOICE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+ }
+ else
+ {
+ PlayMenuSoundIfLoop();
+ }
+}
+
+void DrawInfoScreen_LevelSet()
+{
+ struct TitleMessageInfo *tmi = &readme;
+ char *filename = getLevelSetInfoFilename();
+ char *title = "Level Set Information:";
+ int ystart1 = mSY - SY + 100;
+ int ybottom = mSY - SY + SYSIZE - 20;
+
+ if (filename == NULL)
+ {
+ DrawInfoScreen_NotAvailable(title, "No information for this level set.");
+
+ return;
+ }
+
+ SetMainBackgroundImageIfDefined(IMG_BACKGROUND_INFO_LEVELSET);
+
+ FadeOut(REDRAW_FIELD);
+
+ ClearField();
+ DrawHeadline();
+
+ DrawTextSCentered(ystart1, FONT_TEXT_1, title);
+
+ /* if x position set to "-1", automatically determine by playfield width */
+ if (tmi->x == -1)
+ tmi->x = SXSIZE / 2;
+
+ /* if y position set to "-1", use static default value */
+ if (tmi->y == -1)
+ tmi->y = 150;
+
+ /* if width set to "-1", automatically determine by playfield width */
+ if (tmi->width == -1)
+ tmi->width = SXSIZE - 2 * TILEX;
+
+ /* if height set to "-1", automatically determine by playfield height */
+ if (tmi->height == -1)
+ tmi->height = SYSIZE - 20 - tmi->y - 10;
+
+ /* if chars set to "-1", automatically determine by text and font width */
+ if (tmi->chars == -1)
+ tmi->chars = tmi->width / getFontWidth(tmi->font);
+ else
+ tmi->width = tmi->chars * getFontWidth(tmi->font);
+
+ /* if lines set to "-1", automatically determine by text and font height */
+ if (tmi->lines == -1)
+ tmi->lines = tmi->height / getFontHeight(tmi->font);
+ else
+ tmi->height = tmi->lines * getFontHeight(tmi->font);
+
+ DrawTextFile(mSX + ALIGNED_TEXT_XPOS(tmi), mSY + ALIGNED_TEXT_YPOS(tmi),
+ filename, tmi->font, tmi->chars, -1, tmi->lines, 0, -1,
+ tmi->autowrap, tmi->centered, tmi->parse_comments);
+
+ DrawTextSCentered(ybottom, FONT_TEXT_4,
+ "Press any key or button for info menu");
+
+ FadeIn(REDRAW_FIELD);
+}
+
+void HandleInfoScreen_LevelSet(int button)
+{
+ if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+
+ return;
+ }
+ else if (button == MB_MENU_CHOICE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSoundsAndMusic();
+
+ info_mode = INFO_MODE_MAIN;
+ DrawInfoScreen();
+ }
+ else
+ {
+ PlayMenuSoundIfLoop();
+ }
+}
+
+static void DrawInfoScreen()
+{
+ SetMainBackgroundImage(IMG_BACKGROUND_INFO);
+
+ if (info_mode == INFO_MODE_TITLE)
+ DrawInfoScreen_TitleScreen();
+ else if (info_mode == INFO_MODE_ELEMENTS)
+ DrawInfoScreen_Elements();
+ else if (info_mode == INFO_MODE_MUSIC)
+ DrawInfoScreen_Music();
+ else if (info_mode == INFO_MODE_CREDITS)
+ DrawInfoScreen_Credits();
+ else if (info_mode == INFO_MODE_PROGRAM)
+ DrawInfoScreen_Program();
+ else if (info_mode == INFO_MODE_VERSION)
+ DrawInfoScreen_Version();
+ else if (info_mode == INFO_MODE_LEVELSET)
+ DrawInfoScreen_LevelSet();
+ else
+ DrawInfoScreen_Main();
+
+ if (info_mode != INFO_MODE_MAIN &&
+ info_mode != INFO_MODE_TITLE &&
+ info_mode != INFO_MODE_MUSIC)
+ {
+ PlayMenuSound();
+ PlayMenuMusic();
+ }
+}
+
+void HandleInfoScreen(int mx, int my, int dx, int dy, int button)
+{
+ if (info_mode == INFO_MODE_TITLE)
+ HandleInfoScreen_TitleScreen(button);
+ else if (info_mode == INFO_MODE_ELEMENTS)
+ HandleInfoScreen_Elements(button);
+ else if (info_mode == INFO_MODE_MUSIC)
+ HandleInfoScreen_Music(button);
+ else if (info_mode == INFO_MODE_CREDITS)
+ HandleInfoScreen_Credits(button);
+ else if (info_mode == INFO_MODE_PROGRAM)
+ HandleInfoScreen_Program(button);
+ else if (info_mode == INFO_MODE_VERSION)
+ HandleInfoScreen_Version(button);
+ else if (info_mode == INFO_MODE_LEVELSET)
+ HandleInfoScreen_LevelSet(button);
+ else
+ HandleInfoScreen_Main(mx, my, dx, dy, button);
+}
+
+
+/* ========================================================================= */
+/* type name functions */
+/* ========================================================================= */
+
+void HandleTypeName(int newxpos, Key key)
+{
+ static char last_player_name[MAX_PLAYER_NAME_LEN + 1];
+ struct MainControlInfo *mci = getMainControlInfo(MAIN_CONTROL_NAME);
+ struct TextPosInfo *pos = mci->pos_input;
+ int startx = mSX + ALIGNED_TEXT_XPOS(pos);
+ int starty = mSY + ALIGNED_TEXT_YPOS(pos);
+ static int xpos = 0;
+ int font_nr = pos->font;
+ int font_active_nr = FONT_ACTIVE(font_nr);
+ int font_width = getFontWidth(font_active_nr);
+ char key_char = getValidConfigValueChar(getCharFromKey(key));
+ boolean is_valid_key_char = (key_char != 0 && (key_char != ' ' || xpos > 0));
+ boolean is_active = TRUE;
+
+ DrawBackgroundForFont(startx,starty, pos->width, pos->height, font_active_nr);
+
+ if (newxpos)
+ {
+ strcpy(last_player_name, setup.player_name);
+
+ xpos = newxpos;
+
+#if defined(TARGET_SDL2)
+ SDL_StartTextInput();
+#endif
+ }
+ else if (is_valid_key_char && xpos < MAX_PLAYER_NAME_LEN)
+ {
+ setup.player_name[xpos] = key_char;
+ setup.player_name[xpos + 1] = 0;
+
+ xpos++;
+ }
+ else if ((key == KSYM_Delete || key == KSYM_BackSpace) && xpos > 0)
+ {
+ xpos--;
+
+ setup.player_name[xpos] = 0;
+ }
+ else if (key == KSYM_Return && xpos > 0)
+ {
+ SaveSetup();
+
+ is_active = FALSE;
+
+ SetGameStatus(GAME_MODE_MAIN);
+ }
+ else if (key == KSYM_Escape)
+ {
+ strcpy(setup.player_name, last_player_name);
+
+ is_active = FALSE;
+
+ SetGameStatus(GAME_MODE_MAIN);
+ }
+
+ if (is_active)
+ {
+ pos->width = (strlen(setup.player_name) + 1) * font_width;
+ startx = mSX + ALIGNED_TEXT_XPOS(pos);
+
+ DrawText(startx, starty, setup.player_name, font_active_nr);
+ DrawText(startx + xpos * font_width, starty, "_", font_active_nr);
+ }
+ else
+ {
+ pos->width = strlen(setup.player_name) * font_width;
+ startx = mSX + ALIGNED_TEXT_XPOS(pos);
+
+ DrawText(startx, starty, setup.player_name, font_nr);
+
+#if defined(TARGET_SDL2)
+ SDL_StopTextInput();
+#endif
+ }
+}
+
+
+/* ========================================================================= */
+/* tree menu functions */
+/* ========================================================================= */
+
+static void DrawChooseTree(TreeInfo **ti_ptr)
+{
+ int fade_mask = REDRAW_FIELD;
+
+ if (CheckIfGlobalBorderHasChanged())
+ fade_mask = REDRAW_ALL;
+
+ if (strEqual((*ti_ptr)->subdir, STRING_TOP_DIRECTORY))
+ {
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+
+ return;
+ }
+
+ UnmapAllGadgets();
+
+ FreeScreenGadgets();
+ CreateScreenGadgets();
+
+ FadeOut(fade_mask);
+
+ ClearField();
+
+ OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
+
+ HandleChooseTree(0, 0, 0, 0, MB_MENU_INITIALIZE, ti_ptr);
+ MapScreenTreeGadgets(*ti_ptr);
+
+ DrawMaskedBorder(fade_mask);
+
+ FadeIn(fade_mask);
+
+ InitAnimation();
+}
+
+static void drawChooseTreeList(int first_entry, int num_page_entries,
+ TreeInfo *ti)
+{
+ int i;
+ char *title_string = NULL;
+ int yoffset_sets = MENU_TITLE1_YPOS;
+ int yoffset_setup = 16;
+ int yoffset = (ti->type == TREE_TYPE_LEVEL_DIR ||
+ ti->type == TREE_TYPE_LEVEL_NR ? yoffset_sets : yoffset_setup);
+ int last_game_status = game_status; /* save current game status */
+
+ title_string = ti->infotext;
+
+ DrawTextSCentered(mSY - SY + yoffset, FONT_TITLE_1, title_string);
+
+ clearMenuListArea();
+
+ for (i = 0; i < num_page_entries; i++)
+ {
+ TreeInfo *node, *node_first;
+ int entry_pos = first_entry + i;
+ int xpos = MENU_SCREEN_START_XPOS;
+ int ypos = MENU_SCREEN_START_YPOS + i;
+ int startx = mSX + xpos * 32;
+ int starty = mSY + ypos * 32;
+ int font_nr = FONT_TEXT_1;
+ int font_xoffset = getFontBitmapInfo(font_nr)->draw_xoffset;
+ int startx_text = startx + font_xoffset;
+ int startx_scrollbar = mSX + SC_SCROLLBAR_XPOS + menu.scrollbar_xoffset;
+ int text_size = startx_scrollbar - startx_text;
+ int max_buffer_len = text_size / getFontWidth(font_nr);
+ char buffer[max_buffer_len + 1];
+
+ node_first = getTreeInfoFirstGroupEntry(ti);
+ node = getTreeInfoFromPos(node_first, entry_pos);
+
+ strncpy(buffer, node->name, max_buffer_len);
+ buffer[max_buffer_len] = '\0';
+
+ DrawText(startx, starty, buffer, font_nr + node->color);
+
+ if (node->parent_link)
+ initCursor(i, IMG_MENU_BUTTON_LEAVE_MENU);
+ else if (node->level_group)
+ initCursor(i, IMG_MENU_BUTTON_ENTER_MENU);
+ else
+ initCursor(i, IMG_MENU_BUTTON);
+ }
+
+ SetGameStatus(last_game_status); /* restore current game status */
+
+ redraw_mask |= REDRAW_FIELD;
+}
+
+static void drawChooseTreeInfo(int entry_pos, TreeInfo *ti)
+{
+ TreeInfo *node, *node_first;
+ int x, last_redraw_mask = redraw_mask;
+ int ypos = MENU_TITLE2_YPOS;
+ int font_nr = FONT_TITLE_2;
+
+ if (ti->type == TREE_TYPE_LEVEL_NR)
+ DrawTextFCentered(ypos, font_nr, leveldir_current->name);
+
+ if (ti->type != TREE_TYPE_LEVEL_DIR)
+ return;
+
+ node_first = getTreeInfoFirstGroupEntry(ti);
+ node = getTreeInfoFromPos(node_first, entry_pos);
+
+ DrawBackgroundForFont(SX, SY + ypos, SXSIZE, getFontHeight(font_nr), font_nr);
+
+ if (node->parent_link)
+ DrawTextFCentered(ypos, font_nr, "leave \"%s\"",
+ node->node_parent->name);
+ else if (node->level_group)
+ DrawTextFCentered(ypos, font_nr, "enter \"%s\"",
+ node->name);
+ else if (ti->type == TREE_TYPE_LEVEL_DIR)
+ DrawTextFCentered(ypos, font_nr, "%3d %s (%s)",
+ node->levels, (node->levels > 1 ? "levels" : "level"),
+ node->class_desc);
+
+ /* let BackToFront() redraw only what is needed */
+ redraw_mask = last_redraw_mask;
+ for (x = 0; x < SCR_FIELDX; x++)
+ MarkTileDirty(x, 1);
+}
+
+static void HandleChooseTree(int mx, int my, int dx, int dy, int button,
+ TreeInfo **ti_ptr)
+{
+ TreeInfo *ti = *ti_ptr;
+ int x = 0;
+ int y = ti->cl_cursor;
+ int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
+ int num_entries = numTreeInfoInGroup(ti);
+ int num_page_entries;
+ int last_game_status = game_status; /* save current game status */
+ boolean position_set_by_scrollbar = (dx == 999);
+
+ if (num_entries <= NUM_MENU_ENTRIES_ON_SCREEN)
+ num_page_entries = num_entries;
+ else
+ num_page_entries = NUM_MENU_ENTRIES_ON_SCREEN;
+
+ SetGameStatus(last_game_status); /* restore current game status */
+
+ if (button == MB_MENU_INITIALIZE)
+ {
+ int num_entries = numTreeInfoInGroup(ti);
+ int entry_pos = posTreeInfo(ti);
+
+ if (ti->cl_first == -1)
+ {
+ /* only on initialization */
+ ti->cl_first = MAX(0, entry_pos - num_page_entries + 1);
+ ti->cl_cursor = entry_pos - ti->cl_first;
+ }
+ else if (ti->cl_cursor >= num_page_entries ||
+ (num_entries > num_page_entries &&
+ num_entries - ti->cl_first < num_page_entries))
+ {
+ /* only after change of list size (by custom graphic configuration) */
+ ti->cl_first = MAX(0, entry_pos - num_page_entries + 1);
+ ti->cl_cursor = entry_pos - ti->cl_first;
+ }
+
+ if (position_set_by_scrollbar)
+ ti->cl_first = dy;
+ else
+ AdjustChooseTreeScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL,
+ ti->cl_first, ti);
+
+ drawChooseTreeList(ti->cl_first, num_page_entries, ti);
+ drawChooseTreeInfo(ti->cl_first + ti->cl_cursor, ti);
+ drawChooseTreeCursor(ti->cl_cursor, TRUE);
+
+ return;
+ }
+ else if (button == MB_MENU_LEAVE)
+ {
+ FadeSetLeaveMenu();
+
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ if (ti->node_parent)
+ {
+ *ti_ptr = ti->node_parent;
+ DrawChooseTree(ti_ptr);
+ }
+ else if (game_status == GAME_MODE_SETUP)
+ {
+ if (setup_mode == SETUP_MODE_CHOOSE_GAME_SPEED ||
+ setup_mode == SETUP_MODE_CHOOSE_SCROLL_DELAY ||
+ setup_mode == SETUP_MODE_CHOOSE_SNAPSHOT_MODE)
+ execSetupGame();
+ else if (setup_mode == SETUP_MODE_CHOOSE_WINDOW_SIZE ||
+ setup_mode == SETUP_MODE_CHOOSE_SCALING_TYPE)
+ execSetupGraphics();
+ else if (setup_mode == SETUP_MODE_CHOOSE_VOLUME_SIMPLE ||
+ setup_mode == SETUP_MODE_CHOOSE_VOLUME_LOOPS ||
+ setup_mode == SETUP_MODE_CHOOSE_VOLUME_MUSIC)
+ execSetupSound();
+ else if (setup_mode == SETUP_MODE_CHOOSE_TOUCH_CONTROL ||
+ setup_mode == SETUP_MODE_CHOOSE_MOVE_DISTANCE ||
+ setup_mode == SETUP_MODE_CHOOSE_DROP_DISTANCE)
+ execSetupTouch();
+ else
+ execSetupArtwork();
+ }
+ else
+ {
+ if (game_status == GAME_MODE_LEVELNR)
+ {
+ int new_level_nr = atoi(level_number_current->identifier);
+
+ HandleMainMenu_SelectLevel(0, 0, new_level_nr);
+ }
+
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+
+ return;
+ }
+
+ if (mx || my) /* mouse input */
+ {
+ int last_game_status = game_status; /* save current game status */
+
+ x = (mx - mSX) / 32;
+ y = (my - mSY) / 32 - MENU_SCREEN_START_YPOS;
+
+ SetGameStatus(last_game_status); /* restore current game status */
+ }
+ else if (dx || dy) /* keyboard or scrollbar/scrollbutton input */
+ {
+ /* move cursor instead of scrolling when already at start/end of list */
+ if (dy == -1 * SCROLL_LINE && ti->cl_first == 0)
+ dy = -1;
+ else if (dy == +1 * SCROLL_LINE &&
+ ti->cl_first + num_page_entries == num_entries)
+ dy = 1;
+
+ /* handle scrolling screen one line or page */
+ if (ti->cl_cursor + dy < 0 ||
+ ti->cl_cursor + dy > num_page_entries - 1)
+ {
+ boolean redraw = FALSE;
+
+ if (ABS(dy) == SCROLL_PAGE)
+ step = num_page_entries - 1;
+
+ if (dy < 0 && ti->cl_first > 0)
+ {
+ /* scroll page/line up */
+
+ ti->cl_first -= step;
+ if (ti->cl_first < 0)
+ ti->cl_first = 0;
+
+ redraw = TRUE;
+ }
+ else if (dy > 0 && ti->cl_first + num_page_entries < num_entries)
+ {
+ /* scroll page/line down */
+
+ ti->cl_first += step;
+ if (ti->cl_first + num_page_entries > num_entries)
+ ti->cl_first = MAX(0, num_entries - num_page_entries);
+
+ redraw = TRUE;
+ }
+
+ if (redraw)
+ {
+ drawChooseTreeList(ti->cl_first, num_page_entries, ti);
+ drawChooseTreeInfo(ti->cl_first + ti->cl_cursor, ti);
+ drawChooseTreeCursor(ti->cl_cursor, TRUE);
+
+ AdjustChooseTreeScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL,
+ ti->cl_first, ti);
+ }
+
+ return;
+ }
+
+ /* handle moving cursor one line */
+ y = ti->cl_cursor + dy;
+ }
+
+ if (dx == 1)
+ {
+ TreeInfo *node_first, *node_cursor;
+ int entry_pos = ti->cl_first + y;
+
+ node_first = getTreeInfoFirstGroupEntry(ti);
+ node_cursor = getTreeInfoFromPos(node_first, entry_pos);
+
+ if (node_cursor->node_group)
+ {
+ FadeSetEnterMenu();
+
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ node_cursor->cl_first = ti->cl_first;
+ node_cursor->cl_cursor = ti->cl_cursor;
+ *ti_ptr = node_cursor->node_group;
+ DrawChooseTree(ti_ptr);
+
+ return;
+ }
+ }
+ else if (dx == -1 && ti->node_parent)
+ {
+ FadeSetLeaveMenu();
+
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ *ti_ptr = ti->node_parent;
+ DrawChooseTree(ti_ptr);
+
+ return;
+ }
+
+ if (!anyScrollbarGadgetActive() &&
+ IN_VIS_MENU(x, y) &&
+ mx < screen_gadget[SCREEN_CTRL_ID_SCROLL_VERTICAL]->x &&
+ y >= 0 && y < num_page_entries)
+ {
+ if (button)
+ {
+ if (y != ti->cl_cursor)
+ {
+ PlaySound(SND_MENU_ITEM_ACTIVATING);
+
+ drawChooseTreeCursor(ti->cl_cursor, FALSE);
+ drawChooseTreeCursor(y, TRUE);
+ drawChooseTreeInfo(ti->cl_first + y, ti);
+
+ ti->cl_cursor = y;
+ }
+ }
+ else
+ {
+ TreeInfo *node_first, *node_cursor;
+ int entry_pos = ti->cl_first + y;
+
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ node_first = getTreeInfoFirstGroupEntry(ti);
+ node_cursor = getTreeInfoFromPos(node_first, entry_pos);
+
+ if (node_cursor->node_group)
+ {
+ FadeSetEnterMenu();
+
+ node_cursor->cl_first = ti->cl_first;
+ node_cursor->cl_cursor = ti->cl_cursor;
+ *ti_ptr = node_cursor->node_group;
+ DrawChooseTree(ti_ptr);
+ }
+ else if (node_cursor->parent_link)
+ {
+ FadeSetLeaveMenu();
+
+ *ti_ptr = node_cursor->node_parent;
+ DrawChooseTree(ti_ptr);
+ }
+ else
+ {
+ FadeSetEnterMenu();
+
+ node_cursor->cl_first = ti->cl_first;
+ node_cursor->cl_cursor = ti->cl_cursor;
+ *ti_ptr = node_cursor;
+
+ if (ti->type == TREE_TYPE_LEVEL_DIR)
+ {
+ LoadLevelSetup_SeriesInfo();
+
+ SaveLevelSetup_LastSeries();
+ SaveLevelSetup_SeriesInfo();
+ TapeErase();
+ }
+
+ if (game_status == GAME_MODE_SETUP)
+ {
+ if (setup_mode == SETUP_MODE_CHOOSE_GAME_SPEED ||
+ setup_mode == SETUP_MODE_CHOOSE_SCROLL_DELAY ||
+ setup_mode == SETUP_MODE_CHOOSE_SNAPSHOT_MODE)
+ execSetupGame();
+ else if (setup_mode == SETUP_MODE_CHOOSE_WINDOW_SIZE ||
+ setup_mode == SETUP_MODE_CHOOSE_SCALING_TYPE)
+ execSetupGraphics();
+ else if (setup_mode == SETUP_MODE_CHOOSE_VOLUME_SIMPLE ||
+ setup_mode == SETUP_MODE_CHOOSE_VOLUME_LOOPS ||
+ setup_mode == SETUP_MODE_CHOOSE_VOLUME_MUSIC)
+ execSetupSound();
+ else if (setup_mode == SETUP_MODE_CHOOSE_TOUCH_CONTROL ||
+ setup_mode == SETUP_MODE_CHOOSE_MOVE_DISTANCE ||
+ setup_mode == SETUP_MODE_CHOOSE_DROP_DISTANCE)
+ execSetupTouch();
+ else
+ execSetupArtwork();
+ }
+ else
+ {
+ if (game_status == GAME_MODE_LEVELNR)
+ {
+ int new_level_nr = atoi(level_number_current->identifier);
+
+ HandleMainMenu_SelectLevel(0, 0, new_level_nr);
+ }
+
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+ }
+ }
+ }
+}
+
+void DrawChooseLevelSet()
+{
+ SetMainBackgroundImage(IMG_BACKGROUND_LEVELS);
+
+ DrawChooseTree(&leveldir_current);
+
+ PlayMenuSound();
+ PlayMenuMusic();
+}
+
+void HandleChooseLevelSet(int mx, int my, int dx, int dy, int button)
+{
+ HandleChooseTree(mx, my, dx, dy, button, &leveldir_current);
+}
+
+void DrawChooseLevelNr()
+{
+ int i;
+
+ if (level_number != NULL)
+ {
+ freeTreeInfo(level_number);
+
+ level_number = NULL;
+ }
+
+ for (i = leveldir_current->first_level; i <= leveldir_current->last_level;i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_LEVEL_NR);
+ char identifier[32], name[32];
+ int value = i;
+
+ /* temporarily load level info to get level name */
+ LoadLevelInfoOnly(i);
+
+ ti->node_top = &level_number;
+ ti->sort_priority = 10000 + value;
+ ti->color = (level.no_valid_file ? FC_BLUE :
+ LevelStats_getSolved(i) ? FC_GREEN :
+ LevelStats_getPlayed(i) ? FC_YELLOW : FC_RED);
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%03d: %s", value,
+ (level.no_valid_file ? "(no file)" : level.name));
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+
+ pushTreeInfo(&level_number, ti);
+ }
+
+ /* sort level number values to start with lowest level number */
+ sortTreeInfo(&level_number);
+
+ /* set current level number to current level number */
+ level_number_current =
+ getTreeInfoFromIdentifier(level_number, i_to_a(level_nr));
+
+ /* if that also fails, set current level number to first available level */
+ if (level_number_current == NULL)
+ level_number_current = level_number;
+
+ SetMainBackgroundImage(IMG_BACKGROUND_LEVELNR);
+
+ DrawChooseTree(&level_number_current);
+
+ PlayMenuSound();
+ PlayMenuMusic();
+}
+
+void HandleChooseLevelNr(int mx, int my, int dx, int dy, int button)
+{
+ HandleChooseTree(mx, my, dx, dy, button, &level_number_current);
+}
+
+void DrawHallOfFame(int highlight_position)
+{
+ int fade_mask = REDRAW_FIELD;
+
+ /* needed if different viewport properties defined for scores */
+ ChangeViewportPropertiesIfNeeded();
+
+ if (CheckIfGlobalBorderHasChanged())
+ fade_mask = REDRAW_ALL;
+
+ UnmapAllGadgets();
+ FadeSoundsAndMusic();
+
+ /* (this is needed when called from GameEnd() after winning a game) */
+ KeyboardAutoRepeatOn();
+ ActivateJoystick();
+
+ /* (this is needed when called from GameEnd() after winning a game) */
+ SetDrawDeactivationMask(REDRAW_NONE);
+ SetDrawBackgroundMask(REDRAW_FIELD);
+
+ if (highlight_position < 0)
+ LoadScore(level_nr);
+
+ FadeSetEnterScreen();
+
+ FadeOut(fade_mask);
+
+ InitAnimation();
+
+ PlayMenuSound();
+ PlayMenuMusic();
+
+ OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
+
+ HandleHallOfFame(highlight_position, 0, 0, 0, MB_MENU_INITIALIZE);
+
+ DrawMaskedBorder(fade_mask);
+
+ FadeIn(fade_mask);
+}
+
+static void drawHallOfFameList(int first_entry, int highlight_position)
+{
+ int i, j;
+
+ SetMainBackgroundImage(IMG_BACKGROUND_SCORES);
+ ClearField();
+
+ DrawTextSCentered(MENU_TITLE1_YPOS, FONT_TITLE_1, "Hall Of Fame");
+ DrawTextFCentered(MENU_TITLE2_YPOS, FONT_TITLE_2,
+ "HighScores of Level %d", level_nr);
+
+ for (i = 0; i < NUM_MENU_ENTRIES_ON_SCREEN; i++)
+ {
+ int entry = first_entry + i;
+ boolean active = (entry == highlight_position);
+ int font_nr1 = (active ? FONT_TEXT_1_ACTIVE : FONT_TEXT_1);
+ int font_nr2 = (active ? FONT_TEXT_2_ACTIVE : FONT_TEXT_2);
+ int font_nr3 = (active ? FONT_TEXT_3_ACTIVE : FONT_TEXT_3);
+ int font_nr4 = (active ? FONT_TEXT_4_ACTIVE : FONT_TEXT_4);
+ int dx1 = 3 * getFontWidth(font_nr1);
+ int dx2 = dx1 + getFontWidth(font_nr1);
+ int dx3 = SXSIZE - 2 * (mSX - SX) - 5 * getFontWidth(font_nr4);
+ int num_dots = (dx3 - dx2) / getFontWidth(font_nr3);
+ int sy = mSY + 64 + i * 32;
+
+ DrawText(mSX, sy, int2str(entry + 1, 3), font_nr1);
+ DrawText(mSX + dx1, sy, ".", font_nr1);
+
+ for (j = 0; j < num_dots; j++)
+ DrawText(mSX + dx2 + j * getFontWidth(font_nr3), sy, ".", font_nr3);
+
+ if (!strEqual(highscore[entry].Name, EMPTY_PLAYER_NAME))
+ DrawText(mSX + dx2, sy, highscore[entry].Name, font_nr2);
+
+ DrawText(mSX + dx3, sy, int2str(highscore[entry].Score, 5), font_nr4);
+ }
+
+ redraw_mask |= REDRAW_FIELD;
+}
+
+void HandleHallOfFame(int mx, int my, int dx, int dy, int button)
+{
+ static int first_entry = 0;
+ static int highlight_position = 0;
+ int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
+
+ if (button == MB_MENU_INITIALIZE)
+ {
+ first_entry = 0;
+ highlight_position = mx;
+ drawHallOfFameList(first_entry, highlight_position);
+
+ return;
+ }
+
+ if (ABS(dy) == SCROLL_PAGE) /* handle scrolling one page */
+ step = NUM_MENU_ENTRIES_ON_SCREEN - 1;
+
+ if (dy < 0)
+ {
+ if (first_entry > 0)
+ {
+ first_entry -= step;
+ if (first_entry < 0)
+ first_entry = 0;
+
+ drawHallOfFameList(first_entry, highlight_position);
+ }
+ }
+ else if (dy > 0)
+ {
+ if (first_entry + NUM_MENU_ENTRIES_ON_SCREEN < MAX_SCORE_ENTRIES)
+ {
+ first_entry += step;
+ if (first_entry + NUM_MENU_ENTRIES_ON_SCREEN > MAX_SCORE_ENTRIES)
+ first_entry = MAX(0, MAX_SCORE_ENTRIES - NUM_MENU_ENTRIES_ON_SCREEN);
+
+ drawHallOfFameList(first_entry, highlight_position);
+ }
+ }
+ else if (button == MB_MENU_LEAVE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSound(SND_BACKGROUND_SCORES);
+
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+ else if (button == MB_MENU_CHOICE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSound(SND_BACKGROUND_SCORES);
+
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+
+ if (game_status == GAME_MODE_SCORES)
+ PlayMenuSoundIfLoop();
+}
+
+
+/* ========================================================================= */
+/* setup screen functions */
+/* ========================================================================= */
+
+static struct TokenInfo *setup_info;
+static int num_setup_info; /* number of setup entries shown on screen */
+static int max_setup_info; /* total number of setup entries in list */
+
+static char *window_size_text;
+static char *scaling_type_text;
+static char *scroll_delay_text;
+static char *snapshot_mode_text;
+static char *game_speed_text;
+static char *graphics_set_name;
+static char *sounds_set_name;
+static char *music_set_name;
+static char *volume_simple_text;
+static char *volume_loops_text;
+static char *volume_music_text;
+static char *touch_controls_text;
+static char *move_distance_text;
+static char *drop_distance_text;
+
+static void execSetupMain()
+{
+ setup_mode = SETUP_MODE_MAIN;
+
+ DrawSetupScreen();
+}
+
+static void execSetupGame_setGameSpeeds()
+{
+ if (game_speeds == NULL)
+ {
+ int i;
+
+ for (i = 0; game_speeds_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = game_speeds_list[i].value;
+ char *text = game_speeds_list[i].text;
+
+ ti->node_top = &game_speeds;
+ ti->sort_priority = 10000 - value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Game Speed");
+
+ pushTreeInfo(&game_speeds, ti);
+ }
+
+ /* sort game speed values to start with slowest game speed */
+ sortTreeInfo(&game_speeds);
+
+ /* set current game speed to configured game speed value */
+ game_speed_current =
+ getTreeInfoFromIdentifier(game_speeds, i_to_a(setup.game_frame_delay));
+
+ /* if that fails, set current game speed to reliable default value */
+ if (game_speed_current == NULL)
+ game_speed_current =
+ getTreeInfoFromIdentifier(game_speeds, i_to_a(GAME_FRAME_DELAY));
+
+ /* if that also fails, set current game speed to first available speed */
+ if (game_speed_current == NULL)
+ game_speed_current = game_speeds;
+ }
+
+ setup.game_frame_delay = atoi(game_speed_current->identifier);
+
+ /* needed for displaying game speed text instead of identifier */
+ game_speed_text = game_speed_current->name;
+}
+
+static void execSetupGame_setScrollDelays()
+{
+ if (scroll_delays == NULL)
+ {
+ int i;
+
+ for (i = 0; scroll_delays_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = scroll_delays_list[i].value;
+ char *text = scroll_delays_list[i].text;
+
+ ti->node_top = &scroll_delays;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Scroll Delay");
+
+ pushTreeInfo(&scroll_delays, ti);
+ }
+
+ /* sort scroll delay values to start with lowest scroll delay value */
+ sortTreeInfo(&scroll_delays);
+
+ /* set current scroll delay value to configured scroll delay value */
+ scroll_delay_current =
+ getTreeInfoFromIdentifier(scroll_delays,i_to_a(setup.scroll_delay_value));
+
+ /* if that fails, set current scroll delay to reliable default value */
+ if (scroll_delay_current == NULL)
+ scroll_delay_current =
+ getTreeInfoFromIdentifier(scroll_delays, i_to_a(STD_SCROLL_DELAY));
+
+ /* if that also fails, set current scroll delay to first available value */
+ if (scroll_delay_current == NULL)
+ scroll_delay_current = scroll_delays;
+ }
+
+ setup.scroll_delay_value = atoi(scroll_delay_current->identifier);
+
+ /* needed for displaying scroll delay text instead of identifier */
+ scroll_delay_text = scroll_delay_current->name;
+}
+
+static void execSetupGame_setSnapshotModes()
+{
+ if (snapshot_modes == NULL)
+ {
+ int i;
+
+ for (i = 0; snapshot_modes_list[i].value != NULL; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ char *value = snapshot_modes_list[i].value;
+ char *text = snapshot_modes_list[i].text;
+
+ ti->node_top = &snapshot_modes;
+ ti->sort_priority = i;
+
+ sprintf(identifier, "%s", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Snapshot Mode");
+
+ pushTreeInfo(&snapshot_modes, ti);
+ }
+
+ /* sort snapshot mode values to start with lowest snapshot mode value */
+ sortTreeInfo(&snapshot_modes);
+
+ /* set current snapshot mode value to configured snapshot mode value */
+ snapshot_mode_current =
+ getTreeInfoFromIdentifier(snapshot_modes, setup.engine_snapshot_mode);
+
+ /* if that fails, set current snapshot mode to reliable default value */
+ if (snapshot_mode_current == NULL)
+ snapshot_mode_current =
+ getTreeInfoFromIdentifier(snapshot_modes, STR_SNAPSHOT_MODE_DEFAULT);
+
+ /* if that also fails, set current snapshot mode to first available value */
+ if (snapshot_mode_current == NULL)
+ snapshot_mode_current = snapshot_modes;
+ }
+
+ setup.engine_snapshot_mode = snapshot_mode_current->identifier;
+
+ /* needed for displaying snapshot mode text instead of identifier */
+ snapshot_mode_text = snapshot_mode_current->name;
+}
+
+static void execSetupGame()
+{
+ execSetupGame_setGameSpeeds();
+ execSetupGame_setScrollDelays();
+ execSetupGame_setSnapshotModes();
+
+ setup_mode = SETUP_MODE_GAME;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseGameSpeed()
+{
+ setup_mode = SETUP_MODE_CHOOSE_GAME_SPEED;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseScrollDelay()
+{
+ setup_mode = SETUP_MODE_CHOOSE_SCROLL_DELAY;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseSnapshotMode()
+{
+ setup_mode = SETUP_MODE_CHOOSE_SNAPSHOT_MODE;
+
+ DrawSetupScreen();
+}
+
+static void execSetupEditor()
+{
+ setup_mode = SETUP_MODE_EDITOR;
+
+ DrawSetupScreen();
+}
+
+static void execSetupGraphics_setWindowSizes(boolean update_list)
+{
+ if (window_sizes != NULL && update_list)
+ {
+ freeTreeInfo(window_sizes);
+
+ window_sizes = NULL;
+ }
+
+ if (window_sizes == NULL)
+ {
+ boolean current_window_size_found = FALSE;
+ int i;
+
+ for (i = 0; window_sizes_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = window_sizes_list[i].value;
+ char *text = window_sizes_list[i].text;
+
+ ti->node_top = &window_sizes;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Window Scaling");
+
+ pushTreeInfo(&window_sizes, ti);
+
+ if (value == setup.window_scaling_percent)
+ current_window_size_found = TRUE;
+ }
+
+ if (!current_window_size_found)
+ {
+ // add entry for non-preset window scaling value
+
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = setup.window_scaling_percent;
+
+ ti->node_top = &window_sizes;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%d %% (Current)", value);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Window Scaling");
+
+ pushTreeInfo(&window_sizes, ti);
+ }
+
+ /* sort window size values to start with lowest window size value */
+ sortTreeInfo(&window_sizes);
+
+ /* set current window size value to configured window size value */
+ window_size_current =
+ getTreeInfoFromIdentifier(window_sizes,
+ i_to_a(setup.window_scaling_percent));
+
+ /* if that fails, set current window size to reliable default value */
+ if (window_size_current == NULL)
+ window_size_current =
+ getTreeInfoFromIdentifier(window_sizes,
+ i_to_a(STD_WINDOW_SCALING_PERCENT));
+
+ /* if that also fails, set current window size to first available value */
+ if (window_size_current == NULL)
+ window_size_current = window_sizes;
+ }
+
+ setup.window_scaling_percent = atoi(window_size_current->identifier);
+
+ /* needed for displaying window size text instead of identifier */
+ window_size_text = window_size_current->name;
+}
+
+static void execSetupGraphics_setScalingTypes()
+{
+ if (scaling_types == NULL)
+ {
+ int i;
+
+ for (i = 0; scaling_types_list[i].value != NULL; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ char *value = scaling_types_list[i].value;
+ char *text = scaling_types_list[i].text;
+
+ ti->node_top = &scaling_types;
+ ti->sort_priority = i;
+
+ sprintf(identifier, "%s", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Anti-Aliasing");
+
+ pushTreeInfo(&scaling_types, ti);
+ }
+
+ /* sort scaling type values to start with lowest scaling type value */
+ sortTreeInfo(&scaling_types);
+
+ /* set current scaling type value to configured scaling type value */
+ scaling_type_current =
+ getTreeInfoFromIdentifier(scaling_types, setup.window_scaling_quality);
+
+ /* if that fails, set current scaling type to reliable default value */
+ if (scaling_type_current == NULL)
+ scaling_type_current =
+ getTreeInfoFromIdentifier(scaling_types, SCALING_QUALITY_DEFAULT);
+
+ /* if that also fails, set current scaling type to first available value */
+ if (scaling_type_current == NULL)
+ scaling_type_current = scaling_types;
+ }
+
+ setup.window_scaling_quality = scaling_type_current->identifier;
+
+ /* needed for displaying scaling type text instead of identifier */
+ scaling_type_text = scaling_type_current->name;
+}
+
+static void execSetupGraphics()
+{
+ if (setup_mode == SETUP_MODE_CHOOSE_WINDOW_SIZE)
+ {
+ // update "setup.window_scaling_percent" from list selection
+ execSetupGraphics_setWindowSizes(FALSE);
+ }
+ else
+ {
+ // update list selection from "setup.window_scaling_percent"
+ execSetupGraphics_setWindowSizes(TRUE);
+ }
+
+ execSetupGraphics_setScalingTypes();
+
+ setup_mode = SETUP_MODE_GRAPHICS;
+
+ DrawSetupScreen();
+
+#if defined(TARGET_SDL2)
+ // window scaling may have changed at this point
+ ToggleFullscreenOrChangeWindowScalingIfNeeded();
+
+ // window scaling quality may have changed at this point
+ if (!strEqual(setup.window_scaling_quality, video.window_scaling_quality))
+ SDLSetWindowScalingQuality(setup.window_scaling_quality);
+#endif
+}
+
+#if defined(TARGET_SDL2) && !defined(PLATFORM_ANDROID)
+static void execSetupChooseWindowSize()
+{
+ setup_mode = SETUP_MODE_CHOOSE_WINDOW_SIZE;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseScalingType()
+{
+ setup_mode = SETUP_MODE_CHOOSE_SCALING_TYPE;
+
+ DrawSetupScreen();
+}
+#endif
+
+static void execSetupChooseVolumeSimple()
+{
+ setup_mode = SETUP_MODE_CHOOSE_VOLUME_SIMPLE;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseVolumeLoops()
+{
+ setup_mode = SETUP_MODE_CHOOSE_VOLUME_LOOPS;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseVolumeMusic()
+{
+ setup_mode = SETUP_MODE_CHOOSE_VOLUME_MUSIC;
+
+ DrawSetupScreen();
+}
+
+static void execSetupSound()
+{
+ if (volumes_simple == NULL)
+ {
+ boolean current_volume_simple_found = FALSE;
+ int i;
+
+ for (i = 0; volumes_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = volumes_list[i].value;
+ char *text = volumes_list[i].text;
+
+ ti->node_top = &volumes_simple;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Sound Volume");
+
+ pushTreeInfo(&volumes_simple, ti);
+
+ if (value == setup.volume_simple)
+ current_volume_simple_found = TRUE;
+ }
+
+ if (!current_volume_simple_found)
+ {
+ // add entry for non-preset volume value
+
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = setup.volume_simple;
+
+ ti->node_top = &volumes_simple;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%d %% (Current)", value);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, "Sound Volume");
+
+ pushTreeInfo(&volumes_simple, ti);
+ }
+
+ /* sort volume values to start with lowest volume value */
+ sortTreeInfo(&volumes_simple);
+
+ /* set current volume value to configured volume value */
+ volume_simple_current =
+ getTreeInfoFromIdentifier(volumes_simple,i_to_a(setup.volume_simple));
+
+ /* if that fails, set current volume to reliable default value */
+ if (volume_simple_current == NULL)
+ volume_simple_current =
+ getTreeInfoFromIdentifier(volumes_simple, i_to_a(100));
+
+ /* if that also fails, set current volume to first available value */
+ if (volume_simple_current == NULL)
+ volume_simple_current = volumes_simple;
+ }
+
+ if (volumes_loops == NULL)
+ {
+ boolean current_volume_loops_found = FALSE;
+ int i;
+
+ for (i = 0; volumes_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = volumes_list[i].value;
+ char *text = volumes_list[i].text;