.. Automatically generated file - do not modify.

.. function:: 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.

.. function:: 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.

.. function:: 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."

.. function:: 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.

.. function:: 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.

.. function:: renpy.hide_screen(tag, layer=None)
    
    The programmatic equivalent of the hide screen statement.
    
    Hides the screen with `tag` on `layer`.

.. function:: renpy.predicting()
    
    Returns true if Ren'Py is currently predicting the screen.

.. function:: 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.

.. function:: 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 :func:`renpy.stop_predict_screen`.

.. function:: renpy.stop_predict_screen(name)
    
    Causes Ren'Py to stop predicting the screen named `name` will be shown.

.. function:: renpy.variant(name)
    
    Returns true if a `name` is a screen variant that can be chosen
    by Ren'Py. See :ref:`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.

