Hotkey blocking correction (libretro#14831)

sonninnos · web-flow · commit 2f1a03523ba8 · 2023-01-13T04:56:14.000+01:00
diff --git a/input/input_driver.c b/input/input_driver.c
@@ -4056,13 +4056,19 @@ static void input_keys_pressed(
       rarch_joypad_info_t *joypad_info)
 {
    unsigned i;
-   bool libretro_input_pressed    = false;
    input_driver_state_t *input_st = &input_driver_st;
+   bool block_hotkey[RARCH_BIND_LIST_END];
+   bool libretro_hotkey_set       =
+            binds[port][RARCH_ENABLE_HOTKEY].joykey  != NO_BTN
+         || binds[port][RARCH_ENABLE_HOTKEY].joyaxis != AXIS_NONE;
+   bool keyboard_hotkey_set       =
+         binds[port][RARCH_ENABLE_HOTKEY].key != RETROK_UNKNOWN;
 
    if (!binds)
       return;
 
-   if (CHECK_INPUT_DRIVER_BLOCK_HOTKEY(binds_norm, binds_auto))
+   if (     binds[port][RARCH_ENABLE_HOTKEY].valid
+         && CHECK_INPUT_DRIVER_BLOCK_HOTKEY(binds_norm, binds_auto))
    {
       if (input_state_wrap(
             input_st->current_driver,
@@ -4090,14 +4096,13 @@ static void input_keys_pressed(
    if (!is_menu && binds[port][RARCH_GAME_FOCUS_TOGGLE].valid)
    {
       const struct retro_keybind *focus_binds_auto =
-         &input_autoconf_binds[port][RARCH_GAME_FOCUS_TOGGLE];
+            &input_autoconf_binds[port][RARCH_GAME_FOCUS_TOGGLE];
       const struct retro_keybind *focus_normal     =
-         &binds[port][RARCH_GAME_FOCUS_TOGGLE];
+            &binds[port][RARCH_GAME_FOCUS_TOGGLE];
 
-      /* Allows rarch_focus_toggle hotkey to still work
+      /* Allows Game Focus toggle hotkey to still work
        * even though every hotkey is blocked */
-      if (CHECK_INPUT_DRIVER_BLOCK_HOTKEY(
-               focus_normal, focus_binds_auto))
+      if (CHECK_INPUT_DRIVER_BLOCK_HOTKEY(focus_normal, focus_binds_auto))
       {
          if (input_state_wrap(
                input_st->current_driver,
@@ -4107,106 +4112,236 @@ static void input_keys_pressed(
                joypad_info,
                &binds[port],
                input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
-               port,
-               RETRO_DEVICE_JOYPAD, 0, RARCH_GAME_FOCUS_TOGGLE))
+               port, RETRO_DEVICE_JOYPAD, 0,
+               RARCH_GAME_FOCUS_TOGGLE))
             input_st->flags &= ~INP_FLAG_BLOCK_HOTKEY;
       }
    }
 
    {
-      int16_t ret = 0;
+      int16_t ret                 = 0;
+      bool libretro_input_pressed = false;
 
       /* Check libretro input if emulated device type is active,
-       * except device type is always active in menu. */
+       * except device type must be always active in menu. */
       if (     !(input_st->flags & INP_FLAG_BLOCK_LIBRETRO_INPUT)
             && !(!is_menu && !input_config_get_device(port)))
          ret = input_state_wrap(
                input_st->current_driver,
                input_st->current_data,
                input_st->primary_joypad,
                sec_joypad,
-               joypad_info, &binds[port],
+               joypad_info,
+               &binds[port],
                input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
                port, RETRO_DEVICE_JOYPAD, 0,
                RETRO_DEVICE_ID_JOYPAD_MASK);
 
       for (i = 0; i < RARCH_FIRST_META_KEY; i++)
       {
-         if (
-                  (ret & (UINT64_C(1) <<  i))
-               || input_keys_pressed_other_sources(input_st,
-                  i, p_new_state))
+         if (     (ret & (UINT64_C(1) << i))
+               || input_keys_pressed_other_sources(input_st, i, p_new_state))
          {
             BIT256_SET_PTR(p_new_state, i);
             libretro_input_pressed = true;
          }
       }
 
-      /* Check joypad menu toggle button, because
-       * Guide button is not part of the usual buttons. */
-      i = RARCH_MENU_TOGGLE;
-      if (     !libretro_input_pressed
-            && !input_st->keyboard_menu_toggle_pressed)
+      if (!libretro_input_pressed)
       {
-         bool bit_pressed = binds[port][i].valid
-            && input_state_wrap(
-                  input_st->current_driver,
-                  input_st->current_data,
-                  input_st->primary_joypad,
-                  sec_joypad,
-                  joypad_info,
-                  &binds[port],
-                  input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
-                  port, RETRO_DEVICE_JOYPAD, 0, i);
-
-         if (
-                  bit_pressed
-               || BIT64_GET(lifecycle_state, i)
-               || input_keys_pressed_other_sources(input_st,
-                  i, p_new_state))
+         bool keyboard_menu_pressed = false;
+
+         /* Ignore keyboard menu toggle button and check
+          * joypad menu toggle button for pressing
+          * it without 'enable_hotkey', because Guide button
+          * is not part of the usual buttons. */
+         i = RARCH_MENU_TOGGLE;
+
+         keyboard_menu_pressed = binds[port][i].valid
+               && input_state_wrap(
+                     input_st->current_driver,
+                     input_st->current_data,
+                     input_st->primary_joypad,
+                     sec_joypad,
+                     joypad_info,
+                     &binds[port],
+                     input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                     port, RETRO_DEVICE_KEYBOARD, 0,
+                     input_config_binds[port][i].key);
+
+         if (!keyboard_menu_pressed)
          {
-            BIT256_SET_PTR(p_new_state, i);
-            libretro_input_pressed = true;
+            bool bit_pressed = binds[port][i].valid
+                  && input_state_wrap(
+                        input_st->current_driver,
+                        input_st->current_data,
+                        input_st->primary_joypad,
+                        sec_joypad,
+                        joypad_info,
+                        &binds[port],
+                        input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                        port, RETRO_DEVICE_JOYPAD, 0, i);
+
+            if (
+                     bit_pressed
+                  || BIT64_GET(lifecycle_state, i)
+                  || input_keys_pressed_other_sources(input_st, i, p_new_state))
+            {
+               BIT256_SET_PTR(p_new_state, i);
+            }
          }
       }
    }
 
-   /* Check hotkeys, and block keyboard and joypad hotkeys separately. */
+   /* Hotkeys are only relevant for first port */
+   if (port > 0)
+      return;
+
+   /* Check hotkeys to block keyboard and joypad hotkeys separately.
+    * This looks complicated because hotkeys must be unblocked based
+    * on the device type depending if 'enable_hotkey' is set or not.. */
    if (     input_st->flags & INP_FLAG_BLOCK_HOTKEY
-         && !(    binds[0][RARCH_ENABLE_HOTKEY].key == RETROK_UNKNOWN
-               && !libretro_input_pressed))
+         && (libretro_hotkey_set && keyboard_hotkey_set))
    {
+      /* Block everything when hotkey bind exists for both device types */
+      for (i = RARCH_FIRST_META_KEY; i < RARCH_BIND_LIST_END; i++)
+         block_hotkey[i] = true;
+   }
+   else if (input_st->flags & INP_FLAG_BLOCK_HOTKEY
+         && (!libretro_hotkey_set || !keyboard_hotkey_set))
+   {
+      /* Block selectively when hotkey bind exists for either device type */
       for (i = RARCH_FIRST_META_KEY; i < RARCH_BIND_LIST_END; i++)
       {
-         if (
-                  BIT64_GET(lifecycle_state, i)
-               || input_keys_pressed_other_sources(input_st,
-                  i, p_new_state))
+         bool keyboard_hotkey_pressed = false;
+         bool libretro_hotkey_pressed = false;
+
+         /* Default */
+         block_hotkey[i] = true;
+
+         /* No 'enable_hotkey' in joypad */
+         if (!libretro_hotkey_set)
          {
-            BIT256_SET_PTR(p_new_state, i);
+            if (     binds[port][i].joykey  != NO_BTN
+                  || binds[port][i].joyaxis != AXIS_NONE)
+            {
+               /* Allow blocking if keyboard hotkey is pressed */
+               if (input_state_wrap(
+                     input_st->current_driver,
+                     input_st->current_data,
+                     input_st->primary_joypad,
+                     sec_joypad,
+                     joypad_info,
+                     &binds[port],
+                     input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                     port, RETRO_DEVICE_KEYBOARD, 0,
+                     input_config_binds[port][i].key))
+               {
+                  keyboard_hotkey_pressed = true;
+
+                  /* Always block */
+                  block_hotkey[i] = true;
+               }
+
+               /* Deny blocking if joypad hotkey is pressed */
+               if (input_state_wrap(
+                     input_st->current_driver,
+                     input_st->current_data,
+                     input_st->primary_joypad,
+                     sec_joypad,
+                     joypad_info,
+                     &binds[port],
+                     input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                     port, RETRO_DEVICE_JOYPAD, 0,
+                     i))
+               {
+                  libretro_hotkey_pressed = true;
+
+                  /* Only deny block if keyboard is not pressed */
+                  if (!keyboard_hotkey_pressed)
+                     block_hotkey[i] = false;
+               }
+            }
+         }
+
+         /* No 'enable_hotkey' in keyboard */
+         if (!keyboard_hotkey_set)
+         {
+            if (binds[port][i].key != RETROK_UNKNOWN)
+            {
+               /* Deny blocking if keyboard hotkey is pressed */
+               if (input_state_wrap(
+                     input_st->current_driver,
+                     input_st->current_data,
+                     input_st->primary_joypad,
+                     sec_joypad,
+                     joypad_info,
+                     &binds[port],
+                     input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                     port, RETRO_DEVICE_KEYBOARD, 0,
+                     input_config_binds[port][i].key))
+               {
+                  keyboard_hotkey_pressed = true;
+
+                  /* Only deny block if joypad is not pressed */
+                  if (!libretro_hotkey_pressed)
+                     block_hotkey[i] = false;
+               }
+
+               /* Allow blocking if joypad hotkey is pressed */
+               if (input_state_wrap(
+                     input_st->current_driver,
+                     input_st->current_data,
+                     input_st->primary_joypad,
+                     sec_joypad,
+                     joypad_info,
+                     &binds[port],
+                     input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                     port, RETRO_DEVICE_JOYPAD, 0,
+                     i))
+               {
+                  libretro_hotkey_pressed = true;
+
+                  /* Only block if keyboard is not pressed */
+                  if (!keyboard_hotkey_pressed)
+                     block_hotkey[i] = true;
+               }
+            }
          }
       }
    }
    else
+   {
+      /* Clear everything */
+      for (i = RARCH_FIRST_META_KEY; i < RARCH_BIND_LIST_END; i++)
+         block_hotkey[i] = false;
+   }
+
    {
       for (i = RARCH_FIRST_META_KEY; i < RARCH_BIND_LIST_END; i++)
       {
          bool bit_pressed = binds[port][i].valid
-            && input_state_wrap(
-                  input_st->current_driver,
-                  input_st->current_data,
-                  input_st->primary_joypad,
-                  sec_joypad,
-                  joypad_info,
-                  &binds[port],
-                  input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
-                  port, RETRO_DEVICE_JOYPAD, 0, i);
+               && input_state_wrap(
+                     input_st->current_driver,
+                     input_st->current_data,
+                     input_st->primary_joypad,
+                     sec_joypad,
+                     joypad_info,
+                     &binds[port],
+                     input_st->flags & INP_FLAG_KB_MAPPING_BLOCKED,
+                     port, RETRO_DEVICE_JOYPAD, 0,
+                     i);
 
          if (     bit_pressed
                || BIT64_GET(lifecycle_state, i)
-               || input_keys_pressed_other_sources(input_st,
-                  i, p_new_state))
+               || input_keys_pressed_other_sources(input_st, i, p_new_state))
          {
+            if (libretro_hotkey_set || keyboard_hotkey_set)
+            {
+               if (block_hotkey[i])
+                  continue;
+            }
+
             BIT256_SET_PTR(p_new_state, i);
          }
       }
@@ -6348,11 +6483,6 @@ void input_keyboard_event(bool down, unsigned code,
       if (code == RETROK_UNKNOWN)
          return;
 
-      /* Store keyboard menu toggle key for separating it from
-       * joypad menu toggle button when using 'enable_hotkey'. */
-      if (code == input_config_binds[0][RARCH_MENU_TOGGLE].key)
-         input_st->keyboard_menu_toggle_pressed = !!down;
-
       /* Check if keyboard events should be blocked when
        * pressing hotkeys and RetroPad binds, but
        * - not with Game Focus
diff --git a/input/input_driver.h b/input/input_driver.h
@@ -463,7 +463,6 @@ typedef struct
 
    /* primitives */
    bool analog_requested[MAX_USERS];
-   bool keyboard_menu_toggle_pressed;
    retro_bits_512_t keyboard_mapping_bits;    /* bool alignment */
    input_game_focus_state_t game_focus_state; /* bool alignment */
 } input_driver_state_t;
diff --git a/intl/msg_hash_us.h b/intl/msg_hash_us.h
@@ -3057,7 +3057,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_INPUT_META_ENABLE_HOTKEY,
-   "When assigned, the 'Hotkey Enable' key must be held before any other hotkeys are recognized. Allows controller buttons to be mapped to hotkey functions without affecting normal input. Assigning the modifier to controller only will not require it for keyboard hotkeys, but both modifiers work for both devices."
+   "When assigned, the 'Hotkey Enable' key must be held before any other hotkeys are recognized. Allows controller buttons to be mapped to hotkey functions without affecting normal input. Assigning the modifier to controller only will not require it for keyboard hotkeys, and vice versa, but both modifiers work for both devices."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_HELP_ENABLE_HOTKEY,
diff --git a/menu/menu_driver.c b/menu/menu_driver.c
@@ -6883,8 +6883,8 @@ void retroarch_menu_running(void)
             true);
    }
 
-   /* Prevent stray input (for a single frame) */
-   menu_st->input_driver_flushing_input = 1;
+   /* Prevent stray input */
+   menu_st->input_driver_flushing_input = 2;
 
 #ifdef HAVE_AUDIOMIXER
    if (audio_enable_menu && audio_enable_menu_bgm)
@@ -6952,9 +6952,8 @@ void retroarch_menu_running_finished(bool quit)
             false);
    }
 
-   /* Prevent stray input
-    * (for a single frame) */
-   menu_st->input_driver_flushing_input = 1;
+   /* Prevent stray input */
+   menu_st->input_driver_flushing_input = 2;
 
    if (!quit)
    {
diff --git a/runloop.c b/runloop.c

Original file line number	Diff line number	Diff line change
`@@ -3057,7 +3057,7 @@ MSG_HASH(`
`3057`	`3057`	`)`
`3058`	`3058`	`MSG_HASH(`
`3059`	`3059`	`MENU_ENUM_SUBLABEL_INPUT_META_ENABLE_HOTKEY,`
`3060`		`- "When assigned, the 'Hotkey Enable' key must be held before any other hotkeys are recognized. Allows controller buttons to be mapped to hotkey functions without affecting normal input. Assigning the modifier to controller only will not require it for keyboard hotkeys, but both modifiers work for both devices."`
	`3060`	`+ "When assigned, the 'Hotkey Enable' key must be held before any other hotkeys are recognized. Allows controller buttons to be mapped to hotkey functions without affecting normal input. Assigning the modifier to controller only will not require it for keyboard hotkeys, and vice versa, but both modifiers work for both devices."`
`3061`	`3061`	`)`
`3062`	`3062`	`MSG_HASH(`
`3063`	`3063`	`MENU_ENUM_LABEL_HELP_ENABLE_HOTKEY,`
Original file line number	Diff line number	Diff line change
`@@ -6883,8 +6883,8 @@ void retroarch_menu_running(void)`
`6883`	`6883`	`true);`
`6884`	`6884`	`}`
`6885`	`6885`
`6886`		`- /* Prevent stray input (for a single frame) */`
`6887`		`- menu_st->input_driver_flushing_input = 1;`
	`6886`	`+ /* Prevent stray input */`
	`6887`	`+ menu_st->input_driver_flushing_input = 2;`
`6888`	`6888`
`6889`	`6889`	`#ifdef HAVE_AUDIOMIXER`
`6890`	`6890`	`if (audio_enable_menu && audio_enable_menu_bgm)`
`@@ -6952,9 +6952,8 @@ void retroarch_menu_running_finished(bool quit)`
`6952`	`6952`	`false);`
`6953`	`6953`	`}`
`6954`	`6954`
`6955`		`- /* Prevent stray input`
`6956`		`- * (for a single frame) */`
`6957`		`- menu_st->input_driver_flushing_input = 1;`
	`6955`	`+ /* Prevent stray input */`
	`6956`	`+ menu_st->input_driver_flushing_input = 2;`
`6958`	`6957`
`6959`	`6958`	`if (!quit)`
`6960`	`6959`	`{`