xref: /aoo41x/main/offapi/com/sun/star/rendering/XGraphicDevice.idl (revision d1766043)

/**************************************************************
 *
 * 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_XGraphicDevice_idl__
#define __com_sun_star_rendering_XGraphicDevice_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_IntegerSize2D_idl__
#include <com/sun/star/geometry/IntegerSize2D.idl>
#endif
#ifndef __com_sun_star_geometry_RealSize2D_idl__
#include <com/sun/star/geometry/RealSize2D.idl>
#endif
#ifndef __com_sun_star_rendering_XLinePolyPolygon2D_idl__
#include <com/sun/star/rendering/XLinePolyPolygon2D.idl>
#endif
#ifndef __com_sun_star_rendering_XBezierPolyPolygon2D_idl__
#include <com/sun/star/rendering/XBezierPolyPolygon2D.idl>
#endif
#ifndef __com_sun_star_rendering_XColorSpace_idl__
#include <com/sun/star/rendering/XColorSpace.idl>
#endif
#ifndef __com_sun_star_lang_XMultiServiceFactory_idl__
#include <com/sun/star/lang/XMultiServiceFactory.idl>
#endif

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

published interface XBitmap;
published interface XVolatileBitmap;
published interface XBufferController;

/* TODO: There's obviously a concept called window missing here, where
   methods such as bufferController, fullscreen mode etc . belong
   to. But see below
 */

/** This interface provides access to a graphic device, such as a
    printer, or a screen device. Every canvas (@see XCanvas) has
    exactly one associated graphic device, into which its output is
    rendered.

    For a typical windowing system, the graphic device is equivalent
    to a distinct OS window, with it's own clipped output area,
    fullscreen and double-buffering attributes. That is, even if one
    can have multiple canvases per system window, they all share the
    same graphic device and thus e.g. fullscreen state. If the OS
    restrictions are in such a way that fullscreen or double-buffering
    is screen-exclusive, i.e. that per screen, only one object can
    have this state, it might even be that all windows on the screen
    share a common graphic device.
 */
published interface XGraphicDevice : ::com::sun::star::uno::XInterface
{
    /** Query the controller for multi buffering functionality on this
        graphic device.

        If there is no such functionality available, the NULL
        reference is returned.
     */
    XBufferController                           getBufferController();

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

    /** Query the color space interface for this graphic device.

        This is to be used when interpreting or setting device color
        values.
     */
    XColorSpace		                            getDeviceColorSpace();

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

    /** Query the physical resolution of the device in pixel per
        millimeter.

        A special floating point value of +infinity here indicates
        'unknown', i.e. at the time of rendering undetermined or
        possibly infinite resolution along the corresponding
        direction.
     */
    ::com::sun::star::geometry::RealSize2D	getPhysicalResolution();

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

    /** Query the physical dimensions of the device in millimeter.

        A special floating point value of +infinity here indicates
        'unknown', i.e. at the time of rendering undetermined or
        possibly infinite resolution along the corresponding
        direction.

        @see XBitmap::getSize()
     */
    ::com::sun::star::geometry::RealSize2D	getPhysicalSize();

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

    /** Create a line poly-polygon which can internally use
        device-optimized representations already.

        @param points
        The points of the poly-polygon, in a separate array for every polygon.
     */
    XLinePolyPolygon2D                  createCompatibleLinePolyPolygon( [in] sequence< sequence< ::com::sun::star::geometry::RealPoint2D > > points );

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

    /** Create a bezier poly-polygon which can internally use
        device-optimized representations already.

        @param points
        The points of the poly-polygon, in a separate array for every polygon.
     */
    XBezierPolyPolygon2D            createCompatibleBezierPolyPolygon( [in] sequence< sequence< ::com::sun::star::geometry::RealBezierSegment2D > > points );

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

    /** Create a bitmap whose memory layout and sample model is
        compatible to the graphic device.

        @param size
        Size of the requested bitmap in pixel. Both components of the
        size must be greater than 0
     */
    XBitmap			                createCompatibleBitmap( [in] ::com::sun::star::geometry::IntegerSize2D size )
        raises (com::sun::star::lang::IllegalArgumentException);

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

    /** Create a volatile bitmap that is usable with this graphic device.

        A volatile bitmap's difference in comparison to a plain bitmap
        (e.g. generated via createCompatibleBitmap()) is the fact that
        its content might vanish at any point in time (making any
        operation with them produce a
        <type>VolatileContentDestroyedException</type>). The benefit,
        on the other hand, is that they might be easy to
        hardware-accelerate on certain platforms, without the need to
        keep a safety copy of the content internally.

        @param size
        Size of the requested bitmap in pixel. Both components of the
        size must be greater than 0
     */
    XVolatileBitmap	                createVolatileBitmap( [in] ::com::sun::star::geometry::IntegerSize2D size )
        raises (com::sun::star::lang::IllegalArgumentException);

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

    /** Create a bitmap with alpha channel whose memory layout and
        sample model is compatible to the graphic device.

        @param size
        Size of the requested bitmap in pixel. Both components of the
        size must be greater than 0
     */
    XBitmap			                createCompatibleAlphaBitmap( [in] ::com::sun::star::geometry::IntegerSize2D size )
        raises (com::sun::star::lang::IllegalArgumentException);

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

    /** Create a volatile bitmap with alpha channel that is usable
        with this graphic device.

        A volatile bitmap's difference in comparison to a plain bitmap
        (e.g. generated via createCompatibleBitmap()) is the fact that
        its content might vanish at any point in time (making any
        operation with them produce a
        <type>VolatileContentDestroyedException</type>). The benefit,
        on the other hand, is that they might be easy to
        hardware-accelerate on certain platforms, without the need to
        keep a safety copy of the content internally.

        @param size
        Size of the requested bitmap in pixel. Both components of the
        size must be greater than 0
     */
    XVolatileBitmap	                createVolatileAlphaBitmap( [in] ::com::sun::star::geometry::IntegerSize2D size )
        raises (com::sun::star::lang::IllegalArgumentException);

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

    /** Get a reference to this device's parametric polygon factory.

        @return a reference to this device's parametric polygon
        factory. Although it is possible to use parametric polygons on
        all canvases, regardless of the associated graphic device,
        this is not advisable: each canvas implementation is free to
        internally generate optimized parametric polygons, which can
        be used more directly for e.g. texturing operations.

        <pre>
        Available services (all canvas implementations should provide
        this minimal set, though are free to add more; just check the
        getAvailableServiceNames() on the returned interface):

        - Gradients - all gradients need to support two construction
          parameters, "Colors" being a <type>sequence<Color></type>
          and "Stops" being a <type>sequence<double></type>. Both must
          have the same length, and at least two elements. See
          http://www.w3.org/TR/SVG11/pservers.html#GradientStops for
          the semantics of gradient stops and colors.
          Required gradient services:

          * "LinearGradient" - the gradient varies linearly between
            the given colors. without coordinate system
            transformation, the color interpolation happens in
            increasing x direction, and is constant in y
            direction. Equivalent to svg linear gradient
            http://www.w3.org/TR/SVG11/pservers.html#LinearGradients

          * "EllipticalGradient" - this gradient has zeroth color
            index in the middle, and varies linearly between center
            and final color. The services takes an additional
            parameter named "AspectRatio" of <type>double</type>
            (width divided by height), if this aspect ratio is 1, the
            gradient is circular. If it's not 1, the gradient is
            elliptical, with the special twist that the aspect ratio
            is maintained also for the center color: the gradient will
            not collapse into a single point, but become a line of
            center color. If "AspectRatio" is missing, or equal to 1,
            this gradient yields similar results as the svg radial
            gradient
            http://www.w3.org/TR/SVG11/pservers.html#RadialGradients

          * "RectangularGradient" - this gradient has zeroth color
            index in the middle, and varies linearly between center
            and final color via rectangular boxes
            around the center point. The services takes an additional
            parameter named "AspectRatio" of <type>double</type>
            (width divided by height), if this aspect ratio is 1, the
            gradient is quadratic. If it's not 1, the gradient is
            rectangular, with the special twist that the aspect ratio
            is maintained also for the center color: the gradient will
            not collapse into a single point, but become a line of
            center color.

        - Hatch patterns - Required hatch services:

          * "VerticalLineHatch" - this hatching consists of vertical lines
          * "OrthogonalLinesHatch" - this hatching consists of
            crossing vertical and horizontal lines
          * "ThreeCrossingLinesHatch" - this hatching consists of
            vertical and horizontal lines plus diagonal lines from
            left, top to bottom, right.
          * "FourCrossingLinesHatch" - this hatching consists of
            vertical and horizontal lines plus diagonal lines in both
            directions.
        </pre>
     */
    com::sun::star::lang::XMultiServiceFactory getParametricPolyPolygonFactory();

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

    /** Tells whether this graphic device has a full screen mode,
        i.e. whether a window can cover the whole screen exclusively.
     */
    boolean			                hasFullScreenMode();

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

    /** Enter or leave the fullscreen mode, if possible. The return
        value denotes the success of the operation.

        @attention depending on the underlying operating system,
        fullscreen mode can be left without a enterFullScreenMode(
        false ) call.
     */
    boolean							enterFullScreenMode( [in] boolean bEnter );
};

}; }; }; };

#endif