vcl/inc/unx/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_UNX_SALGDI_H
  21 #define INCLUDED_VCL_INC_UNX_SALGDI_H
  22
  23 #include <X11/Xlib.h>
  24 #include <X11/Xutil.h>
  25 #include <X11/extensions/Xrender.h>
  26
  27 #include <tools/fract.hxx>
  28
  29 #include <vcl/salgtype.hxx>
  30 #include <vcl/vclenum.hxx>
  31 #include <vcl/metric.hxx>
  32
  33 #include "salgdi.hxx"
  34 #include "salgeom.hxx"
  35 #include "sallayout.hxx"
  36 #include "vclpluginapi.h"
  37
  38 #include <deque>
  39 #include <memory>
  40
  41 /* From <X11/Intrinsic.h> */
  42 typedef unsigned long Pixel;
  43
  44 class FontAttributes;
  45 class FontSelectPattern;
  46 class SalBitmap;
  47 class SalColormap;
  48 class SalDisplay;
  49 class SalFrame;
  50 class X11Pixmap;
  51 class X11SalVirtualDevice;
  52 class X11SalGraphicsImpl;
  53 class X11OpenGLSalGraphicsImpl;
  54 class X11OpenGLSalVirtualDevice;
  55 class ServerFont;
  56 class ImplLayoutArgs;
  57 class ServerFontLayout;
  58 class PhysicalFontCollection;
  59 class PhysicalFontFace;
  60 class SalGraphicsImpl;
  61 class TextRenderImpl;
  62
  63 namespace basegfx {
  64     class B2DTrapezoid;
  65 }
  66
  67 class VCLPLUG_GEN_PUBLIC X11SalGraphics : public SalGraphics
  68 {
  69     friend class ServerFontLayout;
  70     friend class X11SalGraphicsImpl;
  71     friend class X11OpenGLSalGraphicsImpl;
  72     friend class X11CairoTextRender;
  73
  74 public:
  75                                     X11SalGraphics();
  76     virtual                         ~X11SalGraphics();
  77
  78     void                            Init( SalFrame *pFrame, Drawable aDrawable, SalX11Screen nXScreen );
  79     void                            Init( X11SalVirtualDevice *pVirtualDevice, SalColormap* pColormap = NULL, bool bDeleteColormap = false );
  80     void                            Init( X11OpenGLSalVirtualDevice *pVirtualDevice );
  81     void                            DeInit();
  82
  83     virtual SalGraphicsImpl*        GetImpl() const override;
  84     inline  const SalDisplay*       GetDisplay() const;
  85     inline  Display*                GetXDisplay() const;
  86     inline  const SalVisual&        GetVisual() const;
  87     SalGeometryProvider*            GetGeometryProvider() const;
  88     inline  Drawable                GetDrawable() const { return hDrawable_; }
  89     void                            SetDrawable( Drawable d, SalX11Screen nXScreen );
  90     XRenderPictFormat*              GetXRenderFormat() const;
  91     inline  void                    SetXRenderFormat( XRenderPictFormat* pXRenderFormat ) { m_pXRenderFormat = pXRenderFormat; }
  92     inline  const SalColormap&      GetColormap() const { return *m_pColormap; }
  93
  94     using SalGraphics::GetPixel;
  95     inline  Pixel                   GetPixel( SalColor nSalColor ) const;
  96
  97     const SalX11Screen&             GetScreenNumber() const { return m_nXScreen; }
  98
  99     // override all pure virtual methods
 100     virtual void                    GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY ) override;
 101     virtual sal_uInt16              GetBitCount() const override;
 102     virtual long                    GetGraphicsWidth() const override;
 103
 104     virtual void                    ResetClipRegion() override;
 105     virtual bool                    setClipRegion( const vcl::Region& ) override;
 106
 107     virtual void                    SetLineColor() override;
 108     virtual void                    SetLineColor( SalColor nSalColor ) override;
 109     virtual void                    SetFillColor() override;
 110
 111     virtual void                    SetFillColor( SalColor nSalColor ) override;
 112
 113     virtual void                    SetXORMode( bool bSet, bool ) override;
 114
 115     virtual void                    SetROPLineColor( SalROPColor nROPColor ) override;
 116     virtual void                    SetROPFillColor( SalROPColor nROPColor ) override;
 117
 118     virtual void                    SetTextColor( SalColor nSalColor ) override;
 119     virtual void                    SetFont( FontSelectPattern*, int nFallbackLevel ) override;
 120     virtual void                    GetFontMetric( ImplFontMetricDataPtr&, int nFallbackLevel ) override;
 121     virtual const FontCharMapPtr    GetFontCharMap() const override;
 122     virtual bool                    GetFontCapabilities(vcl::FontCapabilities &rFontCapabilities) const override;
 123     virtual void                    GetDevFontList( PhysicalFontCollection* ) override;
 124     virtual void                    ClearDevFontCache() override;
 125     virtual bool                    AddTempDevFont( PhysicalFontCollection*, const OUString& rFileURL, const OUString& rFontName ) override;
 126
 127     virtual bool                    CreateFontSubset(
 128                                         const OUString& rToFile,
 129                                         const PhysicalFontFace*,
 130                                         const sal_GlyphId* pGlyphIDs,
 131                                         const sal_uInt8* pEncoding,
 132                                         sal_Int32* pWidths,
 133                                         int nGlyphs,
 134                                         FontSubsetInfo& rInfo ) override;
 135
 136     virtual const Ucs2SIntMap*      GetFontEncodingVector( const PhysicalFontFace*, const Ucs2OStrMap** ppNonEncoded, std::set<sal_Unicode> const**) override;
 137
 138     virtual const void*             GetEmbedFontData(
 139                                         const PhysicalFontFace*,
 140                                         const sal_Ucs* pUnicodes,
 141                                         sal_Int32* pWidths,
 142                                         size_t nLen,
 143                                         FontSubsetInfo& rInfo,
 144                                         long* pDataLen ) override;
 145
 146     virtual void                    FreeEmbedFontData( const void* pData, long nDataLen ) override;
 147
 148     virtual void                    GetGlyphWidths(
 149                                         const PhysicalFontFace*,
 150                                         bool bVertical,
 151                                         Int32Vector& rWidths,
 152                                         Ucs2UIntMap& rUnicodeEnc ) override;
 153
 154     virtual bool                    GetGlyphBoundRect( sal_GlyphId nIndex, Rectangle& ) override;
 155     virtual bool                    GetGlyphOutline( sal_GlyphId nIndex, basegfx::B2DPolyPolygon& ) override;
 156     virtual SalLayout*              GetTextLayout( ImplLayoutArgs&, int nFallbackLevel ) override;
 157     virtual void                    DrawServerFontLayout( const ServerFontLayout& ) override;
 158
 159     virtual bool                    supportsOperation( OutDevSupportType ) const override;
 160     virtual void                    drawPixel( long nX, long nY ) override;
 161     virtual void                    drawPixel( long nX, long nY, SalColor nSalColor ) override;
 162     virtual void                    drawLine( long nX1, long nY1, long nX2, long nY2 ) override;
 163     virtual void                    drawRect( long nX, long nY, long nWidth, long nHeight ) override;
 164     virtual void                    drawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 165     virtual void                    drawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) override;
 166
 167     virtual void                    drawPolyPolygon(
 168                                         sal_uInt32 nPoly,
 169                                         const sal_uInt32* pPoints,
 170                                         PCONSTSALPOINT* pPtAry ) override;
 171
 172     virtual bool                    drawPolyPolygon( const basegfx::B2DPolyPolygon&, double fTransparency ) override;
 173
 174     virtual bool                    drawPolyLine(
 175                                         const basegfx::B2DPolygon&,
 176                                         double fTransparency,
 177                                         const basegfx::B2DVector& rLineWidth,
 178                                         basegfx::B2DLineJoin,
 179                                         css::drawing::LineCap,
 180                                         double fMiterMinimumAngle) override;
 181
 182     virtual bool                    drawGradient( const tools::PolyPolygon&, const Gradient& ) override;
 183
 184 #if 1 // TODO: remove these obsolete methods
 185     virtual bool                    drawPolyLineBezier(
 186                                         sal_uInt32 nPoints,
 187                                         const SalPoint* pPtAry,
 188                                         const sal_uInt8* pFlgAry ) override;
 189
 190     virtual bool                    drawPolygonBezier(
 191                                         sal_uInt32 nPoints,
 192                                         const SalPoint* pPtAry,
 193                                         const sal_uInt8* pFlgAry ) override;
 194
 195     virtual bool                    drawPolyPolygonBezier(
 196                                         sal_uInt32 nPoly,
 197                                         const sal_uInt32* pPoints,
 198                                         const SalPoint* const* pPtAry,
 199                                         const sal_uInt8* const* pFlgAry ) override;
 200 #endif
 201
 202     virtual void                    copyArea(
 203                                         long nDestX,
 204                                         long nDestY,
 205                                         long nSrcX,
 206                                         long nSrcY,
 207                                         long nSrcWidth,
 208                                         long nSrcHeight,
 209                                         bool bWindowInvalidate ) override;
 210
 211     virtual void                    copyBits(
 212                                         const SalTwoRect& rPosAry,
 213                                         SalGraphics* pSrcGraphics ) override;
 214
 215     virtual void                    drawBitmap(
 216                                         const SalTwoRect& rPosAry,
 217                                         const SalBitmap& rSalBitmap ) override;
 218
 219     virtual void                    drawBitmap(
 220                                         const SalTwoRect& rPosAry,
 221                                         const SalBitmap& rSalBitmap,
 222                                         const SalBitmap& rMaskBitmap ) override;
 223
 224     virtual void                    drawMask(
 225                                         const SalTwoRect& rPosAry,
 226                                         const SalBitmap& rSalBitmap,
 227                                         SalColor nMaskColor ) override;
 228
 229     virtual SalBitmap*              getBitmap( long nX, long nY, long nWidth, long nHeight ) override;
 230     virtual SalColor                getPixel( long nX, long nY ) override;
 231     virtual void                    invert( long nX, long nY, long nWidth, long nHeight, SalInvert nFlags ) override;
 232     virtual void                    invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert nFlags ) override;
 233
 234     virtual bool                    drawEPS( long nX, long nY, long nWidth, long nHeight, void* pPtr, sal_uIntPtr nSize ) override;
 235
 236     virtual bool                    blendBitmap(
 237                                         const SalTwoRect&,
 238                                         const SalBitmap& rBitmap ) override;
 239
 240     virtual bool                    blendAlphaBitmap(
 241                                         const SalTwoRect&,
 242                                         const SalBitmap& rSrcBitmap,
 243                                         const SalBitmap& rMaskBitmap,
 244                                         const SalBitmap& rAlphaBitmap ) override;
 245
 246     virtual bool                    drawAlphaBitmap(
 247                                         const SalTwoRect&,
 248                                         const SalBitmap& rSourceBitmap,
 249                                         const SalBitmap& rAlphaBitmap ) override;
 250
 251     virtual bool                    drawTransformedBitmap(
 252                                         const basegfx::B2DPoint& rNull,
 253                                         const basegfx::B2DPoint& rX,
 254                                         const basegfx::B2DPoint& rY,
 255                                         const SalBitmap& rSourceBitmap,
 256                                         const SalBitmap* pAlphaBitmap) override;
 257
 258     virtual bool                    drawAlphaRect(
 259                                         long nX, long nY, long nWidth,
 260                                         long nHeight, sal_uInt8 nTransparency ) override;
 261
 262     virtual SystemGraphicsData      GetGraphicsData() const override;
 263     virtual bool                    SupportsCairo() const override;
 264     virtual cairo::SurfaceSharedPtr CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const override;
 265     virtual cairo::SurfaceSharedPtr CreateSurface(const OutputDevice& rRefDevice, int x, int y, int width, int height) const override;
 266     virtual cairo::SurfaceSharedPtr CreateBitmapSurface(const OutputDevice& rRefDevice, const BitmapSystemData& rData, const Size& rSize) const override;
 267     virtual css::uno::Any           GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const override;
 268     virtual SystemFontData          GetSysFontData( int nFallbackLevel ) const override;
 269
 270     bool TryRenderCachedNativeControl(ControlCacheKey& aControlCacheKey,
 271                                       int nX, int nY);
 272
 273     bool RenderAndCacheNativeControl(X11Pixmap* pPixmap, X11Pixmap* pMask, int nX, int nY,
 274                                      ControlCacheKey& aControlCacheKey);
 275
 276     // fill a pixmap from a screen region
 277     void                            FillPixmapFromScreen( X11Pixmap* pPixmap, int nX, int nY );
 278
 279     // render a pixmap to the screen
 280     bool                            RenderPixmapToScreen( X11Pixmap* pPixmap, X11Pixmap* pMask, int nX, int nY );
 281
 282
 283     /*  use to handle GraphicsExpose/NoExpose after XCopyArea & friends
 284      *  if pFrame is not NULL, corresponding Paint events are generated
 285      *  and dispatched to pFrame
 286      *
 287      *  it is imperative to eat up graphics exposes even in case you don't need
 288      *  them because the next one using XCopyArea can depend on them
 289      */
 290     void                            YieldGraphicsExpose();
 291
 292     cairo_t* getCairoContext();
 293     static void releaseCairoContext(cairo_t* cr);
 294
 295
 296     // do XCopyArea or XGet/PutImage depending on screen numbers
 297     // signature is like XCopyArea with screen numbers added
 298     static void                     CopyScreenArea(
 299                                         Display* pDisplay,
 300                                         Drawable aSrc, SalX11Screen nXScreenSrc, int nSrcDepth,
 301                                         Drawable aDest, SalX11Screen nXScreenDest, int nDestDepth,
 302                                         GC aDestGC,
 303                                         int src_x, int src_y,
 304                                         unsigned int w, unsigned int h,
 305                                         int dest_x, int dest_y );
 306
 307     static void                     releaseGlyphPeer();
 308
 309 protected:
 310     using SalGraphics::SetClipRegion;
 311     void                            SetClipRegion( GC pGC, Region pXReg = NULL ) const;
 312     bool                            GetDitherPixmap ( SalColor nSalColor );
 313
 314     using SalGraphics::DrawBitmap;
 315
 316     GC                              GetFontGC();
 317
 318     void                            freeResources();
 319
 320 protected:
 321     SalFrame*                       m_pFrame; // the SalFrame which created this Graphics or NULL
 322     SalVirtualDevice*               m_pVDev;  // the SalVirtualDevice which created this Graphics or NULL
 323
 324     const SalColormap*              m_pColormap;
 325     SalColormap*                    m_pDeleteColormap;
 326     Drawable                        hDrawable_;     // use
 327     SalX11Screen                    m_nXScreen;
 328     mutable XRenderPictFormat*      m_pXRenderFormat;
 329     XID                             m_aXRenderPicture;
 330
 331     Region                          pPaintRegion_;
 332     Region                          mpClipRegion;
 333
 334     GC                              pFontGC_;       // Font attributes
 335     Pixel                           nTextPixel_;
 336
 337     Pixmap                          hBrush_;        // Dither
 338
 339     bool                            bWindow_ : 1;       // is Window
 340     bool                            bPrinter_ : 1;      // is Printer
 341     bool                            bVirDev_ : 1;       // is VirDev
 342     bool                            bFontGC_ : 1;       // is Font GC valid
 343
 344 private:
 345     std::unique_ptr<SalGraphicsImpl> mxImpl;
 346     std::unique_ptr<TextRenderImpl> mxTextRenderImpl;
 347
 348 };
 349
 350 inline const SalDisplay *X11SalGraphics::GetDisplay() const
 351 { return GetColormap().GetDisplay(); }
 352
 353 inline const SalVisual& X11SalGraphics::GetVisual() const
 354 { return GetColormap().GetVisual(); }
 355
 356 inline Display *X11SalGraphics::GetXDisplay() const
 357 { return GetColormap().GetXDisplay(); }
 358
 359 inline Pixel X11SalGraphics::GetPixel( SalColor nSalColor ) const
 360 { return GetColormap().GetPixel( nSalColor ); }
 361
 362 #endif // INCLUDED_VCL_INC_UNX_SALGDI_H
 363
 364 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */