Merge pull request #299 from ppizarror/fix-docs-typos-widget-id

Fix docs typos widget

Author: ppizarror

docs/_source/gallery.rst

@@ -115,4 +115,4 @@ Other - Image background
     :alt: Image background
     :width: 590
 
-Source: `examples/other/image_background.py <https://github.com/ppizarror/pygame-menu/blob/master/pygame_menu/examples/other/image_background.py>`_
+Source: `examples/other/image_background.py <https://github.com/ppizarror/pygame-menu/blob/master/pygame_menu/examples/other/image_background.py>`_

docs/_source/migration_guide.rst

@@ -43,4 +43,4 @@ Migration Guide - v2 to v3
 - Renamed Menu method parameters
     - ``element_name`` and ``element`` from ``add_button()`` to ``title`` and ``action``
     - ``values`` from ``add_selector()`` to ``items``
-    - ``widget_id`` from ``add_button()`` to ``button_id``
+    - ``widget_id`` from ``add_button()`` to ``button_id``

docs/_source/themes.rst

@@ -70,7 +70,7 @@ Background Color/Images
 
 Theme background can be both a color or an image. All colors can be defined
 using a tuple or an list of 3 or 4 numbers between 0 and 255. The format of
-numers are:
+the numbers are:
 
 .. code-block:: python
 

pygame_menu/baseimage.py

@@ -287,7 +287,7 @@ def checkpoint(self):
     def apply_image_function(self, image_function):
         """
         Apply a function to each pixel of the image. The function will receive the red, green, blue and alpha
-        colors and must return the same values. The color pixel will be overriden by the function output.
+        colors and must return the same values. The color pixel will be overridden by the function output.
 
         .. note::
 

pygame_menu/events.py

@@ -38,7 +38,7 @@
 
 class MenuAction(object):
     """
-    Pymenu events.
+    Pygame-menu events.
 
     :param action: Action identifier
     :type action: int

pygame_menu/examples/scroll_menu.py

@@ -130,6 +130,7 @@ def make_long_menu():
         _menu_sub.add_button(txt, on_button_click, 100 * i)
     _menu_sub.add_button('Back', pygame_menu.events.BACK)
 
+    # noinspection SpellCheckingInspection
     _menu_text.add_label(
         'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod '
         'tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, '

pygame_menu/menu.py

@@ -1208,10 +1208,12 @@ def select_widget(self, widget):
         """
         Select a widget from the Menu.
 
-        :param widget: Widget to be selected
-        :type widget: :py:class:`pygame_menu.widgets.core.widget.Widget`
+        :param widget: Widget to be selected or Widget ID
+        :type widget: :py:class:`pygame_menu.widgets.core.widget.Widget`, str
         :return: None
         """
+        if isinstance(widget, str):
+            widget = self.get_widget(widget_id=widget)
         assert isinstance(widget, _widgets.core.Widget)
         if not widget.is_selectable:
             raise ValueError('widget is not selectable')
@@ -1228,10 +1230,12 @@ def remove_widget(self, widget):
         """
         Remove a widget from the Menu.
 
-        :param widget: Widget object
-        :type widget: :py:class:`pygame_menu.widgets.core.widget.Widget`
+        :param widget: Widget object or ID
+        :type widget: :py:class:`pygame_menu.widgets.core.widget.Widget`, str
         :return: None
         """
+        if isinstance(widget, str):
+            widget = self.get_widget(widget_id=widget)
         assert isinstance(widget, _widgets.core.Widget)
         try:
             index = self._widgets.index(widget)  # If not exists this raises ValueError
@@ -1253,19 +1257,19 @@ def _update_after_remove_or_hidden(self, index, update_surface=True):
         :return: None
         """
         # Check if there's more selectable widgets
-        nselect = 0
+        n_select = 0
         last_selectable = 0
         for indx in range(len(self._widgets)):
             wid = self._widgets[indx]  # type: _widgets.core.Widget
             if wid.is_selectable and wid.visible:
-                nselect += 1
+                n_select += 1
                 last_selectable = indx
 
-        if nselect == 0:
+        if n_select == 0:
             self._index = -1  # Any widget is selected
-        elif nselect == 1:
+        elif n_select == 1:
             self._select(last_selectable)  # Select the unique selectable option
-        elif nselect > 1:
+        elif n_select > 1:
             if index == -1:  # Index was hidden
                 self._select(self._index + 1)
             elif self._index > index:  # If the selected widget was after this
@@ -1400,27 +1404,27 @@ def _update_widget_position(self):
             x_coord += self._widget_offset[0]
 
             # Calculate Y position
-            ysum = 1  # Compute the total height from the current row position to the top of the column
+            y_sum = 1  # Compute the total height from the current row position to the top of the column
             for r in range(row):
-                rwidget = self._widgets[int(self._rows * col + r)]  # type: _widgets.core.Widget
-                if rwidget.visible:
-                    ysum += widget_rects[rwidget.get_id()].height  # Height
-                    ysum += rwidget.get_margin()[1]  # Vertical margin (bottom)
+                r_widget = self._widgets[int(self._rows * col + r)]  # type: _widgets.core.Widget
+                if r_widget.visible:
+                    y_sum += widget_rects[r_widget.get_id()].height  # Height
+                    y_sum += r_widget.get_margin()[1]  # Vertical margin (bottom)
 
                     # If no widget is before add the selection effect
-                    yselh = rwidget.get_selection_effect().get_margin()[0]
-                    if r == 0 and self._widget_offset[1] <= yselh:
-                        if rwidget.is_selectable:
-                            ysum += yselh - self._widget_offset[1]
+                    y_sel_h = r_widget.get_selection_effect().get_margin()[0]
+                    if r == 0 and self._widget_offset[1] <= y_sel_h:
+                        if r_widget.is_selectable:
+                            y_sum += y_sel_h - self._widget_offset[1]
 
             # If the widget offset is zero, then add the selection effect to the height
             # of the widget to avoid visual glitches
-            yselh = widget.get_selection_effect().get_margin()[0]
-            if ysum == 1 and self._widget_offset[1] <= yselh:  # No widget is before
+            y_sel_h = widget.get_selection_effect().get_margin()[0]
+            if y_sum == 1 and self._widget_offset[1] <= y_sel_h:  # No widget is before
                 if widget.is_selectable:  # Add top margin
-                    ysum += yselh - self._widget_offset[1]
+                    y_sum += y_sel_h - self._widget_offset[1]
 
-            y_coord = max(0, self._widget_offset[1]) + ysum + widget.get_padding()[0]
+            y_coord = max(0, self._widget_offset[1]) + y_sum + widget.get_padding()[0]
 
             # Update the position of the widget
             widget.set_position(int(x_coord), int(y_coord))
@@ -1971,8 +1975,8 @@ def update(self, events):
 
             # If mouse motion enabled, add the current mouse position to event list
             if self._current._mouse and self._current._mouse_motion_selection:
-                mousex, mousey = pygame.mouse.get_pos()
-                events.append(pygame.event.Event(pygame.MOUSEMOTION, {'pos': (mousex, mousey)}))
+                mouse_x, mouse_y = pygame.mouse.get_pos()
+                events.append(pygame.event.Event(pygame.MOUSEMOTION, {'pos': (mouse_x, mouse_y)}))
 
             for event in events:  # type: pygame.event.Event
 
@@ -2245,8 +2249,8 @@ def _get_input_data(self, recursive, depth):
 
                 # Check if there is a collision between keys
                 data_keys = data.keys()
-                subdata_keys = data_submenu.keys()
-                for key in subdata_keys:  # type: str
+                sub_data_keys = data_submenu.keys()
+                for key in sub_data_keys:  # type: str
                     if key in data_keys:
                         msg = 'collision between widget data ID="{0}" at depth={1}'.format(key, depth)
                         raise ValueError(msg)

pygame_menu/sound.py

@@ -307,11 +307,11 @@ def _play_sound(self, sound):
             return False
 
         # Play the sound
-        soundtime = time.time()
+        sound_time = time.time()
 
         # If the previous sound is the same and has not ended (max 20% overlap)
         if sound['type'] != self._last_play or \
-                soundtime - self._last_time >= 0.2 * sound['length'] or self._uniquechannel:
+                sound_time - self._last_time >= 0.2 * sound['length'] or self._uniquechannel:
             try:
                 if self._uniquechannel:  # Stop the current channel if it's unique
                     channel.stop()
@@ -325,7 +325,7 @@ def _play_sound(self, sound):
 
         # Store last execution
         self._last_play = sound['type']
-        self._last_time = soundtime
+        self._last_time = sound_time
         return True
 
     def play_click_mouse(self):

pygame_menu/themes.py

@@ -97,8 +97,8 @@ class Theme(object):
     :type title_background_color: tuple, list
     :param title_bar_style: Style of the title, use menubar widget styles
     :type title_bar_style: int
-    :param title_font: Title font color. If ``None`` use the widget font color
-    :type title_font: str, None
+    :param title_font: Title font path or name
+    :type title_font: str
     :param title_font_antialias: Title font renders with antialiasing
     :type title_font_antialias: bool
     :param title_font_color: Title font color, if None use the widget font color
@@ -417,28 +417,28 @@ def _get(params, key, allowed_types=None, default=None):
         if allowed_types:
             if not isinstance(allowed_types, (tuple, list)):
                 allowed_types = (allowed_types,)
-            for valtype in allowed_types:
-                if valtype == 'color':
+            for val_type in allowed_types:
+                if val_type == 'color':
                     _utils.assert_color(value)
-                elif valtype == 'color_none':
+                elif val_type == 'color_none':
                     if value is None:
                         return value
                     _utils.assert_color(value)
-                elif valtype == 'color_image':
+                elif val_type == 'color_image':
                     if isinstance(value, BaseImage):
                         return value
                     _utils.assert_color(value)
-                elif valtype == 'color_image_none':
+                elif val_type == 'color_image_none':
                     if value is None:
                         return value
                     elif isinstance(value, BaseImage):
                         return value
                     _utils.assert_color(value)
-                elif valtype == 'position':
+                elif val_type == 'position':
                     _utils.assert_position(value)
-                elif valtype == 'alignment':
+                elif val_type == 'alignment':
                     _utils.assert_alignment(value)
-                elif valtype == 'tuple2':
+                elif val_type == 'tuple2':
                     _utils.assert_vector2(value)
 
             all_types = ('color', 'color_none', 'color_image', 'color_image_none',

pygame_menu/utils.py

@@ -204,6 +204,7 @@ def is_callable(func):
     return isinstance(func, (types.FunctionType, types.BuiltinFunctionType, types.MethodType, functools.partial))
 
 
+# noinspection SpellCheckingInspection
 def to_string(s, strict=False):
     """
     Check if string, if not convert. See issue #215.

pygame_menu/version.py

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

pygame_menu/widgets/core/widget.py

@@ -298,7 +298,7 @@ def expand_background_inflate_to_selection_effect(self):
         Expand background inflate to match the selection effect
         (the widget don't require to be selected).
 
-        This is a permanent change; for dynamic purpuoses, depending if the widget
+        This is a permanent change; for dynamic purposes, depending if the widget
         is selected or not, setting ``widget.selection_expand_background`` to ``True`` may help.
 
         .. note::

pygame_menu/widgets/examples/scrollbar.py

@@ -59,13 +59,13 @@ def make_world(width, height):
     world.fill((200, 200, 200))
 
     color = [70, 20, 20]
-    maxx = len(list(range(100, width, 200)))
-    maxy = len(list(range(100, height, 200)))
-    numberx = 0
+    max_x = len(list(range(100, width, 200)))
+    max_y = len(list(range(100, height, 200)))
+    number_x = 0
     for x in range(100, width, 200):
-        numbery = 0
+        number_y = 0
         for y in range(100, height, 200):
-            if numberx in (0, maxx - 1) or numbery in (0, maxy - 1):
+            if number_x in (0, max_x - 1) or number_y in (0, max_y - 1):
                 # White circles to delimit world boundaries
                 # noinspection PyArgumentList
                 pygame.draw.circle(world, (255, 255, 255), (x, y), 100, 10)
@@ -78,8 +78,8 @@ def make_world(width, height):
                     color[1] += 15
                 else:
                     color[2] += 15
-            numbery += 1
-        numberx += 1
+            number_y += 1
+        number_x += 1
 
     return world
 

pygame_menu/widgets/widget/colorinput.py

@@ -304,7 +304,7 @@ def _render(self):
     # noinspection PyMissingOrEmptyDocstring
     def update(self, events):
         _input = self._input_string
-        _curpos = self._cursor_position
+        _cur_pos = self._cursor_position
         _disable_remove_separator = True
 
         key = ''  # Pressed key
@@ -316,19 +316,19 @@ def update(self, events):
                     if not check_key_pressed_valid(event):
                         return True
 
-                    if _disable_remove_separator and len(_input) > 0 and len(_input) > _curpos and (
+                    if _disable_remove_separator and len(_input) > 0 and len(_input) > _cur_pos and (
                             '{0}{0}'.format(self._separator) not in _input or
-                            _input[_curpos] == self._separator and len(_input) == _curpos + 1
+                            _input[_cur_pos] == self._separator and len(_input) == _cur_pos + 1
                     ):
 
                         # Backspace button, delete text from right
                         if event.key == pygame.K_BACKSPACE:
-                            if len(_input) >= 1 and _input[_curpos - 1] == self._separator:
+                            if len(_input) >= 1 and _input[_cur_pos - 1] == self._separator:
                                 return True
 
                         # Delete button, delete text from left
                         elif event.key == pygame.K_DELETE:
-                            if _input[_curpos] == self._separator:
+                            if _input[_cur_pos] == self._separator:
                                 return True
 
                     # Verify only on user key input, the rest of events are checked by TextInput on super call
@@ -362,13 +362,13 @@ def update(self, events):
                             if key != self._separator:
                                 _pos_before = 0
                                 _pos_after = 0
-                                for _i in range(_curpos):
-                                    if _new_string[_curpos - _i - 1] == self._separator:
-                                        _pos_before = _curpos - _i
+                                for _i in range(_cur_pos):
+                                    if _new_string[_cur_pos - _i - 1] == self._separator:
+                                        _pos_before = _cur_pos - _i
                                         break
-                                for _i in range(len(_new_string) - _curpos):
-                                    if _new_string[_curpos + _i] == self._separator:
-                                        _pos_after = _curpos + _i
+                                for _i in range(len(_new_string) - _cur_pos):
+                                    if _new_string[_cur_pos + _i] == self._separator:
+                                        _pos_after = _cur_pos + _i
                                         break
                                 if _pos_after == 0:
                                     _pos_after = len(_new_string)
@@ -393,20 +393,20 @@ def update(self, events):
 
                     # Backspace button, delete text from right
                     if event.key == pygame.K_BACKSPACE:
-                        if _curpos == 1:
+                        if _cur_pos == 1:
                             return True
 
                     # Delete button, delete text from left
                     elif event.key == pygame.K_DELETE:
-                        if _curpos == 0:
+                        if _cur_pos == 0:
                             return True
 
                     # Verify only on user key input, the rest of events are checked by TextInput on super call
                     key = str(event.unicode)
                     if key in self._valid_chars:
                         if key == '#':
                             return True
-                        if _curpos == 0:
+                        if _cur_pos == 0:
                             return True
 
         # Update
@@ -433,7 +433,7 @@ def update(self, events):
             for c in colors:
                 if len(c) > 0 and (int(c) > 255 or int(c) < 0):
                     self._input_string = _input
-                    self._cursor_position = _curpos
+                    self._cursor_position = _cur_pos
                     break
 
             if len(colors) == 3:
@@ -442,12 +442,12 @@ def update(self, events):
             # Add an auto separator if the number can't continue growing and the cursor
             # is at the end of the line
             if _total_separator < 2 and len(self._input_string) == self._cursor_position:
-                autopos = len(colors) - 1
-                last_num = colors[autopos]
+                auto_pos = len(colors) - 1
+                last_num = colors[auto_pos]
                 if (len(last_num) == 2 and int(last_num) > 25 or len(last_num) == 3 and int(last_num) <= 255) and \
-                        autopos not in self._auto_separator_pos:
+                        auto_pos not in self._auto_separator_pos:
                     self._push_key_input(self._separator, sounds=False)  # This calls .onchange()
-                    self._auto_separator_pos.append(autopos)
+                    self._auto_separator_pos.append(auto_pos)
 
             # If the user cleared all the string, reset auto separator
             if _total_separator == 0 and \