vcl/inc/quartz/salgdi.h

   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 #pragma once
  21
  22 #include <sal/config.h>
  23
  24 #include <vector>
  25
  26 #include <tools/long.hxx>
  27
  28 #include <premac.h>
  29 #ifdef MACOSX
  30 #include <ApplicationServices/ApplicationServices.h>
  31 #include <osx/osxvcltypes.h>
  32 #include <osx/salframe.h>
  33 #else
  34 #include <CoreGraphics/CoreGraphics.h>
  35 #include <CoreText/CoreText.h>
  36 #endif
  37 #include <postmac.h>
  38
  39 #ifdef IOS
  40 // iOS defines a different Point class so include salgeom.hxx after postmac.h
  41 // so that it will use the Point class in tools/gen.hxx
  42 #include "salgeom.hxx"
  43 #endif
  44
  45 #include <vcl/fontcapabilities.hxx>
  46 #include <vcl/metric.hxx>
  47
  48
  49 #include <font/LogicalFontInstance.hxx>
  50 #include <font/FontMetricData.hxx>
  51 #include <salgdi.hxx>
  52
  53 #include <quartz/salgdicommon.hxx>
  54
  55 #include <quartz/CGHelpers.hxx>
  56
  57 class AquaSalFrame;
  58 class XorEmulation;
  59 class CoreTextFont;
  60
  61 namespace sal::aqua
  62 {
  63 #ifdef MACOSX
  64 NSRect getTotalScreenBounds();
  65 void resetTotalScreenBounds();
  66 #endif
  67 float getWindowScaling();
  68 void resetWindowScaling();
  69 }
  70
  71 struct AquaSharedAttributes
  72 {
  73     /// path representing current clip region
  74     CGMutablePathRef mxClipPath;
  75
  76     /// Drawing colors
  77     /// pen color RGBA
  78     RGBAColor maLineColor;
  79
  80     /// brush color RGBA
  81     RGBAColor maFillColor;
  82
  83     // Graphics types
  84 #ifdef MACOSX
  85     AquaSalFrame* mpFrame;
  86     /// is this a window graphics
  87     bool mbWindow;
  88 #else // IOS
  89     // mirror AquaSalVirtualDevice::mbForeignContext for SvpSalGraphics objects related to such
  90     bool mbForeignContext;
  91 #endif
  92     /// is this a printer graphics
  93     bool mbPrinter;
  94     /// is this a virtual device graphics
  95     bool mbVirDev;
  96
  97     CGLayerHolder maLayer; // Quartz graphics layer
  98     CGContextHolder maContextHolder;  // Quartz drawing context
  99     CGContextHolder maBGContextHolder;  // Quartz drawing context for CGLayer
 100     CGContextHolder maCSContextHolder;  // Quartz drawing context considering the color space
 101     int mnWidth;
 102     int mnHeight;
 103     int mnXorMode; // 0: off 1: on 2: invert only
 104     int mnBitmapDepth;  // zero unless bitmap
 105
 106     Color maTextColor;
 107     /// allows text to be rendered without antialiasing
 108     bool mbNonAntialiasedText;
 109
 110     std::unique_ptr<XorEmulation> mpXorEmulation;
 111
 112     AquaSharedAttributes()
 113         : mxClipPath(nullptr)
 114         , maLineColor(COL_WHITE)
 115         , maFillColor(COL_BLACK)
 116 #ifdef MACOSX
 117         , mpFrame(nullptr)
 118         , mbWindow(false)
 119 #else
 120         , mbForeignContext(false)
 121 #endif
 122         , mbPrinter(false)
 123         , mbVirDev(false)
 124         , mnWidth(0)
 125         , mnHeight(0)
 126         , mnXorMode(0)
 127         , mnBitmapDepth(0)
 128         , maTextColor( COL_BLACK )
 129         , mbNonAntialiasedText( false )
 130     {}
 131
 132     void unsetClipPath()
 133     {
 134         if (mxClipPath)
 135         {
 136             CGPathRelease(mxClipPath);
 137             mxClipPath = nullptr;
 138         }
 139     }
 140
 141     void unsetState()
 142     {
 143         unsetClipPath();
 144     }
 145
 146     bool checkContext();
 147     void setState();
 148
 149     bool isPenVisible() const
 150     {
 151         return maLineColor.IsVisible();
 152     }
 153     bool isBrushVisible() const
 154     {
 155         return maFillColor.IsVisible();
 156     }
 157
 158     void refreshRect(float lX, float lY, float lWidth, float lHeight)
 159     {
 160 #ifdef MACOSX
 161         if (!mbWindow) // view only on Window graphics
 162             return;
 163
 164         if (mpFrame)
 165         {
 166             // update a little more around the designated rectangle
 167             // this helps with antialiased rendering
 168             // Rounding down x and width can accumulate a rounding error of up to 2
 169             // The decrementing of x, the rounding error and the antialiasing border
 170             // require that the width and the height need to be increased by four
 171             const tools::Rectangle aVclRect(
 172                     Point(tools::Long(lX - 1), tools::Long(lY - 1)),
 173                     Size(tools::Long(lWidth + 4), tools::Long(lHeight + 4)));
 174
 175             mpFrame->maInvalidRect.Union(aVclRect);
 176         }
 177 #else
 178         (void) lX;
 179         (void) lY;
 180         (void) lWidth;
 181         (void) lHeight;
 182         return;
 183 #endif
 184     }
 185
 186     // apply the XOR mask to the target context if active and dirty
 187     void applyXorContext()
 188     {
 189         if (!mpXorEmulation)
 190             return;
 191         if (mpXorEmulation->UpdateTarget())
 192         {
 193             refreshRect(0, 0, mnWidth, mnHeight); // TODO: refresh minimal changerect
 194         }
 195     }
 196
 197     // differences between VCL, Quartz and kHiThemeOrientation coordinate systems
 198     // make some graphics seem to be vertically-mirrored from a VCL perspective
 199     bool isFlipped() const
 200     {
 201     #ifdef MACOSX
 202         return mbWindow;
 203     #else
 204         return false;
 205     #endif
 206     }
 207 };
 208
 209 class AquaGraphicsBackendBase
 210 {
 211 public:
 212     virtual ~AquaGraphicsBackendBase() = 0;
 213     AquaSharedAttributes& GetShared() { return mrShared; }
 214     SalGraphicsImpl* GetImpl()
 215     {
 216         return mpImpl;
 217     }
 218     virtual void UpdateGeometryProvider(SalGeometryProvider*) {};
 219     virtual bool drawNativeControl(ControlType nType,
 220                                    ControlPart nPart,
 221                                    const tools::Rectangle &rControlRegion,
 222                                    ControlState nState,
 223                                    const ImplControlValue &aValue) = 0;
 224     virtual void drawTextLayout(const GenericSalLayout& layout) = 0;
 225     virtual void Flush() {}
 226     virtual void Flush( const tools::Rectangle& ) {}
 227     virtual void WindowBackingPropertiesChanged() {};
 228 protected:
 229     AquaGraphicsBackendBase(AquaSharedAttributes& rShared, SalGraphicsImpl * impl)
 230         : mrShared( rShared ), mpImpl(impl)
 231     {}
 232     static bool performDrawNativeControl(ControlType nType,
 233                                          ControlPart nPart,
 234                                          const tools::Rectangle &rControlRegion,
 235                                          ControlState nState,
 236                                          const ImplControlValue &aValue,
 237                                          CGContextRef context,
 238                                          AquaSalFrame* mpFrame);
 239     AquaSharedAttributes& mrShared;
 240 private:
 241     SalGraphicsImpl* mpImpl;
 242 };
 243
 244 inline AquaGraphicsBackendBase::~AquaGraphicsBackendBase() {}
 245
 246 class AquaGraphicsBackend final : public SalGraphicsImpl, public AquaGraphicsBackendBase
 247 {
 248 private:
 249     void drawPixelImpl( tools::Long nX, tools::Long nY, const RGBAColor& rColor); // helper to draw single pixels
 250
 251 #ifdef MACOSX
 252     void refreshRect(const NSRect& rRect)
 253     {
 254         mrShared.refreshRect(rRect.origin.x, rRect.origin.y, rRect.size.width, rRect.size.height);
 255     }
 256 #else
 257     void refreshRect(const CGRect& /*rRect*/)
 258     {}
 259 #endif
 260
 261     void pattern50Fill();
 262
 263 #ifdef MACOSX
 264     void copyScaledArea(tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX, tools::Long nSrcY,
 265                         tools::Long nSrcWidth, tools::Long nSrcHeight, AquaSharedAttributes* pSrcShared);
 266 #endif
 267
 268 public:
 269     AquaGraphicsBackend(AquaSharedAttributes & rShared);
 270     ~AquaGraphicsBackend() override;
 271
 272     void Init() override;
 273
 274     void freeResources() override;
 275
 276     OUString getRenderBackendName() const override
 277     {
 278         return "aqua";
 279     }
 280
 281     void setClipRegion(vcl::Region const& rRegion) override;
 282     void ResetClipRegion() override;
 283
 284     sal_uInt16 GetBitCount() const override;
 285
 286     tools::Long GetGraphicsWidth() const override;
 287
 288     void SetLineColor() override;
 289     void SetLineColor(Color nColor) override;
 290     void SetFillColor() override;
 291     void SetFillColor(Color nColor) override;
 292     void SetXORMode(bool bSet, bool bInvertOnly) override;
 293     void SetROPLineColor(SalROPColor nROPColor) override;
 294     void SetROPFillColor(SalROPColor nROPColor) override;
 295
 296     void drawPixel(tools::Long nX, tools::Long nY) override;
 297     void drawPixel(tools::Long nX, tools::Long nY, Color nColor) override;
 298
 299     void drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2) override;
 300     void drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight) override;
 301     void drawPolyLine(sal_uInt32 nPoints, const Point* pPointArray) override;
 302     void drawPolygon(sal_uInt32 nPoints, const Point* pPointArray) override;
 303     void drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32* pPoints,
 304                          const Point** pPointArray) override;
 305
 306     void drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,
 307                          const basegfx::B2DPolyPolygon&, double fTransparency) override;
 308
 309     bool drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevice, const basegfx::B2DPolygon&,
 310                       double fTransparency, double fLineWidth, const std::vector<double>* pStroke,
 311                       basegfx::B2DLineJoin, css::drawing::LineCap, double fMiterMinimumAngle,
 312                       bool bPixelSnapHairline) override;
 313
 314     bool drawPolyLineBezier(sal_uInt32 nPoints, const Point* pPointArray,
 315                             const PolyFlags* pFlagArray) override;
 316
 317     bool drawPolygonBezier(sal_uInt32 nPoints, const Point* pPointArray,
 318                            const PolyFlags* pFlagArray) override;
 319
 320     bool drawPolyPolygonBezier(sal_uInt32 nPoly, const sal_uInt32* pPoints,
 321                                const Point* const* pPointArray,
 322                                const PolyFlags* const* pFlagArray) override;
 323
 324     void copyArea(tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX, tools::Long nSrcY,
 325                   tools::Long nSrcWidth, tools::Long nSrcHeight, bool bWindowInvalidate) override;
 326
 327     void copyBits(const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics) override;
 328
 329     void drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap) override;
 330
 331     void drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap,
 332                     const SalBitmap& rMaskBitmap) override;
 333
 334     void drawMask(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap,
 335                   Color nMaskColor) override;
 336
 337     std::shared_ptr<SalBitmap> getBitmap(tools::Long nX, tools::Long nY, tools::Long nWidth,
 338                                          tools::Long nHeight) override;
 339
 340     Color getPixel(tools::Long nX, tools::Long nY) override;
 341
 342     void invert(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
 343                 SalInvert nFlags) override;
 344
 345     void invert(sal_uInt32 nPoints, const Point* pPtAry, SalInvert nFlags) override;
 346
 347     bool drawEPS(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
 348                  void* pPtr, sal_uInt32 nSize) override;
 349
 350     bool blendBitmap(const SalTwoRect&, const SalBitmap& rBitmap) override;
 351
 352     bool blendAlphaBitmap(const SalTwoRect&, const SalBitmap& rSrcBitmap,
 353                           const SalBitmap& rMaskBitmap, const SalBitmap& rAlphaBitmap) override;
 354
 355     bool drawAlphaBitmap(const SalTwoRect&, const SalBitmap& rSourceBitmap,
 356                          const SalBitmap& rAlphaBitmap) override;
 357
 358     bool drawTransformedBitmap(const basegfx::B2DPoint& rNull, const basegfx::B2DPoint& rX,
 359                                const basegfx::B2DPoint& rY, const SalBitmap& rSourceBitmap,
 360                                const SalBitmap* pAlphaBitmap, double fAlpha) override;
 361
 362     bool hasFastDrawTransformedBitmap() const override;
 363
 364     bool drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
 365                        sal_uInt8 nTransparency) override;
 366
 367     bool drawGradient(const tools::PolyPolygon& rPolygon, const Gradient& rGradient) override;
 368     bool implDrawGradient(basegfx::B2DPolyPolygon const& rPolyPolygon,
 369                           SalGradient const& rGradient) override;
 370
 371     virtual bool drawNativeControl(ControlType nType,
 372                                    ControlPart nPart,
 373                                    const tools::Rectangle &rControlRegion,
 374                                    ControlState nState,
 375                                    const ImplControlValue &aValue) override;
 376
 377     virtual void drawTextLayout(const GenericSalLayout& layout) override;
 378
 379     bool supportsOperation(OutDevSupportType eType) const override;
 380 };
 381
 382 class AquaSalGraphics : public SalGraphicsAutoDelegateToImpl
 383 {
 384     AquaSharedAttributes maShared;
 385     std::unique_ptr<AquaGraphicsBackendBase> mpBackend;
 386
 387     /// device resolution of this graphics
 388     sal_Int32                               mnRealDPIX;
 389     sal_Int32                               mnRealDPIY;
 390
 391     // Device Font settings
 392     rtl::Reference<CoreTextFont>            mpFont[MAX_FALLBACK];
 393
 394 public:
 395                             AquaSalGraphics(bool bPrinter = false);
 396     virtual                 ~AquaSalGraphics() override;
 397
 398     void                    SetVirDevGraphics(SalVirtualDevice* pVirDev,CGLayerHolder const &rLayer, CGContextRef, int nBitDepth = 0);
 399 #ifdef MACOSX
 400     void                    initResolution( NSWindow* );
 401     void                    copyResolution( AquaSalGraphics& );
 402     void                    updateResolution();
 403
 404     void                    SetWindowGraphics( AquaSalFrame* pFrame );
 405     bool                    IsWindowGraphics() const { return maShared.mbWindow; }
 406     void                    SetPrinterGraphics(CGContextRef, sal_Int32 nRealDPIX, sal_Int32 nRealDPIY);
 407     AquaSalFrame*           getGraphicsFrame() const { return maShared.mpFrame; }
 408     void                    setGraphicsFrame( AquaSalFrame* pFrame ) { maShared.mpFrame = pFrame; }
 409 #endif
 410
 411 #ifdef MACOSX
 412     void                    UpdateWindow( NSRect& ); // delivered in NSView coordinates
 413     void                    RefreshRect(const NSRect& rRect)
 414     {
 415         maShared.refreshRect(rRect.origin.x, rRect.origin.y, rRect.size.width, rRect.size.height);
 416     }
 417 #else
 418     void                    RefreshRect( const CGRect& ) {}
 419 #endif
 420
 421     void                    Flush();
 422     void                    Flush( const tools::Rectangle& );
 423     void                    WindowBackingPropertiesChanged();
 424
 425     void                    UnsetState();
 426     // InvalidateContext does an UnsetState and sets mrContext to 0
 427     void                    InvalidateContext();
 428
 429     AquaGraphicsBackendBase* getAquaGraphicsBackend() const
 430     {
 431         return mpBackend.get();
 432     }
 433
 434     virtual SalGraphicsImpl* GetImpl() const override;
 435
 436 #ifdef MACOSX
 437
 438 protected:
 439
 440     // native widget rendering methods that require mirroring
 441
 442     virtual bool            isNativeControlSupported( ControlType nType, ControlPart nPart ) override;
 443
 444     virtual bool            hitTestNativeControl( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion,
 445                                                   const Point& aPos, bool& rIsInside ) override;
 446     virtual bool            drawNativeControl( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion,
 447                                                ControlState nState, const ImplControlValue& aValue,
 448                                                const OUString& aCaption, const Color& rBackgroundColor ) override;
 449     virtual bool            getNativeControlRegion( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion, ControlState nState,
 450                                                     const ImplControlValue& aValue, const OUString& aCaption,
 451                                                     tools::Rectangle &rNativeBoundingRegion, tools::Rectangle &rNativeContentRegion ) override;
 452 #endif
 453
 454 public:
 455     // get device resolution
 456     virtual void            GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY ) override;
 457     // set the text color to a specific color
 458     virtual void            SetTextColor( Color nColor ) override;
 459     // set the font
 460     virtual void            SetFont( LogicalFontInstance*, int nFallbackLevel ) override;
 461     // get the current font's metrics
 462     virtual void            GetFontMetric( FontMetricDataRef&, int nFallbackLevel ) override;
 463     // get the repertoire of the current font
 464     virtual FontCharMapRef  GetFontCharMap() const override;
 465     virtual bool            GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const override;
 466     // graphics must fill supplied font list
 467     virtual void            GetDevFontList( vcl::font::PhysicalFontCollection* ) override;
 468     // graphics must drop any cached font info
 469     virtual void            ClearDevFontCache() override;
 470     virtual bool            AddTempDevFont( vcl::font::PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
 471
 472     virtual std::unique_ptr<GenericSalLayout>
 473                             GetTextLayout(int nFallbackLevel) override;
 474     virtual void            DrawTextLayout( const GenericSalLayout& ) override;
 475
 476     virtual SystemGraphicsData
 477                             GetGraphicsData() const override;
 478 };
 479
 480 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */