# Screens and Python

Ren'Py supports defining screens in Python, as well as in the Ren'Py screen language. A Python screen is created by supplying a screen function to the `renpy.define_screen()` function. It can then be used like it was any other screen.

The screen function should have parameters corresponding to the scope variables it expects, and it should ignore extra keyword arguments. (That is, it should have **kwargs at the end of its parameter list.) It is then expected to call the UI functions to add displayables to the screen.The screen function is called whenever an interaction starts or restarts.

To ensure that this restarting is seamless to the user (and not causing things to reset), it's important that every call to a UI function supply the id argument. As a screen is re-created, Ren'Py will update each displayable with the contents of the old displayable with the same id. Ids are generated automatically by the screen language, but when doing things by hand, they must be manually specified.

Warning

UI Functions are deprecated and not recommended.

Here's an example Python screen:

    init python:
        def say_screen(who, what, **kwargs):
            ui.window(id="window")
            ui.vbox(id="say_vbox")

            ui.text(who, id="who")
            ui.text(what, id="what")

            ui.close()

        renpy.define_screen("say", say_screen)

## Screen Functions

The following functions support the definition, display, and hiding of screens.

`renpy.``call_screen`(_screen_name, *args, **kwargs)

  The programmatic equivalent of the call screen statement.

  This shows _screen_name as a screen, then causes an interaction to occur. The screen is hidden at the end of the interaction, and the result of the interaction is returned.

  Keyword arguments not beginning with _ are passed to the scope of the screen.

  If the keyword argument _with_none is false, "with None" is not run at the end of end of the interaction.

`renpy.``define_screen`(name, function, modal="False", zorder="0", tag=None, variant=None)

  Defines a screen with name, which should be a string.

  function

    The function that is called to display the screen. The function is called with the screen scope as keyword arguments. It should ignore additional keyword arguments.

    The function should call the ui functions to add things to the screen.

  modal
    A string that, when evaluated, determines of the created screen should be modal. A modal screen prevents screens underneath it from receiving input events.
  zorder
    A string that, when evaluated, should be an integer. The integer controls the order in which screens are displayed. A screen with a greater zorder number is displayed above screens with a lesser zorder number.
  tag
    The tag associated with this screen. When the screen is shown, it replaces any other screen with the same tag. The tag defaults to the name of the screen.
  predict
    If true, this screen can be loaded for image prediction. If false, it can't. Defaults to true.
  variant
    String. Gives the variant of the screen to use.

`renpy.``get_screen`(name, layer=None)

  Returns the ScreenDisplayable with the given name on layer. name is first interpreted as a tag name, and then a screen name. If the screen is not showing, returns None.

  This can also take a list of names, in which case the first screen that is showing is returned.

  This function can be used to check if a screen is showing:

      if renpy.get_screen("say"):
          text "The say screen is showing."
      else:
          text "The say screen is hidden."

`renpy.``get_widget`(screen, id, layer=None)

  From the screen on layer, returns the widget with id. Returns None if the screen doesn't exist, or there is no widget with that id on the screen.

`renpy.``get_widget_properties`(id, screen=None, layer=None)

  Returns the properties for the widget with id in the screen on layer. If screen is None, returns the properties for the current screen. This can be used from Python or property code inside a screen.

  Note that this returns a dictionary containing the widget properties, and so to get an individual property, the dictionary must be accessed.

`renpy.``hide_screen`(tag, layer=None)

  The programmatic equivalent of the hide screen statement.

  Hides the screen with tag on layer.

`renpy.``predicting`()

  Returns true if Ren'Py is currently predicting the screen.

`renpy.``show_screen`(_screen_name, *_args, **kwargs)

  The programmatic equivalent of the show screen statement.

  Shows the named screen. This takes the following keyword arguments:

  _screen_name
    The name of the screen to show.
  _layer
    The layer to show the screen on.
  _tag
    The tag to show the screen with. If not specified, defaults to the tag associated with the screen. It that's not specified, defaults to the name of the screen.,
  _widget_properties
    A map from the id of a widget to a property name -> property value map. When a widget with that id is shown by the screen, the specified properties are added to it.
  _transient
    If true, the screen will be automatically hidden at the end of the current interaction.

  Keyword arguments not beginning with underscore (_) are used to initialize the screen's scope.

`renpy.``start_predict_screen`(_screen_name, *args, **kwargs)

  Causes Ren'Py to start predicting the screen named _screen_name will be shown with the given arguments. This replaces any previous prediction of _screen_name. To stop predicting a screen, call `renpy.stop_predict_screen()`.

`renpy.``stop_predict_screen`(name)

  Causes Ren'Py to stop predicting the screen named name will be shown.

`renpy.``variant`(name)

  Returns true if a name is a screen variant that can be chosen by Ren'Py. See Screen Variants for more details. This function can be used as the condition in a Python if statement to set up the appropriate styles for the selected screen variant.

  name can also be a list of variants, in which case this function returns True if any of the variants is selected.

## UI Functions

Note

The implementation of Ren'Py has changed, and UI functions that create displayables can now be far slower than their screen language equivalents.

The UI functions are Python equivalents of the screen language statements. For each screen language statement, there is a ui function with the same name. For example, ui.text corresponds to the text statement, and ui.add corresponds to the add statement.

There is a simple mapping between screen language parameters and arguments and Python arguments. Screen language parameters become positional arguments, while properties become keyword arguments. For example, the screen language statement:

    text "Hello, World" size 40 xalign 0.5

becomes:

    ui.text("Hello, World", size=40, xalign=0.5)

(It really should have an id parameter added.)

There are three groups of UI functions, corresponding to the number of children they take.

The following UI functions do not take any children.

- ui.add
- ui.bar
- ui.imagebutton
- ui.input
- ui.key
- ui.label
- ui.null
- ui.text
- ui.textbutton
- ui.timer
- ui.vbar
- ui.hotspot
- ui.hotbar
- ui.spritemanager

The following UI functions take a single child. They must be given that child – use `ui.null()` if the child is missing.

- ui.button
- ui.frame
- ui.transform
- ui.window
- ui.drag

The following UI functions take multiple children. They continue taking children until `ui.close()` is called.

- ui.fixed
- ui.grid
- ui.hbox
- ui.side
- ui.vbox
- ui.imagemap
- ui.draggroup

There are a few UI functions that do not correspond to screen language statements, as they correspond to concepts that are not present in the screen language.

`ui.``adjustment`(range=1, value=0, step=None, page=None, changed=None, adjustable=None, ranged=None)

  Adjustment objects represent a value that can be adjusted by a bar or viewport. They contain information about the value, the range of the value, and how to adjust the value in small steps and large pages.

  The following parameters correspond to fields or properties on the adjustment object:

  range
    The range of the adjustment, a number.
  value
    The value of the adjustment, a number.
  step

    The step size of the adjustment, a number. If None, then defaults to 1/10th of a page, if set. Otherwise, defaults to the 1/20th of the range.

    This is used when scrolling a viewport with the mouse wheel.

  page

    The page size of the adjustment. If None, this is set automatically by a viewport. If never set, defaults to 1/10th of the range.

    It's can be used when clicking on a scrollbar.

  The following parameters control the behavior of the adjustment.

  adjustable

    If True, this adjustment can be changed by a bar. If False, it can't.

    It defaults to being adjustable if a changed function is given or if the adjustment is associated with a viewport, and not adjustable otherwise.

  changed
    This function is called with the new value when the value of the adjustment changes.
  ranged
    This function is called with the adjustment object when the range of the adjustment is set by a viewport.
  `change`(value)

    Changes the value of the adjustment to value, updating any bars and viewports that use the adjustment.

`ui.``at`(transform)

  Specifies a transform that is applied to the next displayable to be created. This is largely obsolete, as all UI functions now take an at argument.

`ui.``close`()

  Closes a displayable created with by a UI function. When a displayable is closed, we add new displayables to its parent, or to the layer if no displayable is open.

`ui.``detached`()

  Do not add the next displayable to any later or container. Use this if you want to assign the result of a ui function to a variable.

`ui.``interact`(roll_forward=None, mouse='default')

  Causes an interaction with the user, and returns the result of that interaction. This causes Ren'Py to redraw the screen and begin processing input events. When a displayable returns a value in response to an event, that value is returned from ui.interact, and the interaction ends.

  This function is rarely called directly. It is usually called by other parts of Ren'Py, including the say statement, menu statement, with statement, pause statement, call screen, `renpy.input()`, among many other functions. However, it can be called directly if necessary.

  When an interaction ends, the transient layer and all screens shown with transient=True are cleared from the scene lists.

  The following arguments are documented. As other, undocumented arguments exist for Ren'Py's internal use, please pass all arguments as keyword arguments.

  roll_forward
    The information that will be returned by this function when a roll forward occurs. (If None, the roll forward is ignored.) This should usually be passed the result of the `renpy.roll_forward_info()` function.
  mouse
    The style of mouse cursor to use during this function.

`ui.``layer`(name)

  Adds displayables to the layer named name. The later must be closed with `ui.close()`.

`ui.``screen_id`(id_, d)

  Assigns the displayable d the screen widget id id_, as if it had been created by a screen statement with that id.

## Actions

Many of the displayables created in the screen language take actions as arguments. An action is one of three things:

- A callable Python object (like a function or bound method) that takes no arguments.
- An object of a class that inherits from the Action class.
- A list of other Actions.

The advantage to inheriting from the Action class is that it allows you to override the methods that determine when a button should be sensitive, and when it is selected.

class `Action`

  To define a new action, inherit from this class. Override the methods in this class to change the behavior of the action.

  `__call__`(self)

    This is the method that is called when the action is activated. In many cases, returning a non-None value from the action will cause the current interaction to end.

    This method must be overridden, as the default method will raise NotImplemented (and hence cause Ren'Py to report an error).

  `get_sensitive`(self)

    This is called to determine if the button with this action should be sensitive. It should return true if the button is sensitive.

    Note that __call__ can be called, even if this returns False.

    The default implementation returns True.

  `get_selected`(self)

    This should return true if the button should be rendered as a selected button, and false otherwise.

    The default implemention returns False.

  `periodic`(self, st)

    This method is called once at the start of each interaction, and then is called periodically thereafter. If it returns a number, it will be called before that many seconds elapse, but it might be called sooner.

    The main use of this is to call `renpy.restart_interaction()` if the value of get_selected or get_sensitive should change.

    It takes one argument:

    st
      The number of seconds since the screen or displayable this action is associated with was first shown.
  `unhovered(self):`

    When the action is used as the hovered parameter to a button (or similar object), this method is called when the object loses focus.

To run an action from Python, use `renpy.run()`.

`renpy.``is_selected`(action)

  Returns true if action indicates it is selected, or false otherwise.

`renpy.``is_sensitive`(action)

  Returns true if action indicates it is sensitive, or False otherwise.

`renpy.``run`(action)

  Run an action or list of actions. A single action is called with no arguments, a list of actions is run in order using this function, and None is ignored.

  Returns the result of the first action to return a value.

`ui.``is_selected`(action)

  Returns true if action indicates it is selected, or false otherwise.

`ui.``is_sensitive`(action)

  Returns true if action indicates it is sensitive, or False otherwise.

## BarValues

When creating a bar, vbar, or hotbar, a BarValue object can be supplied as the value property. Methods on the BarValue object are called to get the adjustment and styles.

class `BarValue`

  To define a new BarValue, inherit from this class and override some of the methods.

  `get_adjustment`(self)

    This method is called to get an adjustment object for the bar. It should create the adjustment with `ui.adjustment()`, and then return the object created this way.

    This method must be overridden, as the default method will raise NotImplemented (and hence cause Ren'Py to report an error).

  `get_style`(self)

    This is used to determine the style of bars that use this value. It should return a tuple of two style names or style objects. The first is used for a bar, and the second for vbar.

    This defaults to ("bar", "vbar").

  `replaces`(self, other)

    This is called when a BarValue replaces another BarValue, such as when a screen is updated. It can be used to update this BarValue from the other. It is called before get_adjustment.

    Note that other is not necessarily the same type as self.

  `periodic`(self, st)

    This method is called once at the start of each interaction. If it returns a number of seconds, it will be called before that many seconds elapse, but it might be called sooner. It is called after get_adjustment.

    It can be used to update the value of the bar over time, like `AnimatedValue()` does. To do this, get_adjustment should store the adjustment, and periodic should call the adjustment's changed method.

## InputValue

When creating an input, an InputValue object can be supplied as the value property. Methods on the InputValue object are called to get and set the text, determine if the input is editable, and handle the enter key being pressed.

class `InputValue`

  To define a new InputValue, inherit from this class, override some or all of the methods, and set the value of the default field.

  `default`

    If true, the input is eligible to be editable by default. (That is, it may be given the caret when the screen is shown.)

  `get_text`(self)

    Returns the default text of the input. This must be implemented.

  `set_text`(self, s)

    Called when the text of the input is changed, with the new text. This must be implemented.

  `enter`(self)

    Called when the user presses enter. If this returns a non-None value, that value is returned from the interacton. This may also raise renpy.IgnoreEvent() to ignore the press. Otherwise, the enter-press is propagated to other displayables.

  The following actions are available as methods on InputValue:

  `Enable`()

    Returns an action that enables text editing on the input.

  `Disable`()

    Returns an action that disables text editing on the input.

  `Toggle`()

    Returns an action that toggles text editing on the input.

## Creator-Defined Screen Language Statements

Ren'Py supports defining custom screen language statements. Creator-defined screen language statements are wrappers for the screen language use statement. Positional arguments remain positional arguments, properties become keyword arguments, and if the statement takes a block, so does the use statement. For example, the custom screen language statement:

    titledwindow "Test Window":
        icon "icon.png"

        text "This is a test."

becomes:

    use titledwindow("Test Window", icon="icon.png"):
        text "This is a test."

Creator-defined screen language statements must be registered in a `python early` block. What's more, the filename containing the creator-defined statement must be be loaded earlier than any file that uses it. Since Ren'Py loads files in Unicode sort order, it generally makes sense to prefix the name of any file registering a user-defined statement with 01, or some other small number.

Creator-defined screen language statements are registered with the renpy.register_sl_statement function:

class `renpy.``register_sl_displayable`(name, displayable, style, nchildren=0, scope=False, replaces=False, default_keywords={})

  Registers a screen language statement that creates a displayable.

  name
    The name of the screen language statement, a string containing a Ren'Py keyword. This keyword is used to introduce the new statement.
  displayable

    This is a function that, when called, returns a displayable object. All position arguments, properties, and style properties are passed as arguments to this function. Other keyword arguments are also given to this function, a described below.

    This must return a Displayable. If it returns multiple displayables, the _main attribute of the outermost displayable should be set to the "main" displayable - the one that children should be added to.

  style
    The base name of the style of this displayable. If the style property is not given, this will have the style prefix added to it. The computed style is passed to the displayable function as the `style` keyword argument.
  nchildren

    The number of children of this displayable. One of:

    0
      The displayable takes no children.
    1
      The displayable takes 1 child. If more than one child is given, the children are placed in a Fixed.
    "many"
      The displayable takes more than one child.

  The following arguments should be passed in using keyword arguments:

  replaces
    If true, and the displayable replaces a prior displayable, that displayable is passed as a parameter to the new displayable.
  default_keywords
    The default set of keyword arguments to supply to the displayable.

  Returns an object that can have positional arguments and properties added to it by calling the following methods. Each of these methods returns the object it is called on, allowing methods to be chained together.

  `add_positional`(name)

    Adds a positional argument with name

  `add_property(name):`

    Adds a property with name. Properties are passed as keyword arguments.

  `add_style_property(name):`

    Adds a family of properties, ending with name and prefixed with the various style property prefixes. For example, if called with ("size"), this will define size, idle_size, hover_size, etc.

  `add_prefix_style_property(prefix, name):`

    Adds a family of properties with names consisting of prefix, a style property prefix, and name. For example, if called with a prefix of text_ and a name of size, this will create text_size, text_idle_size, text_hover_size, etc.

  `add_property_group(group, prefix=''):`

    Adds a group of properties, prefixed with prefix. Group may be one of the strings:

    - "bar"
    - "box"
    - "button"
    - "position"
    - "text"
    - "window"

    These correspond to groups of Style Properties. Group can also be "ui", in which case it adds the common ui properties.

class `renpy.``register_sl_statement`(name, positional=0, children='many', screen=None)

  Registers a custom screen language statement with Ren'Py.

  name
    This must be a word. It's the name of the custom screen language statement.
  positional
    The number of positional parameters this statement takes.
  children
    The number of children this custom statement takes. This should be 0, 1, or "many", which means zero or more.
  screen
    The screen to use. If not given, defaults to name.

  Returns an object that can have positional arguments and properties added to it. This object has the same .add_ methods as the objects returned by `renpy.register_sl_displayable`.

As an example of a creator-defined screen language statement, here's an implementation of the `titledwindow` statement given above. First, the statement must be registered in a `python early` block in a file that is loaded early – a name like 01custom.rpy will often load soon enough. The registration call looks like:

    python early:
        renpy.register_sl_statement("titledwindow", positional=1, children=1).add_property("icon").add_property("pos")

Then, we define a screen that implements the custom statement. This screen can be defined in any file. One such screen is:

    screen titledwindow(title, icon=None, pos=(0, 0)):
        drag:
            pos pos

            frame:
                background "#00000080"

                has vbox

                hbox:
                    if icon is not None:
                        add icon

                    text title

                null height 15

                transclude