.. Automatically generated file - do not modify.

.. function:: renpy.can_show(name, layer=None, tag=None)
    
    Determines if `name` can be used to show an image. This interprets `name`
    as a tag and attributes. This is combined with the attributes of the
    currently-showing image with `tag` on `layer` to try to determine a unique image
    to show. If a unique image can be show, returns the name of that image as
    a tuple. Otherwise, returns None.
    
    `tag`
        The image tag to get attributes from. If not given, defaults to the first
        component of `name`.
    
    `layer`
        The layer to check. If None, uses the default layer for `tag`.

.. function:: renpy.check_image_attributes(tag, attributes)
    
    Checks to see if there is a unique image with the given tag and
    attributes. If there is, returns the attributes in order.
    Otherwise, returns None.

.. function:: renpy.copy_images(old, new)
    
    Copies images beginning with one prefix to images beginning with
    another. For example::
    
        renpy.copy_images("eileen", "eileen2")
    
    will create an image beginning with "eileen2" for every image beginning
    with "eileen". If "eileen happy" exists, "eileen2 happy" will be
    created.
    
    `old`
        A space-separated string giving the components of the old image
        name.
    
    `new`
        A space-separated string giving the components of the new image
        name.

.. function:: renpy.get_attributes(tag, layer=None)
    
    Return a tuple giving the image attributes for the image with `tag`. If
    the image is now showing, returns None.
    
    `layer`
        The layer to check. If None, uses the default layer for `tag`.

.. function:: renpy.get_available_image_tags()
    
    Returns a list of image tags that have been defined.

.. function:: renpy.get_image_bounds(tag, width=None, height=None, layer='master')
    
    If an image with `tag` exists on `layer`, returns the bounding box of
    that image. Returns None if the image is not found.
    
    The bounding box is an (x, y, width, height) tuple. The components of
    the tuples are expressed in pixels, and may be floating point numbers.
    
    `width`, `height`
        The width and height of the area that contains the image. If None,
        defaults the width and height of the screen, respectively.
    
    `layer`
        If None, uses the default layer for `tag`.

.. function:: renpy.get_ordered_image_attributes(tag, attributes=(), sort=None)
    
    Returns a list of image tags, ordered in a way that makes sense to
    present to the user.
    
    `attributes`
        If present, only attributes that are compatible with the given
        attributes are considered. (Compatible means that the attributes
        can be in a single image at the same time.)
    
    `sort`
        If not None, the returned list of attributes is sorted. This is a function
        that should be used as a tiebreaker.

.. function:: renpy.get_placement(d)
    
    This gets the placement of displayable d. There's very little warranty on this
    information, as it might change when the displayable is rendered, and might not
    exist until the displayable is first rendered.
    
    This returns an object with the following fields, each corresponding to a style
    property:
    
        * xpos
        * xanchor
        * xoffset
        * ypos
        * yanchor
        * yoffset
        * subpixel

.. function:: renpy.get_showing_tags(layer='master')
    
    Returns the set of image tags that are currently being shown on `layer`

.. function:: renpy.has_image(name, exact=False)
    
    Return true if an image with `name` exists, and false if no such image
    exists.
    
    `name`
        Either a string giving an image name, or a tuple of strings giving
        the name components.
    
    `exact`
        Returns true if and only if an image with the exact name exists -
        parameterized matches are not included.

.. function:: renpy.seen_image(name)
    
    Returns True if the named image has been seen at least once on the user's
    system. An image has been seen if it's been displayed using the show statement,
    scene statement, or :func:`renpy.show` function. (Note that there are cases
    where the user won't actually see the image, like a show immediately followed by
    a hide.)

.. function:: renpy.showing(name, layer='master')
    
    Returns true if an image with the same tag as `name` is showing on
    `layer`
    
    `image`
        May be a string giving the image name or a tuple giving each
        component of the image name. It may also be a string giving
        only the image tag.
    
    
    `layer`
        The layer to check. If None, uses the default layer for `tag`.

.. function:: renpy.start_predict(*args)
    
    This function takes one or more displayables as arguments. It causes
    Ren'Py to predict those displayables during every interaction until
    the displayables are removed by :func:`renpy.stop_predict`.

.. function:: renpy.stop_predict(*args)
    
    This function takes one or more displayables as arguments. It causes
    Ren'Py to stop predicting those displayables during every interaction.

