ProgressBar

class pygame_menu.widgets.ProgressBar(title, progressbar_id='', default=0, width=150, onselect=None, box_background_color=(255, 255, 255), box_border_color=(0, 0, 0), box_border_width=1, box_margin=(25, 0), box_progress_color=(0, 255, 0), box_progress_padding=(1, 1), progress_text_align='align-center', progress_text_enabled=True, progress_text_font=None, progress_text_font_color=(0, 0, 0), progress_text_font_hfactor=0.8, progress_text_format=<function ProgressBar.<lambda>>, progress_text_margin=(0, 0), progress_text_placeholder='{0} %', *args, **kwargs)[source]

Bases: Widget

Progress bar widget, offers a bar that accepts a percentage from 0 to 100.

Note

ProgressBar only accepts translation transformation.

Parameters:

title (Any) – Progressbar title
progressbar_id (str) – ProgressBar ID
default (Union[int, float]) – Default value of the progressbar, from 0 to 100
width (int) – Progress bar width in px
onselect (Optional[Callable]) – Function when selecting the widget
box_background_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Background color of the box
box_border_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Border color of the box
box_border_width (int) – Border width of the box in px
box_margin (Tuple[int, int]) – Box margin on x-axis and y-axis (x, y) respect to the title of the widget in px
box_progress_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Box progress color
box_progress_padding (Union[int, float, List[Union[int, float]], Tuple[Union[int, float]], Tuple[Union[int, float], Union[int, float]], Tuple[Union[int, float], Union[int, float], Union[int, float], Union[int, float]], None]) – Box progress padding
progress_text_align (str) – Align of the progress text, can be CENTER, LEFT or RIGHT. See pygame_menu.locals
progress_text_enabled (bool) – Enables the progress text over box
progress_text_font (Union[str, Font, Path, None]) – Progress font. If None uses the same as the widget font
progress_text_font_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Progress font color. If None uses the same as the widget font
progress_text_font_hfactor (float) – Height factor of the font height relative to the widget font height
progress_text_format (Callable[[Union[int, float]], str]) – Format function of the progress text, which considers as input the progress value (0-100)
progress_text_margin (Tuple[int, int]) – Margin of the progress box on x-axis and y-axis in px
progress_text_placeholder (str) – Placeholder of the progress text, which considers as format the output of progress_text_format
args – Optional arguments for callbacks
kwargs – Optional keyword arguments

add_draw_callback(draw_callback)

Adds a function to the Widget to be executed each time the widget is drawn.

The function that this method receives two objects: the Widget itself and the Menu reference.

import math

def draw_update_function(widget, menu):
    t = widget.get_attribute('t', 0)
    t += menu.get_clock().get_time()
    widget.set_padding(10*(1 + math.sin(t))) # Oscillating padding

button = menu.add.button('This button updates its padding', None)
button.set_draw_callback(draw_update_function)

After creating a new callback, this functions returns the ID of the call. It can be removed anytime using pygame_menu.widgets.core.widget.Widget.remove_draw_callback().

Note

If Menu surface cache is enabled this method may run only once. To force running the added method each time call widget.force_menu_surface_update() to force Menu update the cache status if the drawing callback does not make the Widget to render. Remember that rendering the Widget forces the Menu to update its surface, thus updating the cache too.

Parameters:: draw_callback (Callable[[Widget, Menu], Any]) – Function
Return type:: str
Returns:: Callback ID

add_update_callback(update_callback)

Adds a function to the Widget to be executed each time the Widget is updated.

The function that this method receives three objects: the events list, the Widget itself and the Menu reference. It is similar to pygame_menu.widgets.core.widget.Widget.add_draw_callback().

After creating a new callback, this functions returns the ID of the call. It can be removed anytime using pygame_menu.widgets.core.widget.Widget.remove_update_callback().

Note

Not all widgets are updated, so the provided function may never be executed in some widgets (for example, label or images).

Parameters:: update_callback (Callable[[List[Event], Widget, Menu], Any]) – Function
Return type:: str
Returns:: Callback ID

apply_draw_callbacks()

Apply callbacks on Widget draw.

Return type:: Widget
Returns:: Self reference

apply_update_callbacks(events)

Apply callbacks on Widget update.

Note

Readonly widgets or hidden widgets do not apply update callbacks.

Parameters:: events (List[Event]) – Events list
Return type:: Widget
Returns:: Self reference

background_inflate_to_selection_effect()

Expand the Widget background inflate to match the selection effect (the Widget don’t require to be selected).

This is a permanent change; for dynamic purposes, depending on if the widget is selected or not, setting widget.selection_expand_background to True may help.

Note

This method may have unexpected results with certain selection effects.

Return type:: Widget
Returns:: Self reference

draw(surface)

Draw the Widget on a given surface.

Note

Widget drawing order:

Background color
prev decorator
Widget selection effect (if prev)
Widget surface
Widget selection effect (if post)
Widget border
post decorator

Parameters:: surface (Surface) – Surface to draw
Return type:: Widget
Returns:: Self reference

force_menu_surface_cache_update()

Forces menu surface cache to update after next drawing call. This also updates widget decoration.

Note

This method only updates the surface cache, without forcing re-rendering of all Menu widgets as pygame_menu.widgets.core.widget.Widget.force_menu_surface_update() does.

Return type:: Widget
Returns:: Self reference

force_menu_surface_update()

Forces menu surface update after next rendering call. This method automatically updates widget decoration cache as Menu render forces it to re-render.

This method also should be called by each widget after render.

Note

This method is expensive, as menu surface update forces re-rendering of all widgets (because them can change in size, position, etc…).

Return type:: Widget
Returns:: Self reference

get_alignment()

Return the Widget alignment.

Return type:: str
Returns:: Widget align

get_attribute(key, default=None)

Get an attribute value.

Parameters:

key (str) – Key of the attribute
default (Optional[Any]) – Value if it does not exist

Return type:

Any

Returns:

Attribute data

get_border()

Return the widget border properties.

Return type:: Tuple[Union[Tuple[int, int, int], Tuple[int, int, int, int]], int, Union[str, List[str], Tuple[str, ...]], Tuple[int, int]]
Returns:: Color, width, position, and inflate

get_class_id()

Return the Class+ID as a string.

Return type:: str
Returns:: Class+ID format

get_col_row_index()

Get the Widget column/row position.

Return type:: Tuple[int, int, int]
Returns:: (column, row, index) tuple

get_controller()

Return the widget controller. Each widget has their own controller object.

Return type:: Controller
Returns:: Controller object

get_counter_attribute(key, incr=0, default=0)

Get counter attribute.

Parameters:

key (str) – Key of the attribute
incr (Any) – Increase value
default (Any) – Default vale to start with, by default it’s zero

Return type:

Union[int, float]

Returns:

New increase value

get_decorator()

Return the Widget decorator API.

Return type:: Decorator
Returns:: Decorator API

get_focus_rect()

Return rect to be used in Widget focus.

Return type:: Rect
Returns:: Focus rect

get_font_color_status(check_selection=True)

Return the Widget font color based on the widget status.

Parameters:: check_selection (bool) – If True font is also checked if selected
Return type:: Union[Tuple[int, int, int], Tuple[int, int, int, int]]
Returns:: Color by widget status

get_font_info()

Return a dict with the information of the Widget font.

Return type:: Dict[str, Any]
Returns:: Font information dict

get_frame()

Get container frame of Widget. If Widget is not within a Frame, the method returns None.

Returns:: Frame object
Return type:: pygame_menu.widgets.Frame

get_frame_depth()

Get frame depth (If frame is packed within another frame).

Return type:: int
Returns:: Frame depth

get_height(apply_padding=True, apply_selection=False)

Return the Widget height.

Warning

If the widget is not rendered, this method will return 0.

Parameters:

apply_padding (bool) – Apply padding
apply_selection (bool) – Apply selection

Return type:

int

Returns:

Widget height in px

get_id()

Return the object ID.

Return type:: str
Returns:: Object ID

get_margin()

Return the Widget margin.

Return type:: Tuple[int, int]
Returns:: Widget margin (left, bottom)

get_menu()

Return the Menu reference, None if it has not been set.

Return type:: Optional[Menu]
Returns:: Menu reference

get_padding(transformed=True)

Return the Widget padding.

Parameters:: transformed (bool) – If True, returns the scaled padding if widget is transformed (flip, scale)
Return type:: Tuple
Returns:: Widget padding (top, right, bottom, left)

get_position(apply_padding=False, use_transformed_padding=True, to_real_position=False, to_absolute_position=False, real_position_visible=True)

Return the widget position tuple on x-axis and y-axis (x, y) in px.

Parameters:

apply_padding (bool) – Apply widget padding to position
use_transformed_padding (bool) – Use scaled padding if the widget is scaled
to_real_position (bool) – Get the real position within window (not the surface container)
to_absolute_position (bool) – Get the absolute position within surface container, considering also the parent scrollarea positioning
real_position_visible (bool) – Return only the visible width/height if to_real_position=True

Return type:

Tuple[int, int]

Returns:

Widget position

get_rect(inflate=None, apply_padding=True, use_transformed_padding=True, to_real_position=False, to_absolute_position=False, render=False, real_position_visible=True)

Return the pygame.Rect object of the Widget. This method forces rendering.

Parameters:

inflate (Optional[Tuple[int, int]]) – Inflate rect on x-axis and y-axis (x, y) in px
apply_padding (bool) – Apply widget padding
use_transformed_padding (bool) – Use scaled padding if the widget is scaled
to_real_position (bool) – Transform the widget rect to real coordinates (if the Widget change the position if scrollbars move offsets) within the window. Used by events
to_absolute_position (bool) – Transform the widget rect to absolute coordinates (if the Widget does not change the position if scrollbars move offsets). Used by events
render (bool) – Force widget rendering
real_position_visible (bool) – Return only the visible width/height if to_real_position=True

Return type:

Rect

Returns:

Widget rect object

get_scrollarea()

Return the scrollarea object.

Return type:: ScrollArea
Returns:: ScrollArea object

get_selected_time()

Return time the Widget has been selected in milliseconds. If the Widget is not currently selected, return 0.

Return type:: Union[int, float]
Returns:: Time in milliseconds

get_selection_effect()

Return the selection effect.

Note

If no selection has been provided, _WidgetNullSelection class will be returned.

Note

For drawing, use pygame_menu.widgets.core.widget.Widget.draw_selection_effect().

Warning

Use with caution.

Return type:: Selection
Returns:: Selection effect

get_size(apply_padding=True, apply_selection=False)

Return the Widget size.

Warning

If the widget is not rendered this method might return (0, 0).

Parameters:

apply_padding (bool) – Apply padding
apply_selection (bool) – Apply selection

Return type:

Tuple[int, int]

Returns:

Widget width and height in px

get_surface()

Return the Widget surface.

Warning

Use with caution.

Return type:: Surface
Returns:: Widget surface object

get_title()

Return the Widget title.

Note

Not all widgets implements this method, for example, images don’t accept a title, and such widget would return an empty string if this method is called.

Return type:: str
Returns:: Widget title

get_translate(virtual=False)

Get Widget translation on x-axis and y-axis (x, y) in px.

Parameters:: virtual (bool) – If True get virtual translation, usually applied within frame scrollarea
Return type:: Tuple[int, int]
Returns:: Translation on both axis

get_value()[source]

Return the Widget value. If exception ValueError is raised, no value will be passed to the callbacks.

Warning

Not all widgets return a value.

Return type:: Union[int, float]
Returns:: Widget data value

get_width(apply_padding=True, apply_selection=False)

Return the Widget width.

Warning

If the Widget is not rendered, this method will return 0.

Parameters:

apply_padding (bool) – Apply padding
apply_selection (bool) – Apply selection

Return type:

int

Returns:

Widget width in px

has_attribute(key)

Return True if the object has the given attribute.

Parameters:: key (str) – Key of the attribute
Return type:: bool
Returns:: True if exists

hide()

Hides the Widget.

Return type:: Widget
Returns:: Self reference

is_floating()

Return True if the Widget is floating.

Return type:: bool
Returns:: Float status

is_selected()

Return True if the Widget is selected.

Return type:: bool
Returns:: Selected status

is_visible(check_frame=True)

Return True if the Widget is visible.

Parameters:: check_frame (bool) – If True check frame and sub-frames if they’re opened as well
Return type:: bool
Returns:: Visible status

mouseleave(event, check_all_widget_mouseleave=True)

Run the onmouseleave callback if the mouse is placed outside the Widget. The callback receive the Widget object reference and the mouse event:

onmouseleave(widget, event) <or> onmouseleave()

Warning

This method does not evaluate if the mouse is placed over the Widget. Only executes the callback and updates the cursor if enabled.

Parameters:

event (Event) – MOUSEMOVE pygame event
check_all_widget_mouseleave (bool) – Check widget leave statutes

Return type:

Widget

Returns:

Self reference

mouseover(event, check_all_widget_mouseleave=True)

Run the onmouseover if the mouse is placed over the Widget. The callback receive the Widget object reference and the mouse event:

onmouseover(widget, event) <or> onmouseover()

Warning

This method does not evaluate if the mouse is placed over the Widget. Only executes the callback and updates the cursor if enabled.

Parameters:

event (Event) – MOUSEMOVE pygame event
check_all_widget_mouseleave (bool) – Check widget leave statutes

Return type:

Widget

Returns:

Self reference

on_remove_from_menu()

Function executed if the Widget is removed from the Menu.

Return type:: Widget
Returns:: Self reference

remove_attribute(key)

Removes the given attribute from the object. Throws IndexError if the given key does not exist.

Parameters:: key (str) – Key of the attribute
Return type:: Base
Returns:: Self reference

remove_draw_callback(callback_id)

Removes draw callback from ID.

Parameters:: callback_id (str) – Callback ID
Return type:: Widget
Returns:: Self reference

remove_update_callback(callback_id)

Removes update callback from ID.

Parameters:: callback_id (str) – Callback ID
Return type:: Widget
Returns:: Self reference

render()

Public rendering method.

Note

Unlike private _render method, public method forces widget rendering (calling pygame_menu.widgets.core.widget.Widget._force_render()). Use this method only if the widget has changed the state. Running this function many times may affect the performance.

Note

Before rendering, check out if the widget font/title/values are set. If not, it is probable that a zero-size surface is set.

Return type:: Optional[bool]
Returns:: True if widget has rendered a new state, None if the widget has not changed, so render used a cache

reset_value()

Reset the Widget value to the default one.

Return type:: Widget
Returns:: Self reference

scroll_to_widget(margin=(0, 0), scroll_parent=True)

The container ScrollArea scrolls to the Widget.

Parameters:

margin (Tuple[Union[int, float], Union[int, float]]) – Extra margin around the rect in px on x-axis and y-axis
scroll_parent (bool) – If True parent scroll also scrolls to widget

Return type:

Widget

Returns:

Self reference

select(status=True, update_menu=False)

Mark the Widget as selected and execute the onselect callback function as follows:

onselect(selected, widget, menu) <or> onselect()

If Widget is_selectable is False this function is not executed.

Note

Use pygame_menu.widgets.core.widget.Widget.render() method to force Widget rendering after calling this method.

Warning

This method should only be used by the menu.

Parameters:

status (bool) – Selection status
update_menu (bool) – If True this status is also applied on the menu that contains this widget

Return type:

Widget

Returns:

Self reference

set_alignment(align)

Set the alignment of the Widget.

Note

Alignment is only applied when updating the widget position, done by Menu when rendering the surface. Thus, the alignment change is not immediate.

Note

Use pygame_menu.widgets.core.widget.Widget.render() method to force widget rendering after calling this method.

Note

See pygame_menu.locals for valid align values.

Parameters:: align (str) – Widget align
Return type:: Widget
Returns:: Self reference

set_attribute(key, value=None)

Set an attribute.

Parameters:

key (str) – Key of the attribute
value (Optional[Any]) – Value of the attribute

Return type:

Base

Returns:

Self reference

set_background_color(color, inflate=(0, 0))

Set the Widget background color.

Parameters:

color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color, BaseImage, None]) – Widget background color
inflate (Optional[Tuple[int, int]]) – Inflate background on x-axis and y-axis (x, y). If None, the widget value is not updated

Return type:

Widget

Returns:

Self reference

set_border(width, color, inflate=(0, 0), position=('position-north', 'position-south', 'position-east', 'position-west'))

Set the Widget border.

Note

Inflate is added to the background inflate in drawing time.

Parameters:

width (int) – Border width in px
color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color, None]) – Border color
inflate (Tuple[int, int]) – Inflate on x-axis and y-axis (x, y) in px
position (Union[str, List[str], Tuple[str, ...]]) – Border position. Valid only: north, south, east, and west. See pygame_menu.locals

Return type:

Widget

Returns:

Self reference

set_col_row_index(col, row, index)

Set the (column, row, index) position. If the column or row is -1 then the widget is not assigned to a certain column/row (for example, if it’s hidden).

Parameters:

col (int) – Column
row (int) – Row
index (int) – Index in Menu widget list

Return type:

Widget

Returns:

Self reference

set_controller(controller)

Set a new controller object.

Parameters:: controller (Controller) – Controller
Return type:: Widget
Returns:: Self reference

set_controls(joystick=True, mouse=True, touchscreen=True, keyboard=True)

Enable interfaces to control the Widget.

Parameters:

joystick (bool) – Use joystick events
mouse (bool) – Use mouse events
touchscreen (bool) – Use touchscreen events
keyboard (bool) – Use keyboard events

Return type:

Widget

Returns:

Self reference

set_cursor(cursor)

Set the Widget cursor if user places the mouse over the Widget.

Parameters:: cursor (Union[int, Cursor, None]) – Pygame cursor
Return type:: Widget
Returns:: Self reference

set_default_value(value)

Set the Widget value, and then make it as default.

Note

This method is intended to be used along pygame_menu.widgets.core.widget.Widget.reset_value() method that sets the Widget value back to the default set with this method.

Note

Not all widgets accepts a value, for example the image widget.

Parameters:: value (Any) – Default widget value
Return type:: Widget
Returns:: Self reference

set_float(float_status=True, menu_render=False, origin_position=False)

Set the floating status. If True the Widget don’t contribute its width/height to the Menu widget positioning computation (for example, the surface area or the column/row layout), and don’t add one unit to the rows (use the same vertical place as the previous widget).

For example, before floating:

----------------------------
|    wid1    |    wid3     |
|    wid2    |    wid4     |
----------------------------

After wid3.set_float(True):

----------------------------
|    wid1    |    wid4     |
| wid2,wid3  |             |
----------------------------

If the Widget is within a Frame, it does not contribute to the width/height of the layout. Also, it is being set to the (0, 0) position, thus, the only way to move the Widget to a desired position is by translating it.

Parameters:

float_status (bool) – Float status
menu_render (bool) – If True forces the Menu to render instantly; else, rendering is controlled by menu
origin_position (bool) – If True the widget position is set to the top-left position of the Menu if the widget is floating (updated by the Menu render phase)

Return type:

Widget

set_font(font, font_size, color, selected_color, readonly_color, readonly_selected_color, background_color, antialias=True)

Set the Widget font.

Parameters:

font (Union[str, Font, Path]) – Font name (see pygame.font.match_font() for precise format)
font_size (int) – Size of font in pixels
color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Normal font color
selected_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Font color if widget is selected
readonly_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Font color if widget is in readonly mode
readonly_selected_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Font color if widget is selected and in readonly mode
background_color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color, None]) – Font background color. If None no background color is used
antialias (bool) – Determines if antialias is applied to font (uses more processing power)

Return type:

Widget

Returns:

Self reference

set_font_shadow(enabled=True, color=None, position=None, offset=2)

Set the Widget font shadow.

Note

See pygame_menu.locals for valid position values.

Parameters:

enabled (bool) – Shadow is enabled or not
color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color, None]) – Shadow color
position (Optional[str]) – Shadow position
offset (int) – Shadow offset

Return type:

Widget

Returns:

Self reference

set_frame(frame)

Set Widget frame.

Parameters:: frame (Frame) – Frame object
Return type:: Widget
Returns:: Self reference

set_margin(x, y)

Set the Widget margin (left, bottom).

Parameters:

x (Union[int, float]) – Margin on x-axis (left)
y (Union[int, float]) – Margin on y-axis (bottom)

Return type:

Widget

Returns:

Self reference

set_menu(menu)

Set the Widget menu reference.

Parameters:: menu (Optional[Menu]) – Menu object
Return type:: Widget
Returns:: Self reference

set_onmouseleave(onmouseleave)

Set onmouseleave callback. This method is executed in pygame_menu.widgets.core.widget.Widget.mouseleave() method. The callback function receives the following arguments:

onmouseleave(widget, event) <or> onmouseleave()

Parameters:: onmouseleave (Union[Callable[[Widget, Event], Any], Callable[[], Any], None]) – Callback executed if user leaves the Widget with the mouse; it can be a function or None
Return type:: Widget
Returns:: Self reference

set_onmouseover(onmouseover)

Set onmouseover callback. This method is executed in pygame_menu.widgets.core.widget.Widget.mouseover() method. The callback function receives the following arguments:

onmouseover(widget, event) <or> onmouseover()

Parameters:: onmouseover (Union[Callable[[Widget, Event], Any], Callable[[], Any], None]) – Callback executed if user enters the Widget with the mouse; it can be a function or None
Return type:: Widget
Returns:: Self reference

set_onselect(onselect)

Set onselect callback. This method is executed in pygame_menu.widgets.core.widget.Widget.select() method. The callback function receives the following arguments:

onselect(selected, widget, menu) <or> onselect()

Parameters:: onselect (Union[Callable[[bool, Widget, Menu], Any], Callable[[], Any], None]) – Callback executed if user selects the Widget; it can be a function or None
Return type:: Widget
Returns:: Self reference

set_padding(padding)

Set the Widget padding according to CSS rules:

If an integer or float is provided: top, right, bottom and left values will be the same
If 2-item tuple is provided: top and bottom takes the first value, left and right the second
If 3-item tuple is provided: top will take the first value, left and right the second, and bottom the third
If 4-item tuple is provided: padding will be (top, right, bottom, left)

Note

See CSS W3Schools for more info about padding.

Parameters:: padding (Union[int, float, List[Union[int, float]], Tuple[Union[int, float]], Tuple[Union[int, float], Union[int, float]], Tuple[Union[int, float], Union[int, float], Union[int, float], Union[int, float]], None]) – Can be a single number, or a tuple of 2, 3 or 4 elements following CSS style
Return type:: Widget
Returns:: Self reference

set_position(x, y)

Set the Widget position relative to the Menu/Frame.

This method is executed by the Menu when updating the widget positioning. For moving the widget use translate method instead, as this position will be rewritten on next menu rendering phase.

Note

Use pygame_menu.widgets.core.widget.Widget.render() method to force Widget rendering after calling this method.

Parameters:

x (Union[int, float]) – X position in px
y (Union[int, float]) – Y position in px

Return type:

Widget

Returns:

Self reference

set_scrollarea(scrollarea)

Set scrollarea reference. Mostly used for events.

Parameters:: scrollarea (Optional[ScrollArea]) – Scrollarea object
Return type:: None

set_selection_effect(selection=None)

Set the selection effect handler.

Note

If selection=None the selection effect will be established to _WidgetNullSelection class.

Parameters:: selection (Optional[Selection]) – Selection effect class
Return type:: Widget
Returns:: Self reference

set_tab_size(tab_size)

Set widget tab size.

Parameters:: tab_size (int) – Width of a tab character
Return type:: Widget
Returns:: Self reference

set_title(title)

Update the Widget title.

Note

Not all widgets implements this method, for example, images don’t accept a title.

Parameters:: title (str) – New title
Return type:: Widget
Returns:: Self reference

set_value(value)[source]

Set the Widget value.

Note

Not all widgets accepts a value, for example the image widget.

Warning

This method does not fire the callbacks as it is called programmatically. This behavior is deliberately chosen to avoid infinite loops.

Parameters:: value (Union[int, float]) – Value to be set on the widget
Return type:: None

shadow(shadow_type='rectangular', shadow_width=10, corner_radius=0, color=(0, 0, 0), aa_amount=4)

Configure the widget shadow.

Parameters:

shadow_type (str) – Shadow type, it can be rectangular or ellipse
shadow_width (int) – Shadow width in px. If 0 the shadow is disabled
corner_radius (int) – Shadow corner radius if rectangular in px
color (Union[Tuple[int, int, int], Tuple[int, int, int, int], str, int, Color]) – Shadow color
aa_amount (int) – Antialiasing amout

Return type:

Widget

Returns:

Self reference

show()

Set the Widget visible.

Return type:: Widget
Returns:: Self reference

translate(x, y)

Transformation: Translate to (+x, +y) according to the default position.

Note

Translate is only applied when updating the widget position (calling pygame_menu.widgets.core.widget.Widget.set_position()). This is done by Menu when rendering the surface. Thus, the position change is not immediate. To force translation update you may call Menu render method.

Note

To revert changes, only set to (0, 0).

Note

Use pygame_menu.widgets.core.widget.Widget.render() method to force widget rendering after calling this method.

Parameters:

x (Union[int, float]) – +X in px
y (Union[int, float]) – +Y in px

Return type:

Widget

update(events)[source]

Update according to the given events list and fire the callbacks. This method must return True if it updated (the internal variables changed during user input).

Note

Update is not performed if the Widget is in readonly state, or it’s hidden. However, apply_update_callbacks method is called in most widgets, except pygame_menu.widgets.NoneWidget.

Parameters:: events (Union[List[Event], Tuple[Event]]) – List/Tuple of pygame events
Return type:: bool
Returns:: True if updated

update_font(style)

Updates the Widget font. This method receives a style dict (non-empty).

Optional style keys

antialias (bool) – Font antialias
background_color (tuple) – Background color
color (tuple) – Font color
name (str) – Name of the font
readonly_color (tuple) – Readonly color
readonly_selected_color (tuple) – Readonly selected color
selected_color (tuple) – Selected color
size (int) – Size of the font

Note

If a key is not defined it will be rewritten using current font style from pygame_menu.widgets.core.widget.Widget.get_font_info() method.

Parameters:: style (Dict[str, Any]) – Font style dict
Return type:: Widget
Returns:: Self reference

update_menu(events)

Update the widget from Menu. This method is the same as update(), however, it takes into account the value of widget.receive_menu_update_events.

Parameters:: events (Union[List[Event], Tuple[Event]]) – List/Tuple of pygame events
Return type:: bool
Returns:: True if updated

value_changed()

Return True if the Widget’s value changed from the default value.

Return type:: bool
Returns:: True if changed