.. Automatically generated file - do not modify.

.. class:: Sprite()
    
    This represents a sprite that is managed by the SpriteManager. It contains
    fields that control the placement of the sprite on the screen. Sprites
    should not be created directly. Instead, they should be created by
    calling :meth:`SpriteManager.create`.
    
    The fields of a sprite object are:
    
    `x`, `y`
        The x and y coordinates of the upper-left corner of the sprite,
        relative to the SpriteManager.
    
    `zorder`
        An integer that's used to control the order of this sprite in the
        relative to the other sprites in the SpriteManager. The larger the
        number is, the closer to the viewer the sprite is.
    
    `events`
        If True, then events are passed to child. If False, the default,
        the children ignore events (and hence don't spend time processing
        them).
    
    The methods of a Sprite object are:
        

    .. method:: destroy(self)
        
        Destroys this sprite, preventing it from being displayed and
        removing it from the SpriteManager.
    
    .. method:: set_child(d)
        
        Changes the Displayable associated with this sprite to `d`.
    
.. class:: SpriteManager(update=None, event=None, predict=None, ignore_time=False, **properties)
    
    This displayable manages a collection of sprites, and displays
    them at the fastest speed possible.
    
    `update`
        If not None, a function that is called each time a sprite
        is rendered by this sprite manager. It is called with one
        argument, the time in seconds since this sprite manager
        was first displayed.  It is expected to return the number
        of seconds until the function is called again, and the
        SpriteManager is rendered again.
    
    `event`
        If not None, a function that is called when an event occurs.
        It takes as arguments:
        * A pygame event object.
        * The x coordinate of the event.
        * The y coordinate of the event.
        * The time since the sprite manager was first shown.
        If it returns a non-None value, the interaction ends, and
        that value is returned.
    
    `predict`
        If not None, a function that returns a list of
        displayables. These displayables are predicted when the
        sprite manager is.
    
    `ignore_time`
        If True, then time is ignored when rendering displayables. This
        should be used when the sprite manager is used with a relatively
        small pool of images, and those images do not change over time.
        This should only be used with a small number of displayables, as
        it will keep all displayables used in memory for the life of the
        SpriteManager.
    
    After being rendered once (before the `update` function is called),
    SpriteManagers have the following fields:
    
    `width`, `height`
    
         The width and height of this SpriteManager, in pixels.
    
    
    SpriteManagers have the following methods:

    .. method:: create(d)
        
        Creates a new Sprite for the displayable `d`, and adds it to this
        SpriteManager.
    
    .. method:: redraw(delay=0)
        
        Causes this SpriteManager to be redrawn in `delay` seconds.
    
