update dev300-m58

[ooovba.git] / offapi / com / sun / star / rendering / XCanvas.idl

/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: XCanvas.idl,v $
 * $Revision: 1.8 $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/
#ifndef __com_sun_star_rendering_XCanvas_idl__
#define __com_sun_star_rendering_XCanvas_idl__

#ifndef __com_sun_star_uno_XInterface_idl__ 
#include <com/sun/star/uno/XInterface.idl> 
#endif 
#ifndef __com_sun_star_lang_IllegalArgumentException_idl__
#include <com/sun/star/lang/IllegalArgumentException.idl>
#endif 
#ifndef __com_sun_star_geometry_RealPoint2D_idl__
#include <com/sun/star/geometry/RealPoint2D.idl>
#endif
#ifndef __com_sun_star_geometry_RealBezierSegment2D_idl__
#include <com/sun/star/geometry/RealBezierSegment2D.idl>
#endif
#ifndef __com_sun_star_geometry_RealRectangle2D_idl__
#include <com/sun/star/geometry/RealRectangle2D.idl>
#endif
#ifndef __com_sun_star_geometry_Matrix2D_idl__
#include <com/sun/star/geometry/Matrix2D.idl>
#endif
#ifndef __com_sun_star_rendering_ViewState_idl__
#include <com/sun/star/rendering/ViewState.idl>
#endif
#ifndef __com_sun_star_rendering_RenderState_idl__
#include <com/sun/star/rendering/RenderState.idl>
#endif
#ifndef __com_sun_star_rendering_FontRequest_idl__
#include <com/sun/star/rendering/FontRequest.idl>
#endif
#ifndef __com_sun_star_rendering_FontInfo_idl__
#include <com/sun/star/rendering/FontInfo.idl>
#endif
#ifndef __com_sun_star_rendering_Texture_idl__
#include <com/sun/star/rendering/Texture.idl>
#endif
#ifndef __com_sun_star_rendering_StringContext_idl__
#include <com/sun/star/rendering/StringContext.idl>
#endif
#ifndef __com_sun_star_rendering_StrokeAttributes_idl__
#include <com/sun/star/rendering/StrokeAttributes.idl>
#endif
#ifndef __com_sun_star_rendering_VolatileContentDestroyedException_idl__
#include <com/sun/star/rendering/VolatileContentDestroyedException.idl>
#endif

#ifndef __com_sun_star_beans_PropertyValue_idl__
#include <com/sun/star/beans/PropertyValue.idl>
#endif


module com {  module sun {  module star {  module geometry {
    interface XMapping2D;
}; }; }; };

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

interface XCanvasFont;
interface XPolyPolygon2D;
interface XCachedPrimitive;
interface XBitmap;
interface XGraphicDevice;
interface XTextLayout;

/** Central interface for rendering.<p>

    This is the central interface for graphical output production, and
    the place where all draw methods are located.<p>

    Some notes are in order to explain the concepts used here. The
    <type>XCanvas</type> interface is free of client-modifiable state,
    i.e. it can be used safely and without external synchronization in
    a multi-threaded environment. On the other hand, this implies that
    for nearly every canvas operation, external state is
    required. This is provided by <type>ViewState</type> and
    <type>RenderState</type> in a unified fashion, supplemented by a
    few extra state parameters for some methods (e.g. textured
    polygons or text rendering).<p>

    When used careless, this scheme can be inefficient to some extend,
    because internally, view, render and other states have to be
    combined before rendering. This is especially expensive for
    complex clip polygons, i.e. when both <type>ViewState</type> and
    <type>RenderState</type> have a complex clip polygon set, which
    have to be intersected before rendering. It is therefore
    recommended to combine <type>ViewState</type> and
    <type>RenderState</type> already at the client side, when objects
    are organized in a hierarchical way: the classic example are
    grouped draw shapes, whose parent group object imposes a
    common clipping and a common transformation on its siblings. The
    group object would therefore merge the <type>ViewState</type> and
    the <type>RenderState</type> it is called with into a new
    <type>ViewState</type>, and call its siblings with a
    <type>RenderState</type> containing only the local offset (and no
    extra clipping).<p>

    Furtheron, this stateless nature provides easy ways for
    caching. Every non-trivial operation on <type>XCanvas</type> can
    return a cache object, which, when called to redraw, renders the
    primitive usually much more quickly than the original method. Note
    that such caching is a lot more complicated, should the actual
    rendering a method yields depend on internal state (which is the
    case e.g. for the
    <type
    scope="::com::sun::star::drawing">::com::sun::star::drawing::XGraphics</type>
    interface).  Please note, though, that deciding whether to return
    an <type>XCachedPrimitive</type> is completely up to the
    implementation - don't rely on the methods returning something
    (this is because there might be cases when returning such a cache
    object will actually be a pessimization, since it involves memory
    allocation and comparisons).<p>

    Things that need more than a small, fixed amount of data are
    encapsulated in own interfaces, e.g. polygons and bitmaps. You
    can, in principle, roll your own implementations of these
    interfaces, wrap it around your internal representation of
    polygons and bitmaps, and render them. It might just not be overly
    fast, because the <type>XCanvas</type> would need to convert for
    each render call. It is therefore recommended to create such
    objects via the <type>XGraphicDevice</type> factory (to be
    retrieved from every canvas object via the
    <member>getDevice()</member> call) - they will then internally
    optimize to the underlying graphics subsystem.<p>

    @since OOo 2.0.0
 */
interface XCanvas : ::com::sun::star::uno::XInterface
{
    /** Clear the whole canvas area.<p>
        
        This method clears the whole canvas area to the device default
        color (e.g. white for a printer, transparent for an
        <type>XCustomSprite</type>).
     */
    void                clear();

     /** Draw a point in device resolution on the device.

         @param aPoint
        The point to draw.

        @param aViewState
        The viewstate to be used when drawing this point.

        @param aRenderState
        The renderstate to be used when drawing this point.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    void                                drawPoint( [in] ::com::sun::star::geometry::RealPoint2D aPoint, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Draw a line in device resolution width (i.e. one device pixel
        wide).

         @param aStartPoint
        The start point of the line to draw.

         @param aEndPoint
        The end point of the line to draw.

        @param aViewState
        The viewstate to be used when drawing this line.

        @param aRenderState
        The renderstate to be used when drawing this line.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    void                                drawLine( [in] ::com::sun::star::geometry::RealPoint2D aStartPoint, [in] ::com::sun::star::geometry::RealPoint2D aEndPoint, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Draw a cubic bezier curve in device resolution width (i.e. one
        device pixel wide).

        @param aBezierSegment
        The start and the two control points of the bezier curve.

        @param aEndPoint
        The end point of the bezier curve.

        @param aViewState
        The viewstate to be used when drawing this curve.

        @param aRenderState
        The renderstate to be used when drawing this curve.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    void                                drawBezier( [in] ::com::sun::star::geometry::RealBezierSegment2D aBezierSegment, [in] ::com::sun::star::geometry::RealPoint2D aEndPoint, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException); 
 
    //-------------------------------------------------------------------------

    /** Draw a poly-polygon in device resolution line width (i.e. the
        lines are one device pixel wide).

        @param xPolyPolygon
        The poly-polygon to draw.

        @param aViewState
        The viewstate to be used when drawing this polygon.

        @param aRenderState
        The renderstate to be used when drawing this polygon.

        @return a handle to the cached rendering output.
        
        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    XCachedPrimitive    drawPolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Stroke each polygon of the provided poly-polygon with the
        specified stroke attributes.<p>

        This method considers the stroking of all polygons as an
        atomic operation in relation to the <type>RenderState</type>'s
        <type>CompositeOperationy</type> operation. That means,
        overlapping strokes from distinct polygons will look exactly
        as overlapping segments of the same polygon, even with
        transparency.<p>

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when stroking this polygon.

        @param aRenderState
        The renderstate to be used when stroking this polygon.

        @param aStrokeAttributes
        Further attributes used to parameterize the stroking.

        @return a handle to the cached rendering output.
        
        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    XCachedPrimitive    strokePolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState, [in] StrokeAttributes aStrokeAttributes )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Stroke each polygon of the provided poly-polygon with the
        specified stroke attributes, fill the stroked outline
        with the specified texture graphics.<p>

        This method considers the stroking of all polygons as an
        atomic operation in relation to the <type>RenderState</type>'s
        <type>CompositeOp</type> operation. That means, overlapping
        strokes from distinct polygons will look exactly as
        overlapping segments of the same polygon, even with
        transparency.<p>

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when strokes this polygon.

        @param aRenderState
        The renderstate to be used when stroking this polygon.

        @param aTextures
        A sequence of texture definitions, with which to fill the
        stroked area.

        @param aStrokeAttributes
        Further attributes used to parameterize the stroking.

        @return a handle to the cached rendering output.
        
        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        

        @throws <type>VolatileContentDestroyedException</type>
        if a texture bitmap was volatile, and the content was
        destroyed before the rendering could take place.
     */
    XCachedPrimitive    strokeTexturedPolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState, [in] sequence<Texture> aTextures, [in] StrokeAttributes aStrokeAttributes )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException); 

    //-------------------------------------------------------------------------

    /** Stroke each polygon of the provided poly-polygon with the
        specified stroke attributes, fill the stroked outline
        with the specified texture graphics, map the texture to the
        outline via the specified texture mapping.<p>

        This method considers the stroking of all polygons as an
        atomic operation in relation to the <type>RenderState</type>'s
        <type>CompositeOp</type> operation. That means, overlapping
        strokes from distinct polygons will look exactly as
        overlapping segments of the same polygon, even with
        transparency.

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when stroking this polygon.

        @param aRenderState
        The renderstate to be used when stroking this polygon.

        @param aTextures
        A sequence of texture definitions, with which to fill the
        stroked area.

        @param xMapping
        A bilinear mapping function which defines the warping of the
        textures on the output area.

        @param aStrokeAttributes
        Further attributes used to parameterize the stroking.

        @return a handle to the cached rendering output.
        
        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        

        @throws <type>VolatileContentDestroyedException</type>
        if a texture bitmap was volatile, and the content was
        destroyed before the rendering could take place.
     */
    XCachedPrimitive    strokeTextureMappedPolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState, [in] sequence<Texture> aTextures, [in] ::com::sun::star::geometry::XMapping2D xMapping, [in] StrokeAttributes aStrokeAttributes )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException); 

    //-------------------------------------------------------------------------

    //  [TODO: Method misplaced at this interface?]

    /** Query the polygonal representation of the stroke outlines, as
        it would be generated by the strokePolyPolygon methods.<p>

        This method can be used to e.g. set a clipping which covers the same
        area as a stroke.<p>

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when generating the outline.

        @param aRenderState
        The renderstate to be used when generating the outline.
        
        @param aStrokeAttributes
        Further attributes used to parameterize the stroking.

        @return a poly-polygon describing the outline of the stroked
        area.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    XPolyPolygon2D              queryStrokeShapes( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState, [in] StrokeAttributes aStrokeAttributes )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Fill the given poly-polygon.<p>

        This method fills the given poly-polygon according to the
        <type>RenderState</type>'s color and the poly-polygon's fill
        rule.<p>

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when filling this polygon.

        @param aRenderState
        The renderstate to be used when filling this polygon.
        
        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.                
     */
    XCachedPrimitive    fillPolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Fill the given poly-polygon with a texture.<p>

        This method fills the given poly-polygon according to the
        <type>RenderState</type>'s color, the given textures and
        poly-polygon's fill rule.<p>

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when filling this polygon.

        @param aRenderState
        The renderstate to be used when filling this polygon.
        
        @param aTextures
        A sequence of texture definitions, with which to fill the
        polygonal area.

        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        

        @throws <type>VolatileContentDestroyedException</type>
        if a texture bitmap was volatile, and the content was
        destroyed before the rendering could take place.
    */
    XCachedPrimitive    fillTexturedPolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState, [in] sequence<Texture> xTextures )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException); 

    //-------------------------------------------------------------------------

    /** Fill the given poly-polygon with a mapped texture.<p>

        This method fills the given poly-polygon according to the
        <type>RenderState</type>'s color, the given textures and
        poly-polygon's fill rule. The texture is mapped to the
        poly-polygon's interior via the given texture mapping.<p>

        @param xPolyPolygon
        The poly-polygon to render.

        @param aViewState
        The viewstate to be used when filling this polygon.

        @param aRenderState
        The renderstate to be used when filling this polygon.
        
        @param aTextures
        A sequence of texture definitions, with which to fill the
        polygonal area.

        @param xMapping
        A bilinear mapping function which defines the warping of the
        textures on the output area.

        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        

        @throws <type>VolatileContentDestroyedException</type>
        if a texture bitmap was volatile, and the content was
        destroyed before the rendering could take place.
     */
    XCachedPrimitive    fillTextureMappedPolyPolygon( [in] XPolyPolygon2D xPolyPolygon, [in] ViewState aViewState, [in] RenderState aRenderState, [in] sequence<Texture> xTextures, [in] ::com::sun::star::geometry::XMapping2D xMapping )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException); 

    //-------------------------------------------------------------------------

    /** Create a suitable font for the specified font description.

        @param aFontRequest

        @param aExtraFontProperties
        Additional font properties to be applied when selecting this
        font. Normally, you should not need this parameter. Currently,
        the following properties are recognized: 
        <ul>

            <il>Kerning: a <type>double</type> between 0 and 1, where
            0 completely disables kerning. Whether kerning is on or
            off by default is font-dependent.</il>

            <il>IsEmphasisMarks: a <type>boolean</type>, where <TRUE/>
            enables automatic placements of emphasis marks, e.g. for
            Hebrew. The default value, if this property is not
            specified, is <FALSE/>.</il>

            <il>ExpandedSpacing: a <type>double</type> value which is added 
            between all cell distances for this font. The default value for 
            this property is zero. Use negative values for condensed output, 
            and positive values for expanded output.</il>

            <il>OptionalLayoutFeatures: a sequence of <type
            scope=::com::sun::star::beans>PropertyValue</type> listing
            font-specific optional layout features, like glyph
            variants.</il>

        </ul>

        @param aFontMatrix
        Font-specific transformation matrix, which affects both the
        glyphs as well as the advancement.

        @returns the requested font, or an invalid reference, if the
        request failed.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the parameters is not within the allowed range.
     */
    XCanvasFont                         createFont( [in] FontRequest aFontRequest, [in] sequence< ::com::sun::star::beans::PropertyValue > aExtraFontProperties, [in] ::com::sun::star::geometry::Matrix2D aFontMatrix )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Query font information, specific to this canvas.<p>

        @param aFilter
        Filter parameter to reduce the list of returned fonts. Every
        member of <type>FontInfo</type> that is not the empty string
        or the "don't care" value restricts the list of returned fonts
        to contain only those that have the specified attribute.

        @param xFontProperties
        This interface can provide additional font properties to
        filter the list of available fonts against.

        @returns the list of fonts matching the filter set.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the font properties are invalid or not recognized,
        or if one of the <type>FontInfo</type> members is not within
        the permitted range.
     */
    sequence< FontInfo >        queryAvailableFonts( [in] FontInfo aFilter, [in] sequence< ::com::sun::star::beans::PropertyValue > aFontProperties )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Draw the text given by the substring of the specified string
        with the given font.<p>

        The local origin of this output operation is either the left
        end of the text baseline, for textDirection equal
        LEFT_TO_RIGHT, or the right end of the baseline, for
        textDirection equal to RIGHT_TO_LEFT, respectively.<p>

        @param aText
        The text to output.

        @param xFont
        The font retrieved from this canvas to be used when drawing
        the text.

        @param aViewState
        The viewstate to be used when drawing this text.

        @param aRenderState
        The renderstate to be used when drawing this text.
        
        @param nTextDirection
        A value from the <type>TextDirection</type> collection,
        denoting the main writing direction for this string. The main
        writing direction determines the origin of the text output,
        i.e. the left edge for left-to-right and the right edge for
        right-to-left text.

        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    XCachedPrimitive            drawText( [in] StringContext aText, [in] XCanvasFont xFont, [in] ViewState aViewState, [in] RenderState aRenderState, [in] byte nTextDirection )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Draw the formatted text given by the text layout.<p>

        The glyphs as represented by the text layout are always output
        with the reference position being the leftmost edge of the
        layout object's baseline. If the layout contains more than one
        baseline, the baseline of the first strong character in
        logical order is used here (strong in this context means that
        the character can be unambiguously assigned to a unicode
        script).<p>

        @param xLayoutetText
        An interface to the readily layouted text, obtained from a
        <type>XCanvasFont</type> created at this canvas. The text
        layout already carries intrinsic font information.

        @param aViewState
        The viewstate to be used when drawing this text.

        @param aRenderState
        The renderstate to be used when drawing this text.

        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        
     */
    XCachedPrimitive            drawTextLayout( [in] XTextLayout xLayoutetText, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException); 

    //-------------------------------------------------------------------------

    /** Render the given bitmap.<p>

        This method renders the bitmap, at a position and shape as
        specified by the combined view and render transformations. For
        fast render speed, the bitmap should be created by the
        corresponding <type>XGraphicDevice</type>'s
        <member>XGraphicDevice::createCompatibleBitmap()</member>
        method.<p>

        @param xBitmap
        The bitmap to render.

        @param aViewState
        The viewstate to be used when drawing this text.

        @param aRenderState
        The renderstate to be used when drawing this text.

        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        

        @throws <type>VolatileContentDestroyedException</type>
        if a texture bitmap was volatile, and the content was
        destroyed before the rendering could take place.
     */
    XCachedPrimitive            drawBitmap( [in] XBitmap xBitmap, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException); 

    /** Render the given bitmap, with a global color modulation.<p>

        This method renders the bitmap, at a position and shape as
        specified by the combined view and render transformations. For
        fast render speed, the bitmap should be created by the
        corresponding <type>XGraphicDevice</type>'s
        <member>XGraphicDevice::createCompatibleBitmap()</member>
        method. The bitmap's color channel values are multiplied with
        the device color values as specified in the render state.<p>

        @param xBitmap
        The bitmap to render.

        @param aViewState
        The viewstate to be used when drawing this text.

        @param aRenderState
        The renderstate to be used when drawing this text. The device
        color entry in the renderstate is multiplied with every pixel
        color value, and only the result is rendered into the
        canvas. If, for example, the bitmap should be rendered with
        increased global transparency, set all device color channels
        to 1.0, except for the alpha channel, which should be set to
        the desired transparency.

        @return a handle to the cached rendering output.

        @throws <type>com::sun::star::lang::IllegalArgumentException</type>
        if one of the view and renderstate parameters are outside the 
        specified range.        

        @throws <type>VolatileContentDestroyedException</type>
        if a texture bitmap was volatile, and the content was
        destroyed before the rendering could take place.
     */
    XCachedPrimitive            drawBitmapModulated( [in] XBitmap xBitmap, [in] ViewState aViewState, [in] RenderState aRenderState )
        raises (com::sun::star::lang::IllegalArgumentException,
                VolatileContentDestroyedException); 

    //-------------------------------------------------------------------------

    /** Request the associated graphic device for this canvas.<p>

        A graphic device provides methods specific to the underlying
        output device capabilities, which are common for all canvases
        rendering to such a device. This includes device resolution,
        color space, or bitmap formats.

        @return the associated <type>XGraphicDevice</type>.
     */
    XGraphicDevice                      getDevice();
};

//=============================================================================

/// Service providing an <type>XCanvas</type> interface
service Canvas: XCanvas;

}; }; }; };

#endif