Merge pull request #441 from ppizarror/keyrepeat-option

Keyrepeat option

Author: ppizarror

pygame_menu/baseimage.py

@@ -466,7 +466,7 @@ def get_bitsize(self) -> int:
         """
         Return the image bit size.
 
-        :return: Image bit size
+        :return: Image size
         """
         return self._surface.get_bitsize()
 

pygame_menu/examples/other/maze.py

@@ -571,7 +571,7 @@ def _sleep(ms: float) -> None:
         """
         Sleep time.
 
-        :param ms: Sleep in ms
+        :param ms: Sleep time in milliseconds
         """
         time.sleep(ms)
 
@@ -751,8 +751,8 @@ def _recursive_division(
         """
         Performs recursive division.
 
-        :param chamber: Limits
-        :param halving: Divides the recursion area by two
+        :param chamber: Limit
+        :param halving: Divide the recursion area by two
         """
 
         def _gaps_to_offset() -> List[int]:

pygame_menu/version.py

@@ -34,6 +34,6 @@ def __str__(self) -> str:
     patch = property(lambda self: self[2])
 
 
-vernum = Version(4, 3, 4)
+vernum = Version(4, 3, 5)
 ver = str(vernum)
 rev = ''

pygame_menu/widgets/selection/arrow_selection.py

@@ -90,7 +90,7 @@ def _draw_arrow(
         :param b: Arrow coord B
         :param c: Arrow coord C
         """
-        SELECTOR_CLOCK.tick(60)  # As blink is in ms
+        SELECTOR_CLOCK.tick(60)
         self._blink_time += SELECTOR_CLOCK.get_time()
 
         # Switch the blinking if the time exceeded or the widget has changed

pygame_menu/widgets/widget/button.py

@@ -409,7 +409,7 @@ def button(
             try:
                 self._check_kwargs(kwargs)
             except ValueError:
-                if self._verbose:
+                if self._menu._verbose:
                     warn('button cannot accept kwargs. If you want to use kwargs '
                          'options set accept_kwargs=True')
                 raise

pygame_menu/widgets/widget/colorinput.py

@@ -90,7 +90,7 @@ class ColorInput(TextInput):
     :param onselect: Function when selecting the widget
     :param prev_margin: Horizontal margin between the previsualization and the input text in px
     :param prev_width_factor: Width of the previsualization box in terms of the height of the widget
-    :param repeat_keys_initial_ms: Time in ms before keys are repeated when held
+    :param repeat_keys_initial_ms: Time in milliseconds before keys are repeated when held
     :param repeat_keys_interval_ms: Interval between key press repetition when held
     :param repeat_mouse_interval_ms: Interval between mouse events when held
     :param kwargs: Optional keyword arguments
@@ -635,9 +635,10 @@ def color_input(
             - ``previsualization_width``        (int, float) – Pre-visualization width as a factor of the height. Default is ``3``
             - ``readonly_color``                (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget if readonly mode
             - ``readonly_selected_color``       (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget if readonly mode and is selected
-            - ``repeat_keys_initial_ms``        (int, float) - Time in ms before keys are repeated when held in ms. ``400`` by default
-            - ``repeat_keys_interval_ms``       (int, float) - Interval between key press repetition when held in ms. ``50`` by default
-            - ``repeat_mouse_interval_ms``      (int, float) - Interval between mouse events when held in ms. ``400`` by default
+            - ``repeat_keys``                   (bool) - Enable key repeat. ``True`` by default
+            - ``repeat_keys_initial_ms``        (int, float) - Time in milliseconds before keys are repeated when held in milliseconds. ``400`` by default
+            - ``repeat_keys_interval_ms``       (int, float) - Interval between key press repetition when held in milliseconds. ``50`` by default
+            - ``repeat_mouse_interval_ms``      (int, float) - Interval between mouse events when held in milliseconds. ``400`` by default
             - ``selection_color``               (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the selected widget; only affects the font color
             - ``selection_effect``              (:py:class:`pygame_menu.widgets.core.Selection`) – Widget selection effect
             - ``shadow_color``                  (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget shadow

pygame_menu/widgets/widget/rangeslider.py

@@ -93,8 +93,9 @@ class RangeSlider(Widget):
     :param range_text_value_tick_hfactor: Height factor of the range text value tick (factor of the range title height)
     :param range_text_value_tick_number: Number of range value text, the values are placed uniformly distributed
     :param range_text_value_tick_thick: Thickness of the range text value tick in px
-    :param repeat_keys_initial_ms: Time in ms before keys are repeated when held in ms
-    :param repeat_keys_interval_ms: Interval between key press repetition when held in ms
+    :param repeat_keys: Enable key repeat
+    :param repeat_keys_initial_ms: Time in milliseconds before keys are repeated when held in milliseconds
+    :param repeat_keys_interval_ms: Interval between key press repetition when held in milliseconds
     :param slider_color: Slider color
     :param slider_height_factor: Height of the slider (factor of the range title height)
     :param slider_sel_highlight_color: Color of the selected slider highlight box effect
@@ -120,6 +121,7 @@ class RangeSlider(Widget):
     _font_slider_value: Optional['pygame.font.Font']
     _increment: NumberType
     _increment_shift_factor: float
+    _keyrepeat: bool
     _keyrepeat_counters: Dict[int, int]
     _keyrepeat_initial_interval_ms: NumberType
     _keyrepeat_interval_ms: NumberType
@@ -218,6 +220,7 @@ def __init__(
             range_text_value_tick_hfactor: NumberType = 0.35,
             range_text_value_tick_number: int = 2,
             range_text_value_tick_thick: int = 1,
+            repeat_keys: bool = True,
             repeat_keys_initial_ms: NumberType = 400,
             repeat_keys_interval_ms: NumberType = 50,
             slider_color: ColorInputType = (120, 120, 120),
@@ -379,6 +382,15 @@ def __init__(
             'value_format must be a function that accepts only 1 argument ' \
             '(value) and must return a string'
 
+        # Check keyrepeat
+        assert isinstance(repeat_keys, bool)
+        assert isinstance(repeat_keys_initial_ms, NumberInstance)
+        assert isinstance(repeat_keys_interval_ms, NumberInstance)
+        assert repeat_keys_initial_ms > 0, \
+            'repeat keys initial ms cannot be lower or equal than zero'
+        assert repeat_keys_interval_ms > 0, \
+            'repeat keys interval ms cannot be lower or equal than zero'
+
         # Single value
         single = isinstance(default_value, NumberInstance)
 
@@ -393,6 +405,7 @@ def __init__(
         self._default_value = tuple(default_value)
         self._increment = increment
         self._increment_shift_factor = 0.5
+        self._keyrepeat = repeat_keys
         self._keyrepeat_counters = {}  # {event.key: (counter_int, event.unicode)} (look for "***")
         self._keyrepeat_initial_interval_ms = repeat_keys_initial_ms
         self._keyrepeat_interval_ms = repeat_keys_interval_ms
@@ -1076,14 +1089,15 @@ def update(self, events: EventVectorType) -> bool:
                     if self._update_value(delta):
                         updated = True
 
-        # Update key counters:
-        for key in self._keyrepeat_counters:
-            self._keyrepeat_counters[key] += time_clock  # Update clock
+        # Update key counters
+        if self._keyrepeat:
+            for key in self._keyrepeat_counters:
+                self._keyrepeat_counters[key] += time_clock  # Update clock
 
-            # Generate new key events if enough time has passed:
-            if self._keyrepeat_counters[key] >= self._keyrepeat_initial_interval_ms:
-                self._keyrepeat_counters[key] = self._keyrepeat_initial_interval_ms - self._keyrepeat_interval_ms
-                self._add_event(pygame.event.Event(pygame.KEYDOWN, key=key))
+                # Generate new key events if enough time has passed:
+                if self._keyrepeat_counters[key] >= self._keyrepeat_initial_interval_ms:
+                    self._keyrepeat_counters[key] = self._keyrepeat_initial_interval_ms - self._keyrepeat_interval_ms
+                    self._add_event(pygame.event.Event(pygame.KEYDOWN, key=key))
 
         return updated
 
@@ -1173,8 +1187,9 @@ def range_slider(
             - ``range_text_value_tick_thick``   (int) - Thickness of the range text value tick in px
             - ``readonly_color``                (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget if readonly mode
             - ``readonly_selected_color``       (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget if readonly mode and is selected
-            - ``repeat_keys_initial_ms``        (int) - Time in ms before keys are repeated when held in ms. ``400`` by default
-            - ``repeat_keys_interval_ms``       (int) - Interval between key press repetition when held in ms. ``50`` by default
+            - ``repeat_keys``                   (bool) - Enable key repeat. ``True`` by default
+            - ``repeat_keys_initial_ms``        (int) - Time in milliseconds before keys are repeated when held in milliseconds. ``400`` by default
+            - ``repeat_keys_interval_ms``       (int) - Interval between key press repetition when held in milliseconds. ``50`` by default
             - ``selection_color``               (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the selected widget; only affects the font color
             - ``selection_effect``              (:py:class:`pygame_menu.widgets.core.Selection`) – Widget selection effect
             - ``shadow_color``                  (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget shadow

pygame_menu/widgets/widget/textinput.py

@@ -91,9 +91,10 @@ class TextInput(Widget):
     :param onselect: Function when selecting the widget
     :param password: Input string is displayed as a password
     :param password_char: Character used by password type
-    :param repeat_keys_initial_ms: Time in ms before keys are repeated when held in ms
-    :param repeat_keys_interval_ms: Interval between key press repetition when held in ms
-    :param repeat_mouse_interval_ms: Interval between mouse events when held in ms
+    :param repeat_keys: Enable key repeat
+    :param repeat_keys_initial_ms: Time in milliseconds before keys are repeated when held in milliseconds
+    :param repeat_keys_interval_ms: Interval between key press repetition when held in milliseconds
+    :param repeat_mouse_interval_ms: Interval between mouse events when held in milliseconds
     :param text_ellipsis: Ellipsis text when overflow occurs (input length exceeds maxwidth)
     :param valid_chars: List of chars that are valid, ``None`` if all chars are valid
     :param kwargs: Optional keyword arguments
@@ -130,6 +131,7 @@ class TextInput(Widget):
     _input_underline_vmargin: int
     _key_is_pressed: bool
     _keychar_size: Dict[str, NumberType]
+    _keyrepeat: bool
     _keyrepeat_counters: Dict[int, List[int]]
     _keyrepeat_initial_interval_ms: NumberType
     _keyrepeat_interval_ms: NumberType
@@ -181,6 +183,7 @@ def __init__(
             onselect: CallbackType = None,
             password: bool = False,
             password_char: str = '*',
+            repeat_keys: bool = True,
             repeat_keys_initial_ms: NumberType = 400,
             repeat_keys_interval_ms: NumberType = 50,
             repeat_mouse_interval_ms: NumberType = 400,
@@ -202,6 +205,7 @@ def __init__(
         assert isinstance(maxwidth, int)
         assert isinstance(password, bool)
         assert isinstance(password_char, str)
+        assert isinstance(repeat_keys, bool)
         assert isinstance(repeat_keys_initial_ms, NumberInstance)
         assert isinstance(repeat_keys_interval_ms, NumberInstance)
         assert isinstance(repeat_mouse_interval_ms, NumberInstance)
@@ -222,11 +226,11 @@ def __init__(
         assert cursor_switch_ms > 0, \
             'cursor switch in milliseconds must be greater than zero'
         assert repeat_keys_initial_ms > 0, \
-            'ms cannot be lower or equal than zero'
+            'repeat keys initial ms cannot be lower or equal than zero'
         assert repeat_keys_interval_ms > 0, \
-            'ms cannot be lower or equal than zero'
+            'repeat keys interval ms cannot be lower or equal than zero'
         assert repeat_mouse_interval_ms > 0, \
-            'ms cannot be lower or equal than zero'
+            'repeat mouse interval ms cannot be lower or equal than zero'
 
         cursor_color = assert_color(cursor_color)
         cursor_selection_color = assert_color(cursor_selection_color)
@@ -273,6 +277,7 @@ def __init__(
         # Vars to make keydown repeat after user pressed a key for some time:
         self._block_copy_paste = False  # Blocks event
         self._key_is_pressed = False
+        self._keyrepeat = repeat_keys
         self._keyrepeat_counters = {}  # {event.key: (counter_int, event.unicode)} (look for "***")
         self._keyrepeat_initial_interval_ms = repeat_keys_initial_ms
         self._keyrepeat_interval_ms = repeat_keys_interval_ms
@@ -1877,22 +1882,23 @@ def update(self, events: EventVectorType) -> bool:
                 pos = pygame.mouse.get_pos()
                 self._check_mouse_collide_input((pos[0], pos[1]))
 
-        # Update key counters:
-        for key in self._keyrepeat_counters:
-            self._keyrepeat_counters[key][0] += time_clock  # Update clock
-
-            # Generate new key events if enough time has passed:
-            if self._keyrepeat_counters[key][0] >= self._keyrepeat_initial_interval_ms:
-                self._keyrepeat_counters[key][0] = \
-                    self._keyrepeat_initial_interval_ms - self._keyrepeat_interval_ms
-
-                event_key, event_unicode = key, self._keyrepeat_counters[key][1]
-                self._add_event(
-                    pygame.event.Event(
-                        pygame.KEYDOWN,
-                        key=event_key,
-                        unicode=event_unicode)
-                )
+        # Update key counters
+        if self._keyrepeat:
+            for key in self._keyrepeat_counters:
+                self._keyrepeat_counters[key][0] += time_clock  # Update clock
+
+                # Generate new key events if enough time has passed:
+                if self._keyrepeat_counters[key][0] >= self._keyrepeat_initial_interval_ms:
+                    self._keyrepeat_counters[key][0] = \
+                        self._keyrepeat_initial_interval_ms - self._keyrepeat_interval_ms
+
+                    event_key, event_unicode = key, self._keyrepeat_counters[key][1]
+                    self._add_event(
+                        pygame.event.Event(
+                            pygame.KEYDOWN,
+                            key=event_key,
+                            unicode=event_unicode)
+                    )
 
         return updated
 
@@ -1968,9 +1974,10 @@ def text_input(
             - ``password_char``                 (str) - Character used by password type. ``"*"`` by default
             - ``readonly_color``                (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget if readonly mode
             - ``readonly_selected_color``       (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget if readonly mode and is selected
-            - ``repeat_keys_initial_ms``        (int, float) - Time in ms before keys are repeated when held in ms. ``400`` by default
-            - ``repeat_keys_interval_ms``       (int, float) - Interval between key press repetition when held in ms. ``50`` by default
-            - ``repeat_mouse_interval_ms``      (int, float) - Interval between mouse events when held in ms. ``400`` by default
+            - ``repeat_keys``                   (bool) - Enable key repeat. ``True`` by default
+            - ``repeat_keys_initial_ms``        (int, float) - Time in milliseconds before keys are repeated when held in milliseconds. ``400`` by default
+            - ``repeat_keys_interval_ms``       (int, float) - Interval between key press repetition when held in milliseconds. ``50`` by default
+            - ``repeat_mouse_interval_ms``      (int, float) - Interval between mouse events when held in milliseconds. ``400`` by default
             - ``selection_color``               (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the selected widget; only affects the font color
             - ``selection_effect``              (:py:class:`pygame_menu.widgets.core.Selection`) – Widget selection effect
             - ``shadow_color``                  (tuple, list, str, int, :py:class:`pygame.Color`) – Color of the widget shadow

test/_utils.py

@@ -19,6 +19,7 @@
 
     # Methods
     'reset_widgets_over',
+    'sleep',
     'surface',
     'test_reset_surface',
 
@@ -34,6 +35,8 @@
 import sys
 import unittest
 
+from time import sleep
+
 import pygame
 import pygame_menu
 

test/test_menu.py

@@ -11,7 +11,6 @@
 from test._utils import BaseRSTest, surface, MenuUtils, PygameEventUtils, \
     TEST_THEME, PYGAME_V2, WIDGET_MOUSEOVER, WIDGET_TOP_CURSOR, reset_widgets_over, \
     THEME_NON_FIXED_TITLE
-from typing import Any, Tuple, List
 import copy
 import math
 import sys
@@ -23,6 +22,8 @@
 import pygame_menu.controls as ctrl
 
 from pygame_menu import events
+# noinspection PyProtectedMember
+from pygame_menu._types import Any, Tuple, List
 from pygame_menu.locals import FINGERDOWN, FINGERMOTION
 from pygame_menu.utils import set_pygame_cursor, get_cursor
 from pygame_menu.widgets import Label, Button

test/test_widget_rangeslider.py

@@ -8,7 +8,7 @@
 
 __all__ = ['RangeSliderWidgetTest']
 
-from test._utils import MenuUtils, surface, PygameEventUtils, BaseTest
+from test._utils import MenuUtils, surface, PygameEventUtils, BaseTest, sleep
 
 import pygame
 import pygame_menu
@@ -477,3 +477,23 @@ def test_value(self) -> None:
         r.reset_value()
         self.assertEqual(r.get_value(), (0.2, 0.6))
         self.assertFalse(r.value_changed())
+
+    def test_keyrepeat(self) -> None:
+        """
+        Test keyrepeat.
+        """
+        menu = MenuUtils.generic_menu(keyboard_ignore_nonphysical=False)
+
+        e = PygameEventUtils.key(ctrl.KEY_RIGHT, keydown=True)
+        slider_on = menu.add.range_slider('', 0, [0, 1], increment=0.1)
+        slider_on.update(e)
+        slider_off = menu.add.range_slider('', 0, [0, 1], increment=0.1, repeat_keys=False)
+        slider_off.update(e)
+
+        # Test with time
+        for i in range(5):
+            sleep(0.5)
+            slider_on.update([])
+            slider_off.update([])
+        self.assertGreater(slider_on.get_value(), 0.1)
+        self.assertEqual(slider_off.get_value(), 0.1)

test/test_widget_textinput.py

@@ -9,7 +9,7 @@
 __all__ = ['TextInputWidgetTest']
 
 from test._utils import MenuUtils, surface, PygameEventUtils, TEST_THEME, PYGAME_V2, \
-    BaseTest
+    BaseTest, sleep
 
 import pygame
 import pygame_menu
@@ -410,7 +410,6 @@ def test_copy_paste(self) -> None:
         self.assertEqual(textinput_copy.get_value(), '')
         textinput_copy._block_copy_paste = False
         textinput_copy._paste()
-        #  self.assertEqual(textinput_copy.get_value(), 'er than the max char')
         textinput_copy._cut()
         textinput_copy._block_copy_paste = False
         # self.assertEqual(textinput_copy.get_value(), '')
@@ -824,3 +823,23 @@ def test_empty_title(self) -> None:
         menu = MenuUtils.generic_menu()
         text = menu.add.text_input('')
         self.assertEqual(text.get_size(), (16, 49))
+
+    def test_keyrepeat(self) -> None:
+        """
+        Test keyrepeat.
+        """
+        menu = MenuUtils.generic_menu(keyboard_ignore_nonphysical=False)
+
+        e = PygameEventUtils.key(pygame.K_a, keydown=True, char='a')
+        textinput_on = menu.add.text_input('On', repeat_keys=True)
+        textinput_on.update(e)
+        textinput_off = menu.add.text_input('Off', repeat_keys=False)
+        textinput_off.update(e)
+
+        # Test with time
+        for i in range(5):
+            sleep(0.5)
+            textinput_on.update([])
+            textinput_off.update([])
+        self.assertGreater(len(textinput_on.get_value()), 1)
+        self.assertEqual(len(textinput_off.get_value()), 1)