.. Automatically generated file - do not modify.

.. function:: AlphaMask(child, mask, **properties)
    
    This displayable takes its colors from `child`, and its alpha channel
    from the multiplication of the alpha channels of `child` and `mask`.
    The result is a displayable that has the same colors as `child`, is
    transparent where either `child` or `mask` is transparent, and is
    opaque where `child` and `mask` are both opaque.
    
    The `child` and `mask` parameters may be arbitrary displayables. The
    size of the AlphaMask is the size of the overlap between `child` and
    `mask`.
    
    Note that this takes different arguments from :func:`im.AlphaMask`,
    which uses the mask's color channel.

.. function:: Borders(left, top, right, bottom, pad_left=0, pad_top=0, pad_right=0, pad_bottom=0)
    
    This object provides border size and tiling information to a :func:`Frame`.
    It can also provide padding information that can be supplied to the
    :propref:`padding` style property of a window or frame.
    
    `left`
    `top`
    `right`
    `bottom`
        These provide the size of the insets used by a frame, and are added
        to the padding on each side. They should zero or a positive integer.
    
    `pad_left`
    `pad_top`
    `pad_right`
    `pad_bottom`
        These are added to the padding on each side, and may be positive or
        negative. (For example, if `left` is 5 and `pad_left` is -3, the final
        padding is 2.)
    
    The padding information is supplied via a field:
    
    .. attribute:: padding
    
        This is a four-element tuple containing the padding on each of the
        four sides.

.. function:: DynamicImage(name)
    
    A DynamicImage is a displayable that has text interpolation performed
    on it to yield a string giving a new displayable. Such interpolation is
    performed at the start of each interaction.

.. function:: Flatten(child, **properties)
    
    This flattens `child`, which may be made up of multiple textures, into
    a single texture.
    
    Certain operations, like the alpha transform property, apply to every
    texture making up a displayable, which can yield incorrect results
    when the textures overlap on screen. Flatten creates a single texture
    from multiple textures, which can prevent this problem.
    
    Flatten is a relatively expensive operation, and so should only be used
    when absolutely required.

.. function:: Frame(image, left=0, top=0, right=None, bottom=None, tile=False, **properties)
    
    A displayable that resizes an image to fill the available area,
    while preserving the width and height of its borders.  is often
    used as the background of a window or button.
    
    .. figure:: frame_example.png
    
        Using a frame to resize an image to double its size.
    
    `image`
        An image manipulator that will be resized by this frame.
    
    `left`
        The size of the border on the left side. This can also be an
        :func:`Borders` object, in which case that object is use in place
        of the other parameters.
    
    `top`
        The size of the border on the top.
    
    `right`
        The size of the border on the right side. If None, defaults
        to `left`.
    
    `bottom`
        The side of the border on the bottom. If None, defaults to `top`.
    
    `tile`
        If true, tiling is used to resize sections of the image,
        rather than scaling.
    
    ::
    
         # Resize the background of the text window if it's too small.
         init python:
             style.window.background = Frame("frame.png", 10, 10)
        

.. function:: LiveComposite(size, *args, **properties)
    
    This creates a new displayable of `size`, by compositing other
    displayables. `size` is a (width, height) tuple.
    
    The remaining positional arguments are used to place images inside
    the LiveComposite. The remaining positional arguments should come
    in groups of two, with the first member of each group an (x, y)
    tuple, and the second member of a group is a displayable that
    is composited at that position.
    
    Displayables are composited from back to front.
    
    ::
    
       image eileen composite = LiveComposite(
           (300, 600),
           (0, 0), "body.png",
           (0, 0), "clothes.png",
           (50, 50), "expression.png")

.. function:: LiveCrop(rect, child, **properties)
    
    This created a displayable by cropping `child` to `rect`, where
    `rect` is an (x, y, width, height) tuple. ::
    
        image eileen cropped = LiveCrop((0, 0, 300, 300), "eileen happy")

.. function:: LiveTile(child, style='tile', **properties)
    
    Tiles `child` until it fills the area allocated to this displayable.
    
    ::
    
        image bg tile = LiveTile("bg.png")

.. function:: Null(width=0, height=0, **properties)
    
    A displayable that creates an empty box on the screen. The size
    of the box is controlled by `width` and `height`. This can be used
    when a displayable requires a child, but no child is suitable, or
    as a spacer inside a box.
    
    ::
    
        image logo spaced = HBox("logo.png", Null(width=100), "logo.png")

.. function:: Solid(color, **properties)
    
    A displayable that fills the area its assigned with `color`.
    
    ::
    
        image white = Solid("#fff")

