include/vcl/outdev.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_VCL_OUTDEV_HXX
  21 #define INCLUDED_VCL_OUTDEV_HXX
  22
  23 #include <tools/gen.hxx>
  24 #include <tools/solar.h>
  25 #include <tools/color.hxx>
  26 #include <tools/poly.hxx>
  27 #include <o3tl/typed_flags_set.hxx>
  28
  29 #include <vcl/cairo.hxx>
  30 #include <vcl/devicecoordinate.hxx>
  31 #include <vcl/dllapi.h>
  32 #include <vcl/font.hxx>
  33 #include <vcl/region.hxx>
  34 #include <vcl/mapmod.hxx>
  35 #include <vcl/wall.hxx>
  36 #include <vcl/metaact.hxx>
  37 #include <vcl/metaactiontypes.hxx>
  38 #include <vcl/salnativewidgets.hxx>
  39 #include <vcl/outdevstate.hxx>
  40 #include <vcl/outdevmap.hxx>
  41 #include <vcl/vclreferencebase.hxx>
  42
  43 #include <basegfx/numeric/ftools.hxx>
  44 #include <basegfx/vector/b2enums.hxx>
  45 #include <basegfx/polygon/b2dpolypolygon.hxx>
  46
  47 #include <unotools/fontdefs.hxx>
  48
  49 #include <com/sun/star/drawing/LineCap.hpp>
  50 #include <com/sun/star/uno/Reference.h>
  51
  52 #include <memory>
  53 #include <vector>
  54
  55 struct ImplOutDevData;
  56 class LogicalFontInstance;
  57 class OutDevState;
  58 struct SystemGraphicsData;
  59 struct SystemFontData;
  60 struct SystemTextLayoutData;
  61 class ImplFontCache;
  62 class PhysicalFontCollection;
  63 class ImplDeviceFontList;
  64 class ImplDeviceFontSizeList;
  65 class ImplMultiTextLineInfo;
  66 class SalGraphics;
  67 class Gradient;
  68 class Hatch;
  69 class AllSettings;
  70 class Bitmap;
  71 class BitmapReadAccess;
  72 class BitmapEx;
  73 class Image;
  74 class TextRectInfo;
  75 class FontMetric;
  76 class GDIMetaFile;
  77 class GfxLink;
  78 namespace tools {
  79     class Line;
  80 }
  81 class LineInfo;
  82 class AlphaMask;
  83 class FontCharMap;
  84 class SalLayout;
  85 class ImplLayoutArgs;
  86 class VirtualDevice;
  87 struct SalTwoRect;
  88 class VirtualDevice;
  89 class Printer;
  90 class FontSelectPattern;
  91 class VCLXGraphics;
  92 class OutDevStateStack;
  93 struct BitmapSystemData;
  94
  95 namespace vcl
  96 {
  97     class PDFWriterImpl;
  98     class ExtOutDevData;
  99     class ITextLayout;
 100     struct FontCapabilities;
 101     class TextLayoutCache;
 102     class Window;
 103     class FontInfo;
 104 }
 105
 106 namespace com { namespace sun { namespace star { namespace rendering {
 107     class XCanvas;
 108 }}}}
 109
 110 namespace basegfx {
 111     class B2DHomMatrix;
 112     class B2DPolygon;
 113     class B2DPolyPolygon;
 114     class B2IVector;
 115     typedef B2IVector B2ISize;
 116 }
 117
 118 namespace com { namespace sun { namespace star { namespace awt {
 119     class XGraphics;
 120 } } } }
 121
 122 #if defined UNX
 123 #define GLYPH_FONT_HEIGHT   128
 124 #else
 125 #define GLYPH_FONT_HEIGHT   256
 126 #endif
 127
 128 // Text Layout options
 129 enum class SalLayoutFlags
 130 {
 131     NONE                    = 0x0000,
 132     BiDiRtl                 = 0x0001,
 133     BiDiStrong              = 0x0002,
 134     RightAlign              = 0x0004,
 135     DisableKerning          = 0x0010,
 136     KerningAsian            = 0x0020,
 137     Vertical                = 0x0040,
 138     EnableLigatures         = 0x0200,
 139     SubstituteDigits        = 0x0400,
 140     KashidaJustification    = 0x0800,
 141     ForFallback             = 0x2000,
 142 };
 143 namespace o3tl
 144 {
 145     template<> struct typed_flags<SalLayoutFlags> : is_typed_flags<SalLayoutFlags, 0x2e77> {};
 146 }
 147
 148 typedef std::vector< tools::Rectangle > MetricVector;
 149
 150 // OutputDevice-Types
 151
 152 // Flags for DrawText()
 153 enum class DrawTextFlags
 154 {
 155     NONE                  = 0x00000000,
 156     Disable               = 0x00000001,
 157     Mnemonic              = 0x00000002,
 158     Mono                  = 0x00000004,
 159     Clip                  = 0x00000008,
 160     Left                  = 0x00000010,
 161     Center                = 0x00000020,
 162     Right                 = 0x00000040,
 163     Top                   = 0x00000080,
 164     VCenter               = 0x00000100,
 165     Bottom                = 0x00000200,
 166     EndEllipsis           = 0x00000400,
 167     PathEllipsis          = 0x00000800,
 168     MultiLine             = 0x00001000,
 169     WordBreak             = 0x00002000,
 170     NewsEllipsis          = 0x00004000,
 171     WordBreakHyphenation  = 0x00008000 | WordBreak,
 172     CenterEllipsis        = 0x00010000,
 173     HideMnemonic          = 0x00020000,
 174 };
 175 namespace o3tl
 176 {
 177     template<> struct typed_flags<DrawTextFlags> : is_typed_flags<DrawTextFlags, 0x3ffff> {};
 178 }
 179
 180 // Flags for DrawImage(), these must match the definitions in css::awt::ImageDrawMode
 181 enum class DrawImageFlags
 182 {
 183     NONE                 = 0x0000,
 184     Disable              = 0x0001,
 185     Highlight            = 0x0002,
 186     Deactive             = 0x0004,
 187     ColorTransform       = 0x0008,
 188     SemiTransparent      = 0x0010,
 189 };
 190 namespace o3tl
 191 {
 192     template<> struct typed_flags<DrawImageFlags> : is_typed_flags<DrawImageFlags, 0x001f> {};
 193 }
 194
 195 // Flags for DrawGrid()
 196 enum class DrawGridFlags
 197 {
 198     NONE                 = 0x0000,
 199     Dots                 = 0x0001,
 200     HorzLines            = 0x0002,
 201     VertLines            = 0x0004
 202 };
 203 namespace o3tl
 204 {
 205     template<> struct typed_flags<DrawGridFlags> : is_typed_flags<DrawGridFlags, 0x0007> {};
 206 }
 207
 208 // DrawModes
 209 enum class DrawModeFlags : sal_uLong
 210 {
 211     Default                = 0x00000000,
 212     BlackLine              = 0x00000001,
 213     BlackFill              = 0x00000002,
 214     BlackText              = 0x00000004,
 215     BlackBitmap            = 0x00000008,
 216     BlackGradient          = 0x00000010,
 217     GrayLine               = 0x00000020,
 218     GrayFill               = 0x00000040,
 219     GrayText               = 0x00000080,
 220     GrayBitmap             = 0x00000100,
 221     GrayGradient           = 0x00000200,
 222     NoFill                 = 0x00000400,
 223     NoBitmap               = 0x00000800,
 224     NoGradient             = 0x00001000,
 225     GhostedLine            = 0x00002000,
 226     GhostedFill            = 0x00004000,
 227     GhostedText            = 0x00008000,
 228     GhostedBitmap          = 0x00010000,
 229     GhostedGradient        = 0x00020000,
 230     WhiteLine              = 0x00100000,
 231     WhiteFill              = 0x00200000,
 232     WhiteText              = 0x00400000,
 233     WhiteBitmap            = 0x00800000,
 234     WhiteGradient          = 0x01000000,
 235     SettingsLine           = 0x02000000,
 236     SettingsFill           = 0x04000000,
 237     SettingsText           = 0x08000000,
 238     SettingsGradient       = 0x10000000,
 239     NoTransparency         = 0x80000000,
 240 };
 241 namespace o3tl
 242 {
 243     template<> struct typed_flags<DrawModeFlags> : is_typed_flags<DrawModeFlags, 0x9ff3ffff> {};
 244 }
 245
 246 // Antialiasing
 247 enum class AntialiasingFlags
 248 {
 249     NONE                = 0x0000,
 250     DisableText         = 0x0001,
 251     EnableB2dDraw       = 0x0002,
 252     PixelSnapHairline  = 0x0004,
 253 };
 254 namespace o3tl
 255 {
 256     template<> struct typed_flags<AntialiasingFlags> : is_typed_flags<AntialiasingFlags, 0x07> {};
 257 }
 258
 259 // AddFontSubstitute() flags
 260 enum class AddFontSubstituteFlags
 261 {
 262     NONE            = 0x00,
 263     ALWAYS          = 0x01,
 264     ScreenOnly      = 0x02,
 265 };
 266 namespace o3tl
 267 {
 268     template<> struct typed_flags<AddFontSubstituteFlags> : is_typed_flags<AddFontSubstituteFlags, 0x03> {};
 269 }
 270
 271 // GetDefaultFont() flags
 272 enum class GetDefaultFontFlags
 273 {
 274     NONE          = 0x0000,
 275     OnlyOne       = 0x0001,
 276 };
 277 namespace o3tl
 278 {
 279     template<> struct typed_flags<GetDefaultFontFlags> : is_typed_flags<GetDefaultFontFlags, 0x01> {};
 280 }
 281
 282 // Flags for Invert()
 283 enum class InvertFlags
 284 {
 285     NONE                    = 0x0000,
 286     Highlight               = 0x0001,
 287     N50                     = 0x0002,
 288 };
 289 namespace o3tl
 290 {
 291     template<> struct typed_flags<InvertFlags> : is_typed_flags<InvertFlags, 0x0003> {};
 292 }
 293
 294 enum OutDevType { OUTDEV_DONTKNOW, OUTDEV_WINDOW, OUTDEV_PRINTER, OUTDEV_VIRDEV };
 295
 296 enum class OutDevViewType { DontKnow, PrintPreview, SlideShow };
 297
 298 // OutputDevice
 299
 300 typedef tools::SvRef<FontCharMap> FontCharMapRef;
 301
 302 BmpMirrorFlags AdjustTwoRect( SalTwoRect& rTwoRect, const Size& rSizePix );
 303 void AdjustTwoRect( SalTwoRect& rTwoRect, const tools::Rectangle& rValidSrcRect );
 304
 305 class OutputDevice;
 306
 307 namespace vcl {
 308     typedef OutputDevice RenderContext;
 309 }
 310
 311 /**
 312 * Some things multiple-inherit from VclAbstractDialog and OutputDevice,
 313 * so we need to use virtual inheritance to keep the referencing counting
 314 * OK.
 315 */
 316 class VCL_DLLPUBLIC OutputDevice : public virtual VclReferenceBase
 317 {
 318     friend class Printer;
 319     friend class VirtualDevice;
 320     friend class vcl::Window;
 321     friend class WorkWindow;
 322     friend class vcl::PDFWriterImpl;
 323     friend void ImplHandleResize( vcl::Window* pWindow, long nNewWidth, long nNewHeight );
 324
 325 private:
 326     OutputDevice(const OutputDevice&) = delete;
 327     OutputDevice& operator=(const OutputDevice&) = delete;
 328
 329     mutable SalGraphics*            mpGraphics;         ///< Graphics context to draw on
 330     mutable VclPtr<OutputDevice>    mpPrevGraphics;     ///< Previous output device in list
 331     mutable VclPtr<OutputDevice>    mpNextGraphics;     ///< Next output device in list
 332     GDIMetaFile*                    mpMetaFile;
 333     mutable LogicalFontInstance*    mpFontInstance;
 334     mutable ImplFontCache*          mpFontCache;
 335     mutable PhysicalFontCollection* mpFontCollection;
 336     mutable ImplDeviceFontList*     mpDeviceFontList;
 337     mutable ImplDeviceFontSizeList* mpDeviceFontSizeList;
 338     OutDevStateStack*               mpOutDevStateStack;
 339     ImplOutDevData*                 mpOutDevData;
 340     std::vector< VCLXGraphics* >*   mpUnoGraphicsList;
 341     vcl::PDFWriterImpl*             mpPDFWriter;
 342     vcl::ExtOutDevData*             mpExtOutDevData;
 343
 344     // TEMP TEMP TEMP
 345     VclPtr<VirtualDevice>           mpAlphaVDev;
 346
 347     /// Additional output pixel offset, applied in LogicToPixel (used by SetPixelOffset/GetPixelOffset)
 348     long                            mnOutOffOrigX;
 349     /// Additional output offset in _logical_ coordinates, applied in PixelToLogic (used by SetPixelOffset/GetPixelOffset)
 350     long                            mnOutOffLogicX;
 351     /// Additional output pixel offset, applied in LogicToPixel (used by SetPixelOffset/GetPixelOffset)
 352     long                            mnOutOffOrigY;
 353     /// Additional output offset in _logical_ coordinates, applied in PixelToLogic (used by SetPixelOffset/GetPixelOffset)
 354     long                            mnOutOffLogicY;
 355     /// Output offset for device output in pixel (pseudo window offset within window system's frames)
 356     long                            mnOutOffX;
 357     /// Output offset for device output in pixel (pseudo window offset within window system's frames)
 358     long                            mnOutOffY;
 359     long                            mnOutWidth;
 360     long                            mnOutHeight;
 361     sal_Int32                       mnDPIX;
 362     sal_Int32                       mnDPIY;
 363     sal_Int32                       mnDPIScalePercentage; ///< For Hi-DPI displays, we want to draw elements for a percentage larger
 364     /// font specific text alignment offsets in pixel units
 365     mutable long                    mnTextOffX;
 366     mutable long                    mnTextOffY;
 367     mutable long                    mnEmphasisAscent;
 368     mutable long                    mnEmphasisDescent;
 369     DrawModeFlags                   mnDrawMode;
 370     ComplexTextLayoutFlags           mnTextLayoutMode;
 371     ImplMapRes                      maMapRes;
 372     ImplThresholdRes                maThresRes;
 373     OutDevType                      meOutDevType;
 374     OutDevViewType                  meOutDevViewType;
 375     vcl::Region                     maRegion;           // contains the clip region, see SetClipRegion(...)
 376     Color                           maLineColor;
 377     Color                           maFillColor;
 378     vcl::Font                       maFont;
 379     Color                           maTextColor;
 380     Color                           maTextLineColor;
 381     Color                           maOverlineColor;
 382     TextAlign                       meTextAlign;
 383     RasterOp                        meRasterOp;
 384     Wallpaper                       maBackground;
 385     std::unique_ptr<AllSettings>    mxSettings;
 386     MapMode                         maMapMode;
 387     Point                           maRefPoint;
 388     AntialiasingFlags               mnAntialiasing;
 389     LanguageType                    meTextLanguage;
 390
 391     mutable bool                    mbMap : 1;
 392     mutable bool                    mbClipRegion : 1;
 393     mutable bool                    mbBackground : 1;
 394     mutable bool                    mbOutput : 1;
 395     mutable bool                    mbDevOutput : 1;
 396     mutable bool                    mbOutputClipped : 1;
 397     mutable bool                    mbLineColor : 1;
 398     mutable bool                    mbFillColor : 1;
 399     mutable bool                    mbInitLineColor : 1;
 400     mutable bool                    mbInitFillColor : 1;
 401     mutable bool                    mbInitFont : 1;
 402     mutable bool                    mbInitTextColor : 1;
 403     mutable bool                    mbInitClipRegion : 1;
 404     mutable bool                    mbClipRegionSet : 1;
 405     mutable bool                    mbNewFont : 1;
 406     mutable bool                    mbTextLines : 1;
 407     mutable bool                    mbTextSpecial : 1;
 408     mutable bool                    mbRefPoint : 1;
 409     mutable bool                    mbEnableRTL : 1;
 410
 411     /** @name Initialization and accessor functions
 412      */
 413     ///@{
 414
 415 protected:
 416                                 OutputDevice();
 417     virtual                     ~OutputDevice() override;
 418     virtual void                dispose() override;
 419
 420 public:
 421
 422     /** Get the graphic context that the output device uses to draw on.
 423
 424      If no graphics device exists, then initialize it.
 425
 426      @returns SalGraphics instance.
 427      */
 428     SalGraphics const           *GetGraphics() const;
 429     SalGraphics*                GetGraphics();
 430
 431     void                        SetConnectMetaFile( GDIMetaFile* pMtf );
 432     GDIMetaFile*                GetConnectMetaFile() const { return mpMetaFile; }
 433
 434     virtual void                SetSettings( const AllSettings& rSettings );
 435     const AllSettings&          GetSettings() const { return *mxSettings; }
 436
 437     SystemGraphicsData          GetSystemGfxData() const;
 438     bool                        SupportsCairo() const;
 439     /// Create Surface from given cairo surface
 440     cairo::SurfaceSharedPtr     CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const;
 441     /// Create surface with given dimensions
 442     cairo::SurfaceSharedPtr     CreateSurface(int x, int y, int width, int height) const;
 443     /// Create Surface for given bitmap data
 444     cairo::SurfaceSharedPtr     CreateBitmapSurface(const BitmapSystemData& rData, const Size& rSize) const;
 445     /// Return native handle for underlying surface
 446     css::uno::Any               GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const;
 447     css::uno::Any               GetSystemGfxDataAny() const;
 448
 449     void                        SetRefPoint();
 450     void                        SetRefPoint( const Point& rRefPoint );
 451     const Point&                GetRefPoint() const { return maRefPoint; }
 452     bool                        IsRefPoint() const { return mbRefPoint; }
 453
 454     virtual sal_uInt16          GetBitCount() const;
 455
 456     Size                        GetOutputSizePixel() const
 457                                     { return Size( mnOutWidth, mnOutHeight ); }
 458     long                        GetOutputWidthPixel() const { return mnOutWidth; }
 459     long                        GetOutputHeightPixel() const { return mnOutHeight; }
 460     long                        GetOutOffXPixel() const { return mnOutOffX; }
 461     long                        GetOutOffYPixel() const { return mnOutOffY; }
 462     void                        SetOutOffXPixel(long nOutOffX);
 463     void                        SetOutOffYPixel(long nOutOffY);
 464
 465     Size                        GetOutputSize() const
 466                                     { return PixelToLogic( GetOutputSizePixel() ); }
 467
 468     sal_uLong                   GetColorCount() const;
 469
 470
 471     css::uno::Reference< css::awt::XGraphics >
 472                                 CreateUnoGraphics();
 473     std::vector< VCLXGraphics* > *GetUnoGraphicsList() const  { return mpUnoGraphicsList; }
 474     std::vector< VCLXGraphics* > *CreateUnoGraphicsList();
 475
 476 protected:
 477
 478     /** Acquire a graphics device that the output device uses to draw on.
 479
 480      There is an LRU of OutputDevices that is used to get the graphics. The
 481      actual creation of a SalGraphics instance is done via the SalFrame
 482      implementation.
 483
 484      However, the SalFrame instance will only return a valid SalGraphics
 485      instance if it is not in use or there wasn't one in the first place. When
 486      this happens, AcquireGraphics finds the least recently used OutputDevice
 487      in a different frame and "steals" it (releases it then starts using it).
 488
 489      If there are no frames to steal an OutputDevice's SalGraphics instance from
 490      then it blocks until the graphics is released.
 491
 492      Once it has acquired a graphics instance, then we add the OutputDevice to
 493      the LRU.
 494
 495      @returns true if was able to initialize the graphics device, false otherwise.
 496      */
 497     virtual bool                AcquireGraphics() const = 0;
 498
 499     /** Release the graphics device, and remove it from the graphics device
 500      list.
 501
 502      @param         bRelease    Determines whether to release the fonts of the
 503                                 physically released graphics device.
 504      */
 505     virtual void                ReleaseGraphics( bool bRelease = true ) = 0;
 506     ///@}
 507
 508
 509     /** @name Helper functions
 510      */
 511     ///@{
 512
 513 public:
 514
 515     /** Get the output device's DPI x-axis value.
 516
 517      @returns x-axis DPI value
 518      */
 519     SAL_DLLPRIVATE sal_Int32    GetDPIX() const { return mnDPIX; }
 520
 521     /** Get the output device's DPI y-axis value.
 522
 523      @returns y-axis DPI value
 524      */
 525     SAL_DLLPRIVATE sal_Int32    GetDPIY() const { return mnDPIY; }
 526
 527     SAL_DLLPRIVATE void         SetDPIX( sal_Int32 nDPIX ) { mnDPIX = nDPIX; }
 528     SAL_DLLPRIVATE void         SetDPIY( sal_Int32 nDPIY ) { mnDPIY = nDPIY; }
 529
 530     float GetDPIScaleFactor() const
 531     {
 532         return mnDPIScalePercentage / 100.0f;
 533     }
 534
 535     sal_Int32 GetDPIScalePercentage() const
 536     {
 537         return mnDPIScalePercentage;
 538     }
 539
 540     OutDevType                  GetOutDevType() const { return meOutDevType; }
 541
 542     /** Query an OutputDevice to see whether it supports a specific operation
 543
 544      @returns true if operation supported, else false
 545     */
 546     bool                        SupportsOperation( OutDevSupportType ) const;
 547
 548     vcl::PDFWriterImpl*         GetPDFWriter() const { return mpPDFWriter; }
 549
 550     void                        SetExtOutDevData( vcl::ExtOutDevData* pExtOutDevData ) { mpExtOutDevData = pExtOutDevData; }
 551     vcl::ExtOutDevData*         GetExtOutDevData() const { return mpExtOutDevData; }
 552
 553     ///@}
 554
 555
 556     /** @name Direct OutputDevice drawing functions
 557      */
 558     ///@{
 559
 560 public:
 561
 562     virtual void                DrawOutDev(
 563                                     const Point& rDestPt, const Size& rDestSize,
 564                                     const Point& rSrcPt,  const Size& rSrcSize );
 565
 566     virtual void                DrawOutDev(
 567                                     const Point& rDestPt, const Size& rDestSize,
 568                                     const Point& rSrcPt,  const Size& rSrcSize,
 569                                     const OutputDevice& rOutDev );
 570
 571     virtual void                CopyArea(
 572                                     const Point& rDestPt,
 573                                     const Point& rSrcPt,  const Size& rSrcSize,
 574                                     bool bWindowInvalidate = false );
 575
 576 protected:
 577
 578     virtual void                CopyDeviceArea( SalTwoRect& aPosAry, bool bWindowInvalidate);
 579
 580     SAL_DLLPRIVATE void         drawOutDevDirect ( const OutputDevice* pSrcDev, SalTwoRect& rPosAry );
 581
 582     SAL_DLLPRIVATE bool         is_double_buffered_window() const;
 583
 584 private:
 585
 586     // not implemented; to detect misuses of DrawOutDev(...OutputDevice&);
 587     SAL_DLLPRIVATE void         DrawOutDev( const Point&, const Size&, const Point&,  const Size&, const Printer&) = delete;
 588     ///@}
 589
 590
 591     /** @name OutputDevice state functions
 592      */
 593     ///@{
 594
 595 public:
 596
 597     void                        Push( PushFlags nFlags = PushFlags::ALL );
 598     void                        Pop();
 599
 600     // returns the current stack depth; that is the number of Push() calls minus the number of Pop() calls
 601     // this should not normally be used since Push and Pop must always be used symmetrically
 602     // however this may be e.g. a help when debugging code in which this somehow is not the case
 603     sal_uInt32                  GetGCStackDepth() const;
 604
 605     void                        EnableOutput( bool bEnable = true );
 606     bool                        IsOutputEnabled() const { return mbOutput; }
 607     bool                        IsDeviceOutputNecessary() const { return (mbOutput && mbDevOutput); }
 608
 609     void                        SetAntialiasing( AntialiasingFlags nMode );
 610     AntialiasingFlags           GetAntialiasing() const { return mnAntialiasing; }
 611
 612     void                        SetDrawMode( DrawModeFlags nDrawMode );
 613     DrawModeFlags               GetDrawMode() const { return mnDrawMode; }
 614
 615     void                        SetLayoutMode( ComplexTextLayoutFlags nTextLayoutMode );
 616     ComplexTextLayoutFlags       GetLayoutMode() const { return mnTextLayoutMode; }
 617
 618     void                        SetDigitLanguage( LanguageType );
 619     LanguageType                GetDigitLanguage() const { return meTextLanguage; }
 620
 621     void                        SetRasterOp( RasterOp eRasterOp );
 622     RasterOp                    GetRasterOp() const { return meRasterOp; }
 623
 624     /**
 625     If this OutputDevice is used for displaying a Print Preview
 626     the OutDevViewType should be set to 'OutDevViewType::PrintPreview'.
 627
 628     A View can then make painting decisions dependent on this OutDevViewType.
 629     E.g. text colors need to be handled differently, dependent on whether it's a PrintPreview or not. (see #106611# for more)
 630     */
 631     void                        SetOutDevViewType( OutDevViewType eOutDevViewType ) { meOutDevViewType=eOutDevViewType; }
 632     OutDevViewType              GetOutDevViewType() const { return meOutDevViewType; }
 633
 634     void                        SetLineColor();
 635     void                        SetLineColor( const Color& rColor );
 636     const Color&                GetLineColor() const { return maLineColor; }
 637     bool                        IsLineColor() const { return mbLineColor; }
 638
 639     void                        SetFillColor();
 640     void                        SetFillColor( const Color& rColor );
 641     const Color&                GetFillColor() const { return maFillColor; }
 642     bool                        IsFillColor() const { return mbFillColor; }
 643
 644     void                        SetBackground();
 645     void                        SetBackground( const Wallpaper& rBackground );
 646
 647     const Wallpaper&            GetBackground() const { return maBackground; }
 648     bool                        IsBackground() const { return mbBackground; }
 649
 650     void                        SetFont( const vcl::Font& rNewFont );
 651     const vcl::Font&            GetFont() const { return maFont; }
 652
 653 protected:
 654
 655     virtual void                ImplReleaseFonts();
 656
 657 private:
 658
 659     SAL_DLLPRIVATE void         InitLineColor();
 660
 661     SAL_DLLPRIVATE void         InitFillColor();
 662
 663     ///@}
 664
 665
 666     /** @name Clipping functions
 667      */
 668     ///@{
 669
 670 public:
 671
 672     vcl::Region                 GetClipRegion() const;
 673     void                        SetClipRegion();
 674     void                        SetClipRegion( const vcl::Region& rRegion );
 675     bool                        SelectClipRegion( const vcl::Region&, SalGraphics* pGraphics = nullptr );
 676
 677     bool                        IsClipRegion() const { return mbClipRegion; }
 678
 679     void                        MoveClipRegion( long nHorzMove, long nVertMove );
 680     void                        IntersectClipRegion( const tools::Rectangle& rRect );
 681     void                        IntersectClipRegion( const vcl::Region& rRegion );
 682
 683     virtual vcl::Region         GetActiveClipRegion() const;
 684
 685 protected:
 686
 687     virtual void                InitClipRegion();
 688     virtual void                ClipToPaintRegion    ( tools::Rectangle& rDstRect );
 689
 690 private:
 691
 692     SAL_DLLPRIVATE void         SetDeviceClipRegion( const vcl::Region* pRegion );
 693     ///@}
 694
 695
 696     /** @name Pixel functions
 697      */
 698     ///@{
 699
 700 public:
 701
 702     void                        DrawPixel( const Point& rPt );
 703     void                        DrawPixel( const Point& rPt, const Color& rColor );
 704     void                        DrawPixel( const tools::Polygon& rPts, const Color* pColors );
 705     void                        DrawPixel( const tools::Polygon& rPts, const Color& rColor );
 706
 707     Color                       GetPixel( const Point& rPt ) const;
 708     ///@}
 709
 710
 711     /** @name Rectangle functions
 712      */
 713     ///@{
 714
 715 public:
 716
 717     void                        DrawRect( const tools::Rectangle& rRect );
 718     void                        DrawRect( const tools::Rectangle& rRect,
 719                                           sal_uLong nHorzRount, sal_uLong nVertRound );
 720
 721     /// Fill the given rectangle with checkered rectangles of size nLen x nLen using the colors aStart and aEnd
 722     void                        DrawCheckered(
 723                                     const Point& rPos,
 724                                     const Size& rSize,
 725                                     sal_uInt32 nLen = 8,
 726                                     Color aStart = Color(COL_WHITE),
 727                                     Color aEnd = Color(COL_BLACK));
 728
 729     void                        DrawGrid( const tools::Rectangle& rRect, const Size& rDist, DrawGridFlags nFlags );
 730
 731     ///@}
 732
 733     /** @name Invert functions
 734      */
 735     ///@{
 736 public:
 737     void Invert( const tools::Rectangle& rRect, InvertFlags nFlags = InvertFlags::NONE );
 738     void Invert( const tools::Polygon& rPoly, InvertFlags nFlags = InvertFlags::NONE );
 739     ///@}
 740
 741     /** @name Line functions
 742      */
 743     ///@{
 744
 745 public:
 746
 747     void                        DrawLine( const Point& rStartPt, const Point& rEndPt );
 748
 749     void                        DrawLine( const Point& rStartPt, const Point& rEndPt,
 750                                           const LineInfo& rLineInfo );
 751
 752 private:
 753
 754     /** Helper for line geometry paint with support for graphic expansion (pattern and fat_to_area)
 755      */
 756     SAL_DLLPRIVATE void         drawLine( basegfx::B2DPolyPolygon aLinePolyPolygon, const LineInfo& rInfo );
 757     ///@}
 758
 759
 760     /** @name Polyline functions
 761      */
 762     ///@{
 763
 764 public:
 765
 766     /** Render the given polygon as a line stroke
 767
 768         The given polygon is stroked with the current LineColor, start
 769         and end point are not automatically connected
 770
 771         @see DrawPolygon
 772         @see DrawPolyPolygon
 773      */
 774     void                        DrawPolyLine( const tools::Polygon& rPoly );
 775
 776     void                        DrawPolyLine(
 777                                     const basegfx::B2DPolygon&,
 778                                     double fLineWidth = 0.0,
 779                                     basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::Round,
 780                                     css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT,
 781                                     double fMiterMinimumAngle = 15.0 * F_PI180);
 782
 783     /** Render the given polygon as a line stroke
 784
 785         The given polygon is stroked with the current LineColor, start
 786         and end point are not automatically connected. The line is
 787         rendered according to the specified LineInfo, e.g. supplying a
 788         dash pattern, or a line thickness.
 789
 790         @see DrawPolygon
 791         @see DrawPolyPolygon
 792      */
 793     void                        DrawPolyLine( const tools::Polygon& rPoly,
 794                                               const LineInfo& rLineInfo );
 795
 796     // #i101491#
 797     // Helper who tries to use SalGDI's DrawPolyLine direct and returns it's bool.
 798     bool                        DrawPolyLineDirect(
 799                                     const basegfx::B2DPolygon& rB2DPolygon,
 800                                     double fLineWidth = 0.0,
 801                                     double fTransparency = 0.0,
 802                                     basegfx::B2DLineJoin eLineJoin = basegfx::B2DLineJoin::NONE,
 803                                     css::drawing::LineCap eLineCap = css::drawing::LineCap_BUTT,
 804                                     double fMiterMinimumAngle = 15.0 * F_PI180,
 805                                     bool bBypassAACheck = false);
 806
 807 private:
 808
 809     // #i101491#
 810     // Helper which holds the old line geometry creation and is extended to use AA when
 811     // switched on. Advantage is that line geometry is only temporarily used for paint
 812     SAL_DLLPRIVATE void         drawPolyLine(const tools::Polygon& rPoly, const LineInfo& rLineInfo);
 813
 814     ///@}
 815
 816
 817     /** @name Polygon functions
 818      */
 819     ///@{
 820
 821 public:
 822
 823     /** Render the given polygon
 824
 825         The given polygon is stroked with the current LineColor, and
 826         filled with the current FillColor. If one of these colors are
 827         transparent, the corresponding stroke or fill stays
 828         invisible. Start and end point of the polygon are
 829         automatically connected.
 830
 831         @see DrawPolyLine
 832      */
 833     void                        DrawPolygon( const tools::Polygon& rPoly );
 834     void                        DrawPolygon( const basegfx::B2DPolygon& );
 835
 836     /** Render the given poly-polygon
 837
 838         The given poly-polygon is stroked with the current LineColor,
 839         and filled with the current FillColor. If one of these colors
 840         are transparent, the corresponding stroke or fill stays
 841         invisible. Start and end points of the contained polygons are
 842         automatically connected.
 843
 844         @see DrawPolyLine
 845      */
 846     void                        DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly );
 847     void                        DrawPolyPolygon( const basegfx::B2DPolyPolygon& );
 848
 849 private:
 850
 851     SAL_DLLPRIVATE void         ImplDrawPolygon( const tools::Polygon& rPoly, const tools::PolyPolygon* pClipPolyPoly = nullptr );
 852     SAL_DLLPRIVATE void         ImplDrawPolyPolygon( const tools::PolyPolygon& rPolyPoly, const tools::PolyPolygon* pClipPolyPoly );
 853     SAL_DLLPRIVATE void         ImplDrawPolyPolygon( sal_uInt16 nPoly, const tools::PolyPolygon& rPolyPoly );
 854     // #i101491#
 855     // Helper who implements the DrawPolyPolygon functionality for basegfx::B2DPolyPolygon
 856     // without MetaFile processing
 857     SAL_DLLPRIVATE void         ImplDrawPolyPolygonWithB2DPolyPolygon(const basegfx::B2DPolyPolygon& rB2DPolyPoly);
 858     ///@}
 859
 860
 861     /** @name Curved shape functions
 862      */
 863     ///@{
 864
 865 public:
 866
 867     void                        DrawEllipse( const tools::Rectangle& rRect );
 868
 869     void                        DrawArc(
 870                                     const tools::Rectangle& rRect,
 871                                     const Point& rStartPt, const Point& rEndPt );
 872
 873     void                        DrawPie(
 874                                     const tools::Rectangle& rRect,
 875                                     const Point& rStartPt, const Point& rEndPt );
 876
 877     void                        DrawChord(
 878                                     const tools::Rectangle& rRect,
 879                                     const Point& rStartPt, const Point& rEndPt );
 880
 881     ///@}
 882
 883
 884     /** @name Gradient functions
 885      */
 886     ///@{
 887
 888 public:
 889     void                        DrawGradient( const tools::Rectangle& rRect, const Gradient& rGradient );
 890     void                        DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
 891
 892     void                        AddGradientActions(
 893                                     const tools::Rectangle& rRect,
 894                                     const Gradient& rGradient,
 895                                     GDIMetaFile& rMtf );
 896
 897 protected:
 898
 899     virtual bool                UsePolyPolygonForComplexGradient() = 0;
 900
 901     virtual long                GetGradientStepCount( long nMinRect );
 902
 903 private:
 904
 905     SAL_DLLPRIVATE void         DrawLinearGradient( const tools::Rectangle& rRect, const Gradient& rGradient, const tools::PolyPolygon* pClipPolyPoly );
 906     SAL_DLLPRIVATE void         DrawComplexGradient( const tools::Rectangle& rRect, const Gradient& rGradient, const tools::PolyPolygon* pClipPolyPoly );
 907
 908     SAL_DLLPRIVATE void         DrawGradientToMetafile( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
 909     SAL_DLLPRIVATE void         DrawLinearGradientToMetafile( const tools::Rectangle& rRect, const Gradient& rGradient );
 910     SAL_DLLPRIVATE void         DrawComplexGradientToMetafile( const tools::Rectangle& rRect, const Gradient& rGradient );
 911
 912     SAL_DLLPRIVATE long         GetGradientSteps( const Gradient& rGradient, const tools::Rectangle& rRect, bool bMtf, bool bComplex=false );
 913
 914     SAL_DLLPRIVATE Color        GetSingleColorGradientFill();
 915     SAL_DLLPRIVATE void         SetGrayscaleColors( Gradient &rGradient );
 916     ///@}
 917
 918
 919     /** @name Hatch functions
 920      */
 921     ///@{
 922
 923 public:
 924
 925 #ifdef _MSC_VER
 926     void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const ::Hatch& rHatch );
 927     void                        AddHatchActions( const tools::PolyPolygon& rPolyPoly,
 928                                                  const ::Hatch& rHatch,
 929                                                  GDIMetaFile& rMtf );
 930 #else
 931     void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch );
 932     void                        AddHatchActions( const tools::PolyPolygon& rPolyPoly,
 933                                                  const Hatch& rHatch,
 934                                                  GDIMetaFile& rMtf );
 935 #endif
 936
 937     void                        DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch, bool bMtf );
 938
 939 private:
 940
 941     SAL_DLLPRIVATE void         CalcHatchValues( const tools::Rectangle& rRect, long nDist, sal_uInt16 nAngle10, Point& rPt1, Point& rPt2, Size& rInc, Point& rEndPt1 );
 942     SAL_DLLPRIVATE void         DrawHatchLine( const tools::Line& rLine, const tools::PolyPolygon& rPolyPoly, Point* pPtBuffer, bool bMtf );
 943     ///@}
 944
 945
 946     /** @name Wallpaper functions
 947      */
 948     ///@{
 949
 950 public:
 951     void                        DrawWallpaper( const tools::Rectangle& rRect, const Wallpaper& rWallpaper );
 952
 953     void                        Erase();
 954     void                        Erase( const tools::Rectangle& rRect ) { DrawWallpaper( rRect, GetBackground() ); }
 955
 956 protected:
 957     void                        DrawGradientWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
 958
 959 private:
 960     SAL_DLLPRIVATE void         DrawWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
 961     SAL_DLLPRIVATE void         DrawColorWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
 962     SAL_DLLPRIVATE void         DrawBitmapWallpaper( long nX, long nY, long nWidth, long nHeight, const Wallpaper& rWallpaper );
 963     ///@}
 964
 965
 966     /** @name Text functions
 967      */
 968     ///@{
 969
 970 public:
 971
 972     void                        DrawText( const Point& rStartPt, const OUString& rStr,
 973                                           sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
 974                                           MetricVector* pVector = nullptr, OUString* pDisplayText = nullptr );
 975
 976     void                        DrawText( const tools::Rectangle& rRect,
 977                                           const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::NONE,
 978                                           MetricVector* pVector = nullptr, OUString* pDisplayText = nullptr,
 979                                           vcl::ITextLayout* _pTextLayout = nullptr );
 980
 981     static void                 ImplDrawText( OutputDevice& rTargetDevice, const tools::Rectangle& rRect,
 982                                               const OUString& rOrigStr, DrawTextFlags nStyle,
 983                                               MetricVector* pVector, OUString* pDisplayText, vcl::ITextLayout& _rLayout );
 984
 985     void                        ImplDrawText( SalLayout& );
 986
 987     void                        ImplDrawTextBackground( const SalLayout& );
 988
 989     void                        DrawCtrlText( const Point& rPos, const OUString& rStr,
 990                                               sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
 991                                               DrawTextFlags nStyle = DrawTextFlags::Mnemonic, MetricVector* pVector = nullptr, OUString* pDisplayText = nullptr );
 992
 993     void                        DrawTextLine( const Point& rPos, long nWidth,
 994                                               FontStrikeout eStrikeout,
 995                                               FontLineStyle eUnderline,
 996                                               FontLineStyle eOverline,
 997                                               bool bUnderlineAbove = false );
 998
 999     void                        ImplDrawTextLine( long nBaseX, long nX, long nY, DeviceCoordinate nWidth,
1000                                                   FontStrikeout eStrikeout, FontLineStyle eUnderline,
1001                                                   FontLineStyle eOverline, bool bUnderlineAbove );
1002
1003     void                        ImplDrawTextLines( SalLayout&, FontStrikeout eStrikeout, FontLineStyle eUnderline,
1004                                                    FontLineStyle eOverline, bool bWordLine, bool bUnderlineAbove );
1005
1006     void                        DrawWaveLine( const Point& rStartPos, const Point& rEndPos );
1007
1008     bool                        ImplDrawRotateText( SalLayout& );
1009
1010     tools::Rectangle                   GetTextRect( const tools::Rectangle& rRect,
1011                                              const OUString& rStr, DrawTextFlags nStyle = DrawTextFlags::WordBreak,
1012                                              TextRectInfo* pInfo = nullptr,
1013                                              const vcl::ITextLayout* _pTextLayout = nullptr ) const;
1014
1015     /** Return the exact bounding rectangle of rStr.
1016
1017         The text is then drawn exactly from rRect.TopLeft() to
1018         rRect.BottomRight(), don't assume that rRect.TopLeft() is [0, 0].
1019
1020         Please note that you don't always want to use GetTextBoundRect(); in
1021         many cases you actually want to use GetTextHeight(), because
1022         GetTextBoundRect() gives you the exact bounding rectangle regardless
1023         what is the baseline of the text.
1024
1025         Code snippet to get just exactly the text (no filling around that) as
1026         a bitmap via a VirtualDevice (regardless what is the baseline):
1027
1028         <code>
1029         VirtualDevice aDevice;
1030         vcl::Font aFont = aDevice.GetFont();
1031         aFont.SetSize(Size(0, 96));
1032         aFont.SetColor(COL_BLACK);
1033         aDevice.SetFont(aFont);
1034         aDevice.Erase();
1035
1036         tools::Rectangle aRect;
1037         aDevice.GetTextBoundRect(aRect, aText);
1038         aDevice.SetOutputSize(Size(aRect.BottomRight().X() + 1, aRect.BottomRight().Y() + 1));
1039         aDevice.SetBackground(Wallpaper(COL_TRANSPARENT));
1040         aDevice.DrawText(Point(0,0), aText);
1041
1042         // exactly only the text, regardless of the baseline
1043         Bitmap aBitmap(aDevice.GetBitmap(aRect.TopLeft(), aRect.GetSize()));
1044         </code>
1045
1046         Code snippet to get the text as a bitmap via a Virtual device that
1047         contains even the filling so that the baseline is always preserved
1048         (ie. the text will not jump up and down according to whether it
1049         contains 'y' or not etc.)
1050
1051         <code>
1052         VirtualDevice aDevice;
1053         // + the appropriate font / device setup, see above
1054
1055         aDevice.SetOutputSize(Size(aDevice.GetTextWidth(aText), aDevice.GetTextHeight()));
1056         aDevice.SetBackground(Wallpaper(COL_TRANSPARENT));
1057         aDevice.DrawText(Point(0,0), aText);
1058
1059         // bitmap that contains even the space around the text,
1060         // that means, preserves the baseline etc.
1061         Bitmap aBitmap(aDevice.GetBitmap(Point(0, 0), aDevice.GetOutputSize()));
1062         </code>
1063     */
1064     bool                        GetTextBoundRect( tools::Rectangle& rRect,
1065                                                   const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
1066                                                   sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
1067
1068     tools::Rectangle                   ImplGetTextBoundRect( const SalLayout& );
1069
1070     bool                        GetTextOutline( tools::PolyPolygon&,
1071                                                 const OUString& rStr,
1072                                                 sal_Int32 nLen = -1,
1073                                                 sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
1074
1075     bool                        GetTextOutlines( PolyPolyVector&,
1076                                                  const OUString& rStr, sal_Int32 nBase = 0, sal_Int32 nIndex = 0,
1077                                                  sal_Int32 nLen = -1,
1078                                                  sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
1079
1080     bool                        GetTextOutlines( basegfx::B2DPolyPolygonVector &rVector,
1081                                                  const OUString& rStr, sal_Int32 nBase, sal_Int32 nIndex = 0,
1082                                                  sal_Int32 nLen = -1,
1083                                                  sal_uLong nLayoutWidth = 0, const long* pDXArray = nullptr ) const;
1084
1085
1086     OUString                    GetEllipsisString( const OUString& rStr, long nMaxWidth,
1087                                                    DrawTextFlags nStyle = DrawTextFlags::EndEllipsis ) const;
1088
1089     long                        GetCtrlTextWidth( const OUString& rStr ) const;
1090
1091     static OUString             GetNonMnemonicString( const OUString& rStr, sal_Int32& rMnemonicPos );
1092
1093     static OUString             GetNonMnemonicString( const OUString& rStr )
1094                                             { sal_Int32 nDummy; return GetNonMnemonicString( rStr, nDummy ); }
1095
1096     /** Generate MetaTextActions for the text rect
1097
1098         This method splits up the text rect into multiple
1099         MetaTextActions, one for each line of text. This is comparable
1100         to AddGradientActions(), which splits up a gradient into its
1101         constituent polygons. Parameter semantics fully compatible to
1102         DrawText().
1103      */
1104     void                        AddTextRectActions( const tools::Rectangle& rRect,
1105                                                     const OUString&  rOrigStr,
1106                                                     DrawTextFlags    nStyle,
1107                                                     GDIMetaFile&     rMtf );
1108
1109     void                        SetTextColor( const Color& rColor );
1110     const Color&                GetTextColor() const { return maTextColor; }
1111
1112     void                        SetTextFillColor();
1113     void                        SetTextFillColor( const Color& rColor );
1114     Color                       GetTextFillColor() const;
1115     bool                        IsTextFillColor() const { return !maFont.IsTransparent(); }
1116
1117     void                        SetTextLineColor();
1118     void                        SetTextLineColor( const Color& rColor );
1119     const Color&                GetTextLineColor() const { return maTextLineColor; }
1120     bool                        IsTextLineColor() const { return (maTextLineColor.GetTransparency() == 0); }
1121
1122     void                        SetOverlineColor();
1123     void                        SetOverlineColor( const Color& rColor );
1124     const Color&                GetOverlineColor() const { return maOverlineColor; }
1125     bool                        IsOverlineColor() const { return (maOverlineColor.GetTransparency() == 0); }
1126
1127     void                        SetTextAlign( TextAlign eAlign );
1128     TextAlign                   GetTextAlign() const { return maFont.GetAlignment(); }
1129
1130     /** Width of the text.
1131
1132         See also GetTextBoundRect() for more explanation + code examples.
1133     */
1134     long                        GetTextWidth( const OUString& rStr, sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
1135                                   vcl::TextLayoutCache const* = nullptr) const;
1136
1137     /** Height where any character of the current font fits; in logic coordinates.
1138
1139         See also GetTextBoundRect() for more explanation + code examples.
1140     */
1141     long                        GetTextHeight() const;
1142     float                       approximate_char_width() const;
1143
1144     void                        DrawTextArray( const Point& rStartPt, const OUString& rStr,
1145                                                const long* pDXAry,
1146                                                sal_Int32 nIndex = 0,
1147                                                sal_Int32 nLen = -1,
1148                                                SalLayoutFlags flags = SalLayoutFlags::NONE);
1149     long                        GetTextArray( const OUString& rStr, long* pDXAry,
1150                                               sal_Int32 nIndex = 0, sal_Int32 nLen = -1,
1151                                               vcl::TextLayoutCache const* = nullptr) const;
1152
1153     bool                        GetCaretPositions( const OUString&, long* pCaretXArray,
1154                                               sal_Int32 nIndex, sal_Int32 nLen ) const;
1155     void                        DrawStretchText( const Point& rStartPt, sal_uLong nWidth,
1156                                                  const OUString& rStr,
1157                                                  sal_Int32 nIndex = 0, sal_Int32 nLen = -1);
1158     sal_Int32                   GetTextBreak( const OUString& rStr, long nTextWidth,
1159                                               sal_Int32 nIndex, sal_Int32 nLen = -1,
1160                                               long nCharExtra = 0,
1161                                               vcl::TextLayoutCache const* = nullptr) const;
1162     sal_Int32                   GetTextBreak( const OUString& rStr, long nTextWidth,
1163                                               sal_Unicode nExtraChar, sal_Int32& rExtraCharPos,
1164                                               sal_Int32 nIndex, sal_Int32 nLen,
1165                                               long nCharExtra,
1166                                               vcl::TextLayoutCache const* = nullptr) const;
1167     std::shared_ptr<vcl::TextLayoutCache> CreateTextLayoutCache(OUString const&) const;
1168
1169 private:
1170     SAL_DLLPRIVATE void         ImplInitTextColor();
1171
1172     SAL_DLLPRIVATE void         ImplInitTextLineSize();
1173     SAL_DLLPRIVATE void         ImplInitAboveTextLineSize();
1174
1175
1176     SAL_DLLPRIVATE void         ImplDrawTextDirect( SalLayout&, bool bTextLines);
1177     SAL_DLLPRIVATE void         ImplDrawSpecialText( SalLayout& );
1178     SAL_DLLPRIVATE void         ImplDrawTextRect( long nBaseX, long nBaseY, long nX, long nY, long nWidth, long nHeight );
1179
1180     SAL_DLLPRIVATE static void  ImplDrawWavePixel( long nOriginX, long nOriginY, long nCurX, long nCurY, short nOrientation, SalGraphics* pGraphics, OutputDevice* pOutDev,
1181                                                    bool bDrawPixAsRect, long nPixWidth, long nPixHeight );
1182     SAL_DLLPRIVATE void         ImplDrawWaveLine( long nBaseX, long nBaseY, long nStartX, long nStartY, long nWidth, long nHeight, long nLineWidth, short nOrientation, const Color& rColor );
1183     SAL_DLLPRIVATE void         ImplDrawWaveTextLine( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontLineStyle eTextLine, Color aColor, bool bIsAbove );
1184     SAL_DLLPRIVATE void         ImplDrawStraightTextLine( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontLineStyle eTextLine, Color aColor, bool bIsAbove );
1185     SAL_DLLPRIVATE void         ImplDrawStrikeoutLine( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontStrikeout eStrikeout, Color aColor );
1186     SAL_DLLPRIVATE void         ImplDrawStrikeoutChar( long nBaseX, long nBaseY, long nX, long nY, long nWidth, FontStrikeout eStrikeout, Color aColor );
1187     SAL_DLLPRIVATE void         ImplDrawMnemonicLine( long nX, long nY, long nWidth );
1188
1189     SAL_DLLPRIVATE static bool  ImplIsUnderlineAbove( const vcl::Font& );
1190
1191     static
1192     SAL_DLLPRIVATE long         ImplGetTextLines( ImplMultiTextLineInfo& rLineInfo, long nWidth, const OUString& rStr, DrawTextFlags nStyle, const vcl::ITextLayout& _rLayout );
1193     ///@}
1194
1195
1196     /** @name Font functions
1197      */
1198     ///@{
1199
1200 public:
1201
1202     FontMetric                  GetDevFont( int nDevFontIndex ) const;
1203     int                         GetDevFontCount() const;
1204
1205     bool                        IsFontAvailable( const OUString& rFontName ) const;
1206
1207     Size                        GetDevFontSize( const vcl::Font& rFont, int nSizeIndex ) const;
1208     int                         GetDevFontSizeCount( const vcl::Font& ) const;
1209
1210     bool                        AddTempDevFont( const OUString& rFileURL, const OUString& rFontName );
1211     void                        RefreshFontData( const bool bNewFontLists );
1212
1213     FontMetric                  GetFontMetric() const;
1214     FontMetric                  GetFontMetric( const vcl::Font& rFont ) const;
1215
1216     bool                        GetFontCharMap( FontCharMapRef& rxFontCharMap ) const;
1217     bool                        GetFontCapabilities( vcl::FontCapabilities& rFontCapabilities ) const;
1218
1219     /** Retrieve detailed font information in platform independent structure
1220
1221         @param  nFallbacklevel      Fallback font level (0 = best matching font)
1222
1223         @return SystemFontData
1224      */
1225     SystemFontData              GetSysFontData( int nFallbacklevel ) const;
1226
1227     SAL_DLLPRIVATE void         ImplGetEmphasisMark( tools::PolyPolygon& rPolyPoly, bool& rPolyLine, tools::Rectangle& rRect1, tools::Rectangle& rRect2,
1228                                                      long& rYOff, long& rWidth, FontEmphasisMark eEmphasis, long nHeight );
1229     SAL_DLLPRIVATE static FontEmphasisMark
1230                                 ImplGetEmphasisMarkStyle( const vcl::Font& rFont );
1231
1232     bool                        GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex,
1233                                                     int nLen, MetricVector& rVector );
1234
1235     sal_Int32                   HasGlyphs( const vcl::Font& rFont, const OUString& rStr,
1236                                            sal_Int32 nIndex = 0, sal_Int32 nLen = -1 ) const;
1237
1238     long                        GetMinKashida() const;
1239
1240     // i60594
1241     // validate kashida positions against the current font
1242     // returns count of invalid kashida positions
1243     sal_Int32                   ValidateKashidas( const OUString& rTxt, sal_Int32 nIdx, sal_Int32 nLen,
1244                                                   sal_Int32 nKashCount, // number of suggested kashida positions (in)
1245                                                   const sal_Int32* pKashidaPos, // suggested kashida positions (in)
1246                                                   sal_Int32* pKashidaPosDropped // invalid kashida positions (out)
1247                                                 ) const;
1248
1249     static void                 BeginFontSubstitution();
1250     static void                 EndFontSubstitution();
1251     static void                 AddFontSubstitute( const OUString& rFontName,
1252                                                    const OUString& rReplaceFontName,
1253                                                    AddFontSubstituteFlags nFlags );
1254     static void                 RemoveFontSubstitute( sal_uInt16 n );
1255     static sal_uInt16           GetFontSubstituteCount();
1256
1257     static vcl::Font            GetDefaultFont( DefaultFontType nType,
1258                                                 LanguageType eLang,
1259                                                 GetDefaultFontFlags nFlags,
1260                                                 const OutputDevice* pOutDev = nullptr );
1261
1262     SAL_DLLPRIVATE void         ImplInitFontList() const;
1263     SAL_DLLPRIVATE void         ImplUpdateFontData();
1264
1265     //drop font data for all outputdevices.
1266     //If bNewFontLists is true then empty lists of system fonts
1267     SAL_DLLPRIVATE static void  ImplClearAllFontData( bool bNewFontLists );
1268     //fetch font data for all outputdevices
1269     //If bNewFontLists is true then fetch lists of system fonts
1270     SAL_DLLPRIVATE static void  ImplRefreshAllFontData( bool bNewFontLists );
1271     //drop and fetch font data for all outputdevices
1272     //If bNewFontLists is true then drop and refetch lists of system fonts
1273     SAL_DLLPRIVATE static void  ImplUpdateAllFontData( bool bNewFontLists );
1274
1275 protected:
1276
1277     virtual void                InitFont() const;
1278     virtual void                SetFontOrientation( LogicalFontInstance* const pFontInstance ) const;
1279     virtual long                GetFontExtLeading() const;
1280
1281
1282 private:
1283
1284     typedef void ( OutputDevice::* FontUpdateHandler_t )( bool );
1285
1286     SAL_DLLPRIVATE bool         ImplNewFont() const;
1287
1288     SAL_DLLPRIVATE void         ImplClearFontData( bool bNewFontLists );
1289     SAL_DLLPRIVATE void         ImplRefreshFontData( bool bNewFontLists );
1290     SAL_DLLPRIVATE static void  ImplUpdateFontDataForAllFrames( FontUpdateHandler_t pHdl, bool bNewFontLists );
1291
1292     static
1293     SAL_DLLPRIVATE OUString     ImplGetEllipsisString( const OutputDevice& rTargetDevice, const OUString& rStr,
1294                                                        long nMaxWidth, DrawTextFlags nStyle, const vcl::ITextLayout& _rLayout );
1295
1296     SAL_DLLPRIVATE void         ImplDrawEmphasisMark( long nBaseX, long nX, long nY, const tools::PolyPolygon& rPolyPoly, bool bPolyLine, const tools::Rectangle& rRect1, const tools::Rectangle& rRect2 );
1297     SAL_DLLPRIVATE void         ImplDrawEmphasisMarks( SalLayout& );
1298     ///@}
1299
1300
1301     /** @name Layout functions
1302      */
1303     ///@{
1304
1305 public:
1306
1307     SystemTextLayoutData        GetSysTextLayoutData( const Point& rStartPt, const OUString& rStr,
1308                                                       sal_Int32 nIndex, sal_Int32 nLen,
1309                                                       const long* pDXAry ) const;
1310
1311     SAL_DLLPRIVATE bool         ImplIsAntiparallel() const ;
1312     SAL_DLLPRIVATE void         ReMirror( Point &rPoint ) const;
1313     SAL_DLLPRIVATE void         ReMirror( tools::Rectangle &rRect ) const;
1314     SAL_DLLPRIVATE void         ReMirror( vcl::Region &rRegion ) const;
1315     SAL_DLLPRIVATE bool         ImplIsRecordLayout() const;
1316     virtual bool                HasMirroredGraphics() const;
1317     SAL_DLLPRIVATE SalLayout*   ImplLayout( const OUString&, sal_Int32 nIndex, sal_Int32 nLen,
1318                                             const Point& rLogicPos = Point(0,0), long nLogicWidth=0,
1319                                             const long* pLogicDXArray=nullptr, SalLayoutFlags flags = SalLayoutFlags::NONE,
1320                                             vcl::TextLayoutCache const* = nullptr) const;
1321     SAL_DLLPRIVATE ImplLayoutArgs ImplPrepareLayoutArgs( OUString&, const sal_Int32 nIndex, const sal_Int32 nLen,
1322                                                          DeviceCoordinate nPixelWidth, const DeviceCoordinate* pPixelDXArray,
1323                                                          SalLayoutFlags flags = SalLayoutFlags::NONE,
1324                                                          vcl::TextLayoutCache const* = nullptr) const;
1325     SAL_DLLPRIVATE SalLayout*   ImplGlyphFallbackLayout( SalLayout*, ImplLayoutArgs& ) const;
1326     // tells whether this output device is RTL in an LTR UI or LTR in a RTL UI
1327     SAL_DLLPRIVATE SalLayout*   getFallbackFont(
1328                                     FontSelectPattern &rFontSelData, int nFallbackLevel,
1329                                     ImplLayoutArgs& rLayoutArgs) const;
1330
1331
1332     // Enabling/disabling RTL only makes sense for OutputDevices that use a mirroring SalGraphisLayout
1333     virtual void                EnableRTL( bool bEnable = true);
1334     bool                        IsRTLEnabled() const { return mbEnableRTL; }
1335
1336     bool                        GetTextIsRTL( const OUString&, sal_Int32 nIndex, sal_Int32 nLen ) const;
1337
1338     ///@}
1339
1340
1341     /** @name Bitmap functions
1342      */
1343     ///@{
1344
1345 public:
1346
1347     /** @overload
1348         void DrawBitmap(
1349                 const Point& rDestPt,
1350                 const Size& rDestSize,
1351                 const Point& rSrcPtPixel,
1352                 const Size& rSecSizePixel,
1353                 const Bitmap& rBitmap,
1354                 MetaActionType nAction = MetaActionType::BMPSCALEPART)
1355       */
1356     void                        DrawBitmap(
1357                                     const Point& rDestPt,
1358                                     const Bitmap& rBitmap );
1359
1360     /** @overload
1361         void DrawBitmap(
1362                 const Point& rDestPt,
1363                 const Size& rDestSize,
1364                 const Point& rSrcPtPixel,
1365                 const Size& rSecSizePixel,
1366                 const Bitmap& rBitmap,
1367                 MetaActionType nAction = MetaActionType::BMPSCALEPART)
1368       */
1369     void                        DrawBitmap(
1370                                     const Point& rDestPt,
1371                                     const Size& rDestSize,
1372                                     const Bitmap& rBitmap );
1373
1374     void                        DrawBitmap(
1375                                     const Point& rDestPt,
1376                                     const Size& rDestSize,
1377                                     const Point& rSrcPtPixel,
1378                                     const Size& rSrcSizePixel,
1379                                     const Bitmap& rBitmap,
1380                                     MetaActionType nAction = MetaActionType::BMPSCALEPART );
1381
1382     /** @overload
1383         void DrawBitmapEx(
1384                 const Point& rDestPt,
1385                 const Size& rDestSize,
1386                 const Point& rSrcPtPixel,
1387                 const Size& rSecSizePixel,
1388                 const BitmapEx& rBitmapEx,
1389                 MetaActionType nAction = MetaActionType::BMPEXSCALEPART)
1390      */
1391     void                        DrawBitmapEx(
1392                                     const Point& rDestPt,
1393                                     const BitmapEx& rBitmapEx );
1394
1395
1396     /** @overload
1397         void DrawBitmapEx(
1398                 const Point& rDestPt,
1399                 const Size& rDestSize,
1400                 const Point& rSrcPtPixel,
1401                 const Size& rSecSizePixel,
1402                 const BitmapEx& rBitmapEx,
1403                 MetaActionType nAction = MetaActionType::BMPEXSCALEPART)
1404      */
1405     void                        DrawBitmapEx(
1406                                     const Point& rDestPt,
1407                                     const Size& rDestSize,
1408                                     const BitmapEx& rBitmapEx );
1409
1410     void                        DrawBitmapEx(
1411                                     const Point& rDestPt,
1412                                     const Size& rDestSize,
1413                                     const Point& rSrcPtPixel,
1414                                     const Size& rSrcSizePixel,
1415                                     const BitmapEx& rBitmapEx,
1416                                     MetaActionType nAction = MetaActionType::BMPEXSCALEPART );
1417
1418     /** @overload
1419         virtual void DrawImage(
1420                         const Point& rPos,
1421                         const Size& rSize,
1422                         const Image& rImage,
1423                         sal_uInt16 nStyle = 0)
1424      */
1425     void                        DrawImage(
1426                                     const Point& rPos,
1427                                     const Image& rImage,
1428                                     DrawImageFlags nStyle = DrawImageFlags::NONE );
1429
1430     void                        DrawImage(
1431                                     const Point& rPos,
1432                                     const Size& rSize,
1433                                     const Image& rImage,
1434                                     DrawImageFlags nStyle = DrawImageFlags::NONE );
1435
1436
1437     virtual Bitmap              GetBitmap( const Point& rSrcPt, const Size& rSize ) const;
1438
1439     /** Query extended bitmap (with alpha channel, if available).
1440      */
1441     BitmapEx                    GetBitmapEx( const Point& rSrcPt, const Size& rSize ) const;
1442
1443
1444     /** Draw BitmapEx transformed
1445
1446         @param rTransformation
1447         The transformation describing the target positioning of the given bitmap. Transforming
1448         the unit object coordinates (0, 0, 1, 1) with this matrix is the transformation to
1449         discrete coordinates
1450
1451         @param rBitmapEx
1452         The BitmapEx to be painted
1453     */
1454     void                        DrawTransformedBitmapEx(
1455                                     const basegfx::B2DHomMatrix& rTransformation,
1456                                     const BitmapEx& rBitmapEx);
1457
1458
1459 protected:
1460
1461     virtual void                DrawDeviceBitmap(
1462                                     const Point& rDestPt, const Size& rDestSize,
1463                                     const Point& rSrcPtPixel, const Size& rSrcSizePixel,
1464                                     BitmapEx& rBitmapEx );
1465
1466     virtual void                ScaleBitmap ( Bitmap &rBmp, SalTwoRect &rPosAry );
1467
1468     /** Transform and draw a bitmap directly
1469
1470      @param     aFullTransform      The B2DHomMatrix used for the transformation
1471      @param     rBitmapEx           Reference to the bitmap to be transformed and drawn
1472
1473      @return true if it was able to draw the bitmap, false if not
1474      */
1475     virtual bool                DrawTransformBitmapExDirect(
1476                                     const basegfx::B2DHomMatrix& aFullTransform,
1477                                     const BitmapEx& rBitmapEx);
1478
1479     /** Transform and reduce the area that needs to be drawn of the bitmap and return the new
1480         visible range and the maximum area.
1481
1482
1483       @param     aFullTransform      B2DHomMatrix used for transformation
1484       @param     aVisibleRange       The new visible area of the bitmap
1485       @param     fMaximumArea        The maximum area of the bitmap
1486
1487       @returns true if there is an area to be drawn, otherwise nothing is left to be drawn
1488         so return false
1489       */
1490     virtual bool                TransformAndReduceBitmapExToTargetRange(
1491                                     const basegfx::B2DHomMatrix& aFullTransform,
1492                                     basegfx::B2DRange &aVisibleRange,
1493                                     double &fMaximumArea);
1494
1495 private:
1496
1497     SAL_DLLPRIVATE void         DrawDeviceAlphaBitmap(
1498                                     const Bitmap& rBmp,
1499                                     const AlphaMask& rAlpha,
1500                                     const Point& rDestPt,
1501                                     const Size& rDestSize,
1502                                     const Point& rSrcPtPixel,
1503                                     const Size& rSrcSizePixel );
1504
1505     SAL_DLLPRIVATE void DrawDeviceAlphaBitmapSlowPath(
1506                                 const Bitmap& rBitmap, const AlphaMask& rAlpha,
1507                                 tools::Rectangle aDstRect, tools::Rectangle aBmpRect,
1508                                 Size& aOutSz, Point& aOutPt);
1509
1510
1511     SAL_DLLPRIVATE bool         BlendBitmap(
1512                                     const SalTwoRect&   rPosAry,
1513                                     const Bitmap&       rBmp );
1514
1515     SAL_DLLPRIVATE Bitmap       BlendBitmap(
1516                                     Bitmap&             aBmp,
1517                                     BitmapReadAccess*   pP,
1518                                     BitmapReadAccess*   pA,
1519                                     const sal_Int32     nOffY,
1520                                     const sal_Int32     nDstHeight,
1521                                     const sal_Int32     nOffX,
1522                                     const sal_Int32     nDstWidth,
1523                                     const tools::Rectangle&    aBmpRect,
1524                                     const Size&         aOutSz,
1525                                     const bool          bHMirr,
1526                                     const bool          bVMirr,
1527                                     const long*         pMapX,
1528                                     const long*         pMapY );
1529
1530     SAL_DLLPRIVATE Bitmap       BlendBitmapWithAlpha(
1531                                     Bitmap&             aBmp,
1532                                     BitmapReadAccess*   pP,
1533                                     BitmapReadAccess*   pA,
1534                                     const tools::Rectangle&    aDstRect,
1535                                     const sal_Int32     nOffY,
1536                                     const sal_Int32     nDstHeight,
1537                                     const sal_Int32     nOffX,
1538                                     const sal_Int32     nDstWidth,
1539                                     const long*         pMapX,
1540                                     const long*         pMapY );
1541
1542     /** Retrieve downsampled and cropped bitmap
1543
1544         @attention This method ignores negative rDstSz values, thus
1545         mirroring must happen outside this method (e.g. in DrawBitmap)
1546      */
1547     SAL_DLLPRIVATE Bitmap       GetDownsampledBitmap(
1548                                     const Size& rDstSz,
1549                                     const Point& rSrcPt,
1550                                     const Size& rSrcSz,
1551                                     const Bitmap& rBmp,
1552                                     long nMaxBmpDPIX,
1553                                     long nMaxBmpDPIY );
1554
1555     ///@}
1556
1557
1558     /** @name Transparency functions
1559      */
1560     ///@{
1561
1562 public:
1563
1564     /** helper method removing transparencies from a metafile (e.g. for printing)
1565
1566         @returns
1567         true: transparencies were removed
1568         false: output metafile is unchanged input metafile
1569
1570         @attention this is a member method, so current state can influence the result !
1571         @attention the output metafile is prepared in pixel mode for the currentOutputDevice
1572                    state. It can not be moved or rotated reliably anymore.
1573     */
1574     bool                        RemoveTransparenciesFromMetaFile(
1575                                     const GDIMetaFile& rInMtf, GDIMetaFile& rOutMtf,
1576                                     long nMaxBmpDPIX, long nMaxBmpDPIY,
1577                                     bool bReduceTransparency,
1578                                     bool bTransparencyAutoMode,
1579                                     bool bDownsampleBitmaps,
1580                                     const Color& rBackground = Color( COL_TRANSPARENT ) );
1581
1582     SAL_DLLPRIVATE void         ImplPrintTransparent (
1583                                     const Bitmap& rBmp, const Bitmap& rMask,
1584                                     const Point& rDestPt, const Size& rDestSize,
1585                                     const Point& rSrcPtPixel, const Size& rSrcSizePixel );
1586
1587     SAL_DLLPRIVATE Color        ImplDrawModeToColor  ( const Color& rColor ) const;
1588
1589
1590     void                        DrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
1591     void                        DrawTransparent( const basegfx::B2DPolyPolygon& rB2DPolyPoly, double fTransparency);
1592     void                        DrawTransparent(
1593                                         const GDIMetaFile& rMtf, const Point& rPos, const Size& rSize,
1594                                         const Gradient& rTransparenceGradient );
1595
1596 protected:
1597
1598     virtual void                EmulateDrawTransparent( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
1599     void                        DrawInvisiblePolygon( const tools::PolyPolygon& rPolyPoly );
1600
1601     virtual void                ClipAndDrawGradientMetafile ( const Gradient &rGradient, const tools::PolyPolygon &rPolyPoly );
1602
1603 private:
1604
1605     SAL_DLLPRIVATE bool         DrawTransparentNatively( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransparencePercent );
1606     ///@}
1607
1608
1609     /** @name Mask functions
1610      */
1611     ///@{
1612
1613 public:
1614
1615     void                        DrawMask( const Point& rDestPt,
1616                                           const Bitmap& rBitmap, const Color& rMaskColor );
1617
1618     void                        DrawMask( const Point& rDestPt, const Size& rDestSize,
1619                                           const Bitmap& rBitmap, const Color& rMaskColor );
1620
1621     void                        DrawMask( const Point& rDestPt, const Size& rDestSize,
1622                                           const Point& rSrcPtPixel, const Size& rSrcSizePixel,
1623                                           const Bitmap& rBitmap, const Color& rMaskColor,
1624                                           MetaActionType nAction );
1625
1626 protected:
1627
1628     virtual void                DrawDeviceMask (
1629                                          const Bitmap& rMask, const Color& rMaskColor,
1630                                          const Point& rDestPt, const Size& rDestSize,
1631                                          const Point& rSrcPtPixel, const Size& rSrcSizePixel );
1632     ///@}
1633
1634
1635     /** @name Map functions
1636      */
1637     ///@{
1638
1639 public:
1640
1641     void                        EnableMapMode( bool bEnable = true );
1642     bool                        IsMapModeEnabled() const { return mbMap; }
1643
1644     void                        SetMapMode();
1645     virtual void                SetMapMode( const MapMode& rNewMapMode );
1646     void                        SetRelativeMapMode( const MapMode& rNewMapMode );
1647     const MapMode&              GetMapMode() const { return maMapMode; }
1648
1649      // #i75163#
1650     basegfx::B2DHomMatrix       GetViewTransformation() const;
1651     basegfx::B2DHomMatrix       GetInverseViewTransformation() const;
1652
1653     basegfx::B2DHomMatrix       GetViewTransformation( const MapMode& rMapMode ) const;
1654     basegfx::B2DHomMatrix       GetInverseViewTransformation( const MapMode& rMapMode ) const;
1655
1656
1657     /** Set an offset in pixel
1658
1659         This method offsets every drawing operation that converts its
1660         coordinates to pixel by the given value. Normally, the effect
1661         can be achieved by setting a MapMode with a different
1662         origin. Unfortunately, this origin is in logical coordinates
1663         and can lead to rounding errors (see #102532# for details).
1664
1665         @attention This offset is only applied when converting to
1666         pixel, i.e. some output modes such as metafile recordings
1667         might be completely unaffected by this method! Use with
1668         care. Furthermore, if the OutputDevice's MapMode is the
1669         default (that's MapUnit::MapPixel), then any pixel offset set is
1670         ignored also. This might be unintuitive for cases, but would
1671         have been far more fragile to implement. What's more, the
1672         reason why the pixel offset was introduced (avoiding rounding
1673         errors) does not apply for MapUnit::MapPixel, because one can always
1674         use the MapMode origin then.
1675
1676         @param rOffset
1677         The offset in pixel
1678      */
1679     void                        SetPixelOffset( const Size& rOffset );
1680
1681     /** Get the offset in pixel
1682
1683         @see OutputDevice::SetPixelOffset for details
1684
1685         @return the current offset in pixel
1686      */
1687     Size                        GetPixelOffset() const { return Size(mnOutOffOrigX, mnOutOffOrigY);}
1688
1689     Point                       LogicToPixel( const Point& rLogicPt ) const;
1690     Size                        LogicToPixel( const Size& rLogicSize ) const;
1691     tools::Rectangle                   LogicToPixel( const tools::Rectangle& rLogicRect ) const;
1692     tools::Polygon              LogicToPixel( const tools::Polygon& rLogicPoly ) const;
1693     tools::PolyPolygon          LogicToPixel( const tools::PolyPolygon& rLogicPolyPoly ) const;
1694     basegfx::B2DPolyPolygon     LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly ) const;
1695     vcl::Region                 LogicToPixel( const vcl::Region& rLogicRegion )const;
1696     Point                       LogicToPixel( const Point& rLogicPt,
1697                                               const MapMode& rMapMode ) const;
1698     Size                        LogicToPixel( const Size& rLogicSize,
1699                                               const MapMode& rMapMode ) const;
1700     tools::Rectangle                   LogicToPixel( const tools::Rectangle& rLogicRect,
1701                                               const MapMode& rMapMode ) const;
1702     tools::Polygon              LogicToPixel( const tools::Polygon& rLogicPoly,
1703                                               const MapMode& rMapMode ) const;
1704     basegfx::B2DPolyPolygon     LogicToPixel( const basegfx::B2DPolyPolygon& rLogicPolyPoly,
1705                                               const MapMode& rMapMode ) const;
1706
1707     Point                       PixelToLogic( const Point& rDevicePt ) const;
1708     Size                        PixelToLogic( const Size& rDeviceSize ) const;
1709     tools::Rectangle                   PixelToLogic( const tools::Rectangle& rDeviceRect ) const;
1710     tools::Polygon              PixelToLogic( const tools::Polygon& rDevicePoly ) const;
1711     tools::PolyPolygon          PixelToLogic( const tools::PolyPolygon& rDevicePolyPoly ) const;
1712     basegfx::B2DPolyPolygon     PixelToLogic( const basegfx::B2DPolyPolygon& rDevicePolyPoly ) const;
1713     vcl::Region                 PixelToLogic( const vcl::Region& rDeviceRegion ) const;
1714     Point                       PixelToLogic( const Point& rDevicePt,
1715                                               const MapMode& rMapMode ) const;
1716     Size                        PixelToLogic( const Size& rDeviceSize,
1717                                               const MapMode& rMapMode ) const;
1718     tools::Rectangle                   PixelToLogic( const tools::Rectangle& rDeviceRect,
1719                                               const MapMode& rMapMode ) const;
1720     tools::Polygon              PixelToLogic( const tools::Polygon& rDevicePoly,
1721                                               const MapMode& rMapMode ) const;
1722     basegfx::B2DPolygon         PixelToLogic( const basegfx::B2DPolygon& rDevicePoly,
1723                                               const MapMode& rMapMode ) const;
1724     basegfx::B2DPolyPolygon     PixelToLogic( const basegfx::B2DPolyPolygon& rDevicePolyPoly,
1725                                               const MapMode& rMapMode ) const;
1726
1727     Point                       LogicToLogic( const Point&      rPtSource,
1728                                               const MapMode*    pMapModeSource,
1729                                               const MapMode*    pMapModeDest ) const;
1730     Size                        LogicToLogic( const Size&       rSzSource,
1731                                               const MapMode*    pMapModeSource,
1732                                               const MapMode*    pMapModeDest ) const;
1733     tools::Rectangle                   LogicToLogic( const tools::Rectangle&  rRectSource,
1734                                               const MapMode*    pMapModeSource,
1735                                               const MapMode*    pMapModeDest ) const;
1736     static Point                LogicToLogic( const Point&      rPtSource,
1737                                               const MapMode&    rMapModeSource,
1738                                               const MapMode&    rMapModeDest );
1739     static Size                 LogicToLogic( const Size&       rSzSource,
1740                                               const MapMode&    rMapModeSource,
1741                                               const MapMode&    rMapModeDest );
1742     static tools::Rectangle            LogicToLogic( const tools::Rectangle&  rRectSource,
1743                                               const MapMode&    rMapModeSource,
1744                                               const MapMode&    rMapModeDest );
1745     static long                 LogicToLogic( long              nLongSource,
1746                                               MapUnit           eUnitSource,
1747                                               MapUnit           eUnitDest );
1748
1749     static basegfx::B2DPolygon  LogicToLogic( const basegfx::B2DPolygon& rPoly,
1750                                               const MapMode&    rMapModeSource,
1751                                               const MapMode&    rMapModeDest );
1752
1753     // create a mapping transformation from rMapModeSource to rMapModeDest (the above methods
1754     // for B2DPoly/Polygons use this internally anyway to transform the B2DPolygon)
1755     static basegfx::B2DHomMatrix LogicToLogic(const MapMode& rMapModeSource, const MapMode& rMapModeDest);
1756
1757     /** Convert a logical rectangle to a rectangle in physical device pixel units.
1758
1759      @param         rLogicRect  Const reference to a rectangle in logical units
1760
1761      @returns Rectangle based on physical device pixel coordinates and units.
1762      */
1763     SAL_DLLPRIVATE tools::Rectangle    ImplLogicToDevicePixel( const tools::Rectangle& rLogicRect ) const;
1764
1765     /** Convert a logical point to a physical point on the device.
1766
1767      @param         rLogicPt    Const reference to a point in logical units.
1768
1769      @returns Physical point on the device.
1770      */
1771     SAL_DLLPRIVATE Point        ImplLogicToDevicePixel( const Point& rLogicPt ) const;
1772
1773     /** Convert a logical width to a width in units of device pixels.
1774
1775      To get the number of device pixels, it must calculate the X-DPI of the device and
1776      the map scaling factor. If there is no mapping, then it just returns the
1777      width as nothing more needs to be done.
1778
1779      @param         nWidth      Logical width
1780
1781      @returns Width in units of device pixels.
1782      */
1783     SAL_DLLPRIVATE long         ImplLogicWidthToDevicePixel( long nWidth ) const;
1784
1785     SAL_DLLPRIVATE DeviceCoordinate LogicWidthToDeviceCoordinate( long nWidth ) const;
1786
1787 protected:
1788     /**
1789      * Notification about some rectangle of the output device got invalidated.
1790      *
1791      * @param pRectangle If 0, that means the whole area, otherwise the area in logic coordinates.
1792      */
1793     virtual void LogicInvalidate(const tools::Rectangle* pRectangle) { (void)pRectangle; }
1794
1795 private:
1796
1797     /** Convert a logical X coordinate to a device pixel's X coordinate.
1798
1799      To get the device's X coordinate, it must calculate the mapping offset
1800      coordinate X position (if there is one - if not then it just adds
1801      the pseudo-window offset to the logical X coordinate), the X-DPI of
1802      the device and the mapping's X scaling factor.
1803
1804      @param         nX          Logical X coordinate
1805
1806      @returns Device's X pixel coordinate
1807      */
1808     SAL_DLLPRIVATE long         ImplLogicXToDevicePixel( long nX ) const;
1809
1810     /** Convert a logical Y coordinate to a device pixel's Y coordinate.
1811
1812      To get the device's Y coordinate, it must calculate the mapping offset
1813      coordinate Y position (if there is one - if not then it just adds
1814      the pseudo-window offset to the logical Y coordinate), the Y-DPI of
1815      the device and the mapping's Y scaling factor.
1816
1817      @param         nY          Logical Y coordinate
1818
1819      @returns Device's Y pixel coordinate
1820      */
1821     SAL_DLLPRIVATE long         ImplLogicYToDevicePixel( long nY ) const;
1822
1823     /** Convert a logical height to a height in units of device pixels.
1824
1825      To get the number of device pixels, it must calculate the Y-DPI of the device and
1826      the map scaling factor. If there is no mapping, then it just returns the
1827      height as nothing more needs to be done.
1828
1829      @param         nHeight     Logical height
1830
1831      @returns Height in units of device pixels.
1832      */
1833     SAL_DLLPRIVATE long         ImplLogicHeightToDevicePixel( long nHeight ) const;
1834
1835     /** Convert device pixels to a width in logical units.
1836
1837      To get the logical width, it must calculate the X-DPI of the device and the
1838      map scaling factor.
1839
1840      @param         nWidth      Width in device pixels
1841
1842      @returns Width in logical units.
1843      */
1844     SAL_DLLPRIVATE long         ImplDevicePixelToLogicWidth( long nWidth ) const;
1845
1846     /** Convert device pixels to a height in logical units.
1847
1848      To get the logical height, it must calculate the Y-DPI of the device and the
1849      map scaling factor.
1850
1851      @param         nHeight     Height in device pixels
1852
1853      @returns Height in logical units.
1854      */
1855     SAL_DLLPRIVATE long         ImplDevicePixelToLogicHeight( long nHeight ) const;
1856
1857     /** Convert logical height to device pixels, with exact sub-pixel value.
1858
1859      To get the \em exact pixel height, it must calculate the Y-DPI of the device and the
1860      map scaling factor.
1861
1862      @param         fLogicHeight     Exact height in logical units.
1863
1864      @returns Exact height in pixels - returns as a float to provide for subpixel value.
1865      */
1866     SAL_DLLPRIVATE float        ImplFloatLogicHeightToDevicePixel( float fLogicHeight ) const;
1867
1868     /** Convert a logical size to the size on the physical device.
1869
1870      @param         rLogicSize  Const reference to a size in logical units
1871
1872      @returns Physical size on the device.
1873      */
1874     SAL_DLLPRIVATE Size         ImplLogicToDevicePixel( const Size& rLogicSize ) const;
1875
1876     /** Convert a rectangle in physical pixel units to a rectangle in physical pixel units and coords.
1877
1878      @param         rPixelRect  Const reference to rectangle in logical units and coords.
1879
1880      @returns Rectangle based on logical coordinates and units.
1881      */
1882     SAL_DLLPRIVATE tools::Rectangle    ImplDevicePixelToLogic( const tools::Rectangle& rPixelRect ) const;
1883
1884     /** Convert a logical polygon to a polygon in physical device pixel units.
1885
1886      @param         rLogicPoly  Const reference to a polygon in logical units
1887
1888      @returns Polygon based on physical device pixel coordinates and units.
1889      */
1890     SAL_DLLPRIVATE tools::Polygon ImplLogicToDevicePixel( const tools::Polygon& rLogicPoly ) const;
1891
1892     /** Convert a logical polypolygon to a polypolygon in physical device pixel units.
1893
1894      @param         rLogicPolyPoly  Const reference to a polypolygon in logical units
1895
1896      @returns Polypolygon based on physical device pixel coordinates and units.
1897      */
1898     SAL_DLLPRIVATE tools::PolyPolygon  ImplLogicToDevicePixel( const tools::PolyPolygon& rLogicPolyPoly ) const;
1899
1900     /** Convert a line in logical units to a line in physical device pixel units.
1901
1902      @param         rLineInfo   Const refernece to a line in logical units
1903
1904      @returns Line based on physical device pixel coordinates and units.
1905      */
1906     SAL_DLLPRIVATE LineInfo     ImplLogicToDevicePixel( const LineInfo& rLineInfo ) const;
1907
1908     /** Convert a region in pixel units to a region in device pixel units and coords.
1909
1910      @param         rRegion  Const reference to region.
1911
1912      @returns vcl::Region based on device pixel coordinates and units.
1913      */
1914     SAL_DLLPRIVATE vcl::Region       ImplPixelToDevicePixel( const vcl::Region& rRegion ) const;
1915
1916     /** Invalidate the view transformation.
1917
1918      @since AOO bug 75163 (OpenOffice.org 2.4.3 - OOH 680 milestone 212)
1919      */
1920     SAL_DLLPRIVATE void         ImplInvalidateViewTransform();
1921
1922     /** Get device transformation.
1923
1924      @since AOO bug 75163 (OpenOffice.org 2.4.3 - OOH 680 milestone 212)
1925      */
1926     SAL_DLLPRIVATE basegfx::B2DHomMatrix ImplGetDeviceTransformation() const;
1927     ///@}
1928
1929
1930     /** @name Native Widget Rendering functions
1931
1932         These all just call through to the private mpGraphics functions of the same name.
1933      */
1934     ///@{
1935
1936 public:
1937
1938     /** Query the platform layer for control support
1939      */
1940     bool                        IsNativeControlSupported( ControlType nType, ControlPart nPart ) const;
1941
1942     /** Query the native control to determine if it was acted upon
1943      */
1944     bool                        HitTestNativeScrollbar(
1945                                     ControlPart nPart,
1946                                     const tools::Rectangle& rControlRegion,
1947                                     const Point& aPos,
1948                                     bool& rIsInside ) const;
1949
1950     /** Request rendering of a particular control and/or part
1951      */
1952     bool                        DrawNativeControl(
1953                                     ControlType nType,
1954                                     ControlPart nPart,
1955                                     const tools::Rectangle& rControlRegion,
1956                                     ControlState nState,
1957                                     const ImplControlValue& aValue,
1958                                     const OUString& aCaption );
1959
1960     /** Query the native control's actual drawing region (including adornment)
1961      */
1962     bool                        GetNativeControlRegion(
1963                                     ControlType nType,
1964                                     ControlPart nPart,
1965                                     const tools::Rectangle& rControlRegion,
1966                                     ControlState nState,
1967                                     const ImplControlValue& aValue,
1968                                     tools::Rectangle &rNativeBoundingRegion,
1969                                     tools::Rectangle &rNativeContentRegion ) const;
1970     ///@}
1971
1972     /** @name EPS functions
1973      */
1974     ///@{
1975
1976 public:
1977
1978     /** @returns boolean value to see if EPS could be painted directly.
1979         Theoreticaly, handing over a matrix would be needed to handle
1980         painting rotated EPS files (e.g. contained in Metafiles). This
1981         would then need to be supported for Mac and PS printers, but
1982         that's too much for now, wrote \#i107046# for this */
1983     bool                        DrawEPS(
1984                                     const Point& rPt, const Size& rSz,
1985                                     const GfxLink& rGfxLink, GDIMetaFile* pSubst = nullptr );
1986     ///@}
1987 };
1988
1989 #endif // INCLUDED_VCL_OUTDEV_HXX
1990
1991 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */