Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 267 insertions, 0 deletions

diff --git a/offapi/com/sun/star/rendering/XGraphicDevice.idl b/offapi/com/sun/star/rendering/XGraphicDevice.idl
new file mode 100644
index 000000000..a91becfe2
--- /dev/null
+++ b/offapi/com/sun/star/rendering/XGraphicDevice.idl
@@ -0,0 +1,267 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+#ifndef __com_sun_star_rendering_XGraphicDevice_idl__
+#define __com_sun_star_rendering_XGraphicDevice_idl__
+
+#include <com/sun/star/uno/XInterface.idl>
+#include <com/sun/star/lang/IllegalArgumentException.idl>
+#include <com/sun/star/geometry/IntegerSize2D.idl>
+#include <com/sun/star/geometry/RealSize2D.idl>
+#include <com/sun/star/rendering/XLinePolyPolygon2D.idl>
+#include <com/sun/star/rendering/XBezierPolyPolygon2D.idl>
+#include <com/sun/star/rendering/XColorSpace.idl>
+#include <com/sun/star/lang/XMultiServiceFactory.idl>
+
+module com { module sun { module star { module rendering {
+
+interface XBitmap;
+interface XVolatileBitmap;
+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 its 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.
+ */
+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
+        VolatileContentDestroyedException). 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
+        VolatileContentDestroyedException). 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.
+
+        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 `sequence&lt; Color &gt;`
+          and "Stops" being a `sequence&lt; double &gt;`. 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 double
+            (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 double
+            (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.
+     */
+    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 an enterFullScreenMode(
+        false ) call.
+     */
+    boolean                         enterFullScreenMode( [in] boolean bEnter );
+};
+
+}; }; }; };
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */