vcl/inc/win/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 <sallayout.hxx>
  25 #include <salgeom.hxx>
  26 #include <salgdi.hxx>
  27 #include <font/LogicalFontInstance.hxx>
  28 #include <fontattributes.hxx>
  29 #include <font/PhysicalFontFace.hxx>
  30 #include <impfont.hxx>
  31 #include <vcl/fontcapabilities.hxx>
  32 #include <vcl/fontcharmap.hxx>
  33 #include <systools/win32/comtools.hxx>
  34
  35 #include <memory>
  36 #include <unordered_set>
  37
  38 #ifndef INCLUDED_PRE_POST_WIN_H
  39 #define INCLUDED_PRE_POST_WIN_H
  40 #  include <prewin.h>
  41 #  include <postwin.h>
  42 #endif
  43
  44 #include <hb-ot.h>
  45 #include <dwrite.h>
  46
  47 namespace vcl::font
  48 {
  49 class PhysicalFontCollection;
  50 class FontSelectPattern;
  51 }
  52 class WinFontInstance;
  53 class ImplFontAttrCache;
  54 class SalGraphicsImpl;
  55 class WinSalGraphicsImplBase;
  56 class FontMetricData;
  57
  58 #define RGB_TO_PALRGB(nRGB)         ((nRGB)|0x02000000)
  59 #define PALRGB_TO_RGB(nPalRGB)      ((nPalRGB)&0x00ffffff)
  60
  61 // win32 specific physically available font face
  62 class WinFontFace final : public vcl::font::PhysicalFontFace
  63 {
  64 public:
  65     explicit                WinFontFace(const ENUMLOGFONTEXW&, const NEWTEXTMETRICW&);
  66                             ~WinFontFace() override;
  67
  68     rtl::Reference<LogicalFontInstance> CreateFontInstance( const vcl::font::FontSelectPattern& ) const override;
  69     sal_IntPtr              GetFontId() const override;
  70     void                    SetFontId( sal_IntPtr nId ) { mnId = nId; }
  71
  72     BYTE                    GetCharSet() const          { return meWinCharSet; }
  73     BYTE                    GetPitchAndFamily() const   { return mnPitchAndFamily; }
  74
  75     hb_blob_t*              GetHbTable(hb_tag_t nTag) const override;
  76
  77     const std::vector<hb_variation_t>& GetVariations(const LogicalFontInstance&) const override;
  78
  79 private:
  80     sal_IntPtr              mnId;
  81
  82     BYTE                    meWinCharSet;
  83     BYTE                    mnPitchAndFamily;
  84     LOGFONTW                maLogFont;
  85     mutable sal::systools::COMReference<IDWriteFontFace> mxDWFontFace;
  86 };
  87
  88 /** Class that creates (and destroys) a compatible Device Context.
  89
  90 This is to be used for GDI drawing into a DIB that we later use for a different
  91 drawing method, such as a texture for OpenGL drawing or surface for Skia drawing.
  92 */
  93 class CompatibleDC
  94 {
  95 protected:
  96     /// The compatible DC that we create for our purposes.
  97     HDC mhCompatibleDC;
  98
  99     /// DIBSection that we use for the GDI drawing, and later obtain.
 100     HBITMAP mhBitmap;
 101
 102     /// Return the previous bitmap to undo the SelectObject.
 103     HBITMAP mhOrigBitmap;
 104
 105     /// DIBSection data.
 106     sal_uInt32 *mpData;
 107
 108     /// Mapping between the GDI position and OpenGL, to use for OpenGL drawing.
 109     SalTwoRect maRects;
 110
 111     /// The SalGraphicsImpl where we will draw.  If null, we ignore the drawing, it means it happened directly to the DC...
 112     WinSalGraphicsImplBase *mpImpl;
 113
 114     // If 'disable' is true, this class is a simple wrapper for drawing directly. Subclasses should use true.
 115     CompatibleDC(SalGraphics &rGraphics, int x, int y, int width, int height, bool disable=true);
 116
 117 public:
 118     static std::unique_ptr< CompatibleDC > create(SalGraphics &rGraphics, int x, int y, int width, int height);
 119
 120     virtual ~CompatibleDC();
 121
 122     HDC getCompatibleHDC() { return mhCompatibleDC; }
 123
 124     SalTwoRect getTwoRect() const { return maRects; }
 125
 126     tools::Long getBitmapWidth() const { return maRects.mnSrcWidth; }
 127     tools::Long getBitmapHeight() const { return maRects.mnSrcHeight; }
 128
 129     /// Reset the DC with the defined color.
 130     void fill(sal_uInt32 color);
 131 };
 132
 133 /**
 134  * WinSalGraphics never owns the HDC it uses to draw, because the HDC can have
 135  * various origins with different ways to correctly free it. And WinSalGraphics
 136  * stores all default values (mhDef*) of the HDC, which must be restored when
 137  * the HDC changes (setHDC) or the SalGraphics is destructed. So think of the
 138  * HDC in terms of Rust's Borrowing semantics.
 139  */
 140 class WinSalGraphics : public SalGraphics
 141 {
 142     friend class WinSalGraphicsImpl;
 143     friend class ScopedFont;
 144
 145 protected:
 146     std::unique_ptr<SalGraphicsImpl> mpImpl;
 147     WinSalGraphicsImplBase * mWinSalGraphicsImplBase;
 148
 149 private:
 150     HDC                     mhLocalDC;              // HDC
 151     bool                    mbPrinter : 1;          // is Printer
 152     bool                    mbVirDev : 1;           // is VirDev
 153     bool                    mbWindow : 1;           // is Window
 154     bool                    mbScreen : 1;           // is Screen compatible
 155     HWND                    mhWnd;              // Window-Handle, when Window-Graphics
 156
 157     rtl::Reference<WinFontInstance>
 158                             mpWinFontEntry[ MAX_FALLBACK ]; // pointer to the most recent font instance
 159     HRGN                    mhRegion;           // vcl::Region Handle
 160     HPEN                    mhDefPen;           // DefaultPen
 161     HBRUSH                  mhDefBrush;         // DefaultBrush
 162     HFONT                   mhDefFont;          // DefaultFont
 163     HPALETTE                mhDefPal;           // DefaultPalette
 164     COLORREF                mnTextColor;        // TextColor
 165     RGNDATA*                mpClipRgnData;      // ClipRegion-Data
 166     RGNDATA*                mpStdClipRgnData;   // Cache Standard-ClipRegion-Data
 167     int                     mnPenWidth;         // line width
 168
 169     inline static sal::systools::COMReference<IDWriteFactory> mxDWriteFactory;
 170     inline static sal::systools::COMReference<IDWriteGdiInterop> mxDWriteGdiInterop;
 171     inline static bool bDWriteDone = false;
 172
 173     // just call both from setHDC!
 174     void InitGraphics();
 175     void DeInitGraphics();
 176
 177 public:
 178     // Return HFONT, and whether the font is for vertical writing ( prefixed with '@' )
 179     // and tmDescent value for adjusting offset in vertical writing mode.
 180     std::tuple<HFONT,bool,sal_Int32> ImplDoSetFont(HDC hDC, vcl::font::FontSelectPattern const & i_rFont, const vcl::font::PhysicalFontFace * i_pFontFace, HFONT& o_rOldFont);
 181
 182     HDC getHDC() const { return mhLocalDC; }
 183     // NOTE: this doesn't transfer ownership! See class comment.
 184     void setHDC(HDC aNew);
 185
 186     HPALETTE getDefPal() const;
 187     // returns the result from RealizePalette, otherwise 0 on success or GDI_ERROR
 188     UINT setPalette(HPALETTE, BOOL bForceBkgd = TRUE);
 189
 190     HRGN getRegion() const;
 191
 192
 193     enum Type
 194     {
 195         PRINTER,
 196         VIRTUAL_DEVICE,
 197         WINDOW,
 198         SCREEN
 199     };
 200
 201     static void getDWriteFactory(IDWriteFactory** pFactory, IDWriteGdiInterop** pInterop = nullptr);
 202
 203 public:
 204
 205     HWND gethWnd();
 206
 207
 208 public:
 209     explicit WinSalGraphics(WinSalGraphics::Type eType, bool bScreen, HWND hWnd,
 210                             SalGeometryProvider *pProvider);
 211     virtual ~WinSalGraphics() override;
 212
 213     SalGraphicsImpl* GetImpl() const override;
 214     WinSalGraphicsImplBase * getWinSalGraphicsImplBase() const { return mWinSalGraphicsImplBase; }
 215     bool isPrinter() const;
 216     bool isVirtualDevice() const;
 217     bool isWindow() const;
 218     bool isScreen() const;
 219
 220     void setHWND(HWND hWnd);
 221     void Flush();
 222
 223 protected:
 224     virtual void        setClipRegion( const vcl::Region& ) override;
 225     // draw --> LineColor and FillColor and RasterOp and ClipRegion
 226     virtual void        drawPixel( tools::Long nX, tools::Long nY ) override;
 227     virtual void        drawPixel( tools::Long nX, tools::Long nY, Color nColor ) override;
 228     virtual void        drawLine( tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2 ) override;
 229     virtual void        drawRect( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight ) override;
 230     virtual void        drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry ) override;
 231     virtual void        drawPolygon( sal_uInt32 nPoints, const Point* pPtAry ) override;
 232     virtual void        drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, const Point** pPtAry ) override;
 233     virtual void        drawPolyPolygon(
 234         const basegfx::B2DHomMatrix& rObjectToDevice,
 235         const basegfx::B2DPolyPolygon&,
 236         double fTransparency) override;
 237     virtual bool        drawPolyLine(
 238         const basegfx::B2DHomMatrix& rObjectToDevice,
 239         const basegfx::B2DPolygon&,
 240         double fTransparency,
 241         double fLineWidth,
 242         const std::vector< double >* pStroke, // MM01
 243         basegfx::B2DLineJoin,
 244         css::drawing::LineCap,
 245         double fMiterMinimumAngle,
 246         bool bPixelSnapHairline) override;
 247     virtual bool        drawPolyLineBezier( sal_uInt32 nPoints, const Point* pPtAry, const PolyFlags* pFlgAry ) override;
 248     virtual bool        drawPolygonBezier( sal_uInt32 nPoints, const Point* pPtAry, const PolyFlags* pFlgAry ) override;
 249     virtual bool        drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints, const Point* const* pPtAry, const PolyFlags* const* pFlgAry ) override;
 250     virtual bool        drawGradient( const tools::PolyPolygon&, const Gradient& ) override;
 251     virtual bool        implDrawGradient(basegfx::B2DPolyPolygon const & rPolyPolygon, SalGradient const & rGradient) override;
 252
 253     // CopyArea --> No RasterOp, but ClipRegion
 254     virtual void        copyArea( tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX, tools::Long nSrcY, tools::Long nSrcWidth,
 255                                   tools::Long nSrcHeight, bool bWindowInvalidate ) override;
 256
 257     // CopyBits and DrawBitmap --> RasterOp and ClipRegion
 258     // CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics
 259     virtual void        copyBits( const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics ) override;
 260     virtual void        drawBitmap( const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap ) override;
 261     virtual void        drawBitmap( const SalTwoRect& rPosAry,
 262                                     const SalBitmap& rSalBitmap,
 263                                     const SalBitmap& rTransparentBitmap ) override;
 264     virtual void        drawMask( const SalTwoRect& rPosAry,
 265                                   const SalBitmap& rSalBitmap,
 266                                   Color nMaskColor ) override;
 267
 268     virtual std::shared_ptr<SalBitmap> getBitmap( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight ) override;
 269     virtual Color       getPixel( tools::Long nX, tools::Long nY ) override;
 270
 271     // invert --> ClipRegion (only Windows or VirDevs)
 272     virtual void        invert( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, SalInvert nFlags) override;
 273     virtual void        invert( sal_uInt32 nPoints, const Point* pPtAry, SalInvert nFlags ) override;
 274
 275     virtual bool        drawEPS( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, void* pPtr, sal_uInt32 nSize ) override;
 276
 277     // native widget rendering methods that require mirroring
 278 protected:
 279     virtual bool        isNativeControlSupported( ControlType nType, ControlPart nPart ) override;
 280     virtual bool        hitTestNativeControl( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion,
 281                                               const Point& aPos, bool& rIsInside ) override;
 282     virtual bool        drawNativeControl( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion,
 283                                            ControlState nState, const ImplControlValue& aValue,
 284                                            const OUString& aCaption, const Color& rBackgroundColor ) override;
 285     virtual bool        getNativeControlRegion( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion, ControlState nState,
 286                                                 const ImplControlValue& aValue, const OUString& aCaption,
 287                                                 tools::Rectangle &rNativeBoundingRegion, tools::Rectangle &rNativeContentRegion ) override;
 288
 289 public:
 290     virtual bool        blendBitmap( const SalTwoRect&,
 291                                      const SalBitmap& rBitmap ) override;
 292
 293     virtual bool        blendAlphaBitmap( const SalTwoRect&,
 294                                           const SalBitmap& rSrcBitmap,
 295                                           const SalBitmap& rMaskBitmap,
 296                                           const SalBitmap& rAlphaBitmap ) override;
 297
 298     virtual bool        drawAlphaBitmap( const SalTwoRect&,
 299                                          const SalBitmap& rSourceBitmap,
 300                                          const SalBitmap& rAlphaBitmap ) override;
 301     virtual bool       drawTransformedBitmap(
 302                            const basegfx::B2DPoint& rNull,
 303                            const basegfx::B2DPoint& rX,
 304                            const basegfx::B2DPoint& rY,
 305                            const SalBitmap& rSourceBitmap,
 306                            const SalBitmap* pAlphaBitmap,
 307                            double fAlpha) override;
 308
 309     virtual bool       hasFastDrawTransformedBitmap() const override;
 310
 311     virtual bool       drawAlphaRect( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, sal_uInt8 nTransparency ) override;
 312
 313 private:
 314     // local helpers
 315
 316     void DrawTextLayout(const GenericSalLayout&, HDC, bool bUseDWrite, bool bRenderingModeNatural);
 317
 318 public:
 319     // public SalGraphics methods, the interface to the independent vcl part
 320
 321     // get device resolution
 322     virtual void            GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY ) override;
 323     // get the depth of the device
 324     virtual sal_uInt16          GetBitCount() const override;
 325     // get the width of the device
 326     virtual tools::Long            GetGraphicsWidth() const override;
 327
 328     // set the clip region to empty
 329     virtual void            ResetClipRegion() override;
 330
 331     // set the line color to transparent (= don't draw lines)
 332     virtual void            SetLineColor() override;
 333     // set the line color to a specific color
 334     virtual void            SetLineColor( Color nColor ) override;
 335     // set the fill color to transparent (= don't fill)
 336     virtual void            SetFillColor() override;
 337     // set the fill color to a specific color, shapes will be
 338     // filled accordingly
 339     virtual void            SetFillColor( Color nColor ) override;
 340     // enable/disable XOR drawing
 341     virtual void            SetXORMode( bool bSet, bool ) override;
 342     // set line color for raster operations
 343     virtual void            SetROPLineColor( SalROPColor nROPColor ) override;
 344     // set fill color for raster operations
 345     virtual void            SetROPFillColor( SalROPColor nROPColor ) override;
 346     // set the text color to a specific color
 347     virtual void            SetTextColor( Color nColor ) override;
 348     // set the font
 349     virtual void            SetFont( LogicalFontInstance*, int nFallbackLevel ) override;
 350     // get the current font's metrics
 351     virtual void            GetFontMetric( FontMetricDataRef&, int nFallbackLevel ) override;
 352     // get the repertoire of the current font
 353     virtual FontCharMapRef  GetFontCharMap() const override;
 354     // get the layout capabilities of the current font
 355     virtual bool GetFontCapabilities(vcl::FontCapabilities &rGetFontCapabilities) const override;
 356     // graphics must fill supplied font list
 357     virtual void            GetDevFontList( vcl::font::PhysicalFontCollection* ) override;
 358     // graphics must drop any cached font info
 359     virtual void            ClearDevFontCache() override;
 360     virtual bool            AddTempDevFont( vcl::font::PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
 361
 362     virtual std::unique_ptr<GenericSalLayout>
 363                             GetTextLayout(int nFallbackLevel) override;
 364     virtual void            DrawTextLayout( const GenericSalLayout& ) override;
 365
 366     virtual bool            supportsOperation( OutDevSupportType ) const override;
 367
 368     virtual SystemGraphicsData GetGraphicsData() const override;
 369
 370     /// Update settings based on the platform values
 371     static void updateSettingsNative( AllSettings& rSettings );
 372 };
 373
 374 // Init/Deinit Graphics
 375 void    ImplUpdateSysColorEntries();
 376 int     ImplIsSysColorEntry( Color nColor );
 377 void    ImplGetLogFontFromFontSelect( const vcl::font::FontSelectPattern&,
 378             const vcl::font::PhysicalFontFace*, LOGFONTW& );
 379
 380 #define MAX_64KSALPOINTS    ((((sal_uInt16)0xFFFF)-8)/sizeof(POINTS))
 381
 382 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */