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.