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 #ifndef INCLUDED_VCL_INC_WIN_SALGDI_H
  21 #define INCLUDED_VCL_INC_WIN_SALGDI_H
  22
  23 #include <sallayout.hxx>
  24 #include <salgeom.hxx>
  25 #include <salgdi.hxx>
  26 #include <fontinstance.hxx>
  27 #include <fontattributes.hxx>
  28 #include <PhysicalFontFace.hxx>
  29 #include <impfont.hxx>
  30 #include <vcl/fontcapabilities.hxx>
  31 #include <vcl/fontcharmap.hxx>
  32
  33 #include <memory>
  34 #include <unordered_set>
  35
  36 #ifndef INCLUDED_PRE_POST_WIN_H
  37 #define INCLUDED_PRE_POST_WIN_H
  38 #  include <prewin.h>
  39 #  include <postwin.h>
  40 #endif
  41
  42 #include <hb-ot.h>
  43 #include <dwrite.h>
  44
  45 class FontSelectPattern;
  46 class WinFontInstance;
  47 class ImplFontAttrCache;
  48 class PhysicalFontCollection;
  49 class SalGraphicsImpl;
  50 class WinSalGraphicsImplBase;
  51 class ImplFontMetricData;
  52
  53 #define RGB_TO_PALRGB(nRGB)         ((nRGB)|0x02000000)
  54 #define PALRGB_TO_RGB(nPalRGB)      ((nPalRGB)&0x00ffffff)
  55
  56 // win32 specific physically available font face
  57 class WinFontFace : public PhysicalFontFace
  58 {
  59 public:
  60     explicit                WinFontFace( const FontAttributes&,
  61                                 BYTE eWinCharSet,
  62                                 BYTE nPitchAndFamily  );
  63     virtual                 ~WinFontFace() override;
  64
  65     virtual rtl::Reference<LogicalFontInstance> CreateFontInstance( const FontSelectPattern& ) const override;
  66     virtual sal_IntPtr      GetFontId() const override;
  67     void                    SetFontId( sal_IntPtr nId ) { mnId = nId; }
  68     void                    UpdateFromHDC( HDC ) const;
  69
  70     bool                    HasChar( sal_uInt32 cChar ) const;
  71
  72     BYTE                    GetCharSet() const          { return meWinCharSet; }
  73     BYTE                    GetPitchAndFamily() const   { return mnPitchAndFamily; }
  74
  75     FontCharMapRef GetFontCharMap() const override;
  76     bool GetFontCapabilities(vcl::FontCapabilities&) const override;
  77
  78 private:
  79     sal_IntPtr              mnId;
  80
  81     // some members that are initialized lazily when the font gets selected into a HDC
  82     mutable bool                    mbFontCapabilitiesRead;
  83     mutable FontCharMapRef          mxUnicodeMap;
  84     mutable vcl::FontCapabilities   maFontCapabilities;
  85
  86     BYTE                    meWinCharSet;
  87     BYTE                    mnPitchAndFamily;
  88     bool                    mbAliasSymbolsHigh;
  89     bool                    mbAliasSymbolsLow;
  90
  91     void                    ReadCmapTable( HDC ) const;
  92     void                    GetFontCapabilities( HDC hDC ) const;
  93 };
  94
  95 /** Class that creates (and destroys) a compatible Device Context.
  96
  97 This is to be used for GDI drawing into a DIB that we later use for a different
  98 drawing method, such as a texture for OpenGL drawing or surface for Skia drawing.
  99 */
 100 class CompatibleDC
 101 {
 102 protected:
 103     /// The compatible DC that we create for our purposes.
 104     HDC mhCompatibleDC;
 105
 106     /// DIBSection that we use for the GDI drawing, and later obtain.
 107     HBITMAP mhBitmap;
 108
 109     /// Return the previous bitmap to undo the SelectObject.
 110     HBITMAP mhOrigBitmap;
 111
 112     /// DIBSection data.
 113     sal_uInt32 *mpData;
 114
 115     /// Mapping between the GDI position and OpenGL, to use for OpenGL drawing.
 116     SalTwoRect maRects;
 117
 118     /// The SalGraphicsImpl where we will draw.  If null, we ignore the drawing, it means it happened directly to the DC...
 119     WinSalGraphicsImplBase *mpImpl;
 120
 121     // If 'disable' is true, this class is a simple wrapper for drawing directly. Subclasses should use true.
 122     CompatibleDC(SalGraphics &rGraphics, int x, int y, int width, int height, bool disable=true);
 123
 124 public:
 125     static std::unique_ptr< CompatibleDC > create(SalGraphics &rGraphics, int x, int y, int width, int height);
 126
 127     virtual ~CompatibleDC();
 128
 129     HDC getCompatibleHDC() { return mhCompatibleDC; }
 130
 131     SalTwoRect getTwoRect() const { return maRects; }
 132
 133     tools::Long getBitmapWidth() const { return maRects.mnSrcWidth; }
 134     tools::Long getBitmapHeight() const { return maRects.mnSrcHeight; }
 135
 136     /// Reset the DC with the defined color.
 137     void fill(sal_uInt32 color);
 138 };
 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
 148 private:
 149     HDC                     mhLocalDC;              // HDC
 150     bool                    mbPrinter : 1;          // is Printer
 151     bool                    mbVirDev : 1;           // is VirDev
 152     bool                    mbWindow : 1;           // is Window
 153     bool                    mbScreen : 1;           // is Screen compatible
 154     HWND                    mhWnd;              // Window-Handle, when Window-Graphics
 155
 156     rtl::Reference<WinFontInstance>
 157                             mpWinFontEntry[ MAX_FALLBACK ]; // pointer to the most recent font instance
 158     HRGN                    mhRegion;           // vcl::Region Handle
 159     HPEN                    mhDefPen;           // DefaultPen
 160     HBRUSH                  mhDefBrush;         // DefaultBrush
 161     HFONT                   mhDefFont;          // DefaultFont
 162     HPALETTE                mhDefPal;           // DefaultPalette
 163     COLORREF                mnTextColor;        // TextColor
 164     RGNDATA*                mpClipRgnData;      // ClipRegion-Data
 165     RGNDATA*                mpStdClipRgnData;   // Cache Standard-ClipRegion-Data
 166     int                     mnPenWidth;         // line width
 167
 168 public:
 169     // Return HFONT, and whether the font is for vertical writing ( prefixed with '@' )
 170     // and tmDescent value for adjusting offset in vertical writing mode.
 171     std::tuple<HFONT,bool,sal_Int32> ImplDoSetFont(FontSelectPattern const & i_rFont, const PhysicalFontFace * i_pFontFace, HFONT& o_rOldFont);
 172
 173     HDC getHDC() const { return mhLocalDC; }
 174     void setHDC(HDC aNew) { mhLocalDC = aNew; }
 175
 176     HPALETTE getDefPal() const;
 177     void setDefPal(HPALETTE hDefPal);
 178
 179     HRGN getRegion() const;
 180
 181     void InitGraphics();
 182     void DeInitGraphics();
 183
 184     enum Type
 185     {
 186         PRINTER,
 187         VIRTUAL_DEVICE,
 188         WINDOW,
 189         SCREEN
 190     };
 191
 192 public:
 193
 194     HWND gethWnd();
 195
 196
 197 public:
 198     explicit WinSalGraphics(WinSalGraphics::Type eType, bool bScreen, HWND hWnd,
 199                             SalGeometryProvider *pProvider);
 200     virtual ~WinSalGraphics() override;
 201
 202     SalGraphicsImpl* GetImpl() const override;
 203     bool isPrinter() const;
 204     bool isVirtualDevice() const;
 205     bool isWindow() const;
 206     bool isScreen() const;
 207
 208     void setHWND(HWND hWnd);
 209     void Flush();
 210
 211 protected:
 212     virtual bool        setClipRegion( const vcl::Region& ) override;
 213     // draw --> LineColor and FillColor and RasterOp and ClipRegion
 214     virtual void        drawPixel( tools::Long nX, tools::Long nY ) override;
 215     virtual void        drawPixel( tools::Long nX, tools::Long nY, Color nColor ) override;
 216     virtual void        drawLine( tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2 ) override;
 217     virtual void        drawRect( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight ) override;
 218     virtual void        drawPolyLine( sal_uInt32 nPoints, const Point* pPtAry ) override;
 219     virtual void        drawPolygon( sal_uInt32 nPoints, const Point* pPtAry ) override;
 220     virtual void        drawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, const Point** pPtAry ) override;
 221     virtual bool        drawPolyPolygon(
 222         const basegfx::B2DHomMatrix& rObjectToDevice,
 223         const basegfx::B2DPolyPolygon&,
 224         double fTransparency) override;
 225     virtual bool        drawPolyLine(
 226         const basegfx::B2DHomMatrix& rObjectToDevice,
 227         const basegfx::B2DPolygon&,
 228         double fTransparency,
 229         double fLineWidth,
 230         const std::vector< double >* pStroke, // MM01
 231         basegfx::B2DLineJoin,
 232         css::drawing::LineCap,
 233         double fMiterMinimumAngle,
 234         bool bPixelSnapHairline) override;
 235     virtual bool        drawPolyLineBezier( sal_uInt32 nPoints, const Point* pPtAry, const PolyFlags* pFlgAry ) override;
 236     virtual bool        drawPolygonBezier( sal_uInt32 nPoints, const Point* pPtAry, const PolyFlags* pFlgAry ) override;
 237     virtual bool        drawPolyPolygonBezier( sal_uInt32 nPoly, const sal_uInt32* pPoints, const Point* const* pPtAry, const PolyFlags* const* pFlgAry ) override;
 238     virtual bool        drawGradient( const tools::PolyPolygon&, const Gradient& ) override;
 239     virtual bool        implDrawGradient(basegfx::B2DPolyPolygon const & rPolyPolygon, SalGradient const & rGradient) override;
 240
 241     // CopyArea --> No RasterOp, but ClipRegion
 242     virtual void        copyArea( tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX, tools::Long nSrcY, tools::Long nSrcWidth,
 243                                   tools::Long nSrcHeight, bool bWindowInvalidate ) override;
 244
 245     // CopyBits and DrawBitmap --> RasterOp and ClipRegion
 246     // CopyBits() --> pSrcGraphics == NULL, then CopyBits on same Graphics
 247     virtual void        copyBits( const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics ) override;
 248     virtual void        drawBitmap( const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap ) override;
 249     virtual void        drawBitmap( const SalTwoRect& rPosAry,
 250                                     const SalBitmap& rSalBitmap,
 251                                     const SalBitmap& rTransparentBitmap ) override;
 252     virtual void        drawMask( const SalTwoRect& rPosAry,
 253                                   const SalBitmap& rSalBitmap,
 254                                   Color nMaskColor ) override;
 255
 256     virtual std::shared_ptr<SalBitmap> getBitmap( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight ) override;
 257     virtual Color       getPixel( tools::Long nX, tools::Long nY ) override;
 258
 259     // invert --> ClipRegion (only Windows or VirDevs)
 260     virtual void        invert( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, SalInvert nFlags) override;
 261     virtual void        invert( sal_uInt32 nPoints, const Point* pPtAry, SalInvert nFlags ) override;
 262
 263     virtual bool        drawEPS( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, void* pPtr, sal_uInt32 nSize ) override;
 264
 265     // native widget rendering methods that require mirroring
 266 protected:
 267     virtual bool        isNativeControlSupported( ControlType nType, ControlPart nPart ) override;
 268     virtual bool        hitTestNativeControl( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion,
 269                                               const Point& aPos, bool& rIsInside ) override;
 270     virtual bool        drawNativeControl( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion,
 271                                            ControlState nState, const ImplControlValue& aValue,
 272                                            const OUString& aCaption, const Color& rBackgroundColor ) override;
 273     virtual bool        getNativeControlRegion( ControlType nType, ControlPart nPart, const tools::Rectangle& rControlRegion, ControlState nState,
 274                                                 const ImplControlValue& aValue, const OUString& aCaption,
 275                                                 tools::Rectangle &rNativeBoundingRegion, tools::Rectangle &rNativeContentRegion ) override;
 276
 277 public:
 278     virtual bool        blendBitmap( const SalTwoRect&,
 279                                      const SalBitmap& rBitmap ) override;
 280
 281     virtual bool        blendAlphaBitmap( const SalTwoRect&,
 282                                           const SalBitmap& rSrcBitmap,
 283                                           const SalBitmap& rMaskBitmap,
 284                                           const SalBitmap& rAlphaBitmap ) override;
 285
 286     virtual bool        drawAlphaBitmap( const SalTwoRect&,
 287                                          const SalBitmap& rSourceBitmap,
 288                                          const SalBitmap& rAlphaBitmap ) override;
 289     virtual bool       drawTransformedBitmap(
 290                            const basegfx::B2DPoint& rNull,
 291                            const basegfx::B2DPoint& rX,
 292                            const basegfx::B2DPoint& rY,
 293                            const SalBitmap& rSourceBitmap,
 294                            const SalBitmap* pAlphaBitmap,
 295                            double fAlpha) override;
 296
 297     virtual bool       hasFastDrawTransformedBitmap() const override;
 298
 299     virtual bool       drawAlphaRect( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, sal_uInt8 nTransparency ) override;
 300
 301 private:
 302     // local helpers
 303
 304     void                    DrawTextLayout(const GenericSalLayout&, HDC, bool bUseDWrite);
 305
 306 public:
 307     // public SalGraphics methods, the interface to the independent vcl part
 308
 309     // get device resolution
 310     virtual void            GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY ) override;
 311     // get the depth of the device
 312     virtual sal_uInt16          GetBitCount() const override;
 313     // get the width of the device
 314     virtual tools::Long            GetGraphicsWidth() const override;
 315
 316     // set the clip region to empty
 317     virtual void            ResetClipRegion() override;
 318
 319     // set the line color to transparent (= don't draw lines)
 320     virtual void            SetLineColor() override;
 321     // set the line color to a specific color
 322     virtual void            SetLineColor( Color nColor ) override;
 323     // set the fill color to transparent (= don't fill)
 324     virtual void            SetFillColor() override;
 325     // set the fill color to a specific color, shapes will be
 326     // filled accordingly
 327     virtual void            SetFillColor( Color nColor ) override;
 328     // enable/disable XOR drawing
 329     virtual void            SetXORMode( bool bSet, bool ) override;
 330     // set line color for raster operations
 331     virtual void            SetROPLineColor( SalROPColor nROPColor ) override;
 332     // set fill color for raster operations
 333     virtual void            SetROPFillColor( SalROPColor nROPColor ) override;
 334     // set the text color to a specific color
 335     virtual void            SetTextColor( Color nColor ) override;
 336     // set the font
 337     virtual void            SetFont( LogicalFontInstance*, int nFallbackLevel ) override;
 338     // get the current font's metrics
 339     virtual void            GetFontMetric( ImplFontMetricDataRef&, int nFallbackLevel ) override;
 340     // get the repertoire of the current font
 341     virtual FontCharMapRef  GetFontCharMap() const override;
 342     // get the layout capabilities of the current font
 343     virtual bool GetFontCapabilities(vcl::FontCapabilities &rGetFontCapabilities) const override;
 344     // graphics must fill supplied font list
 345     virtual void            GetDevFontList( PhysicalFontCollection* ) override;
 346     // graphics must drop any cached font info
 347     virtual void            ClearDevFontCache() override;
 348     virtual bool            AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
 349     // CreateFontSubset: a method to get a subset of glyhps of a font
 350     // inside a new valid font file
 351     // returns TRUE if creation of subset was successful
 352     // parameters: rToFile: contains an osl file URL to write the subset to
 353     //             pFont: describes from which font to create a subset
 354     //             pGlyphIDs: the glyph ids to be extracted
 355     //             pEncoding: the character code corresponding to each glyph
 356     //             pWidths: the advance widths of the corresponding glyphs (in PS font units)
 357     //             nGlyphs: the number of glyphs
 358     //             rInfo: additional outgoing information
 359     // implementation note: encoding 0 with glyph id 0 should be added implicitly
 360     // as "undefined character"
 361     virtual bool            CreateFontSubset( const OUString& rToFile,
 362                                               const PhysicalFontFace*,
 363                                               const sal_GlyphId* pGlyphIDs,
 364                                               const sal_uInt8* pEncoding,
 365                                               sal_Int32* pWidths,
 366                                               int nGlyphs,
 367                                               FontSubsetInfo& rInfo // out parameter
 368                                               ) override;
 369
 370     // GetEmbedFontData: gets the font data for a font marked
 371     // embeddable by GetDevFontList or NULL in case of error
 372     // parameters: pFont: describes the font in question
 373     //             pDataLen: out parameter, contains the byte length of the returned buffer
 374     virtual const void* GetEmbedFontData(const PhysicalFontFace*, tools::Long* pDataLen) override;
 375     // frees the font data again
 376     virtual void            FreeEmbedFontData( const void* pData, tools::Long nDataLen ) override;
 377     virtual void            GetGlyphWidths( const PhysicalFontFace*,
 378                                             bool bVertical,
 379                                             std::vector< sal_Int32 >& rWidths,
 380                                             Ucs2UIntMap& rUnicodeEnc ) override;
 381
 382     virtual std::unique_ptr<GenericSalLayout>
 383                             GetTextLayout(int nFallbackLevel) override;
 384     virtual void            DrawTextLayout( const GenericSalLayout& ) override;
 385
 386     virtual bool            supportsOperation( OutDevSupportType ) const override;
 387
 388     virtual SystemGraphicsData GetGraphicsData() const override;
 389
 390     /// Update settings based on the platform values
 391     static void updateSettingsNative( AllSettings& rSettings );
 392 };
 393
 394 // Init/Deinit Graphics
 395 void    ImplUpdateSysColorEntries();
 396 int     ImplIsSysColorEntry( Color nColor );
 397 void    ImplGetLogFontFromFontSelect( const FontSelectPattern&,
 398             const PhysicalFontFace*, LOGFONTW& );
 399
 400 #define MAX_64KSALPOINTS    ((((sal_uInt16)0xFFFF)-8)/sizeof(POINTS))
 401
 402 // called extremely often from just one spot => inline
 403 inline bool WinFontFace::HasChar( sal_uInt32 cChar ) const
 404 {
 405     if( mxUnicodeMap->HasChar( cChar ) )
 406         return true;
 407     // second chance to allow symbol aliasing
 408     if( mbAliasSymbolsLow && ((cChar-0xF000) <= 0xFF) )
 409         cChar -= 0xF000;
 410     else if( mbAliasSymbolsHigh && (cChar <= 0xFF) )
 411         cChar += 0xF000;
 412     else
 413         return false;
 414     return mxUnicodeMap->HasChar( cChar );
 415 }
 416
 417 #endif // INCLUDED_VCL_INC_WIN_SALGDI_H
 418
 419 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */