Merge pull request #393 from ppizarror/menu_border_color

Menu border color

Author: ppizarror

pygame_menu/_scrollarea.py

@@ -19,6 +19,7 @@
 import pygame
 import pygame_menu
 
+from itertools import product
 from pygame_menu._base import Base
 from pygame_menu._decorator import Decorator
 from pygame_menu.locals import POSITION_SOUTHEAST, POSITION_SOUTHWEST, POSITION_WEST, \
@@ -91,6 +92,8 @@ class ScrollArea(Base):
     :param area_width: Width of scrollable area in px
     :param area_height: Height of scrollable area in px
     :param area_color: Background color, it can be a color or an image
+    :param border_color: Border color
+    :param border_width: Border width in px
     :param controls_joystick: Use joystick events
     :param controls_keyboard: Use keyboard events
     :param controls_mouse: Use mouse events
@@ -114,6 +117,10 @@ class ScrollArea(Base):
     :param world: Surface to draw and scroll
     """
     _area_color: Optional[Union[ColorInputType, 'pygame_menu.BaseImage']]
+    _border_color: Optional[Union[ColorInputType, 'pygame_menu.BaseImage']]
+    _border_tiles: List['pygame.Surface']
+    _border_tiles_size: Tuple2IntType
+    _border_width: int
     _bg_surface: Optional['pygame.Surface']
     _decorator: 'Decorator'
     _extend_x: int
@@ -135,6 +142,8 @@ def __init__(
             area_width: int,
             area_height: int,
             area_color: Optional[Union[ColorInputType, 'pygame_menu.BaseImage']] = None,
+            border_color: Optional[Union[ColorInputType, 'pygame_menu.BaseImage']] = None,
+            border_width: int = 0,
             controls_joystick: bool = True,
             controls_keyboard: bool = True,
             controls_mouse: bool = True,
@@ -161,6 +170,7 @@ def __init__(
 
         assert isinstance(area_height, int)
         assert isinstance(area_width, int)
+        assert isinstance(border_width, int)
         assert isinstance(controls_joystick, bool)
         assert isinstance(controls_keyboard, bool)
         assert isinstance(controls_mouse, bool)
@@ -175,6 +185,18 @@ def __init__(
 
         if area_color is not None and not isinstance(area_color, pygame_menu.BaseImage):
             area_color = assert_color(area_color)
+        if border_color is not None and not isinstance(border_color, pygame_menu.BaseImage):
+            border_color = assert_color(border_color)
+
+        # Create tiles
+        if isinstance(border_color, pygame_menu.BaseImage):
+            iw, ih = border_color.get_size()
+            tw, th = iw // 3, ih // 3
+            self._border_tiles_size = tw, th
+            self._border_tiles = [
+                border_color.subsurface((x, y, tw, th))
+                for x, y in product(range(0, iw, tw), range(0, ih, th))
+            ]
 
         scrollbar_color = assert_color(scrollbar_color)
         scrollbar_slider_color = assert_color(scrollbar_slider_color)
@@ -195,7 +217,8 @@ def __init__(
                     unique_scrolls.append(s)
 
         self._area_color = area_color
-        self._bg_surface = None
+        self._border_color = border_color
+        self._border_width = border_width
         self._bg_surface = None
         self._decorator = Decorator(self)
         self._scrollbar_positions = tuple(unique_scrolls)  # Ensure unique
@@ -300,10 +323,11 @@ def _make_background_surface(self) -> None:
         # Make surface
         self._bg_surface = make_surface(width=self._rect.width + self._extend_x,
                                         height=self._rect.height + self._extend_y)
+        rect = self._bg_surface.get_rect()
         if self._area_color is not None:
             if isinstance(self._area_color, pygame_menu.BaseImage):
                 self._area_color.draw(surface=self._bg_surface,
-                                      area=self._bg_surface.get_rect())
+                                      area=rect)
             else:
                 self._bg_surface.fill(assert_color(self._area_color))
 
@@ -476,6 +500,74 @@ def draw(self, surface: 'pygame.Surface') -> 'ScrollArea':
         # Draw post decorator
         self._decorator.draw_post(surface)
 
+        # Create border
+        if isinstance(self._border_color, pygame_menu.BaseImage):  # Image
+            tw, th = self._border_tiles_size
+            border_rect = pygame.Rect(
+                int(self._rect.x - tw),
+                int(self._rect.y - th),
+                int(self._rect.width + 2 * tw),
+                int(self._rect.height + 2 * th)
+            )
+
+            surface_blit = surface.blit
+            (
+                tile_nw,
+                tile_w,
+                tile_sw,
+                tile_n,
+                tile_c,
+                tile_s,
+                tile_ne,
+                tile_e,
+                tile_se,
+            ) = self._border_tiles
+            left, top = self._rect.topleft
+            left -= tw
+            top -= th
+
+            # draw top and bottom tiles
+            area: Optional[Tuple[int, int, int, int]]
+
+            for x in range(border_rect.left, border_rect.right, tw):
+                if x + tw >= border_rect.right:
+                    area = 0, 0, tw - (x + border_rect.right), th
+                else:
+                    area = None
+                surface_blit(tile_n, (x, top), area)
+                surface_blit(tile_s, (x, border_rect.bottom - th), area)
+
+            # draw left and right tiles
+            for y in range(border_rect.top, border_rect.bottom, th):
+                if y + th >= border_rect.bottom:
+                    area = 0, 0, tw, th - (y + border_rect.bottom)
+                else:
+                    area = None
+                surface_blit(tile_w, (left, y), area)
+                surface_blit(tile_e, (border_rect.right - tw, y), area)
+
+            # draw corners
+            surface_blit(tile_nw, (left, top))
+            surface_blit(tile_sw, (left, border_rect.bottom - th))
+            surface_blit(tile_ne, (border_rect.right - tw, top))
+            surface_blit(tile_se, (border_rect.right - tw, border_rect.bottom - th))
+
+        else:  # Color
+            if self._border_width == 0 or self._border_color is None:
+                return self
+            border_rect = pygame.Rect(
+                int(self._rect.x - self._border_width),
+                int(self._rect.y - self._border_width),
+                int(self._rect.width + 2 * self._border_width),
+                int(self._rect.height + 2 * self._border_width)
+            )
+            pygame.draw.rect(
+                surface,
+                self._border_color,
+                border_rect,
+                self._border_width
+            )
+
         return self
 
     def get_hidden_width(self) -> int:

pygame_menu/baseimage.py

@@ -18,6 +18,7 @@
     'IMAGE_EXAMPLE_METAL',
     'IMAGE_EXAMPLE_PYGAME_MENU',
     'IMAGE_EXAMPLE_PYTHON',
+    'IMAGE_EXAMPLE_TILED_BORDER',
     'IMAGE_EXAMPLE_WALLPAPER',
     'IMAGE_EXAMPLES',
 
@@ -58,11 +59,12 @@
 IMAGE_EXAMPLE_METAL = __images_path__.format('metal.png')
 IMAGE_EXAMPLE_PYGAME_MENU = __images_path__.format('pygame_menu.png')
 IMAGE_EXAMPLE_PYTHON = __images_path__.format('python.svg')
+IMAGE_EXAMPLE_TILED_BORDER = __images_path__.format('tiled_border.png')
 IMAGE_EXAMPLE_WALLPAPER = __images_path__.format('wallpaper.jpg')
 
 IMAGE_EXAMPLES = (IMAGE_EXAMPLE_CARBON_FIBER, IMAGE_EXAMPLE_GRAY_LINES,
                   IMAGE_EXAMPLE_METAL, IMAGE_EXAMPLE_PYGAME_MENU, IMAGE_EXAMPLE_PYTHON,
-                  IMAGE_EXAMPLE_WALLPAPER)
+                  IMAGE_EXAMPLE_TILED_BORDER, IMAGE_EXAMPLE_WALLPAPER)
 
 # Drawing modes
 IMAGE_MODE_CENTER = 100
@@ -404,6 +406,15 @@ def get_height(self) -> int:
         """
         return int(self._surface.get_height())
 
+    def subsurface(self, rect: Union[Tuple4IntType, 'pygame.Rect']) -> 'pygame.Surface':
+        """
+        Return a subsurface from a rect.
+
+        :param rect: Rect
+        :return: Subsurface
+        """
+        return self._surface.subsurface(rect)
+
     def get_size(self) -> Tuple2IntType:
         """
         Return the size in pixels of the image.

pygame_menu/menu.py

@@ -541,6 +541,8 @@ def __init__(
             area_color=self._theme.background_color,
             area_height=self._height - extend_y,
             area_width=self._width,
+            border_color=self._theme.border_color,
+            border_width=self._theme.border_width,
             controls_joystick=self._joystick,
             controls_keyboard=self._keyboard,
             controls_mouse=self._mouse,

pygame_menu/resources/images/tiled_border.png

@@ -80,7 +80,11 @@ class Theme(object):
         width/height see Menu parameters.
 
     :param background_color: Menu background color
-    :type background_color: tuple, list, :py:class:`pygame_menu.baseimage.BaseImage`
+    :type background_color: tuple, list, str, int, :py:class:`pygame.Color`, :py:class:`pygame_menu.baseimage.BaseImage`
+    :param border_color: Menu border color. If border is an image, it will be split in 9 tiles to use top, left, bottom, right, and the corners
+    :type border_color: tuple, list, str, int, :py:class:`pygame.Color`, :py:class:`pygame_menu.baseimage.BaseImage`, None
+    :param border_width: Border width in px. Used only if ``border_color`` is not an image
+    :type border_width: int
     :param cursor_color: Cursor color (used in some text-gathering widgets like ``TextInput``)
     :type cursor_color: tuple, list, str, int, :py:class:`pygame.Color`
     :param cursor_selection_color: Color of the text selection if the cursor is enabled on certain widgets
@@ -238,6 +242,7 @@ class Theme(object):
     """
     _disable_validation: bool
     background_color: Union[ColorType, 'BaseImage']
+    border_color: Union[ColorType, 'BaseImage']
     cursor_color: ColorType
     cursor_selection_color: ColorType
     cursor_switch_ms: NumberType
@@ -320,6 +325,8 @@ def __init__(self, **kwargs) -> None:
 
         # Menu general
         self.background_color = self._get(kwargs, 'background_color', 'color_image', (220, 220, 220))
+        self.border_color = self._get(kwargs, 'border_color', 'color_image_none')
+        self.border_width = self._get(kwargs, 'border_width', int, 0)
         self.focus_background_color = self._get(kwargs, 'focus_background_color', 'color', (0, 0, 0, 180))
         self.fps = self._get(kwargs, 'fps', NumberInstance, 30)
         self.readonly_color = self._get(kwargs, 'readonly_color', 'color', (120, 120, 120))
@@ -463,6 +470,7 @@ def validate(self) -> 'Theme':
         if self.widget_selection_effect is None:
             self.widget_selection_effect = NoneSelection()
 
+        assert isinstance(self.border_width, int)
         assert isinstance(self.cursor_switch_ms, NumberInstance)
         assert isinstance(self.fps, NumberInstance)
         assert isinstance(self.scrollbar_shadow_offset, int)
@@ -489,6 +497,7 @@ def validate(self) -> 'Theme':
         # Format colors, this converts all color lists to tuples automatically,
         # if it is an image, return the same object
         self.background_color = self._format_color_opacity(self.background_color)
+        self.border_color = self._format_color_opacity(self.border_color, none=True)
         self.cursor_color = self._format_color_opacity(self.cursor_color)
         self.cursor_selection_color = self._format_color_opacity(self.cursor_selection_color)
         self.focus_background_color = self._format_color_opacity(self.focus_background_color)
@@ -538,6 +547,7 @@ def validate(self) -> 'Theme':
         self.widget_offset = self._vec_to_tuple(self.widget_offset, 2, NumberInstance)
 
         # Check sizes
+        assert self.border_width >= 0, 'border width must be equal or greater than zero'
         assert self.scrollarea_outer_margin[0] >= 0 and self.scrollarea_outer_margin[1] >= 0, \
             'scroll area outer margin must be equal or greater than zero on both axis'
         assert self.widget_offset[0] >= 0 and self.widget_offset[1] >= 0, \

pygame_menu/themes.py

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

pygame_menu/version.py

@@ -422,3 +422,11 @@ def test_cache(self) -> None:
         image.draw(surface, r)
         self.assertNotEqual(image._last_transform[2], s)
         self.assertEqual(image._last_transform[0], 300)
+
+    def test_subsurface(self) -> None:
+        """
+        Test subsurface.
+        """
+        image = pygame_menu.BaseImage(pygame_menu.baseimage.IMAGE_EXAMPLE_TILED_BORDER)
+        self.assertEqual(image.get_size(), (18, 18))
+        self.assertEqual(image.subsurface((0, 0, 3, 3)).get_size(), (3, 3))

test/test_baseimage.py

@@ -2395,3 +2395,26 @@ def _resize():
         menu.resize(400, 400, position=(50, 50, False))
         self.assertFalse(menu._position_relative)
         self.assertEqual(menu._position, (50, 50))
+
+    def test_border_color(self) -> None:
+        """
+        Test menu border color.
+        """
+        theme = pygame_menu.themes.THEME_DEFAULT.copy()
+        self.assertIsNone(theme.border_color)
+        theme.border_width = 10
+        theme.title_font_size = 15
+
+        # Test invalid
+        theme.border_color = 'invalid'
+        self.assertRaises(ValueError, lambda: pygame_menu.Menu('Menu with border color', 250, 250, theme=theme))
+
+        # Test with border color
+        theme.border_color = 'red'
+        menu = pygame_menu.Menu('Menu with border color', 250, 250, theme=theme)
+        menu.draw(surface)
+
+        # Test with image
+        theme.border_color = pygame_menu.BaseImage(pygame_menu.baseimage.IMAGE_EXAMPLE_TILED_BORDER)
+        menu = pygame_menu.Menu('Menu with border image', 250, 250, theme=theme)
+        menu.draw(surface)