def add_ellipse(self,
x: NumberType,
y: NumberType,
rx: NumberType,
ry: NumberType,
color: ColorType,
filled: bool,
prev: bool = True) -> str:
"""
Add an ellipse.
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param rx: Horizontal radius of the ellipse
:param ry: Vertical radius of the ellipse
:param color: Color of the polygon
:param filled: If ``True`` fills the polygon with the given color
:param prev: If ``True`` draw previous the object, else draws post
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
assert_color(color)
assert isinstance(rx, (int, float)) and rx > 0
assert isinstance(ry, (int, float)) and ry > 0
assert isinstance(filled, bool)
return self._add_decor(DECORATION_ELLIPSE, prev,
(tuple(coords), rx, ry, color, filled))
def add_pie(self,
x: NumberType,
y: NumberType,
radius: NumberType,
init_angle: NumberType,
final_angle: NumberType,
color: ColorType,
prev: bool = True) -> str:
"""
Add a unfilled pie.
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param radius: Circle radius (px)
:param init_angle: Initial angle in degrees ``(0-360)``
:param final_angle: Final angle in degrees ``(0-360)``
:param color: Color of the polygon
:param prev: If ``True`` draw previous the object, else draws post
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
assert_color(color)
assert isinstance(radius, (int, float)) and radius > 0
assert isinstance(init_angle, (int, float))
assert isinstance(final_angle, (int, float))
assert init_angle != final_angle
return self._add_decor(
DECORATION_PIE, prev,
(tuple(coords), int(radius), init_angle, final_angle, color))
def add_polygon(self, coords: Union[List[Tuple2NumberType], Tuple[Tuple2NumberType, ...]], color: ColorType,
filled: bool, width: int = 0, prev: bool = True, gfx: bool = True) -> str:
"""
Add polygon.
:param coords: Coordinate list, being ``(0, 0)`` the center of the object
:param color: Color of the polygon
:param filled: If ``True`` fills the polygon with the given color
:param width: Line border width. Only valid if ``filled=False``
:param prev: If ``True`` draw previous the object, else draws post
:param gfx: If ``True`` uses pygame gfxdraw instead of draw
:return: ID of the decoration
"""
assert_list_vector(coords, 2)
assert_color(color)
assert len(coords) >= 3
assert isinstance(filled, bool)
assert isinstance(width, int) and width >= 0
if filled:
assert width == 0, 'width must be 0 if the polygon is filled'
assert gfx, 'only gfxdraw support filled polygon, then gfx should be True'
else:
if width != 0 and gfx:
gfx = False # gfx don't support width
return self._add_decor(DECORATION_POLYGON, prev, (tuple(coords), color, filled, width, gfx))
def add_line(self,
pos1: Tuple2NumberType,
pos2: Tuple2NumberType,
color: ColorType,
width: int = 1,
prev: bool = True,
**kwargs) -> str:
"""
Adds a line.
.. note::
Consider ``(0, 0)`` coordinates as the center of the object.
kwargs (Optional)
- ``use_center_positioning`` Uses object center position as *(0, 0)*. ``True`` by default
:param pos1: Position 1 *(x1, y1)*
:param pos2: Position 2 *(x2, y2)*
:param color: Line color
:param width: Line width in px
:param prev: If ``True`` draw previous the object, else draws post
:param kwargs: Optional keyword arguments
:return: ID of the decoration
"""
assert_vector(pos1, 2)
assert_vector(pos2, 2)
assert_color(color)
assert isinstance(width, int) and width >= 1
length = math.sqrt(
math.pow(pos1[0] - pos2[0], 2) + math.pow(pos1[1] - pos2[1], 2))
assert length > 0, 'line cannot be zero-length'
return self._add_decor(
DECORATION_LINE, prev,
((tuple(pos1), tuple(pos2)), color, width, kwargs))
def set_shadow(self, enabled=True, color=None, position=None, offset=None):
"""
Show text shadow.
:param enabled: Shadow is enabled or not
:type enabled: bool
:param color: Shadow color
:type color: list, None
:param position: Shadow position
:type position: str, None
:param offset: Shadow offset
:type offset: int, float, None
:return: None
"""
self._shadow = enabled
if color is not None:
assert_color(color)
self._shadow_color = color
if position is not None:
assert_position(position)
self._shadow_position = position
if offset is not None:
assert isinstance(offset, (int, float))
if offset <= 0:
raise ValueError('shadow offset must be greater than zero')
self._shadow_offset = offset
# Create shadow tuple position
self._create_shadow_tuple()
def add_bezier(self,
coords: Union[List[Tuple2NumberType],
Tuple[Tuple2NumberType, ...]],
color: ColorType,
steps: int = 5,
prev: bool = True,
**kwargs) -> str:
"""
Add bezier curve.
.. note::
Consider ``(0, 0)`` coordinates as the center of the object.
kwargs (Optional)
- ``use_center_positioning`` Uses object center position as *(0, 0)*. ``True`` by default
:param coords: Coordinate list, being ``(0, 0)`` the center of the object
:param color: Color of the polygon
:param steps: Interpolation steps
:param prev: If ``True`` draw previous the object, else draws post
:param kwargs: Optional keyword arguments
:return: ID of the decoration
"""
assert_list_vector(coords, 2)
assert_color(color)
assert len(coords) >= 3
assert isinstance(steps, int) and steps >= 1
return self._add_decor(DECORATION_BEZIER, prev,
(tuple(coords), color, steps, kwargs))
def add_pixel(self,
x: NumberType,
y: NumberType,
color: ColorType,
prev: bool = True,
**kwargs) -> str:
"""
Add a pixel.
.. note::
Consider ``(0, 0)`` coordinates as the center of the object.
kwargs (Optional)
- ``use_center_positioning`` Uses object center position as *(0, 0)*. ``True`` by default
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param color: Color of the pixel
:param prev: If ``True`` draw previous the object, else draws post
:param kwargs: Optional keyword arguments
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
assert_color(color)
return self._add_decor(DECORATION_PIXEL, prev,
(tuple(coords), color, kwargs))
def add_circle(self, x: NumberType, y: NumberType, radius: NumberType, color: ColorType, filled: bool,
width: int = 0, prev: bool = True, gfx: bool = True) -> str:
"""
Add circle.
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param radius: Circle radius (px)
:param color: Color of the polygon
:param filled: If ``True`` fills the polygon with the given color
:param width: Line border width. Only valid if ``filled=False``
:param prev: If ``True`` draw previous the object, else draws post
:param gfx: If ``True`` uses pygame gfxdraw instead of draw
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
assert_color(color)
assert isinstance(radius, (int, float)) and radius > 0
assert isinstance(filled, bool)
assert isinstance(width, int) and width >= 0
if filled:
assert width == 0, 'width must be 0 if the circle is filled'
else:
if width != 0 and gfx:
gfx = False # gfx don't support width
return self._add_decor(DECORATION_CIRCLE, prev, (tuple(coords), int(radius), color, filled, width, gfx))
def __init__(self,
title,
width,
background_color,
back_box=False,
mode=MENUBAR_STYLE_ADAPTIVE,
offsetx=0.0,
offsety=0.0,
onreturn=None,
*args,
**kwargs):
assert isinstance(width, (int, float))
assert isinstance(back_box, bool)
assert_color(background_color)
# MenuBar has no ID
super(MenuBar, self).__init__(title=title,
onreturn=onreturn,
args=args,
kwargs=kwargs)
self._backbox = back_box
self._backbox_pos = None # type: (tuple,None)
self._backbox_rect = None # type: (pygame.rect.Rect,None)
self._background_color = background_color
self._box_mode = 0
self._offsetx = 0.0
self._offsety = 0.0
self._polygon_pos = None # type: (tuple,None)
self._style = mode
self._title = ''
self._width = width
self.set_title(title, offsetx, offsety)
def add_arc(self, x: NumberType, y: NumberType, radius: NumberType,
init_angle: NumberType, final_angle: NumberType, color: ColorType,
width: int = 0, prev: bool = True, gfx: bool = True) -> str:
"""
Add arc.
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param radius: Circle radius (px)
:param init_angle: Initial angle in degrees ``(0-360)``
:param final_angle: Final angle in degrees ``(0-360)``
:param color: Color of the polygon
:param width: Line border width. Only valid if ``filled=False``
:param prev: If ``True`` draw previous the object, else draws post
:param gfx: If ``True`` uses pygame gfxdraw instead of draw
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
assert_color(color)
assert isinstance(radius, (int, float)) and radius > 0
assert isinstance(init_angle, (int, float))
assert isinstance(final_angle, (int, float))
assert isinstance(width, int) and width >= 0
assert init_angle != final_angle
return self._add_decor(DECORATION_ARC, prev, (tuple(coords), int(radius), init_angle, final_angle,
color, width, gfx))
def _format_opacity(color: Optional[Union[VectorType, 'BaseImage']]
) -> Optional[Union[ColorType, 'BaseImage']]:
"""
Adds opacity to a 3 channel color. (R,G,B) -> (R,G,B,A) if the color
has not an alpha channel. Also updates the opacity to a number between
0 and 255.
Color may be an Image, so if this is the case return the same object.
- If the color is a list, return a tuple.
- If the color is ``None``, return ``None``.
:param color: Color object
:return: Color in the same format
"""
if isinstance(color, BaseImage):
return color
if color is None:
return color
if isinstance(color, (tuple, list)):
_utils.assert_color(color)
if len(color) == 4:
if isinstance(color, tuple):
return color
return tuple(color)
elif len(color) == 3:
color = color[0], color[1], color[2], 255
else:
raise ValueError('invalid color type {0}, only tuple or list are valid'.format(color))
return color
def _format_color_opacity(
color: Optional[Union[ColorInputType, 'BaseImage']],
none: bool = False) -> Optional[Union[ColorType, 'BaseImage']]:
"""
Adds opacity to a 3 channel color. (R,G,B) -> (R,G,B,A) if the color
has not an alpha channel. Also updates the opacity to a number between
``0`` (transparent) and ``255`` (opaque).
Color may be an Image, so if this is the case return the same object.
- If the color is a list, return a tuple.
- If the color is ``None``, return ``None`` if ``None`` is True.
:param color: Color object
:param none: If ``True`` Color can be ``None``
:return: Color in the same format
"""
if isinstance(color, BaseImage):
return color
if color is None and none:
return color
color = format_color(color)
if isinstance(color, VectorInstance):
assert_color(color)
if len(color) == 4:
if isinstance(color, tuple):
return color
return tuple(color)
elif len(color) == 3:
color = color[0], color[1], color[2], 255
else:
raise ValueError(
'invalid color type {0}, only tuple or list are valid'.format(
color))
return color
def _format_opacity(color):
"""
Adds opacity to a 3 channel color. (R,G,B) -> (R,G,B,A) if the color
has not an alpha channel. Also updates the opacity to a number between
0 and 255.
Color may be an Image, so if this is the case return the same object.
If the color is a list, return a tuple.
:param color: Color tuple
:type color: tuple, list
:return: Color in the same format
:rtype: tuple, None
"""
if isinstance(color, BaseImage):
return color
if color is None:
return color
if isinstance(color, (tuple, list)):
_utils.assert_color(color)
if len(color) == 4:
if isinstance(color, tuple):
return color
else:
return color[0], color[1], color[2], color[3]
elif len(color) == 3:
color = color[0], color[1], color[2], 255
else:
raise ValueError(
'invalid color type {0}, only tuple or list are valid'.format(
color))
return color
def __init__(
self,
title: Any,
width: NumberType,
background_color: ColorInputType,
menubar_id: str = '',
back_box: bool = False,
back_box_background_color: ColorInputType = (0, 0, 0),
mode: MenuBarStyleModeType = MENUBAR_STYLE_ADAPTIVE,
modify_scrollarea: bool = True,
offsetx: NumberType = 0,
offsety: NumberType = 0,
onreturn: CallbackType = None,
*args,
**kwargs
) -> None:
assert isinstance(width, NumberInstance)
assert isinstance(back_box, bool)
assert width > 0, 'width must be greater or equal than zero'
background_color = assert_color(background_color)
back_box_background_color = assert_color(back_box_background_color)
# MenuBar has no ID
super(MenuBar, self).__init__(
args=args,
kwargs=kwargs,
onreturn=onreturn,
title=title,
widget_id=menubar_id
)
self._backbox = back_box
self._backbox_background_color = back_box_background_color
self._backbox_border_width = 1 # px
self._backbox_pos = None
self._backbox_rect = None
self._background_color = background_color
self._box_mode = 0
self._modify_scrollarea = modify_scrollarea
self._mouseover_check_rect = lambda: self._backbox_rect
self._offsetx = 0
self._offsety = 0
self._polygon_pos = None
# north, east, south, west
self._scrollbar_deltas = [(0, (0, 0)), (0, (0, 0)), (0, (0, 0)), (0, (0, 0))]
self._style = mode
self._title = ''
self._width = int(width)
self.set_title(title, offsetx, offsety)
# Public's
self.is_selectable = False
self.fixed = True
def set_color(self, color: ColorType) -> 'Selection':
"""
Set the selection effect color.
:param color: Selection color
:return: Self reference
"""
assert_color(color)
self.color = color
return self
def set_color(self, color):
"""
Set the selection color.
:param color: Selection color
:type color: tuple, list
:return: None
"""
assert_color(color)
self.color = color
def __init__(self,
length: NumberType,
values_range: VectorIntType,
scrollbar_id: str = '',
orientation: ScrollBarOrientationType = _locals.
ORIENTATION_HORIZONTAL,
slider_pad: NumberType = 0,
slider_color: ColorType = (200, 200, 200),
page_ctrl_thick: int = 20,
page_ctrl_color: ColorType = (235, 235, 235),
onchange: CallbackType = None,
*args,
**kwargs) -> None:
assert isinstance(length, (int, float))
assert isinstance(values_range, (tuple, list))
assert values_range[1] > values_range[
0], 'minimum value first is expected'
assert isinstance(slider_pad, (int, float))
assert isinstance(page_ctrl_thick, int)
assert page_ctrl_thick - 2 * slider_pad >= 2, 'slider shall be visible'
assert_color(slider_color)
assert_color(page_ctrl_color)
super(ScrollBar, self).__init__(widget_id=scrollbar_id,
onchange=onchange,
args=args,
kwargs=kwargs)
self._values_range = list(values_range)
self.scrolling = False
self._mouseover = False
self._orientation = 0
self._opp_orientation = int(not self._orientation)
self._page_ctrl_length = length
self._page_ctrl_thick = page_ctrl_thick
self._page_ctrl_color = page_ctrl_color
self._slider_rect = None
self._slider_pad = slider_pad
self._slider_color = slider_color
self._slider_position = 0
self._single_step = 20
self._page_step = 0
if values_range[1] - values_range[0] > length:
self.set_page_step(length)
else:
self.set_page_step(
(values_range[1] - values_range[0]) / 5.0) # Arbitrary
self.set_orientation(orientation)
self.is_selectable = False
def __init__(self,
length,
values_range,
scrollbar_id='',
orientation=_locals.ORIENTATION_HORIZONTAL,
slider_pad=0,
slider_color=(200, 200, 200),
page_ctrl_thick=20,
page_ctrl_color=(235, 235, 235),
onchange=None,
onreturn=None,
*args,
**kwargs):
assert isinstance(length, (int, float))
assert isinstance(values_range, (tuple, list))
assert values_range[1] > values_range[
0], 'minimum value first is expected'
assert isinstance(slider_pad, (int, float))
assert isinstance(page_ctrl_thick, (int, float))
assert page_ctrl_thick - 2 * slider_pad >= 2, 'slider shall be visible'
assert_color(slider_color)
assert_color(page_ctrl_color)
super(ScrollBar, self).__init__(widget_id=scrollbar_id,
onchange=onchange,
onreturn=onreturn,
args=args,
kwargs=kwargs)
self._values_range = list(values_range)
self.scrolling = False # type: bool
self._orientation = 0 # type: int
self._opp_orientation = int(not self._orientation) # type: int
self._page_ctrl_length = length
self._page_ctrl_thick = page_ctrl_thick
self._page_ctrl_color = page_ctrl_color
self._slider_rect = None # type: (pygame.Rect,None)
self._slider_pad = slider_pad
self._slider_color = slider_color
self._slider_position = 0 # type: int
self._single_step = 20 # type: int
self._page_step = None # type: (int,None)
if values_range[1] - values_range[0] > length:
self.set_page_step(length)
else:
self.set_page_step(
(values_range[1] - values_range[0]) / 5.0) # Arbitrary
self.set_orientation(orientation)
def set_background_color_opacity(self, opacity: float) -> 'Theme':
"""
Modify the Menu background color with given opacity.
:param opacity: Opacity value, from ``0`` (transparent) to ``1`` (opaque)
:return: Self reference
"""
_utils.assert_color(self.background_color)
assert isinstance(opacity, float)
assert 0 <= opacity <= 1, 'opacity must be a number between 0 (transparent) and 1 (opaque)'
self.background_color = (self.background_color[0], self.background_color[1],
self.background_color[2], int(opacity * 255))
return self
def add_pixel(self, x: NumberType, y: NumberType, color: ColorType, prev: bool = True) -> str:
"""
Add a pixel.
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param color: Color of the pixel
:param prev: If ``True`` draw previous the object, else draws post
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
assert_color(color)
return self._add_decor(DECORATION_PIXEL, prev, (tuple(coords), color))
def add_rect(
self,
x: NumberType,
y: NumberType,
rect: 'pygame.Rect',
color: ColorInputType,
width: int = 0,
prev: bool = True,
**kwargs
) -> str:
"""
Adds a BaseImage object.
.. note::
Consider ``(0, 0)`` coordinates as the center of the object.
kwargs (Optional)
- ``use_center_positioning`` Uses object center position as *(0, 0)*. ``True`` by default
:param x: X position (px), being ``0`` the center of the object
:param y: Y position (px), being ``0`` the center of the object
:param rect: Rect to draw
:param color: Color of the rect
:param width: Border width of the rect. If ``0`` draw a filled rectangle
:param prev: If ``True`` draw previous the object, else draws post
:param kwargs: Optional keyword arguments
:return: ID of the decoration
"""
assert isinstance(width, int) and width >= 0
coords = [(x, y)]
assert_list_vector(coords, 2)
color = assert_color(color)
assert isinstance(rect, pygame.Rect)
return self._add_decor(DECORATION_RECT, prev, (tuple(coords), rect, color, width, kwargs))
def add_ellipse(self,
x: NumberType,
y: NumberType,
rx: NumberType,
ry: NumberType,
color: ColorInputType,
filled: bool,
prev: bool = True,
**kwargs) -> str:
"""
Adds an ellipse.
kwargs (Optional)
- ``use_center_positioning`` (bool) – Uses object center position as *(0, 0)*. ``True`` by default
:param x: X position in px, being ``0`` the center of the object
:param y: Y position in px, being ``0`` the center of the object
:param rx: Horizontal radius of the ellipse
:param ry: Vertical radius of the ellipse
:param color: Color of the polygon
:param filled: If ``True`` fills the polygon with the given color
:param prev: If ``True`` draw previous the object, else draws post
:param kwargs: Optional keyword arguments
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
color = assert_color(color)
assert isinstance(rx, NumberInstance) and rx > 0
assert isinstance(ry, NumberInstance) and ry > 0
assert isinstance(filled, bool)
return self._add_decor(DECORATION_ELLIPSE, prev,
(tuple(coords), rx, ry, color, filled, kwargs))
def add_pie(self,
x: NumberType,
y: NumberType,
radius: NumberType,
init_angle: NumberType,
final_angle: NumberType,
color: ColorInputType,
prev: bool = True,
**kwargs) -> str:
"""
Adds a unfilled pie.
kwargs (Optional)
- ``use_center_positioning`` (bool) – Uses object center position as *(0, 0)*. ``True`` by default
:param x: X position in px, being ``0`` the center of the object
:param y: Y position in px, being ``0`` the center of the object
:param radius: Circle radius in px
:param init_angle: Initial angle in degrees, from ``0`` to ``360``
:param final_angle: Final angle in degrees, from ``0`` to ``360``
:param color: Color of the polygon
:param prev: If ``True`` draw previous the object, else draws post
:param kwargs: Optional keyword arguments
:return: ID of the decoration
"""
coords = [(x, y)]
assert_list_vector(coords, 2)
color = assert_color(color)
assert isinstance(radius, NumberInstance) and radius > 0
assert isinstance(init_angle, NumberInstance)
assert isinstance(final_angle, NumberInstance)
assert init_angle != final_angle
return self._add_decor(DECORATION_PIE, prev,
(tuple(coords), int(radius), init_angle,
final_angle, color, kwargs))
def add_bezier(self, coords: Union[List[Tuple2NumberType], Tuple[Tuple2NumberType, ...]],
color: ColorType, steps: int = 5, prev: bool = True) -> str:
"""
Add bezier curve.
:param coords: Coordinate list, being ``(0, 0)`` the center of the object
:param color: Color of the polygon
:param steps: Interpolation steps
:param prev: If ``True`` draw previous the object, else draws post
:return: ID of the decoration
"""
assert_list_vector(coords, 2)
assert_color(color)
assert len(coords) >= 3
assert isinstance(steps, int) and steps >= 1
return self._add_decor(DECORATION_BEZIER, prev, (tuple(coords), color, steps))
def _check_cell_style(align: str, background_color: ColorInputType,
border_color: ColorInputType,
border_position: WidgetBorderPositionType,
border_width: int, padding: PaddingType,
vertical_position: str) -> None:
"""
Assert cell style.
:param align: Horizontal align of each cell. See :py:mod:`pygame_menu.locals`
:param background_color: Background color
:param border_color: Border color of each cell
:param border_position: Border position of each cell. Valid only: north, south, east, and west. See :py:mod:`pygame_menu.locals`
:param border_width: Border width in px of each cell
:param padding: Cell padding according to CSS rules. General shape: (top, right, bottom, left)
:param vertical_position: Vertical position of each cell. Only valid: north, center, and south. See :py:mod:`pygame_menu.locals`
:return: None
"""
# Alignment
assert_alignment(align)
# Background color
if background_color is not None:
assert_color(background_color)
# Padding
parse_padding(padding)
# Vertical position
assert_position(vertical_position)
assert vertical_position in (POSITION_NORTH, POSITION_CENTER, POSITION_SOUTH), \
'cell vertical position must be NORTH, CENTER, or SOUTH'
# Border color
assert isinstance(border_width, int) and border_width >= 0
if border_color is not None:
assert_color(border_color)
# Border position
assert isinstance(border_position, (str, VectorInstance))
if isinstance(border_position, str):
border_position = [border_position]
# Border positioning
for pos in border_position:
assert pos in (POSITION_NORTH, POSITION_SOUTH, POSITION_EAST, POSITION_WEST), \
'only north, south, east, and west border positions are valid, ' \
'but received "{0}"'.format(pos)
def add_line(self, pos1: Tuple2NumberType, pos2: Tuple2NumberType, color: ColorType, width: int = 1,
prev: bool = True) -> str:
"""
Adds a line.
:param pos1: Position 1 *(x1, y1)*
:param pos2: Position 2 *(x2, y2)*
:param color: Line color
:param width: Line width in px
:param prev: If ``True`` draw previous the object, else draws post
:return: ID of the decoration
"""
assert_vector(pos1, 2)
assert_vector(pos2, 2)
assert_color(color)
assert isinstance(width, int) and width >= 1
return self._add_decor(DECORATION_LINE, prev, ((tuple(pos1), tuple(pos2)), color, width))
def add_underline(self, color: ColorType, offset: int, width: int, force_render: bool = False) -> 'Widget':
"""
Adds a underline to text. This is added if widget is rendered
:param color: Underline color
:param offset: Underline offset
:param width: Underline width
:param force_render: If ``True`` force widget render after addition
:return: Self reference
"""
assert_color(color)
assert isinstance(offset, int)
assert isinstance(width, int) and width > 0
self._last_underline[1] = (color, offset, width)
if force_render:
self._force_render()
return self
def _get(params, key, allowed_types=None, default=None):
"""
Return a value from a dictionary.
:param params: parameters dictionary
:type params: dict
:param key: key to look for
:type key: str
:param allowed_types: list of allowed types
:type allowed_types: any
:param default: default value to return
:type default: any
:return: The value associated to the key
:rtype: any
"""
if key not in params:
return default
value = params.pop(key)
if allowed_types:
if not isinstance(allowed_types, (tuple, list)):
allowed_types = (allowed_types, )
for valtype in allowed_types:
if valtype == 'color':
_utils.assert_color(value)
elif valtype == 'color_none':
if value is None:
return value
_utils.assert_color(value)
elif valtype == 'color_image':
if isinstance(value, BaseImage):
return value
_utils.assert_color(value)
elif valtype == 'color_image_none':
if value is None:
return value
elif isinstance(value, BaseImage):
return value
_utils.assert_color(value)
elif valtype == 'position':
_utils.assert_position(value)
elif valtype == 'alignment':
_utils.assert_alignment(value)
elif valtype == 'tuple2':
_utils.assert_vector2(value)
all_types = ('color', 'color_none', 'color_image',
'color_image_none', 'position', 'alignment', 'tuple2')
others = tuple(t for t in allowed_types if t not in all_types)
if others:
msg = 'Theme.{} type shall be in {} types (got {})'.format(
key, others, type(value))
assert isinstance(value, others), msg
return value
def set_at(self, pos: Tuple2NumberType, color: ColorInputType) -> 'BaseImage':
"""
Set the color of pixel on x-axis and y-axis (x, y).
:param pos: Position on x-axis and y-axis (x, y) in px
:param color: Color
:return: Self reference
"""
assert_vector(pos, 2)
self._surface.set_at(pos, assert_color(color))
return self
def set_background_color(self, color, inflate=(0, 0)):
"""
Set widget background color.
:param color: Widget background color
:type color: tuple, list, :py:class:`pygame_menu.baseimage.BaseImage`, None
:param inflate: Inflate background in x,y
:type inflate: tuple, list
:return: None
"""
if color is not None:
if isinstance(color, _baseimage.BaseImage):
assert color.get_drawing_mode() == _baseimage.IMAGE_MODE_FILL, \
'currently widget only support IMAGE_MODE_FILL drawing mode'
else:
assert_color(color)
assert_vector2(inflate)
assert inflate[0] >= 0 and inflate[1] >= 0, \
'widget background inflate must be equal or greater than zero in both axis'
self._background_color = color
self._background_inflate = inflate
