+ else
+ {
+ Error(ERR_DEBUG, "---------- SNAP STARTED ----------");
+
+ HandleKey(setup.input[0].key.snap, KEY_PRESSED);
+ }
+ }
+ else if (dx != 0 || dy != 0)
+ {
+ if (player_is_dropping &&
+ player_drop_count == getPlayerInventorySize(0))
+ {
+ Error(ERR_DEBUG, "---------- DROP -> SNAP ----------");
+
+ HandleKey(setup.input[0].key.drop, KEY_RELEASED);
+ HandleKey(setup.input[0].key.snap, KEY_PRESSED);
+
+ player_is_dropping = FALSE;
+ }
+ }
+
+ if (new_motion_key_x != motion_key_x)
+ {
+ Error(ERR_DEBUG, "---------- %s %s ----------",
+ started_on_player && !player_is_dropping ? "SNAPPING" : "MOVING",
+ dx < 0 ? "LEFT" : dx > 0 ? "RIGHT" : "PAUSED");
+
+ if (motion_key_x != KSYM_UNDEFINED)
+ HandleKey(motion_key_x, KEY_RELEASED);
+ if (new_motion_key_x != KSYM_UNDEFINED)
+ HandleKey(new_motion_key_x, KEY_PRESSED);
+ }
+
+ if (new_motion_key_y != motion_key_y)
+ {
+ Error(ERR_DEBUG, "---------- %s %s ----------",
+ started_on_player && !player_is_dropping ? "SNAPPING" : "MOVING",
+ dy < 0 ? "UP" : dy > 0 ? "DOWN" : "PAUSED");
+
+ if (motion_key_y != KSYM_UNDEFINED)
+ HandleKey(motion_key_y, KEY_RELEASED);
+ if (new_motion_key_y != KSYM_UNDEFINED)
+ HandleKey(new_motion_key_y, KEY_PRESSED);
+ }
+
+ motion_key_x = new_motion_key_x;
+ motion_key_y = new_motion_key_y;
+ }
+}
+
+static void HandleButtonOrFinger(int mx, int my, int button)
+{
+ if (game_status != GAME_MODE_PLAYING)
+ return;
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
+ {
+ if (strEqual(setup.touch.control_type, TOUCH_CONTROL_WIPE_GESTURES))
+ HandleButtonOrFinger_WipeGestures_MM(mx, my, button);
+ else if (strEqual(setup.touch.control_type, TOUCH_CONTROL_FOLLOW_FINGER))
+ HandleButtonOrFinger_FollowFinger_MM(mx, my, button);
+ else if (strEqual(setup.touch.control_type, TOUCH_CONTROL_VIRTUAL_BUTTONS))
+ SetPlayerMouseAction(mx, my, button); // special case
+ }
+ else
+ {
+ if (strEqual(setup.touch.control_type, TOUCH_CONTROL_FOLLOW_FINGER))
+ HandleButtonOrFinger_FollowFinger(mx, my, button);
+ }
+}
+
+#if defined(TARGET_SDL2)
+
+static boolean checkTextInputKeyModState(void)
+{
+ // when playing, only handle raw key events and ignore text input
+ if (game_status == GAME_MODE_PLAYING)
+ return FALSE;
+
+ return ((GetKeyModState() & KMOD_TextInput) != KMOD_None);
+}
+
+void HandleTextEvent(TextEvent *event)
+{
+ char *text = event->text;
+ Key key = getKeyFromKeyName(text);
+
+#if DEBUG_EVENTS_TEXT
+ Error(ERR_DEBUG, "TEXT EVENT: text == '%s' [%d byte(s), '%c'/%d], resulting key == %d (%s) [%04x]",
+ text,
+ strlen(text),
+ text[0], (int)(text[0]),
+ key,
+ getKeyNameFromKey(key),
+ GetKeyModState());
+#endif
+
+#if !defined(HAS_SCREEN_KEYBOARD)
+ // non-mobile devices: only handle key input with modifier keys pressed here
+ // (every other key input is handled directly as physical key input event)
+ if (!checkTextInputKeyModState())
+ return;
+#endif
+
+ // process text input as "classic" (with uppercase etc.) key input event
+ HandleKey(key, KEY_PRESSED);
+ HandleKey(key, KEY_RELEASED);
+}
+
+void HandlePauseResumeEvent(PauseResumeEvent *event)
+{
+ if (event->type == SDL_APP_WILLENTERBACKGROUND)
+ {
+ Mix_PauseMusic();
+ }
+ else if (event->type == SDL_APP_DIDENTERFOREGROUND)
+ {
+ Mix_ResumeMusic();
+ }
+}
+
+#endif
+
+void HandleKeyEvent(KeyEvent *event)
+{
+ int key_status = (event->type == EVENT_KEYPRESS ? KEY_PRESSED : KEY_RELEASED);
+ boolean with_modifiers = (game_status == GAME_MODE_PLAYING ? FALSE : TRUE);
+ Key key = GetEventKey(event, with_modifiers);
+ Key keymod = (with_modifiers ? GetEventKey(event, FALSE) : key);
+
+#if DEBUG_EVENTS_KEY
+ Error(ERR_DEBUG, "KEY EVENT: key was %s, keysym.scancode == %d, keysym.sym == %d, keymod = %d, GetKeyModState() = 0x%04x, resulting key == %d (%s)",
+ event->type == EVENT_KEYPRESS ? "pressed" : "released",
+ event->keysym.scancode,
+ event->keysym.sym,
+ keymod,
+ GetKeyModState(),
+ key,
+ getKeyNameFromKey(key));
+#endif
+
+#if defined(PLATFORM_ANDROID)
+ if (key == KSYM_Back)
+ {
+ // always map the "back" button to the "escape" key on Android devices
+ key = KSYM_Escape;
+ }
+ else
+ {
+ // for any key event other than "back" button, disable overlay buttons
+ SetOverlayEnabled(FALSE);
+ }
+#endif
+
+ HandleKeyModState(keymod, key_status);
+
+#if defined(TARGET_SDL2)
+ // only handle raw key input without text modifier keys pressed
+ if (!checkTextInputKeyModState())
+ HandleKey(key, key_status);
+#else
+ HandleKey(key, key_status);
+#endif
+}
+
+void HandleFocusEvent(FocusChangeEvent *event)
+{
+ static int old_joystick_status = -1;
+
+ if (event->type == EVENT_FOCUSOUT)
+ {
+ KeyboardAutoRepeatOn();
+ old_joystick_status = joystick.status;
+ joystick.status = JOYSTICK_NOT_AVAILABLE;
+
+ ClearPlayerAction();
+ }
+ else if (event->type == EVENT_FOCUSIN)
+ {
+ /* When there are two Rocks'n'Diamonds windows which overlap and
+ the player moves the pointer from one game window to the other,
+ a 'FocusOut' event is generated for the window the pointer is
+ leaving and a 'FocusIn' event is generated for the window the
+ pointer is entering. In some cases, it can happen that the
+ 'FocusIn' event is handled by the one game process before the
+ 'FocusOut' event by the other game process. In this case the
+ X11 environment would end up with activated keyboard auto repeat,
+ because unfortunately this is a global setting and not (which
+ would be far better) set for each X11 window individually.
+ The effect would be keyboard auto repeat while playing the game
+ (game_status == GAME_MODE_PLAYING), which is not desired.
+ To avoid this special case, we just wait 1/10 second before
+ processing the 'FocusIn' event. */
+
+ if (game_status == GAME_MODE_PLAYING)
+ {
+ Delay(100);
+ KeyboardAutoRepeatOffUnlessAutoplay();
+ }
+
+ if (old_joystick_status != -1)
+ joystick.status = old_joystick_status;
+ }
+}
+
+void HandleClientMessageEvent(ClientMessageEvent *event)
+{
+ if (CheckCloseWindowEvent(event))
+ CloseAllAndExit(0);
+}
+
+void HandleWindowManagerEvent(Event *event)
+{
+#if defined(TARGET_SDL)
+ SDLHandleWindowManagerEvent(event);
+#endif
+}
+
+void HandleButton(int mx, int my, int button, int button_nr)
+{
+ static int old_mx = 0, old_my = 0;
+ boolean button_hold = FALSE;
+ boolean handle_gadgets = TRUE;
+
+ if (button_nr < 0)
+ {
+ mx = old_mx;
+ my = old_my;
+ button_nr = -button_nr;
+ button_hold = TRUE;
+ }
+ else
+ {
+ old_mx = mx;
+ old_my = my;
+ }
+
+#if defined(PLATFORM_ANDROID)
+ // when playing, only handle gadgets when using "follow finger" controls
+ // or when using touch controls in combination with the MM game engine
+ handle_gadgets =
+ (game_status != GAME_MODE_PLAYING ||
+ level.game_engine_type == GAME_ENGINE_TYPE_MM ||
+ strEqual(setup.touch.control_type, TOUCH_CONTROL_FOLLOW_FINGER));
+#endif
+
+ if (HandleGlobalAnimClicks(mx, my, button))
+ {
+ // do not handle this button event anymore
+ return; // force mouse event not to be handled at all
+ }
+
+ if (handle_gadgets && HandleGadgets(mx, my, button))
+ {
+ // do not handle this button event anymore
+ mx = my = -32; // force mouse event to be outside screen tiles
+ }
+
+ if (button_hold && game_status == GAME_MODE_PLAYING && tape.pausing)
+ return;
+
+ // do not use scroll wheel button events for anything other than gadgets
+ if (IS_WHEEL_BUTTON(button_nr))
+ return;
+
+ switch (game_status)
+ {
+ case GAME_MODE_TITLE:
+ HandleTitleScreen(mx, my, 0, 0, button);
+ break;
+
+ case GAME_MODE_MAIN:
+ HandleMainMenu(mx, my, 0, 0, button);
+ break;
+
+ case GAME_MODE_PSEUDO_TYPENAME:
+ HandleTypeName(0, KSYM_Return);
+ break;
+
+ case GAME_MODE_LEVELS:
+ HandleChooseLevelSet(mx, my, 0, 0, button);
+ break;
+
+ case GAME_MODE_LEVELNR:
+ HandleChooseLevelNr(mx, my, 0, 0, button);
+ break;
+
+ case GAME_MODE_SCORES:
+ HandleHallOfFame(0, 0, 0, 0, button);
+ break;
+
+ case GAME_MODE_EDITOR:
+ HandleLevelEditorIdle();
+ break;
+
+ case GAME_MODE_INFO:
+ HandleInfoScreen(mx, my, 0, 0, button);
+ break;
+
+ case GAME_MODE_SETUP:
+ HandleSetupScreen(mx, my, 0, 0, button);
+ break;
+
+ case GAME_MODE_PLAYING:
+ if (!strEqual(setup.touch.control_type, TOUCH_CONTROL_OFF))
+ HandleButtonOrFinger(mx, my, button);
+ else
+ SetPlayerMouseAction(mx, my, button);
+
+#ifdef DEBUG
+ if (button == MB_PRESSED && !motion_status && !button_hold &&
+ IN_GFX_FIELD_PLAY(mx, my) && GetKeyModState() & KMOD_Control)
+ DumpTileFromScreen(mx, my);