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

diff --git a/include/vcl/outdev.hxx b/include/vcl/outdev.hxx
new file mode 100644
index 000000000..42b2d4cdf
--- /dev/null
+++ b/include/vcl/outdev.hxx
@@ -0,0 +1,2021 @@
+/* -*- 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_OUTDEV_HXX
+#define INCLUDED_VCL_OUTDEV_HXX
+
+#include <tools/gen.hxx>
+#include <tools/ref.hxx>
+#include <tools/solar.h>
+#include <tools/color.hxx>
+#include <tools/poly.hxx>
+#include <o3tl/typed_flags_set.hxx>
+#include <vcl/bitmap.hxx>
+#include <vcl/cairo.hxx>
+#include <vcl/devicecoordinate.hxx>
+#include <vcl/dllapi.h>
+#include <vcl/font.hxx>
+#include <vcl/region.hxx>
+#include <vcl/mapmod.hxx>
+#include <vcl/wall.hxx>
+#include <vcl/metaactiontypes.hxx>
+#include <vcl/salnativewidgets.hxx>
+#include <vcl/outdevstate.hxx>
+#include <vcl/outdevmap.hxx>
+#include <vcl/vclreferencebase.hxx>
+
+#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/vector/b2enums.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+#include <unotools/fontdefs.hxx>
+
+#include <com/sun/star/drawing/LineCap.hpp>
+#include <com/sun/star/uno/Reference.h>
+
+#include <memory>
+#include <vector>
+
+struct ImplOutDevData;
+class LogicalFontInstance;
+struct SystemGraphicsData;
+struct SystemFontData;
+struct SystemTextLayoutData;
+class ImplFontCache;
+class PhysicalFontCollection;
+class ImplDeviceFontList;
+class ImplDeviceFontSizeList;
+class ImplMultiTextLineInfo;
+class SalGraphics;
+class Gradient;
+class Hatch;
+class AllSettings;
+class BitmapReadAccess;
+class BitmapEx;
+class Image;
+class TextRectInfo;
+class FontMetric;
+class GDIMetaFile;
+class GfxLink;
+namespace tools {
+    class Line;
+}
+class LineInfo;
+class AlphaMask;
+class FontCharMap;
+class SalLayout;
+class ImplLayoutArgs;
+class VirtualDevice;
+struct SalTwoRect;
+class Printer;
+class VCLXGraphics;
+class OutDevStateStack;
+class SalLayoutGlyphs;
+
+namespace vcl
+{
+    class ExtOutDevData;
+    class ITextLayout;
+    struct FontCapabilities;
+    class TextLayoutCache;
+    class Window;
+    namespace font {
+        struct Feature;
+    }
+}
+
+namespace basegfx {
+    class B2DHomMatrix;
+    class B2DPolygon;
+    class B2IVector;
+    typedef B2IVector B2ISize;
+}
+
+namespace com::sun::star::awt {
+    class XGraphics;
+}
+
+#if defined UNX
+#define GLYPH_FONT_HEIGHT   128
+#else
+#define GLYPH_FONT_HEIGHT   256
+#endif
+
+// Text Layout options
+enum class SalLayoutFlags
+{
+    NONE                    = 0x0000,
+    BiDiRtl                 = 0x0001,
+    BiDiStrong              = 0x0002,
+    RightAlign              = 0x0004,
+    DisableKerning          = 0x0010,
+    KerningAsian            = 0x0020,
+    Vertical                = 0x0040,
+    KashidaJustification    = 0x0800,
+    ForFallback             = 0x2000,
+    GlyphItemsOnly          = 0x4000,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<SalLayoutFlags> : is_typed_flags<SalLayoutFlags, 0x6877> {};
+}
+
+typedef std::vector< tools::Rectangle > MetricVector;
+
+// OutputDevice-Types
+
+// Flags for DrawText()
+enum class DrawTextFlags
+{
+    NONE                  = 0x00000000,
+    Disable               = 0x00000001,
+    Mnemonic              = 0x00000002,
+    Mono                  = 0x00000004,
+    Clip                  = 0x00000008,
+    Left                  = 0x00000010,
+    Center                = 0x00000020,
+    Right                 = 0x00000040,
+    Top                   = 0x00000080,
+    VCenter               = 0x00000100,
+    Bottom                = 0x00000200,
+    EndEllipsis           = 0x00000400,
+    PathEllipsis          = 0x00000800,
+    MultiLine             = 0x00001000,
+    WordBreak             = 0x00002000,
+    NewsEllipsis          = 0x00004000,
+    WordBreakHyphenation  = 0x00008000 | WordBreak,
+    CenterEllipsis        = 0x00010000,
+    HideMnemonic          = 0x00020000,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<DrawTextFlags> : is_typed_flags<DrawTextFlags, 0x3ffff> {};
+}
+
+// Flags for DrawImage(), these must match the definitions in css::awt::ImageDrawMode
+enum class DrawImageFlags
+{
+    NONE                 = 0x0000,
+    Disable              = 0x0001,
+    Highlight            = 0x0002,
+    Deactive             = 0x0004,
+    ColorTransform       = 0x0008,
+    SemiTransparent      = 0x0010,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<DrawImageFlags> : is_typed_flags<DrawImageFlags, 0x001f> {};
+}
+
+// Flags for DrawGrid()
+enum class DrawGridFlags
+{
+    NONE                 = 0x0000,
+    Dots                 = 0x0001,
+    HorzLines            = 0x0002,
+    VertLines            = 0x0004
+};
+namespace o3tl
+{
+    template<> struct typed_flags<DrawGridFlags> : is_typed_flags<DrawGridFlags, 0x0007> {};
+}
+
+// DrawModes
+enum class DrawModeFlags : sal_uInt32
+{
+    Default                = 0x00000000,
+    BlackLine              = 0x00000001,
+    BlackFill              = 0x00000002,
+    BlackText              = 0x00000004,
+    BlackBitmap            = 0x00000008,
+    BlackGradient          = 0x00000010,
+    GrayLine               = 0x00000020,
+    GrayFill               = 0x00000040,
+    GrayText               = 0x00000080,
+    GrayBitmap             = 0x00000100,
+    GrayGradient           = 0x00000200,
+    NoFill                 = 0x00000400,
+    WhiteLine              = 0x00000800,
+    WhiteFill              = 0x00001000,
+    WhiteText              = 0x00002000,
+    WhiteBitmap            = 0x00004000,
+    WhiteGradient          = 0x00008000,
+    SettingsLine           = 0x00010000,
+    SettingsFill           = 0x00020000,
+    SettingsText           = 0x00040000,
+    SettingsGradient       = 0x00080000,
+    NoTransparency         = 0x00100000,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<DrawModeFlags> : is_typed_flags<DrawModeFlags, 0x1fffff> {};
+}
+
+// Antialiasing
+enum class AntialiasingFlags
+{
+    NONE                = 0x0000,
+    DisableText         = 0x0001,
+    EnableB2dDraw       = 0x0002,
+    PixelSnapHairline  = 0x0004,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<AntialiasingFlags> : is_typed_flags<AntialiasingFlags, 0x07> {};
+}
+
+// AddFontSubstitute() flags
+enum class AddFontSubstituteFlags
+{
+    NONE            = 0x00,
+    ALWAYS          = 0x01,
+    ScreenOnly      = 0x02,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<AddFontSubstituteFlags> : is_typed_flags<AddFontSubstituteFlags, 0x03> {};
+}
+
+// GetDefaultFont() flags
+enum class GetDefaultFontFlags
+{
+    NONE          = 0x0000,
+    OnlyOne       = 0x0001,
+};
+namespace o3tl
+{
+    template<> struct typed_flags<GetDefaultFontFlags> : is_typed_flags<GetDefaultFontFlags, 0x01> {};
+}
+
+// Flags for Invert()
+enum class InvertFlags
+{
+    NONE                    = 0x0000,
+    N50                     = 0x0001,
+    TrackFrame              = 0x0002
+};
+namespace o3tl
+{
+    template<> struct typed_flags<InvertFlags> : is_typed_flags<InvertFlags, 0x0003> {};
+}
+
+enum OutDevType { OUTDEV_WINDOW, OUTDEV_PRINTER, OUTDEV_VIRDEV, OUTDEV_PDF };
+
+enum class OutDevViewType { DontKnow, PrintPreview, SlideShow };
+
+// OutputDevice
+
+typedef tools::SvRef<FontCharMap> FontCharMapRef;
+
+BmpMirrorFlags AdjustTwoRect( SalTwoRect& rTwoRect, const Size& rSizePix );
+void AdjustTwoRect( SalTwoRect& rTwoRect, const tools::Rectangle& rValidSrcRect );
+
+class OutputDevice;
+
+namespace vcl {
+    typedef OutputDevice RenderContext;
+}
+
+VCL_DLLPUBLIC void DrawFocusRect(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect);
+
+typedef struct _cairo_surface cairo_surface_t;
+
+/**
+* Some things multiple-inherit from VclAbstractDialog and OutputDevice,
+* so we need to use virtual inheritance to keep the referencing counting
+* OK.
+*/
+class SAL_WARN_UNUSED VCL_DLLPUBLIC OutputDevice : public virtual VclReferenceBase
+{
+    friend class Printer;
+    friend class VirtualDevice;
+    friend class vcl::Window;
+    friend class WorkWindow;
+    friend void ImplHandleResize( vcl::Window* pWindow, long nNewWidth, long nNewHeight );
+
+private:
+    OutputDevice(const OutputDevice&) = delete;
+    OutputDevice& operator=(const OutputDevice&) = delete;
+
+    mutable SalGraphics*            mpGraphics;         ///< Graphics context to draw on
+    mutable VclPtr<OutputDevice>    mpPrevGraphics;     ///< Previous output device in list
+    mutable VclPtr<OutputDevice>    mpNextGraphics;     ///< Next output device in list
+    GDIMetaFile*                    mpMetaFile;
+    mutable rtl::Reference<LogicalFontInstance> mpFontInstance;
+    mutable std::shared_ptr<ImplFontCache> mxFontCache;
+    mutable std::shared_ptr<PhysicalFontCollection> mxFontCollection;
+    mutable std::unique_ptr<ImplDeviceFontList>     mpDeviceFontList;
+    mutable std::unique_ptr<ImplDeviceFontSizeList> mpDeviceFontSizeList;
+    std::vector<OutDevState>        maOutDevStateStack;
+    std::unique_ptr<ImplOutDevData> mpOutDevData;
+    std::vector< VCLXGraphics* >*   mpUnoGraphicsList;
+    vcl::ExtOutDevData*             mpExtOutDevData;
+
+    // TEMP TEMP TEMP
+    VclPtr<VirtualDevice>           mpAlphaVDev;
+
+    /// Additional output pixel offset, applied in LogicToPixel (used by SetPixelOffset/GetPixelOffset)
+    long                            mnOutOffOrigX;
+    /// Additional output offset in _logical_ coordinates, applied in PixelToLogic (used by SetPixelOffset/GetPixelOffset)
+    long                            mnOutOffLogicX;
+    /// Additional output pixel offset, applied in LogicToPixel (used by SetPixelOffset/GetPixelOffset)
+    long                            mnOutOffOrigY;
+    /// Additional output offset in _logical_ coordinates, applied in PixelToLogic (used by SetPixelOffset/GetPixelOffset)
+    long                            mnOutOffLogicY;
+    /// Output offset for device output in pixel (pseudo window offset within window system's frames)
+    long                            mnOutOffX;
+    /// Output offset for device output in pixel (pseudo window offset within window system's frames)
+    long                            mnOutOffY;
+    long                            mnOutWidth;
+    long                            mnOutHeight;
+    sal_Int32                       mnDPIX;
+    sal_Int32                       mnDPIY;
+    sal_Int32                       mnDPIScalePercentage; ///< For HiDPI displays, we want to draw elements for a percentage larger
+    /// font specific text alignment offsets in pixel units
+    mutable long                    mnTextOffX;
+    mutable long                    mnTextOffY;
+    mutable long                    mnEmphasisAscent;
+    mutable long                    mnEmphasisDescent;
+    DrawModeFlags                   mnDrawMode;
+    ComplexTextLayoutFlags           mnTextLayoutMode;
+    ImplMapRes                      maMapRes;
+    ImplThresholdRes                maThresRes;
+    const OutDevType                meOutDevType;
+    OutDevViewType                  meOutDevViewType;
+    vcl::Region                     maRegion;           // contains the clip region, see SetClipRegion(...)
+    Color                           maLineColor;
+    Color                           maFillColor;
+    vcl::Font                       maFont;
+    Color                           maTextColor;
+    Color                           maTextLineColor;
+    Color                           maOverlineColor;
+    RasterOp                        meRasterOp;
+    Wallpaper                       maBackground;
+    std::unique_ptr<AllSettings>    mxSettings;
+    MapMode                         maMapMode;
+    Point                           maRefPoint;
+    AntialiasingFlags               mnAntialiasing;
+    LanguageType                    meTextLanguage;
+
+    mutable bool                    mbMap : 1;
+    mutable bool                    mbClipRegion : 1;
+    mutable bool                    mbBackground : 1;
+    mutable bool                    mbOutput : 1;
+    mutable bool                    mbDevOutput : 1;
+    mutable bool                    mbOutputClipped : 1;
+    mutable bool                    mbLineColor : 1;
+    mutable bool                    mbFillColor : 1;
+    mutable bool                    mbInitLineColor : 1;
+    mutable bool                    mbInitFillColor : 1;
+    mutable bool                    mbInitFont : 1;
+    mutable bool                    mbInitTextColor : 1;
+    mutable bool                    mbInitClipRegion : 1;
+    mutable bool                    mbClipRegionSet : 1;
+    mutable bool                    mbNewFont : 1;
+    mutable bool                    mbTextLines : 1;
+    mutable bool                    mbTextSpecial : 1;
+    mutable bool                    mbRefPoint : 1;
+    mutable bool                    mbEnableRTL : 1;
+
+    /** @name Initialization and accessor functions
+     */
+    ///@{
+
+protected:
+                                OutputDevice(OutDevType eOutDevType);
+    virtual                     ~OutputDevice() override;
+    virtual void                dispose() override;
+
+public:
+
+    /** Get the graphic context that the output device uses to draw on.
+
+     If no graphics device exists, then initialize it.
+
+     @returns SalGraphics instance.
+     */
+    SalGraphics const           *GetGraphics() const;
+    SalGraphics*                GetGraphics();
+
+    void                        SetConnectMetaFile( GDIMetaFile* pMtf );
+    GDIMetaFile*                GetConnectMetaFile() const { return mpMetaFile; }
+
+    virtual void                SetSettings( const AllSettings& rSettings );
+    const AllSettings&          GetSettings() const { return *mxSettings; }
+
+    SystemGraphicsData          GetSystemGfxData() const;
+    bool                        SupportsCairo() const;
+    /// Create Surface from given cairo surface
+    cairo::SurfaceSharedPtr     CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const;
+    /// Create surface with given dimensions
+    cairo::SurfaceSharedPtr     CreateSurface(int x, int y, int width, int height) const;
+    /// Create Surface for given bitmap data
+    cairo::SurfaceSharedPtr     CreateBitmapSurface(const BitmapSystemData& rData, const Size& rSize) const;
+    /// Return native handle for underlying surface
+    css::uno::Any               GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const;
+    css::uno::Any               GetSystemGfxDataAny() const;
+
+    void                        SetRefPoint();
+    void                        SetRefPoint( const Point& rRefPoint );
+    const Point&                GetRefPoint() const { return maRefPoint; }
+    bool                        IsRefPoint() const { return mbRefPoint; }
+
+    virtual bool                IsScreenComp() const { return true; }
+
+    virtual sal_uInt16          GetBitCount() const;
+
+    Size                        GetOutputSizePixel() const
+                                    { return Size( mnOutWidth, mnOutHeight ); }
+    long                        GetOutputWidthPixel() const { return mnOutWidth; }
+    long                        GetOutputHeightPixel() const { return mnOutHeight; }
+    long                        GetOutOffXPixel() const { return mnOutOffX; }
+    long                        GetOutOffYPixel() const { return mnOutOffY; }
+    void                        SetOutOffXPixel(long nOutOffX);
+    void                        SetOutOffYPixel(long nOutOffY);
+
+    Size                        GetOutputSize() const
+                                    { return PixelToLogic( GetOutputSizePixel() ); }
+
+    css::uno::Reference< css::awt::XGraphics >
+                                CreateUnoGraphics();
+    std::vector< VCLXGraphics* > *GetUnoGraphicsList() const  { return mpUnoGraphicsList; }
+    std::vector< VCLXGraphics* > *CreateUnoGraphicsList();
+
+protected:
+
+    /** Acquire a graphics device that the output device uses to draw on.
+
+     There is an LRU of OutputDevices that is used to get the graphics. The
+     actual creation of a SalGraphics instance is done via the SalFrame
+     implementation.
+
+     However, the SalFrame instance will only return a valid SalGraphics
+     instance if it is not in use or there wasn't one in the first place. When
+     this happens, AcquireGraphics finds the least recently used OutputDevice
+     in a different frame and "steals" it (releases it then starts using it).
+
+     If there are no frames to steal an OutputDevice's SalGraphics instance from
+     then it blocks until the graphics is released.
+
+     Once it has acquired a graphics instance, then we add the OutputDevice to
+     the LRU.
+
+     @returns true if was able to initialize the graphics device, false otherwise.
+     */
+    virtual bool                AcquireGraphics() const = 0;
+
+    /** Release the graphics device, and remove it from the graphics device
+     list.
+
+     @param         bRelease    Determines whether to release the fonts of the
+                                physically released graphics device.
+     */
+    virtual void                ReleaseGraphics( bool bRelease = true ) = 0;
+    ///@}
+
+
+    /** @name Helper functions
+     */
+    ///@{
+
+public:
+
+    /** Get the output device's DPI x-axis value.
+
+     @returns x-axis DPI value
+     */
+    SAL_DLLPRIVATE sal_Int32    GetDPIX() const { return mnDPIX; }
+
+    /** Get the output device's DPI y-axis value.
+
+     @returns y-axis DPI value
+     */
+    SAL_DLLPRIVATE sal_Int32    GetDPIY() const { return mnDPIY; }
+
+    SAL_DLLPRIVATE void         SetDPIX( sal_Int32 nDPIX ) { mnDPIX = nDPIX; }
+    SAL_DLLPRIVATE void         SetDPIY( sal_Int32 nDPIY ) { mnDPIY = nDPIY; }
+
+    float GetDPIScaleFactor() const
+    {
+        return mnDPIScalePercentage / 100.0f;
+    }
+
+    sal_Int32 GetDPIScalePercentage() const
+    {
+        return mnDPIScalePercentage;
+    }
+
+    OutDevType                  GetOutDevType() const { return meOutDevType; }
+    virtual bool IsVirtual() const;
+
+    /** Query an OutputDevice to see whether it supports a specific operation
+
+     @returns true if operation supported, else false
+    */
+    bool                        SupportsOperation( OutDevSupportType ) const;
+
+    void                        SetExtOutDevData( vcl::ExtOutDevData* pExtOutDevData ) { mpExtOutDevData = pExtOutDevData; }
+    vcl::ExtOutDevData*         GetExtOutDevData() const { return mpExtOutDevData; }
+
+    ///@}
+
+
+    /** @name Direct OutputDevice drawing functions
+     */
+    ///@{
+
+public:
+    virtual void                Flush() {}
+
+    virtual void                DrawOutDev(
+                                    const Point& rDestPt, const Size& rDestSize,
+                                    const Point& rSrcPt,  const Size& rSrcSize );
+
+    virtual void                DrawOutDev(
+                                    const Point& rDestPt, const Size& rDestSize,
+                                    const Point& rSrcPt,  const Size& rSrcSize,
+                                    const OutputDevice& rOutDev );
+
+    virtual void                CopyArea(
+                                    const Point& rDestPt,
+                                    const Point& rSrcPt,  const Size& rSrcSize,
+                                    bool bWindowInvalidate = false );
+
+protected:
+
+    virtual void                CopyDeviceArea( SalTwoRect& aPosAry, bool bWindowInvalidate);
+
+    virtual tools::Rectangle    GetBackgroundComponentBounds() const;
+
+    virtual const OutputDevice* DrawOutDevDirectCheck(const OutputDevice* pSrcDev) const;
+
+    virtual void                DrawOutDevDirectProcess( const OutputDevice* pSrcDev, SalTwoRect& rPosAry, SalGraphics* pSrcGraphics );
+
+    SAL_DLLPRIVATE void         drawOutDevDirect ( const OutputDevice* pSrcDev, SalTwoRect& rPosAry );
+
+    SAL_DLLPRIVATE bool         is_double_buffered_window() const;
+
+private:
+
+    // not implemented; to detect misuses of DrawOutDev(...OutputDevice&);
+    SAL_DLLPRIVATE void         DrawOutDev( const Point&, const Size&, const Point&,  const Size&, const Printer&) = delete;
+    ///@}
+
+
+    /** @name OutputDevice state functions
+     */
+    ///@{
+
+public:
+
+    void                        Push( PushFlags nFlags = PushFlags::ALL );
+    void                        Pop();
+
+    // returns the current stack depth; that is the number of Push() calls minus the number of Pop() calls
+    // this should not normally be used since Push and Pop must always be used symmetrically
+    // however this may be e.g. a help when debugging code in which this somehow is not the case
+    sal_uInt32                  GetGCStackDepth() const;
+    void                        ClearStack();
+
+    void                        EnableOutput( bool bEnable = true );
+    bool                        IsOutputEnabled() const { return mbOutput; }
+    bool                        IsDeviceOutputNecessary() const { return (mbOutput && mbDevOutput); }
+
+    void                        SetAntialiasing( AntialiasingFlags nMode );
+    AntialiasingFlags           GetAntialiasing() const { return mnAntialiasing; }
+
+    void                        SetDrawMode( DrawModeFlags nDrawMode );
+    DrawModeFlags               GetDrawMode() const { return mnDrawMode; }
+
+    void                        SetLayoutMode( ComplexTextLayoutFlags nTextLayoutMode );
+    ComplexTextLayoutFlags       GetLayoutMode() const { return mnTextLayoutMode; }
+
+    void                        SetDigitLanguage( LanguageType );
+    LanguageType                GetDigitLanguage() const { return meTextLanguage; }
+
+    void                        SetRasterOp( RasterOp eRasterOp );
+    RasterOp                    GetRasterOp() const { return meRasterOp; }
+
+    /**
+    If this OutputDevice is used for displaying a Print Preview
+    the OutDevViewType should be set to 'OutDevViewType::PrintPreview'.
+
+    A View can then make painting decisions dependent on this OutDevViewType.
+    E.g. text colors need to be handled differently, dependent on whether it's a PrintPreview or not. (see #106611# for more)
+    */
+    void                        SetOutDevViewType( OutDevViewType eOutDevViewType ) { meOutDevViewType=eOutDevViewType; }
+    OutDevViewType              GetOutDevViewType() const { return meOutDevViewType; }
+
+    void                        SetLineColor();
+    void                        SetLineColor( const Color& rColor );
+    const Color&                GetLineColor() const { return maLineColor; }
+    bool                        IsLineColor() const { return mbLineColor; }
+
+    void                        SetFillColor();
+    void                        SetFillColor( const Color& rColor );
+    const Color&                GetFillColor() const { return maFillColor; }
+    bool                        IsFillColor() const { return mbFillColor; }
+
+    void                        SetBackground();
+    void                        SetBackground( const Wallpaper& rBackground );
+    virtual void                SaveBackground(VirtualDevice& rSaveDevice,
+                                               const Point& rPos, const Size& rSize, const Size& rBackgroundSize) const;
+
+    const Wallpaper&            GetBackground() const { return maBackground; }
+    virtual Color               GetBackgroundColor() const;
+    virtual Color               GetReadableFontColor(const Color& rFontColor, const Color& rBgColor) const;
+    bool                        IsBackground() const { return mbBackground; }
+
+    void                        SetFont( const vcl::Font& rNewFont );
+    const vcl::Font&            GetFont() const { return maFont; }
+
+protected:
+
+    virtual void                ImplReleaseFonts();
+
+private:
+
+    SAL_DLLPRIVATE void         InitLineColor();
+
+    SAL_DLLPRIVATE void         InitFillColor();
+
+    ///@}
+
+
+    /** @name Clipping functions
+     */
+    ///@{
+
+public:
+
+    vcl::Region                 GetClipRegion() const;
+    void                        SetClipRegion();
+    void                        SetClipRegion( const vcl::Region& rRegion );
+    bool                        SelectClipRegion( const vcl::Region&, SalGraphics* pGraphics = nullptr );
+
+    bool                        IsClipRegion() const { return mbClipRegion; }
+
+    void                        MoveClipRegion( long nHorzMove, long nVertMove );
+    void                        IntersectClipRegion( const tools::Rectangle& rRect );
+    void                        IntersectClipRegion( const vcl::Region& rRegion );
+
+    virtual vcl::Region         GetActiveClipRegion() const;
+    virtual vcl::Region         GetOutputBoundsClipRegion() const;
+
+protected:
+
+    virtual void                InitClipRegion();
+
+    /** Perform actual rect clip against outdev dimensions, to generate
+        empty clips whenever one of the values is completely off the device.
+
+        @param aRegion      region to be clipped to the device dimensions
+        @returns            region clipped to the device bounds
+     **/
+    virtual vcl::Region         ClipToDeviceBounds(vcl::Region aRegion) const;
+    virtual void                ClipToPaintRegion    ( tools::Rectangle& rDstRect );
+
+private:
+
+    SAL_DLLPRIVATE void         SetDeviceClipRegion( const vcl::Region* pRegion );
+    ///@}
+
+
+    /** @name Pixel functions
+     */
+    ///@{
+
+public:
+
+    void                        DrawPixel( const Point& rPt );
+    void                        DrawPixel( const Point& rPt, const Color& rColor );
+
+    Color                       GetPixel( const Point& rPt ) const;
+    ///@}
+
+
+    /** @name Rectangle functions
+     */
+    ///@{
+
+public:
+
+    void                        DrawRect( const tools::Rectangle& rRect );
+    void                        DrawRect( const tools::Rectangle& rRect,
+                                          sal_uLong nHorzRount, sal_uLong nVertRound );
+
+    /// Fill the given rectangle with checkered rectangles of size nLen x nLen using the colors aStart and aEnd
+    void                        DrawCheckered(
+                                    const Point& rPos,
+                                    const Size& rSize,
+                                    sal_uInt32 nLen = 8,
+                                    Color aStart = COL_WHITE,
+                                    Color aEnd = COL_BLACK);
+
+    void                        DrawGrid( const tools::Rectangle& rRect, const Size& rDist, DrawGridFlags nFlags );
+
+    ///@}
+
+    /** @name Invert functions
+     */
+    ///@{
+public:
+    void Invert( const tools::Rectangle& rRect, InvertFlags nFlags = InvertFlags::NONE );
+    void Invert( const tools::Polygon& rPoly, InvertFlags nFlags = InvertFlags::NONE );
+    ///@}
+
+    /** @name Line functions
+     */
+    ///@{
+
+public:
+
+    void                        DrawLine( const Point& rStartPt, const Point& rEndPt );
+
+    void                        DrawLine( const Point& rStartPt, const Point& rEndPt,
+                                          const LineInfo& rLineInfo );
+
+protected:
+    virtual void DrawHatchLine_DrawLine(const Point& rStartPoint, const Point& rEndPoint);
+
+private:
+
+    /** Helper for line geometry paint with support for graphic expansion (pattern and fat_to_area)
+     */
+    SAL_DLLPRIVATE void         drawLine( basegfx::B2DPolyPolygon aLinePolyPolygon, const LineInfo& rInfo );
+    ///@}
+
+
+    /** @name Polyline functions
+     */
+    ///@{
+
+public:
+
+    /** Render the given polygon as a line stroke
+
+        The given polygon is stroked with the current LineColor, start
+        and end point are not automatically connected
+
+        @see DrawPolygon
+        @see DrawPolyPolygon
+     */
+    void                        DrawPolyLine( const tools::Polygon& rPoly );
+
+    void                        DrawPolyLine(
+                                    const basegfx::B2DPolygon&,
+                                    double fLineWidth = 0.0,
+                                    basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::Round,
+                                    css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT,
+                                    double fMiterMinimumAngle = basegfx::deg2rad(15.0));
+
+    /** Render the given polygon as a line stroke
+
+        The given polygon is stroked with the current LineColor, start
+        and end point are not automatically connected. The line is
+        rendered according to the specified LineInfo, e.g. supplying a
+        dash pattern, or a line thickness.
+
+        @see DrawPolygon
+        @see DrawPolyPolygon
+     */
+    void                        DrawPolyLine( const tools::Polygon& rPoly,
+                                              const LineInfo& rLineInfo );
+
+    // #i101491#
+    // Helper who tries to use SalGDI's DrawPolyLine direct and returns it's bool.
+    bool                        DrawPolyLineDirect(
+                                    const basegfx::B2DHomMatrix& rObjectTransform,
+                                    const basegfx::B2DPolygon& rB2DPolygon,
+                                    double fLineWidth = 0.0,
+                                    double fTransparency = 0.0,
+                                    const std::vector< double >* = nullptr, // MM01
+                                    basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::NONE,
+                                    css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT,
+                                    double fMiterMinimumAngle = basegfx::deg2rad(15.0),
+                                    bool bBypassAACheck = false);
+
+private:
+
+    // #i101491#
+    // Helper which holds the old line geometry creation and is extended to use AA when
+    // switched on. Advantage is that line geometry is only temporarily used for paint
+    SAL_DLLPRIVATE void         drawPolyLine(const tools::Polygon& rPoly, const LineInfo& rLineInfo);
+
+    ///@}
+
+
+    /** @name Polygon functions
+     */
+    ///@{
+
+public:
+
+    /** Render the given polygon
+
+        The given polygon is stroked with the current LineColor, and
+        filled with the current FillColor. If one of these colors are
+        transparent, the corresponding stroke or fill stays
+        invisible. Start and end point of the polygon are
+        automatically connected.
+
+        @see DrawPolyLine
+     */
+    void                        DrawPolygon( const tools::Polygon& rPoly );
+    void                        DrawPolygon( const basegfx::B2DPolygon& );
+
+    /** Render the given poly-polygon
+
+        The given poly-polygon is stroked with the current LineColor,
+        and filled with the current FillColor. If one of these colors
+        are transparent, the corresponding stroke or fill stays
+        invisible. Start and end points of the contained polygons are
+        automatically connected.
+
+        @see DrawPolyLine
+     */
+    void                        DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly );
+    void                        DrawPolyPolygon( const basegfx::B2DPolyPolygon& );
+
+private:
+
+    SAL_DLLPRIVATE void         ImplDrawPolygon( const tools::Polygon& rPoly, const tools::PolyPolygon* pClipPolyPoly = nullptr );
+    SAL_DLLPRIVATE void         ImplDrawPolyPolygon( const tools::PolyPolygon& rPolyPoly, const tools::PolyPolygon* pClipPolyPoly );
+    SAL_DLLPRIVATE void         ImplDrawPolyPolygon( sal_uInt16 nPoly, const tools::PolyPolygon& rPolyPoly );
+    // #i101491#
+    // Helper who implements the DrawPolyPolygon functionality for basegfx::B2DPolyPolygon
+    // without MetaFile processing
+    SAL_DLLPRIVATE void         ImplDrawPolyPolygonWithB2DPolyPolygon(const basegfx::B2DPolyPolygon& rB2DPolyPoly);
+    ///@}
+
+
+    /** @name Curved shape functions
+     */
+    ///@{
+
+public:
+
+    void                        DrawEllipse( const tools::Rectangle& rRect );
+
+    void                        DrawArc(
+                                    const tools::Rectangle& rRect,
+                                    const Point& rStartPt, const Point& rEndPt );
+
+    void                        DrawPie(
+                                    const tools::Rectangle& rRect,
+                                    const Point& rStartPt, const Point& rEndPt );
+
+    void                        DrawChord(
+                                    const tools::Rectangle& rRect,
+                                    const Point& rStartPt, const Point& rEndPt );
+
+    ///@}
+
+
+    /** @name Gradient functions
+     */
+    ///@{
+
+public:
+    void                        DrawGradient( const tools::Rectangle& rRect, const Gradient& rGradient );
+    void                        DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
+
+    void                        AddGradientActions(
+                                    const tools::Rectangle& rRect,
+                                    const Gradient& rGradient,
+                                    GDIMetaFile& rMtf );
+
+protected:
+
+    virtual bool                UsePolyPolygonForComplexGradient() = 0;
+
+    virtual long                GetGradientStepCount( long nMinRect );
+
+private:
+
+    SAL_DLLPRIVATE void         DrawLinearGradient( const tools::Rectangle& rRect, const Gradient& rGradient, const tools::PolyPolygon* pClipPolyPoly );
+    SAL_DLLPRIVATE void         DrawComplexGradient( const tools::Rectangle& rRect, const Gradient& rGradient, const tools::PolyPolygon* pClipPolyPoly );
+
+    SAL_DLLPRIVATE void         DrawGradientToMetafile( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
+    SAL_DLLPRIVATE void         DrawLinearGradientToMetafile( const tools::Rectangle& rRect, const Gradient& rGradient );
+    SAL_DLLPRIVATE void         DrawComplexGradientToMetafile( const tools::Rectangle& rRect, const Gradient& rGradient );
+
+    SAL_DLLPRIVATE long         GetGradientSteps( const Gradient& rGradient, const tools::Rectangle& rRect, bool bMtf, bool bComplex=false );
+
+    SAL_DLLPRIVATE Color        GetSingleColorGradientFill();
+    SAL_DLLPRIVATE void         SetGrayscaleColors( Gradient &rGradient );
+    ///@}
+
+
+    /** @name Hatch functions
+     */
+    ///@{
+
+public:
+
+#ifdef _MSC_VER
+    void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const ::Hatch& rHatch );
+    void                        AddHatchActions( const tools::PolyPolygon& rPolyPoly,
+                                                 const ::Hatch& rHatch,
+                                                 GDIMetaFile& rMtf );
+#else
+    void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch );
+    void                        AddHatchActions( const tools::PolyPolygon& rPolyPoly,
+                                                 const Hatch& rHatch,
+                                                 GDIMetaFile& rMtf );
+#endif
+
+    void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch, bool bMtf );
+
+private:
+
+    SAL_DLLPRIVATE void         CalcHatchValues( const tools::Rectangle& rRect, long nDist, sal_uInt16 nAngle10, Point& rPt1, Point& rPt2, Size& rInc, Point& rEndPt1 );
+    SAL_DLLPRIVATE void         DrawHatchLine( const tools::Line& rLine, const tools::PolyPolygon& rPolyPoly, Point* pPtBuffer, bool bMtf );
+    ///@}
+
+
+    /** @name Wallpaper functions
+     */
+    ///@{
+
+public:
+    void                        DrawWallpaper( const tools::Rectangle& rRect, const Wallpaper& rWallpaper );
+
+    void                        Erase();
+    void                        Erase(const tools::Rectangle& rRect);
+
+protected:
+    void                        DrawGradientWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
+
+private:
+    SAL_DLLPRIVATE void         DrawWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
+    SAL_DLLPRIVATE void         DrawColorWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
+    SAL_DLLPRIVATE void         DrawBitmapWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
+    ///@}
+
+
+    /** @name Text functions
+     */
+    ///@{
+
+public:
+
+    void                        DrawText( const Point& rStartPt, const OUString& rStr,
+                                          sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
+                                          MetricVector* pVector = nullptr, OUString* pDisplayText = nullptr,
+                                          const SalLayoutGlyphs* pLayoutCache = nullptr );
+
+    void                        DrawText( const tools::Rectangle& rRect,
+                                          const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::NONE,
+                                          MetricVector* pVector = nullptr, OUString* pDisplayText = nullptr,
+                                          vcl::ITextLayout* _pTextLayout = nullptr );
+
+    static void                 ImplDrawText( OutputDevice& rTargetDevice, const tools::Rectangle& rRect,
+                                              const OUString& rOrigStr, DrawTextFlags nStyle,
+                                              MetricVector* pVector, OUString* pDisplayText, vcl::ITextLayout& _rLayout );
+
+    void                        ImplDrawText( SalLayout& );
+
+    void                        ImplDrawTextBackground( const SalLayout& );
+
+    void                        DrawCtrlText( const Point& rPos, const OUString& rStr,
+                                              sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
+                                              DrawTextFlags nStyle = DrawTextFlags::Mnemonic, MetricVector* pVector = nullptr, OUString* pDisplayText = nullptr,
+                                              const SalLayoutGlyphs* pGlyphs = nullptr);
+
+    void                        DrawTextLine( const Point& rPos, long nWidth,
+                                              FontStrikeout eStrikeout,
+                                              FontLineStyle eUnderline,
+                                              FontLineStyle eOverline,
+                                              bool bUnderlineAbove = false );
+
+    void                        ImplDrawTextLine( long nBaseX, long nX, long nY, DeviceCoordinate nWidth,
+                                                  FontStrikeout eStrikeout, FontLineStyle eUnderline,
+                                                  FontLineStyle eOverline, bool bUnderlineAbove );
+
+    void                        ImplDrawTextLines( SalLayout&, FontStrikeout eStrikeout, FontLineStyle eUnderline,
+                                                   FontLineStyle eOverline, bool bWordLine, bool bUnderlineAbove );
+
+    void                        DrawWaveLine( const Point& rStartPos, const Point& rEndPos, long nLineWidth = 1 );
+
+    bool                        ImplDrawRotateText( SalLayout& );
+
+    tools::Rectangle                   GetTextRect( const tools::Rectangle& rRect,
+                                             const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::WordBreak,
+                                             TextRectInfo* pInfo = nullptr,
+                                             const vcl::ITextLayout* _pTextLayout = nullptr ) const;
+
+    /** Return the exact bounding rectangle of rStr.
+
+        The text is then drawn exactly from rRect.TopLeft() to
+        rRect.BottomRight(), don't assume that rRect.TopLeft() is [0, 0].
+
+        Please note that you don't always want to use GetTextBoundRect(); in
+        many cases you actually want to use GetTextHeight(), because
+        GetTextBoundRect() gives you the exact bounding rectangle regardless
+        what is the baseline of the text.
+
+        Code snippet to get just exactly the text (no filling around that) as
+        a bitmap via a VirtualDevice (regardless what is the baseline):
+
+        <code>
+        VirtualDevice aDevice;
+        vcl::Font aFont = aDevice.GetFont();
+        aFont.SetSize(Size(0, 96));
+        aFont.SetColor(COL_BLACK);
+        aDevice.SetFont(aFont);
+        aDevice.Erase();
+
+        tools::Rectangle aRect;
+        aDevice.GetTextBoundRect(aRect, aText);
+        aDevice.SetOutputSize(Size(aRect.BottomRight().X() + 1, aRect.BottomRight().Y() + 1));
+        aDevice.SetBackground(Wallpaper(COL_TRANSPARENT));
+        aDevice.DrawText(Point(0,0), aText);
+
+        // exactly only the text, regardless of the baseline
+        Bitmap aBitmap(aDevice.GetBitmap(aRect.TopLeft(), aRect.GetSize()));
+        </code>
+
+        Code snippet to get the text as a bitmap via a Virtual device that
+        contains even the filling so that the baseline is always preserved
+        (ie. the text will not jump up and down according to whether it
+        contains 'y' or not etc.)
+
+        <code>
+        VirtualDevice aDevice;
+        // + the appropriate font / device setup, see above
+
+        aDevice.SetOutputSize(Size(aDevice.GetTextWidth(aText), aDevice.GetTextHeight()));
+        aDevice.SetBackground(Wallpaper(COL_TRANSPARENT));
+        aDevice.DrawText(Point(0,0), aText);
+
+        // bitmap that contains even the space around the text,
+        // that means, preserves the baseline etc.
+        Bitmap aBitmap(aDevice.GetBitmap(Point(0, 0), aDevice.GetOutputSize()));
+        </code>
+    */
+    bool                        GetTextBoundRect( tools::Rectangle& rRect,
+                                                  const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
+                                                  sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr,
+                                                  const SalLayoutGlyphs* pGlyphs = nullptr ) const;
+
+    tools::Rectangle                   ImplGetTextBoundRect( const SalLayout& );
+
+    bool                        GetTextOutline( tools::PolyPolygon&,
+                                                const OUString& rStr,
+                                                sal_Int32 nLen = -1,
+                                                sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
+
+    bool                        GetTextOutlines( PolyPolyVector&,
+                                                 const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0,
+                                                 sal_Int32 nLen = -1,
+                                                 sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
+
+    bool                        GetTextOutlines( basegfx::B2DPolyPolygonVector &rVector,
+                                                 const OUString& rStr, sal_Int32 nBase, sal_Int32 nIndex = 0,
+                                                 sal_Int32 nLen = -1,
+                                                 sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
+
+
+    OUString                    GetEllipsisString( const OUString& rStr, long nMaxWidth,
+                                                   DrawTextFlags nStyle = DrawTextFlags::EndEllipsis ) const;
+
+    long                        GetCtrlTextWidth( const OUString& rStr,
+                                                  const SalLayoutGlyphs* pLayoutCache = nullptr ) const;
+
+    static OUString             GetNonMnemonicString( const OUString& rStr, sal_Int32& rMnemonicPos );
+
+    static OUString             GetNonMnemonicString( const OUString& rStr )
+                                            { sal_Int32 nDummy; return GetNonMnemonicString( rStr, nDummy ); }
+
+    /** Generate MetaTextActions for the text rect
+
+        This method splits up the text rect into multiple
+        MetaTextActions, one for each line of text. This is comparable
+        to AddGradientActions(), which splits up a gradient into its
+        constituent polygons. Parameter semantics fully compatible to
+        DrawText().
+     */
+    void                        AddTextRectActions( const tools::Rectangle& rRect,
+                                                    const OUString&  rOrigStr,
+                                                    DrawTextFlags    nStyle,
+                                                    GDIMetaFile&     rMtf );
+
+    void                        SetTextColor( const Color& rColor );
+    const Color&                GetTextColor() const { return maTextColor; }
+
+    void                        SetTextFillColor();
+    void                        SetTextFillColor( const Color& rColor );
+    Color                       GetTextFillColor() const;
+    bool                        IsTextFillColor() const { return !maFont.IsTransparent(); }
+
+    void                        SetTextLineColor();
+    void                        SetTextLineColor( const Color& rColor );
+    const Color&                GetTextLineColor() const { return maTextLineColor; }
+    bool                        IsTextLineColor() const { return (maTextLineColor.GetTransparency() == 0); }
+
+    void                        SetOverlineColor();
+    void                        SetOverlineColor( const Color& rColor );
+    const Color&                GetOverlineColor() const { return maOverlineColor; }
+    bool                        IsOverlineColor() const { return (maOverlineColor.GetTransparency() == 0); }
+
+    void                        SetTextAlign( TextAlign eAlign );
+    TextAlign                   GetTextAlign() const { return maFont.GetAlignment(); }
+
+    /** Width of the text.
+
+        See also GetTextBoundRect() for more explanation + code examples.
+    */
+    long                        GetTextWidth( const OUString& rStr, sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
+                                  vcl::TextLayoutCache const* = nullptr,
+                                  SalLayoutGlyphs const*const pLayoutCache = nullptr) const;
+
+    /** Height where any character of the current font fits; in logic coordinates.
+
+        See also GetTextBoundRect() for more explanation + code examples.
+    */
+    long                        GetTextHeight() const;
+    float                       approximate_digit_width() const;
+
+    void                        DrawTextArray( const Point& rStartPt, const OUString& rStr,
+                                               const long* pDXAry,
+                                               sal_Int32 nIndex = 0,
+                                               sal_Int32 nLen = -1,
+                                               SalLayoutFlags flags = SalLayoutFlags::NONE,
+                                               const SalLayoutGlyphs* pLayoutCache = nullptr);
+    long                        GetTextArray( const OUString& rStr, long* pDXAry,
+                                              sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
+                                              vcl::TextLayoutCache const* = nullptr,
+                                              SalLayoutGlyphs const*const pLayoutCache = nullptr) const;
+
+    void                        GetCaretPositions( const OUString&, long* pCaretXArray,
+                                              sal_Int32 nIndex, sal_Int32 nLen,
+                                              const SalLayoutGlyphs* pGlyphs = nullptr ) const;
+    void                        DrawStretchText( const Point& rStartPt, sal_uLong nWidth,
+                                                 const OUString& rStr,
+                                                 sal_Int32 nIndex = 0, sal_Int32 nLen = -1);
+    sal_Int32                   GetTextBreak( const OUString& rStr, long nTextWidth,
+                                              sal_Int32 nIndex, sal_Int32 nLen = -1,
+                                              long nCharExtra = 0,
+                                              vcl::TextLayoutCache const* = nullptr,
+                                              const SalLayoutGlyphs* pGlyphs = nullptr) const;
+    sal_Int32                   GetTextBreak( const OUString& rStr, long nTextWidth,
+                                              sal_Unicode nExtraChar, sal_Int32& rExtraCharPos,
+                                              sal_Int32 nIndex, sal_Int32 nLen,
+                                              long nCharExtra,
+                                              vcl::TextLayoutCache const* = nullptr) const;
+    static std::shared_ptr<vcl::TextLayoutCache> CreateTextLayoutCache(OUString const&);
+
+protected:
+    SAL_DLLPRIVATE void         ImplInitTextLineSize();
+    SAL_DLLPRIVATE void         ImplInitAboveTextLineSize();
+    static
+    SAL_DLLPRIVATE long         ImplGetTextLines( ImplMultiTextLineInfo& rLineInfo, long nWidth, const OUString& rStr, DrawTextFlags nStyle, const vcl::ITextLayout& _rLayout );
+    SAL_DLLPRIVATE float        approximate_char_width() const;
+private:
+    SAL_DLLPRIVATE void         ImplInitTextColor();
+
+    SAL_DLLPRIVATE void         ImplDrawTextDirect( SalLayout&, bool bTextLines);
+    SAL_DLLPRIVATE void         ImplDrawSpecialText( SalLayout& );
+    SAL_DLLPRIVATE void         ImplDrawTextRect( long nBaseX, long nBaseY, long nX, long nY, long nWidth, long nHeight );
+
+    SAL_DLLPRIVATE static void  ImplDrawWavePixel( long nOriginX, long nOriginY, long nCurX, long nCurY, short nOrientation, SalGraphics* pGraphics, OutputDevice const * pOutDev,
+                                                   bool bDrawPixAsRect, long nPixWidth, long nPixHeight );
+    SAL_DLLPRIVATE void         ImplDrawWaveLine( long nBaseX, long nBaseY, long nStartX, long nStartY, long nWidth, long nHeight, long nLineWidth, short nOrientation, const Color& rColor );
+    SAL_DLLPRIVATE void         ImplDrawWaveTextLine( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontLineStyle eTextLine, Color aColor, bool bIsAbove );
+    SAL_DLLPRIVATE void         ImplDrawStraightTextLine( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontLineStyle eTextLine, Color aColor, bool bIsAbove );
+    SAL_DLLPRIVATE void         ImplDrawStrikeoutLine( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontStrikeout eStrikeout, Color aColor );
+    SAL_DLLPRIVATE void         ImplDrawStrikeoutChar( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontStrikeout eStrikeout, Color aColor );
+    SAL_DLLPRIVATE void         ImplDrawMnemonicLine( long nX, long nY, long nWidth );
+
+
+    ///@}
+
+
+    /** @name Font functions
+     */
+    ///@{
+
+public:
+
+    FontMetric                  GetDevFont( int nDevFontIndex ) const;
+    int                         GetDevFontCount() const;
+
+    bool                        IsFontAvailable( const OUString& rFontName ) const;
+
+    Size                        GetDevFontSize( const vcl::Font& rFont, int nSizeIndex ) const;
+    int                         GetDevFontSizeCount( const vcl::Font& ) const;
+
+    bool                        AddTempDevFont( const OUString& rFileURL, const OUString& rFontName );
+    void                        RefreshFontData( const bool bNewFontLists );
+
+    FontMetric                  GetFontMetric() const;
+    FontMetric                  GetFontMetric( const vcl::Font& rFont ) const;
+
+    bool                        GetFontCharMap( FontCharMapRef& rxFontCharMap ) const;
+    bool                        GetFontCapabilities( vcl::FontCapabilities& rFontCapabilities ) const;
+
+    bool GetFontFeatures(std::vector<vcl::font::Feature>& rFontFeatures) const;
+
+
+    /** Retrieve detailed font information in platform independent structure
+
+        @param  nFallbacklevel      Fallback font level (0 = best matching font)
+
+        @return SystemFontData
+     */
+    SystemFontData              GetSysFontData( int nFallbacklevel ) const;
+
+    SAL_DLLPRIVATE void         ImplGetEmphasisMark( tools::PolyPolygon& rPolyPoly, bool& rPolyLine, tools::Rectangle& rRect1, tools::Rectangle& rRect2,
+                                                     long& rYOff, long& rWidth, FontEmphasisMark eEmphasis, long nHeight );
+    SAL_DLLPRIVATE static FontEmphasisMark
+                                ImplGetEmphasisMarkStyle( const vcl::Font& rFont );
+
+    bool                        GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex,
+                                                    int nLen, MetricVector& rVector );
+
+    sal_Int32                   HasGlyphs( const vcl::Font& rFont, const OUString& rStr,
+                                           sal_Int32 nIndex = 0, sal_Int32 nLen = -1 ) const;
+
+    long                        GetMinKashida() const;
+
+    // i60594
+    // validate kashida positions against the current font
+    // returns count of invalid kashida positions
+    sal_Int32                   ValidateKashidas( const OUString& rTxt, sal_Int32 nIdx, sal_Int32 nLen,
+                                                  sal_Int32 nKashCount, // number of suggested kashida positions (in)
+                                                  const sal_Int32* pKashidaPos, // suggested kashida positions (in)
+                                                  sal_Int32* pKashidaPosDropped // invalid kashida positions (out)
+                                                ) const;
+
+    static void                 BeginFontSubstitution();
+    static void                 EndFontSubstitution();
+    static void                 AddFontSubstitute( const OUString& rFontName,
+                                                   const OUString& rReplaceFontName,
+                                                   AddFontSubstituteFlags nFlags );
+    static void                 RemoveFontsSubstitute();
+
+    static vcl::Font            GetDefaultFont( DefaultFontType nType,
+                                                LanguageType eLang,
+                                                GetDefaultFontFlags nFlags,
+                                                const OutputDevice* pOutDev = nullptr );
+
+    SAL_DLLPRIVATE void         ImplInitFontList() const;
+    SAL_DLLPRIVATE void         ImplUpdateFontData();
+
+    //drop font data for all outputdevices.
+    //If bNewFontLists is true then empty lists of system fonts
+    SAL_DLLPRIVATE static void  ImplClearAllFontData( bool bNewFontLists );
+    //fetch font data for all outputdevices
+    //If bNewFontLists is true then fetch lists of system fonts
+    SAL_DLLPRIVATE static void  ImplRefreshAllFontData( bool bNewFontLists );
+    //drop and fetch font data for all outputdevices
+    //If bNewFontLists is true then drop and refetch lists of system fonts
+    SAL_DLLPRIVATE static void  ImplUpdateAllFontData( bool bNewFontLists );
+
+protected:
+    SAL_DLLPRIVATE const LogicalFontInstance* GetFontInstance() const;
+    SAL_DLLPRIVATE long GetEmphasisAscent() const { return mnEmphasisAscent; }
+    SAL_DLLPRIVATE long GetEmphasisDescent() const { return mnEmphasisDescent; }
+
+    SAL_DLLPRIVATE bool InitFont() const;
+    virtual void                SetFontOrientation( LogicalFontInstance* const pFontInstance ) const;
+    virtual long                GetFontExtLeading() const;
+
+    virtual void ImplClearFontData(bool bNewFontLists);
+    virtual void ImplRefreshFontData(bool bNewFontLists);
+    void ReleaseFontCache();
+    void ReleaseFontCollection();
+    void SetFontCollectionFromSVData();
+    void ResetNewFontCache();
+
+private:
+
+    typedef void ( OutputDevice::* FontUpdateHandler_t )( bool );
+
+    SAL_DLLPRIVATE bool         ImplNewFont() const;
+
+    SAL_DLLPRIVATE static void  ImplUpdateFontDataForAllFrames( FontUpdateHandler_t pHdl, bool bNewFontLists );
+
+    static
+    SAL_DLLPRIVATE OUString     ImplGetEllipsisString( const OutputDevice& rTargetDevice, const OUString& rStr,
+                                                       long nMaxWidth, DrawTextFlags nStyle, const vcl::ITextLayout& _rLayout );
+
+    SAL_DLLPRIVATE void         ImplDrawEmphasisMark( long nBaseX, long nX, long nY, const tools::PolyPolygon& rPolyPoly, bool bPolyLine, const tools::Rectangle& rRect1, const tools::Rectangle& rRect2 );
+    SAL_DLLPRIVATE void         ImplDrawEmphasisMarks( SalLayout& );
+    ///@}
+
+
+    /** @name Layout functions
+     */
+    ///@{
+
+public:
+
+    SystemTextLayoutData        GetSysTextLayoutData( const Point& rStartPt, const OUString& rStr,
+                                                      sal_Int32 nIndex, sal_Int32 nLen,
+                                                      const long* pDXAry ) const;
+
+    // tells whether this output device is RTL in an LTR UI or LTR in a RTL UI
+    SAL_DLLPRIVATE bool         ImplIsAntiparallel() const ;
+    SAL_DLLPRIVATE void         ReMirror( Point &rPoint ) const;
+    SAL_DLLPRIVATE void         ReMirror( tools::Rectangle &rRect ) const;
+    SAL_DLLPRIVATE void         ReMirror( vcl::Region &rRegion ) const;
+    SAL_DLLPRIVATE bool         ImplIsRecordLayout() const;
+    virtual bool                HasMirroredGraphics() const;
+    std::unique_ptr<SalLayout>
+                                ImplLayout( const OUString&, sal_Int32 nIndex, sal_Int32 nLen,
+                                            const Point& rLogicPos = Point(0,0), long nLogicWidth=0,
+                                            const long* pLogicDXArray=nullptr, SalLayoutFlags flags = SalLayoutFlags::NONE,
+                                            vcl::TextLayoutCache const* = nullptr,
+                                            const SalLayoutGlyphs* pGlyphs = nullptr) const;
+    SAL_DLLPRIVATE ImplLayoutArgs ImplPrepareLayoutArgs( OUString&, const sal_Int32 nIndex, const sal_Int32 nLen,
+                                                         DeviceCoordinate nPixelWidth, const DeviceCoordinate* pPixelDXArray,
+                                                         SalLayoutFlags flags = SalLayoutFlags::NONE,
+                                                         vcl::TextLayoutCache const* = nullptr) const;
+    SAL_DLLPRIVATE std::unique_ptr<SalLayout>
+                                ImplGlyphFallbackLayout( std::unique_ptr<SalLayout>, ImplLayoutArgs& ) const;
+    SAL_DLLPRIVATE std::unique_ptr<SalLayout>
+                                getFallbackLayout(
+                                    LogicalFontInstance* pLogicalFont, int nFallbackLevel,
+                                    ImplLayoutArgs& rLayoutArgs) const;
+
+
+    // Enabling/disabling RTL only makes sense for OutputDevices that use a mirroring SalGraphisLayout
+    virtual void                EnableRTL( bool bEnable = true);
+    bool                        IsRTLEnabled() const { return mbEnableRTL; }
+
+    bool                        GetTextIsRTL( const OUString&, sal_Int32 nIndex, sal_Int32 nLen ) const;
+
+    ///@}
+
+
+    /** @name Bitmap functions
+     */
+    ///@{
+
+public:
+
+    /** @overload
+        void DrawBitmap(
+                const Point& rDestPt,
+                const Size& rDestSize,
+                const Point& rSrcPtPixel,
+                const Size& rSecSizePixel,
+                const Bitmap& rBitmap,
+                MetaActionType nAction = MetaActionType::BMPSCALEPART)
+      */
+    void                        DrawBitmap(
+                                    const Point& rDestPt,
+                                    const Bitmap& rBitmap );
+
+    /** @overload
+        void DrawBitmap(
+                const Point& rDestPt,
+                const Size& rDestSize,
+                const Point& rSrcPtPixel,
+                const Size& rSecSizePixel,
+                const Bitmap& rBitmap,
+                MetaActionType nAction = MetaActionType::BMPSCALEPART)
+      */
+    void                        DrawBitmap(
+                                    const Point& rDestPt,
+                                    const Size& rDestSize,
+                                    const Bitmap& rBitmap );
+
+    void                        DrawBitmap(
+                                    const Point& rDestPt,
+                                    const Size& rDestSize,
+                                    const Point& rSrcPtPixel,
+                                    const Size& rSrcSizePixel,
+                                    const Bitmap& rBitmap,
+                                    MetaActionType nAction = MetaActionType::BMPSCALEPART );
+
+    /** @overload
+        void DrawBitmapEx(
+                const Point& rDestPt,
+                const Size& rDestSize,
+                const Point& rSrcPtPixel,
+                const Size& rSecSizePixel,
+                const BitmapEx& rBitmapEx,
+                MetaActionType nAction = MetaActionType::BMPEXSCALEPART)
+     */
+    void                        DrawBitmapEx(
+                                    const Point& rDestPt,
+                                    const BitmapEx& rBitmapEx );
+
+
+    /** @overload
+        void DrawBitmapEx(
+                const Point& rDestPt,
+                const Size& rDestSize,
+                const Point& rSrcPtPixel,
+                const Size& rSecSizePixel,
+                const BitmapEx& rBitmapEx,
+                MetaActionType nAction = MetaActionType::BMPEXSCALEPART)
+     */
+    void                        DrawBitmapEx(
+                                    const Point& rDestPt,
+                                    const Size& rDestSize,
+                                    const BitmapEx& rBitmapEx );
+
+    void                        DrawBitmapEx(
+                                    const Point& rDestPt,
+                                    const Size& rDestSize,
+                                    const Point& rSrcPtPixel,
+                                    const Size& rSrcSizePixel,
+                                    const BitmapEx& rBitmapEx,
+                                    MetaActionType nAction = MetaActionType::BMPEXSCALEPART );
+
+    /** @overload
+        virtual void DrawImage(
+                        const Point& rPos,
+                        const Size& rSize,
+                        const Image& rImage,
+                        sal_uInt16 nStyle = 0)
+     */
+    void                        DrawImage(
+                                    const Point& rPos,
+                                    const Image& rImage,
+                                    DrawImageFlags nStyle = DrawImageFlags::NONE );
+
+    void                        DrawImage(
+                                    const Point& rPos,
+                                    const Size& rSize,
+                                    const Image& rImage,
+                                    DrawImageFlags nStyle = DrawImageFlags::NONE );
+
+
+    virtual Bitmap              GetBitmap( const Point& rSrcPt, const Size& rSize ) const;
+
+    /** Query extended bitmap (with alpha channel, if available).
+     */
+    BitmapEx                    GetBitmapEx( const Point& rSrcPt, const Size& rSize ) const;
+
+
+    /** Draw BitmapEx transformed
+
+        @param rTransformation
+        The transformation describing the target positioning of the given bitmap. Transforming
+        the unit object coordinates (0, 0, 1, 1) with this matrix is the transformation to
+        discrete coordinates
+
+        @param rBitmapEx
+        The BitmapEx to be painted
+    */
+    void                        DrawTransformedBitmapEx(
+                                    const basegfx::B2DHomMatrix& rTransformation,
+                                    const BitmapEx& rBitmapEx);
+
+    void                        DrawShadowBitmapEx(
+                                    const BitmapEx& rBitmapEx,
+                                    ::Color aShadowColor);
+protected:
+
+    virtual void                DrawDeviceBitmap(
+                                    const Point& rDestPt, const Size& rDestSize,
+                                    const Point& rSrcPtPixel, const Size& rSrcSizePixel,
+                                    BitmapEx& rBitmapEx );
+
+    virtual void                ScaleBitmap ( Bitmap &rBmp, SalTwoRect &rPosAry );
+
+    /** Transform and draw a bitmap directly
+
+     @param     aFullTransform      The B2DHomMatrix used for the transformation
+     @param     rBitmapEx           Reference to the bitmap to be transformed and drawn
+
+     @return true if it was able to draw the bitmap, false if not
+     */
+    virtual bool                DrawTransformBitmapExDirect(
+                                    const basegfx::B2DHomMatrix& aFullTransform,
+                                    const BitmapEx& rBitmapEx);
+
+    /** Transform and reduce the area that needs to be drawn of the bitmap and return the new
+        visible range and the maximum area.
+
+
+      @param     aFullTransform      B2DHomMatrix used for transformation
+      @param     aVisibleRange       The new visible area of the bitmap
+      @param     fMaximumArea        The maximum area of the bitmap
+
+      @returns true if there is an area to be drawn, otherwise nothing is left to be drawn
+        so return false
+      */
+    virtual bool                TransformAndReduceBitmapExToTargetRange(
+                                    const basegfx::B2DHomMatrix& aFullTransform,
+                                    basegfx::B2DRange &aVisibleRange,
+                                    double &fMaximumArea);
+
+private:
+
+    SAL_DLLPRIVATE void         DrawDeviceAlphaBitmap(
+                                    const Bitmap& rBmp,
+                                    const AlphaMask& rAlpha,
+                                    const Point& rDestPt,
+                                    const Size& rDestSize,
+                                    const Point& rSrcPtPixel,
+                                    const Size& rSrcSizePixel );
+
+    SAL_DLLPRIVATE void DrawDeviceAlphaBitmapSlowPath(
+                                const Bitmap& rBitmap, const AlphaMask& rAlpha,
+                                tools::Rectangle aDstRect, tools::Rectangle aBmpRect,
+                                Size const & aOutSz, Point const & aOutPt);
+
+
+    SAL_DLLPRIVATE void         BlendBitmap(
+                                    const SalTwoRect&   rPosAry,
+                                    const Bitmap&       rBmp );
+
+    SAL_DLLPRIVATE Bitmap       BlendBitmap(
+                                    Bitmap&             aBmp,
+                                    BitmapReadAccess const * pP,
+                                    BitmapReadAccess const * pA,
+                                    const sal_Int32     nOffY,
+                                    const sal_Int32     nDstHeight,
+                                    const sal_Int32     nOffX,
+                                    const sal_Int32     nDstWidth,
+                                    const tools::Rectangle&    aBmpRect,
+                                    const Size&         aOutSz,
+                                    const bool          bHMirr,
+                                    const bool          bVMirr,
+                                    const long*         pMapX,
+                                    const long*         pMapY );
+
+    SAL_DLLPRIVATE Bitmap       BlendBitmapWithAlpha(
+                                    Bitmap&             aBmp,
+                                    BitmapReadAccess const *   pP,
+                                    BitmapReadAccess const *   pA,
+                                    const tools::Rectangle&    aDstRect,
+                                    const sal_Int32     nOffY,
+                                    const sal_Int32     nDstHeight,
+                                    const sal_Int32     nOffX,
+                                    const sal_Int32     nDstWidth,
+                                    const long*         pMapX,
+                                    const long*         pMapY );
+
+    /** Retrieve downsampled and cropped bitmap
+
+        @attention This method ignores negative rDstSz values, thus
+        mirroring must happen outside this method (e.g. in DrawBitmap)
+     */
+    SAL_DLLPRIVATE Bitmap       GetDownsampledBitmap(
+                                    const Size& rDstSz,
+                                    const Point& rSrcPt,
+                                    const Size& rSrcSz,
+                                    const Bitmap& rBmp,
+                                    long nMaxBmpDPIX,
+                                    long nMaxBmpDPIY );
+
+    ///@}
+
+
+    /** @name Transparency functions
+     */
+    ///@{
+
+public:
+
+    /** helper method removing transparencies from a metafile (e.g. for printing)
+
+        @returns
+        true: transparencies were removed
+        false: output metafile is unchanged input metafile
+
+        @attention this is a member method, so current state can influence the result !
+        @attention the output metafile is prepared in pixel mode for the currentOutputDevice
+                   state. It can not be moved or rotated reliably anymore.
+    */
+    bool                        RemoveTransparenciesFromMetaFile(
+                                    const GDIMetaFile& rInMtf, GDIMetaFile& rOutMtf,
+                                    long nMaxBmpDPIX, long nMaxBmpDPIY,
+                                    bool bReduceTransparency,
+                                    bool bTransparencyAutoMode,
+                                    bool bDownsampleBitmaps,
+                                    const Color& rBackground = COL_TRANSPARENT );
+
+    SAL_DLLPRIVATE void         ImplPrintTransparent (
+                                    const Bitmap& rBmp, const Bitmap& rMask,
+                                    const Point& rDestPt, const Size& rDestSize,
+                                    const Point& rSrcPtPixel, const Size& rSrcSizePixel );
+
+    SAL_DLLPRIVATE Color        ImplDrawModeToColor  ( const Color& rColor ) const;
+
+
+    void                        DrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
+
+    void                        DrawTransparent(
+                                    const basegfx::B2DHomMatrix& rObjectTransform,
+                                    const basegfx::B2DPolyPolygon& rB2DPolyPoly,
+                                    double fTransparency);
+
+    void                        DrawTransparent(
+                                        const GDIMetaFile& rMtf, const Point& rPos, const Size& rSize,
+                                        const Gradient& rTransparenceGradient );
+
+protected:
+
+    virtual void                EmulateDrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
+    void                        DrawInvisiblePolygon( const tools::PolyPolygon& rPolyPoly );
+
+    virtual void                ClipAndDrawGradientMetafile ( const Gradient &rGradient, const tools::PolyPolygon &rPolyPoly );
+
+private:
+
+    SAL_DLLPRIVATE bool         DrawTransparentNatively( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
+    ///@}
+
+
+    /** @name Mask functions
+     */
+    ///@{
+
+public:
+
+    void                        DrawMask( const Point& rDestPt,
+                                          const Bitmap& rBitmap, const Color& rMaskColor );
+
+    void                        DrawMask( const Point& rDestPt, const Size& rDestSize,
+                                          const Bitmap& rBitmap, const Color& rMaskColor );
+
+    void                        DrawMask( const Point& rDestPt, const Size& rDestSize,
+                                          const Point& rSrcPtPixel, const Size& rSrcSizePixel,
+                                          const Bitmap& rBitmap, const Color& rMaskColor,
+                                          MetaActionType nAction );
+
+protected:
+
+    virtual void                DrawDeviceMask (
+                                         const Bitmap& rMask, const Color& rMaskColor,
+                                         const Point& rDestPt, const Size& rDestSize,
+                                         const Point& rSrcPtPixel, const Size& rSrcSizePixel );
+    ///@}
+
+
+    /** @name Map functions
+     */
+    ///@{
+
+public:
+
+    void                        EnableMapMode( bool bEnable = true );
+    bool                        IsMapModeEnabled() const { return mbMap; }
+
+    void                        SetMapMode();
+    virtual void                SetMapMode( const MapMode& rNewMapMode );
+    void                        SetRelativeMapMode( const MapMode& rNewMapMode );
+    const MapMode&              GetMapMode() const { return maMapMode; }
+
+protected:
+    virtual void ImplInitMapModeObjects();
+
+public:
+     // #i75163#
+    basegfx::B2DHomMatrix       GetViewTransformation() const;
+    basegfx::B2DHomMatrix       GetInverseViewTransformation() const;
+
+    basegfx::B2DHomMatrix       GetViewTransformation( const MapMode& rMapMode ) const;
+    basegfx::B2DHomMatrix       GetInverseViewTransformation( const MapMode& rMapMode ) const;
+
+
+    /** Set an offset in pixel
+
+        This method offsets every drawing operation that converts its
+        coordinates to pixel by the given value. Normally, the effect
+        can be achieved by setting a MapMode with a different
+        origin. Unfortunately, this origin is in logical coordinates
+        and can lead to rounding errors (see #102532# for details).
+
+        @attention This offset is only applied when converting to
+        pixel, i.e. some output modes such as metafile recordings
+        might be completely unaffected by this method! Use with
+        care. Furthermore, if the OutputDevice's MapMode is the
+        default (that's MapUnit::MapPixel), then any pixel offset set is
+        ignored also. This might be unintuitive for cases, but would
+        have been far more fragile to implement. What's more, the
+        reason why the pixel offset was introduced (avoiding rounding
+        errors) does not apply for MapUnit::MapPixel, because one can always
+        use the MapMode origin then.
+
+        @param rOffset
+        The offset in pixel
+     */
+    void                        SetPixelOffset( const Size& rOffset );
+
+    /** Get the offset in pixel
+
+        @see OutputDevice::SetPixelOffset for details
+
+        @return the current offset in pixel
+     */
+    Size                        GetPixelOffset() const { return Size(mnOutOffOrigX, mnOutOffOrigY);}
+
+    Point                       LogicToPixel( const Point& rLogicPt ) const;
+    Size                        LogicToPixel( const Size& rLogicSize ) const;
+    tools::Rectangle                   LogicToPixel( const tools::Rectangle& rLogicRect ) const;
+    tools::Polygon              LogicToPixel( const tools::Polygon& rLogicPoly ) const;
+    tools::PolyPolygon          LogicToPixel( const tools::PolyPolygon& rLogicPolyPoly ) const;
+    basegfx::B2DPolyPolygon     LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly ) const;
+    vcl::Region                 LogicToPixel( const vcl::Region& rLogicRegion )const;
+    Point                       LogicToPixel( const Point& rLogicPt,
+                                              const MapMode& rMapMode ) const;
+    Size                        LogicToPixel( const Size& rLogicSize,
+                                              const MapMode& rMapMode ) const;
+    tools::Rectangle                   LogicToPixel( const tools::Rectangle& rLogicRect,
+                                              const MapMode& rMapMode ) const;
+    tools::Polygon              LogicToPixel( const tools::Polygon& rLogicPoly,
+                                              const MapMode& rMapMode ) const;
+    basegfx::B2DPolyPolygon     LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly,
+                                              const MapMode& rMapMode ) const;
+
+    Point                       PixelToLogic( const Point& rDevicePt ) const;
+    Size                        PixelToLogic( const Size& rDeviceSize ) const;
+    tools::Rectangle                   PixelToLogic( const tools::Rectangle& rDeviceRect ) const;
+    tools::Polygon              PixelToLogic( const tools::Polygon& rDevicePoly ) const;
+    tools::PolyPolygon          PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly ) const;
+    basegfx::B2DPolyPolygon     PixelToLogic( const basegfx::B2DPolyPolygon& rDevicePolyPoly ) const;
+    vcl::Region                 PixelToLogic( const vcl::Region& rDeviceRegion ) const;
+    Point                       PixelToLogic( const Point& rDevicePt,
+                                              const MapMode& rMapMode ) const;
+    Size                        PixelToLogic( const Size& rDeviceSize,
+                                              const MapMode& rMapMode ) const;
+    tools::Rectangle                   PixelToLogic( const tools::Rectangle& rDeviceRect,
+                                              const MapMode& rMapMode ) const;
+    tools::Polygon              PixelToLogic( const tools::Polygon& rDevicePoly,
+                                              const MapMode& rMapMode ) const;
+    basegfx::B2DPolygon         PixelToLogic( const basegfx::B2DPolygon& rDevicePoly,
+                                              const MapMode& rMapMode ) const;
+    basegfx::B2DPolyPolygon     PixelToLogic( const basegfx::B2DPolyPolygon& rDevicePolyPoly,
+                                              const MapMode& rMapMode ) const;
+
+    Point                       LogicToLogic( const Point&      rPtSource,
+                                              const MapMode*    pMapModeSource,
+                                              const MapMode*    pMapModeDest ) const;
+    Size                        LogicToLogic( const Size&       rSzSource,
+                                              const MapMode*    pMapModeSource,
+                                              const MapMode*    pMapModeDest ) const;
+    tools::Rectangle                   LogicToLogic( const tools::Rectangle&  rRectSource,
+                                              const MapMode*    pMapModeSource,
+                                              const MapMode*    pMapModeDest ) const;
+    static Point                LogicToLogic( const Point&      rPtSource,
+                                              const MapMode&    rMapModeSource,
+                                              const MapMode&    rMapModeDest );
+    static Size                 LogicToLogic( const Size&       rSzSource,
+                                              const MapMode&    rMapModeSource,
+                                              const MapMode&    rMapModeDest );
+    static tools::Rectangle            LogicToLogic( const tools::Rectangle&  rRectSource,
+                                              const MapMode&    rMapModeSource,
+                                              const MapMode&    rMapModeDest );
+    static long                 LogicToLogic( long              nLongSource,
+                                              MapUnit           eUnitSource,
+                                              MapUnit           eUnitDest );
+
+    static basegfx::B2DPolygon  LogicToLogic( const basegfx::B2DPolygon& rPoly,
+                                              const MapMode&    rMapModeSource,
+                                              const MapMode&    rMapModeDest );
+
+    // create a mapping transformation from rMapModeSource to rMapModeDest (the above methods
+    // for B2DPoly/Polygons use this internally anyway to transform the B2DPolygon)
+    static basegfx::B2DHomMatrix LogicToLogic(const MapMode& rMapModeSource, const MapMode& rMapModeDest);
+
+    /** Convert a logical rectangle to a rectangle in physical device pixel units.
+
+     @param         rLogicRect  Const reference to a rectangle in logical units
+
+     @returns Rectangle based on physical device pixel coordinates and units.
+     */
+    SAL_DLLPRIVATE tools::Rectangle    ImplLogicToDevicePixel( const tools::Rectangle& rLogicRect ) const;
+
+    /** Convert a logical point to a physical point on the device.
+
+     @param         rLogicPt    Const reference to a point in logical units.
+
+     @returns Physical point on the device.
+     */
+    SAL_DLLPRIVATE Point        ImplLogicToDevicePixel( const Point& rLogicPt ) const;
+
+    /** Convert a logical width to a width in units of device pixels.
+
+     To get the number of device pixels, it must calculate the X-DPI of the device and
+     the map scaling factor. If there is no mapping, then it just returns the
+     width as nothing more needs to be done.
+
+     @param         nWidth      Logical width
+
+     @returns Width in units of device pixels.
+     */
+    SAL_DLLPRIVATE long         ImplLogicWidthToDevicePixel( long nWidth ) const;
+
+    SAL_DLLPRIVATE DeviceCoordinate LogicWidthToDeviceCoordinate( long nWidth ) const;
+
+    /** Convert a logical X coordinate to a device pixel's X coordinate.
+
+     To get the device's X coordinate, it must calculate the mapping offset
+     coordinate X position (if there is one - if not then it just adds
+     the pseudo-window offset to the logical X coordinate), the X-DPI of
+     the device and the mapping's X scaling factor.
+
+     @param         nX          Logical X coordinate
+
+     @returns Device's X pixel coordinate
+     */
+    SAL_DLLPRIVATE long         ImplLogicXToDevicePixel( long nX ) const;
+
+    /** Convert a logical Y coordinate to a device pixel's Y coordinate.
+
+     To get the device's Y coordinate, it must calculate the mapping offset
+     coordinate Y position (if there is one - if not then it just adds
+     the pseudo-window offset to the logical Y coordinate), the Y-DPI of
+     the device and the mapping's Y scaling factor.
+
+     @param         nY          Logical Y coordinate
+
+     @returns Device's Y pixel coordinate
+     */
+    SAL_DLLPRIVATE long         ImplLogicYToDevicePixel( long nY ) const;
+
+    /** Convert a logical height to a height in units of device pixels.
+
+     To get the number of device pixels, it must calculate the Y-DPI of the device and
+     the map scaling factor. If there is no mapping, then it just returns the
+     height as nothing more needs to be done.
+
+     @param         nHeight     Logical height
+
+     @returns Height in units of device pixels.
+     */
+    SAL_DLLPRIVATE long         ImplLogicHeightToDevicePixel( long nHeight ) const;
+
+    /** Convert device pixels to a width in logical units.
+
+     To get the logical width, it must calculate the X-DPI of the device and the
+     map scaling factor.
+
+     @param         nWidth      Width in device pixels
+
+     @returns Width in logical units.
+     */
+    SAL_DLLPRIVATE long         ImplDevicePixelToLogicWidth( long nWidth ) const;
+
+    /** Convert device pixels to a height in logical units.
+
+     To get the logical height, it must calculate the Y-DPI of the device and the
+     map scaling factor.
+
+     @param         nHeight     Height in device pixels
+
+     @returns Height in logical units.
+     */
+    SAL_DLLPRIVATE long         ImplDevicePixelToLogicHeight( long nHeight ) const;
+
+    /** Convert logical height to device pixels, with exact sub-pixel value.
+
+     To get the \em exact pixel height, it must calculate the Y-DPI of the device and the
+     map scaling factor.
+
+     @param         fLogicHeight     Exact height in logical units.
+
+     @returns Exact height in pixels - returns as a float to provide for subpixel value.
+     */
+    SAL_DLLPRIVATE float        ImplFloatLogicHeightToDevicePixel( float fLogicHeight ) const;
+
+    /** Convert a logical size to the size on the physical device.
+
+     @param         rLogicSize  Const reference to a size in logical units
+
+     @returns Physical size on the device.
+     */
+    SAL_DLLPRIVATE Size         ImplLogicToDevicePixel( const Size& rLogicSize ) const;
+
+    /** Convert a rectangle in physical pixel units to a rectangle in physical pixel units and coords.
+
+     @param         rPixelRect  Const reference to rectangle in logical units and coords.
+
+     @returns Rectangle based on logical coordinates and units.
+     */
+    SAL_DLLPRIVATE tools::Rectangle    ImplDevicePixelToLogic( const tools::Rectangle& rPixelRect ) const;
+
+    /** Convert a logical polygon to a polygon in physical device pixel units.
+
+     @param         rLogicPoly  Const reference to a polygon in logical units
+
+     @returns Polygon based on physical device pixel coordinates and units.
+     */
+    SAL_DLLPRIVATE tools::Polygon ImplLogicToDevicePixel( const tools::Polygon& rLogicPoly ) const;
+
+    /** Convert a logical polypolygon to a polypolygon in physical device pixel units.
+
+     @param         rLogicPolyPoly  Const reference to a polypolygon in logical units
+
+     @returns Polypolygon based on physical device pixel coordinates and units.
+     */
+    SAL_DLLPRIVATE tools::PolyPolygon  ImplLogicToDevicePixel( const tools::PolyPolygon& rLogicPolyPoly ) const;
+
+    /** Convert a line in logical units to a line in physical device pixel units.
+
+     @param         rLineInfo   Const reference to a line in logical units
+
+     @returns Line based on physical device pixel coordinates and units.
+     */
+    SAL_DLLPRIVATE LineInfo     ImplLogicToDevicePixel( const LineInfo& rLineInfo ) const;
+
+    /** Convert a region in pixel units to a region in device pixel units and coords.
+
+     @param         rRegion  Const reference to region.
+
+     @returns vcl::Region based on device pixel coordinates and units.
+     */
+    SAL_DLLPRIVATE vcl::Region       ImplPixelToDevicePixel( const vcl::Region& rRegion ) const;
+
+    /** Invalidate the view transformation.
+
+     @since AOO bug 75163 (OpenOffice.org 2.4.3 - OOH 680 milestone 212)
+     */
+    SAL_DLLPRIVATE void         ImplInvalidateViewTransform();
+
+    /** Get device transformation.
+
+     @since AOO bug 75163 (OpenOffice.org 2.4.3 - OOH 680 milestone 212)
+     */
+    SAL_DLLPRIVATE basegfx::B2DHomMatrix ImplGetDeviceTransformation() const;
+    ///@}
+
+
+    /** @name Native Widget Rendering functions
+
+        These all just call through to the private mpGraphics functions of the same name.
+     */
+    ///@{
+
+public:
+
+    /** Query the platform layer for control support
+     */
+    bool                        IsNativeControlSupported( ControlType nType, ControlPart nPart ) const;
+
+    /** Query the native control to determine if it was acted upon
+     */
+    bool                        HitTestNativeScrollbar(
+                                    ControlPart nPart,
+                                    const tools::Rectangle& rControlRegion,
+                                    const Point& aPos,
+                                    bool& rIsInside ) const;
+
+    /** Request rendering of a particular control and/or part
+     */
+    bool                        DrawNativeControl(
+                                    ControlType nType,
+                                    ControlPart nPart,
+                                    const tools::Rectangle& rControlRegion,
+                                    ControlState nState,
+                                    const ImplControlValue& aValue,
+                                    const OUString& aCaption,
+                                    const Color& rBackgroundColor = COL_AUTO );
+
+    /** Query the native control's actual drawing region (including adornment)
+     */
+    bool                        GetNativeControlRegion(
+                                    ControlType nType,
+                                    ControlPart nPart,
+                                    const tools::Rectangle& rControlRegion,
+                                    ControlState nState,
+                                    const ImplControlValue& aValue,
+                                    tools::Rectangle &rNativeBoundingRegion,
+                                    tools::Rectangle &rNativeContentRegion ) const;
+    ///@}
+
+    /** @name EPS functions
+     */
+    ///@{
+
+public:
+
+    /** @returns boolean value to see if EPS could be painted directly.
+        Theoretically, handing over a matrix would be needed to handle
+        painting rotated EPS files (e.g. contained in Metafiles). This
+        would then need to be supported for Mac and PS printers, but
+        that's too much for now, wrote \#i107046# for this */
+    bool                        DrawEPS(
+                                    const Point& rPt, const Size& rSz,
+                                    const GfxLink& rGfxLink, GDIMetaFile* pSubst = nullptr );
+    ///@}
+};
+
+#endif // INCLUDED_VCL_OUTDEV_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */