.. Automatically generated file - do not modify.

.. 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.
    
    .. method:: add_positional(name)
    
        Adds a positional argument with `name`
    
    .. method:: add_property(name):
    
        Adds a property with `name`. Properties are passed as keyword
        arguments.
    
    .. method:: 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.
    
    .. method:: 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.
    
    .. method:: 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 :ref:`style-properties`. Group can
        also be "ui", in which case it adds the :ref:`common ui properties <common-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 :class:`renpy.register_sl_displayable`.

