/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#ifndef __com_sun_star_rendering_XSpriteCanvas_idl__
#define __com_sun_star_rendering_XSpriteCanvas_idl__

#ifndef __com_sun_star_lang_IllegalArgumentException_idl__
#include <com/sun/star/lang/IllegalArgumentException.idl>
#endif
#ifndef __com_sun_star_rendering_XBitmapCanvas_idl__
#include <com/sun/star/rendering/XBitmapCanvas.idl>
#endif
#ifndef __com_sun_star_rendering_XAnimation_idl__
#include <com/sun/star/rendering/XAnimation.idl>
#endif
#ifndef __com_sun_star_rendering_VolatileContentDestroyedException_idl__
#include <com/sun/star/rendering/VolatileContentDestroyedException.idl>
#endif

module com { module sun { module star { module rendering {

published interface XSprite;
published interface XAnimatedSprite;
published interface XCustomSprite;

/** Specialization of a XBitmapCanvas, where moving, animated objects
    (called sprites) are supported.<p>

    @attention The screen output of canvas drawing operations is
    undefined, unless XSpriteCanvas::updateScreen() is called. This is
    because a sprite canvas might choose to employ double buffering to
    reduce animation flicker, and cannot know the instant suitable to
    display the newly rendered canvas content. When using external
    double-buffering via XBufferController on a sprite canvas, the
    implementation takes care of this issue, and in this case is able
    to render correctly even without explicit updateScreen() calls
    (because there's a defined moment in time where content display
    can happen, namely the XBufferController::showBuffer()) call. If
    you don't need sprite functionality, and don't want the
    updateScreen hassle, simply use the XBitmapCanvas.
 */
published interface XSpriteCanvas : XBitmapCanvas
{
    /** Create a sprite object from the specified animation
        sequence. A sprite is a back-buffered object with its own,
        independent animation.
     */
    XAnimatedSprite	createSpriteFromAnimation( [in] XAnimation animation )
        raises (com::sun::star::lang::IllegalArgumentException);

    /** Create a sprite object from the specified animation
        sequence.

        A sprite is a back-buffered object with its own,
        independent animation.

        @param animationBitmaps
        Sequence of bitmaps. The bitmaps don't need to have the same
        size, but they are all rendered with their left, top edges
        aligned.

        @param interpolationMode
        Value of <type>InterpolationMode</type>, to determine whether
        and how to interpolate between the provided bitmaps, if
        animation runs fast enough.

        @throws <type>VolatileContentDestroyedException</type>
        if at least one of the bitmap is volatile, and its content has been destroyed by the system.
     */
    XAnimatedSprite	createSpriteFromBitmaps( [in] sequence<XBitmap> animationBitmaps, [in] byte interpolationMode )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException);

    /** Create a custom, user-handles-it-all sprite object.

        A sprite is a back-buffered object with its own, independent
        animation.

        @param spriteSize
        The required size of the sprite in device
        coordinates. Everything that is rendered outside this area
        might be clipped on output. Both components of the size must
        be greater than zero.

        @return an interface to a custom sprite object.
     */
    XCustomSprite createCustomSprite( [in] ::com::sun::star::geometry::RealSize2D spriteSize )
        raises (com::sun::star::lang::IllegalArgumentException);

    /** Create a cloned version of an already existing sprite
        object.

        The cloned sprite always shows the same content as its
        original. Furthermore, cloned copies of a hidden original are
        never visible, although cloned copies of a visible original
        can of course be invisible.

        @param original
        The original sprite to copy the content from. This sprite must
        have been created by the same XSpriteCanvas instance as this
        method is called on. Other sprite instances will generate an
        IllegalArgumentException.

        @return an interface to a sprite object.
     */
    XSprite createClonedSprite( [in] XSprite original )
        raises (com::sun::star::lang::IllegalArgumentException);

    /** Tells the sprite canvas to now update the screen
        representation.

        Required to display rendered changes to the canvas, and
        updates to stopped animations and XCustomSprites in
        general. This method will return only after the screen update
        is done, or earlier if an error happened.<p>

        If double buffering is enabled via XBufferController, no
        explicit call of updateScreen() is necessary, since the
        XBufferController methods will automatically notify all
        associated XSpriteCanvas instances.<p>

        @param bUpdateAll
        When <TRUE/>, update the whole screen. When <FALSE/>,
        implementation is permitted to restrict update to areas the
        canvas itself changed (e.g. because of render operations, or
        changes on the sprites). The former is useful for updates
        after window expose events. the latter for animation display.

        @return <TRUE/>, if the screen update was successfully
        performed
     */
    boolean updateScreen( [in] boolean bUpdateAll );
};

}; }; }; };

#endif