class arcade.gui.UIMessageBox(*, width: float, height: float, message_text: str, buttons=('Ok',))[source]#

A simple dialog box that pops up a message with buttons to close. Subclass this class or overwrite the ‘on_action’ event handler with

box = UIMessageBox(...)
def on_action(event: UIOnActionEvent):
  • width – Width of the message box

  • height – Height of the message box

  • message_text – Text to show as message to the user

  • buttons – List of strings, which are shown as buttons

on_action(event: UIOnActionEvent)[source]#

Called when button was pressed


class arcade.gui.UIDraggableMixin(*, x: float = 0, y: float = 0, width: float = 100, height: float = 100, children: Iterable[UIWidget] = (), size_hint=None, size_hint_min=None, size_hint_max=None, **kwargs)[source]#

UIDraggableMixin can be used to make any UIWidget draggable.

Example, create a draggable Frame, with a background, useful for window like constructs:

class DraggablePane(UITexturePane, UIDraggableMixin):

This does overwrite UILayout behaviour which position themselves, like UIAnchorWidget


class arcade.gui.UIMouseFilterMixin(*, x: float = 0, y: float = 0, width: float = 100, height: float = 100, children: Iterable[UIWidget] = (), size_hint=None, size_hint_min=None, size_hint_max=None, **kwargs)[source]#

UIMouseFilterMixin can be used to catch all mouse events which occur inside this widget.

Useful for window like widgets, UIMouseEvents should not trigger effects which are under the widget.


class arcade.gui.UIWindowLikeMixin(*, x: float = 0, y: float = 0, width: float = 100, height: float = 100, children: Iterable[UIWidget] = (), size_hint=None, size_hint_min=None, size_hint_max=None, **kwargs)[source]#

Makes a widget window like:

  • handles all mouse events that occur within the widgets boundaries

  • can be dragged


class arcade.gui.Surface(*, size: Tuple[int, int], position: Tuple[int, int] = (0, 0), pixel_ratio: float = 1.0)[source]#

Holds a and abstracts the drawing on it. Used internally for rendering widgets.


Save and restore projection and activate Surface buffer to draw on. Also resets the limit of the surface (viewport).

clear(color: Union[Tuple[int, int, int], Tuple[int, int, int, int]] = (0, 0, 0, 0))[source]#

Clear the surface

draw() None[source]#

Draws the current buffer on screen

draw_sprite(x, y, width, height, sprite)[source]#

Draw a sprite to the surface

limit(x, y, width, height)[source]#

Reduces the draw area to the given rect

property position: Tuple[int, int]#

Get or set the surface position

resize(*, size: Tuple[int, int], pixel_ratio: float) None[source]#

Resize the internal texture by re-allocating a new one

  • size (Tuple[int,int]) – The new size in pixels (xy)

  • pixel_ratio (float) – The pixel scale of the window

property size#

Size of the surface in window coordinates

property size_scaled#

The physical size of the buffer


class arcade.gui.NinePatchTexture(*, left: int, right: int, bottom: int, top: int, texture: Texture, atlas: Optional[TextureAtlas] = None)[source]#

A 9-patch texture is a texture that can be stretched in specific ways to keep the edges a specific width/height. This is useful for GUI elements that need to be stretched but have a specific border that should not be stretched. The center content of the texture will be stretched.

Patch structure:

      left              right 
| (1)  | (2)             | (3)  |
|      |                 |      |
+------+-----------------+------+ top
| (4)  | (5)             | (6)  |
|      |                 |      |
|      |                 |      |
|      |                 |      |
|      |                 |      |
|      |                 |      |
+------+-----------------+------+ bottom
| (7)  | (8)             | (9)  |
|      |                 |      |

To summarize, the texture will be stretched in the following ways: * Areas (1), (3), (7) and (9) will not be stretched. * Area (5) will be stretched horizontally and vertically. * Areas (2) and (8) will be stretched horizontally. * Areas (4) and (6) will be stretched vertically.

  • left (int) – The left border of the 9-patch (in pixels)

  • right (int) – The right border of the 9-patch (in pixels)

  • bottom (int) – The bottom border of the 9-patch (in pixels)

  • top (int) – The top border of the 9-patch (in pixels)

  • texture (Texture) – The texture used for the 9-patch

  • atlas (TextureAtlas) – the atlas which the texture belongs to (defaults to arcades default atlas)

property bottom: int#

Get or set the bottom border of the 9-patch.

property ctx: ArcadeContext#

The OpenGL context.

draw_sized(*, position: Tuple[float, float] = (0, 0), size: Tuple[float, float], pixelated: bool = False, **kwargs)[source]#

Draw the 9-patch.


size – size of the 9-patch

property height: int#

The height of the texture in pixels.

property left: int#

Get or set the left border of the 9-patch.

property program: Program#

Get or set the shader program. Returns the default shader if no shader is assigned.

property right: int#

Get or set the right border of the 9-patch.

property size: Tuple[int, int]#

Get size of texture.

property texture: Texture#

Get or set the texture.

property top: int#

Get or set the top border of the 9-patch.

property width: int#

The width of the texture in pixels.


class arcade.gui.UIManager(window: Optional[Window] = None)[source]#

UIManager is the central component within Arcade’s GUI system. Handles window events, layout process and rendering.

To process window events, UIManager.enable() has to be called, which will inject event callbacks for all window events and redirects them through the widget tree.

If used within a view UIManager.enable() should be called from View.on_show_view() and UIManager.disable() should be called from View.on_hide_view()

Supports size_hint to grow/shrink direct children dependent on window size. Supports size_hint_min to ensure size of direct children (e.g. UIBoxLayout). Supports size_hint_max to ensure size of direct children (e.g. UIBoxLayout).

manager = UIManager()
manager.enable() # hook up window events


def on_draw():


    manager.draw() # draws the UI on screen
add(widget: W, *, index=None) W[source]#

Add a widget to the UIManager. Added widgets will receive ui events and be rendered.

By default the latest added widget will receive ui events first and will be rendered on top of others.

  • widget – widget to add

  • index – position a widget is added, None has the highest priority


the widget

adjust_mouse_coordinates(x, y)[source]#

This method is used, to translate mouse coordinates to coordinates respecting the viewport and projection of cameras. The implementation should work in most common cases.

If you use scrolling in the arcade.Camera you have to reset scrolling or overwrite this method using the camera conversion:

ui_manager.adjust_mouse_coordinates = camera.mouse_coordinates_to_world

Remove all widgets from UIManager


Walks through all widgets of a UIManager and prints out the rect

disable() None[source]#

Remove handler functions (on_…) from arcade.Window

If every arcade.View uses its own arcade.gui.UIManager, this method should be called in arcade.View.on_hide_view().

enable() None[source]#

Registers handler functions (on_…) to arcade.gui.UIElement

on_draw is not registered, to provide full control about draw order, so it has to be called by the devs themselves.

get_widgets_at(pos, cls=<class 'arcade.gui.widgets.UIWidget'>) Iterable[W][source]#

Yields all widgets containing a position, returns first top laying widgets which is instance of cls.

  • pos – Pos within the widget bounds

  • cls – class which the widget should be instance of


iterator of widgets of given type at position

remove(child: UIWidget)[source]#

Removes the given widget from UIManager.


child (UIWidget) – widget to remove


Request rendering of all widgets

walk_widgets(*, root: Optional[UIWidget] = None) Iterable[UIWidget][source]#

walks through widget tree, in reverse draw order (most top drawn widget first)