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, 401 insertions, 0 deletions

diff --git a/include/vcl/GraphicObject.hxx b/include/vcl/GraphicObject.hxx
new file mode 100644
index 000000000..5a4053fa6
--- /dev/null
+++ b/include/vcl/GraphicObject.hxx
@@ -0,0 +1,401 @@
+/* -*- 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 INCLUDED_VCL_GRAPHICOBJECT_HXX
+#define INCLUDED_VCL_GRAPHICOBJECT_HXX
+
+#include <memory>
+#include <vcl/graph.hxx>
+#include <vcl/dllapi.h>
+#include <o3tl/typed_flags_set.hxx>
+
+namespace com::sun::star::graphic { class XGraphic; }
+
+// Adjustment defines
+enum class GraphicAdjustmentFlags
+{
+    NONE                 = 0x00,
+    DRAWMODE             = 0x01,
+    COLORS               = 0x02,
+    MIRROR               = 0x04,
+    ROTATE               = 0x08,
+    TRANSPARENCY         = 0x10,
+    ALL                  = 0x1f,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<GraphicAdjustmentFlags> : is_typed_flags<GraphicAdjustmentFlags, 0x1f> {};
+}
+
+enum class GraphicDrawMode
+{
+    Standard = 0,
+    Greys = 1,
+    Mono = 2,
+    Watermark = 3
+};
+
+class VirtualDevice;
+struct GrfSimpleCacheObj;
+struct ImplTileInfo;
+
+class VCL_DLLPUBLIC GraphicAttr
+{
+private:
+
+    double          mfGamma;
+    BmpMirrorFlags  mnMirrFlags;
+    long            mnLeftCrop;
+    long            mnTopCrop;
+    long            mnRightCrop;
+    long            mnBottomCrop;
+    sal_uInt16      mnRotate10;
+    short           mnContPercent;
+    short           mnLumPercent;
+    short           mnRPercent;
+    short           mnGPercent;
+    short           mnBPercent;
+    bool            mbInvert;
+    sal_uInt8       mcTransparency;
+    GraphicDrawMode meDrawMode;
+
+public:
+
+                    GraphicAttr();
+
+    bool            operator==( const GraphicAttr& rAttr ) const;
+    bool            operator!=( const GraphicAttr& rAttr ) const { return !( *this == rAttr ); }
+
+    void            SetDrawMode( GraphicDrawMode eDrawMode ) { meDrawMode = eDrawMode; }
+    GraphicDrawMode GetDrawMode() const { return meDrawMode; }
+
+    void            SetMirrorFlags( BmpMirrorFlags nMirrFlags ) { mnMirrFlags = nMirrFlags; }
+    BmpMirrorFlags  GetMirrorFlags() const { return mnMirrFlags; }
+
+    void            SetCrop( long nLeft_100TH_MM, long nTop_100TH_MM, long nRight_100TH_MM, long nBottom_100TH_MM )
+                    {
+                        mnLeftCrop = nLeft_100TH_MM; mnTopCrop = nTop_100TH_MM;
+                        mnRightCrop = nRight_100TH_MM; mnBottomCrop = nBottom_100TH_MM;
+                    }
+    long            GetLeftCrop() const { return mnLeftCrop; }
+    long            GetTopCrop() const { return mnTopCrop; }
+    long            GetRightCrop() const { return mnRightCrop; }
+    long            GetBottomCrop() const { return mnBottomCrop; }
+
+    void            SetRotation( sal_uInt16 nRotate10 ) { mnRotate10 = nRotate10; }
+    sal_uInt16      GetRotation() const { return mnRotate10; }
+
+    void            SetLuminance( short nLuminancePercent ) { mnLumPercent = nLuminancePercent; }
+    short           GetLuminance() const { return mnLumPercent; }
+
+    void            SetContrast( short nContrastPercent ) { mnContPercent = nContrastPercent; }
+    short           GetContrast() const { return mnContPercent; }
+
+    void            SetChannelR( short nChannelRPercent ) { mnRPercent = nChannelRPercent; }
+    short           GetChannelR() const { return mnRPercent; }
+
+    void            SetChannelG( short nChannelGPercent ) { mnGPercent = nChannelGPercent; }
+    short           GetChannelG() const { return mnGPercent; }
+
+    void            SetChannelB( short nChannelBPercent ) { mnBPercent = nChannelBPercent; }
+    short           GetChannelB() const { return mnBPercent; }
+
+    void            SetGamma( double fGamma ) { mfGamma = fGamma; }
+    double          GetGamma() const { return mfGamma; }
+
+    void            SetInvert( bool bInvert ) { mbInvert = bInvert; }
+    bool            IsInvert() const { return mbInvert; }
+
+    void            SetTransparency( sal_uInt8 cTransparency ) { mcTransparency = cTransparency; }
+    sal_uInt8       GetTransparency() const { return mcTransparency; }
+
+    bool            IsSpecialDrawMode() const { return( meDrawMode != GraphicDrawMode::Standard ); }
+    bool            IsMirrored() const { return mnMirrFlags != BmpMirrorFlags::NONE; }
+    bool            IsCropped() const
+                    {
+                        return( mnLeftCrop != 0 || mnTopCrop != 0 ||
+                                mnRightCrop != 0 || mnBottomCrop != 0 );
+                    }
+    bool            IsRotated() const { return( ( mnRotate10 % 3600 ) != 0 ); }
+    bool            IsTransparent() const { return( mcTransparency > 0 ); }
+    bool            IsAdjusted() const
+                    {
+                        return( mnLumPercent != 0 || mnContPercent != 0 || mnRPercent != 0 ||
+                                mnGPercent != 0 || mnBPercent != 0 || mfGamma != 1.0 || mbInvert );
+                    }
+};
+
+class VCL_DLLPUBLIC GraphicObject
+{
+    friend class SdrGrafObj;
+
+private:
+    Graphic                 maGraphic;
+    GraphicAttr             maAttr;
+    OUString                maUserData;
+    std::unique_ptr<GrfSimpleCacheObj> mxSimpleCache;
+
+    bool                    VCL_DLLPRIVATE ImplGetCropParams(
+                                OutputDevice const * pOut,
+                                Point& rPt,
+                                Size& rSz,
+                                const GraphicAttr* pAttr,
+                                tools::PolyPolygon& rClipPolyPoly,
+                                bool& bRectClipRegion
+                            ) const;
+
+    /** Render a given number of tiles in an optimized way
+
+        This method recursively subdivides the tile rendering problem
+        in smaller parts, i.e. rendering output size x with few tiles
+        of size y, which in turn are generated from the original
+        bitmap in a recursive fashion. The subdivision size can be
+        controlled by the exponent argument, which specifies the
+        minimal number of smaller tiles used in one recursion
+        step. The resulting tile size is given as the integer number
+        of repetitions of the original bitmap along x and y. As the
+        exponent need not necessarily divide these numbers without
+        remainder, the repetition counts are effectively converted to
+        base-exponent numbers, where each place denotes the number of
+        times the corresponding tile size is rendered.
+
+        @param rVDev
+        Virtual device to render everything into
+
+        @param nNumTilesX
+        Number of original tiles to generate in x direction
+
+        @param nNumTilesY
+        Number of original tiles to generate in y direction
+
+        @param rTileSizePixel
+        Size in pixel of the original tile bitmap to render it in
+
+        @param pAttr
+        Graphic attributes to be used for rendering
+
+        @param nFlags
+        Graphic flags to be used for rendering
+
+        @param rCurrPos
+        Current output point for this recursion level (should start with (0,0))
+
+        @return true, if everything was successfully rendered.
+    */
+    bool VCL_DLLPRIVATE     ImplRenderTempTile(
+                                VirtualDevice& rVDev,
+                                int nNumTilesX,
+                                int nNumTilesY,
+                                const Size& rTileSizePixel,
+                                const GraphicAttr* pAttr
+                            );
+
+    /// internally called by ImplRenderTempTile()
+    bool VCL_DLLPRIVATE     ImplRenderTileRecursive(
+                                VirtualDevice& rVDev,
+                                int nExponent,
+                                int nMSBFactor,
+                                int nNumOrigTilesX,
+                                int nNumOrigTilesY,
+                                int nRemainderTilesX,
+                                int nRemainderTilesY,
+                                const Size& rTileSizePixel,
+                                const GraphicAttr* pAttr,
+                                ImplTileInfo& rTileInfo
+                            );
+
+    bool VCL_DLLPRIVATE     ImplDrawTiled(
+                                OutputDevice* pOut,
+                                const tools::Rectangle& rArea,
+                                const Size& rSizePixel,
+                                const Size& rOffset,
+                                const GraphicAttr* pAttr,
+                                int nTileCacheSize1D
+                            );
+
+    bool VCL_DLLPRIVATE     ImplDrawTiled(
+                                OutputDevice& rOut,
+                                const Point& rPos,
+                                int nNumTilesX,
+                                int nNumTilesY,
+                                const Size& rTileSize,
+                                const GraphicAttr* pAttr
+                            );
+
+    void VCL_DLLPRIVATE     ImplTransformBitmap(
+                                BitmapEx&           rBmpEx,
+                                const GraphicAttr&  rAttr,
+                                const Size&         rCropLeftTop,
+                                const Size&         rCropRightBottom,
+                                const tools::Rectangle&    rCropRect,
+                                const Size&         rDstSize,
+                                bool                bEnlarge
+                            ) const;
+
+public:
+                            GraphicObject();
+                            GraphicObject( const Graphic& rGraphic );
+                            GraphicObject( const GraphicObject& rCacheObj );
+                            ~GraphicObject();
+
+    GraphicObject&          operator=( const GraphicObject& rCacheObj );
+    bool                    operator==( const GraphicObject& rCacheObj ) const;
+    bool                    operator!=( const GraphicObject& rCacheObj ) const { return !( *this == rCacheObj ); }
+
+    const Graphic&          GetGraphic() const;
+    void                    SetGraphic( const Graphic& rGraphic, const GraphicObject* pCopyObj = nullptr);
+    void                    SetGraphic( const Graphic& rGraphic, const OUString& rLink );
+
+    /** Get graphic transformed according to given attributes
+
+        This method returns a Graphic transformed, cropped and scaled
+        to the given parameters, ready to be rendered to printer or
+        display. The returned graphic has the same visual appearance
+        as if it had been drawn via GraphicObject::Draw() to a
+        specific output device.
+
+        @param rDestSize
+        Desired output size in logical coordinates. The mapmode to
+        interpret these logical coordinates in is given by the second
+        parameter, rDestMap.
+
+        @param rDestMap
+        Mapmode the output should be interpreted in. This is used to
+        interpret rDestSize, to set the appropriate PrefMapMode on the
+        returned Graphic, and to deal correctly with metafile graphics.
+
+        @param rAttr
+        Graphic attributes used to transform the graphic. This
+        includes cropping, rotation, mirroring, and various color
+        adjustment parameters.
+
+        @return the readily transformed Graphic
+     */
+    Graphic                 GetTransformedGraphic(
+                                const Size& rDestSize,
+                                const MapMode& rDestMap,
+                                const GraphicAttr& rAttr
+                            ) const;
+    Graphic                 GetTransformedGraphic( const GraphicAttr* pAttr ) const; // TODO: Change to Impl
+
+    void                    SetAttr( const GraphicAttr& rAttr );
+    const GraphicAttr&      GetAttr() const { return maAttr; }
+
+    bool                    HasUserData() const { return !maUserData.isEmpty(); }
+    void                    SetUserData();
+    void                    SetUserData( const OUString& rUserData );
+    const OUString&         GetUserData() const { return maUserData; }
+
+    OString                 GetUniqueID() const;
+
+    GraphicType             GetType() const;
+    Size                    GetPrefSize() const;
+    MapMode                 GetPrefMapMode() const;
+    bool                    IsTransparent() const;
+    bool                    IsAnimated() const;
+    bool                    IsEPS() const;
+
+    bool                    Draw(
+                                OutputDevice* pOut,
+                                const Point& rPt,
+                                const Size& rSz,
+                                const GraphicAttr* pAttr = nullptr
+                            );
+
+    /** Draw the graphic repeatedly into the given output rectangle
+
+        @param pOut
+        OutputDevice where the rendering should take place
+
+        @param rArea
+        The output area that is filled with tiled instances of this graphic
+
+        @param rSize
+        The actual size of a single tile
+
+        @param rOffset
+        Offset from the left, top position of rArea, where to start
+        the tiling. The upper left corner of the graphic tilings will
+        virtually start at this position. Concretely, only that many
+        tiles are drawn to completely fill the given output area.
+
+        @param nFlags
+        Optional rendering flags
+
+        @param nTileCacheSize1D
+        Optional dimension of the generated cache tiles. The pOut sees
+        a number of tile draws, which have approximately
+        nTileCacheSize1D times nTileCacheSize1D bitmap sizes if the
+        tile bitmap is smaller. Otherwise, the tile is drawn as
+        is. This is useful if e.g. you want only a few, very large
+        bitmap drawings appear on the outdev.
+     */
+    void                    DrawTiled(
+                                OutputDevice* pOut,
+                                const tools::Rectangle& rArea,
+                                const Size& rSize,
+                                const Size& rOffset,
+                                int nTileCacheSize1D=128
+                            );
+
+    bool                    StartAnimation(
+                                OutputDevice* pOut,
+                                const Point& rPt,
+                                const Size& rSz,
+                                long nExtraData = 0,
+                                OutputDevice* pFirstFrameOutDev = nullptr
+                            );
+
+    void                    StopAnimation( OutputDevice* pOut = nullptr, long nExtraData = 0 );
+
+    static bool isGraphicObjectUniqueIdURL(OUString const & rURL);
+
+    // create CropScaling information
+    // fWidth, fHeight: object size
+    // f*Crop: crop values relative to original bitmap size
+    basegfx::B2DVector calculateCropScaling(
+        double fWidth,
+        double fHeight,
+        double fLeftCrop,
+        double fTopCrop,
+        double fRightCrop,
+        double fBottomCrop) const;
+};
+
+namespace vcl
+{
+namespace graphic
+{
+
+// Will search an object ( e.g. a control ) for any 'ImageURL' or 'Graphic'
+// properties and return graphics from the properties in a vector. ImageURL
+// will be loaded from the URL.
+//
+// Note: this implementation will cater for XNameContainer objects and deep inspect any containers
+// if they exist
+
+VCL_DLLPUBLIC void SearchForGraphics(css::uno::Reference<css::uno::XInterface> const & rxInterface,
+                                     std::vector<css::uno::Reference<css::graphic::XGraphic>> & raGraphicList);
+
+}
+} // end namespace vcl::graphic
+
+#endif // INCLUDED_VCL_GRAPHICOBJECT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */