vcl/inc/unx/salbmp.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_SALBMP_H
  21 #define INCLUDED_VCL_INC_UNX_SALBMP_H
  22
  23 #include <X11/Xlib.h>
  24
  25 #include <vcl/salgtype.hxx>
  26 #include <unx/saldisp.hxx>
  27 #include <salbmp.hxx>
  28 #include <vclpluginapi.h>
  29
  30 struct  BitmapBuffer;
  31 class   BitmapPalette;
  32 class   SalGraphics;
  33 class   ImplSalDDB;
  34 class   ImplSalBitmapCache;
  35
  36
  37 class VCLPLUG_GEN_PUBLIC X11SalBitmap final : public SalBitmap
  38 {
  39 private:
  40
  41     static std::unique_ptr<BitmapBuffer>
  42                                 ImplCreateDIB(
  43                                     const Size& rSize,
  44                                     sal_uInt16 nBitCount,
  45                                     const BitmapPalette& rPal
  46                                 );
  47
  48     static std::unique_ptr<BitmapBuffer>
  49                                 ImplCreateDIB(
  50                                     Drawable aDrawable,
  51                                     SalX11Screen nXScreen,
  52                                     long nDrawableDepth,
  53                                     long nX,
  54                                     long nY,
  55                                     long nWidth,
  56                                     long nHeight,
  57                                     bool bGrey
  58                                 );
  59
  60 public:
  61
  62     static ImplSalBitmapCache*  mpCache;
  63     static unsigned int         mnCacheInstCount;
  64
  65     static void                 ImplCreateCache();
  66     static void                 ImplDestroyCache();
  67     void                        ImplRemovedFromCache();
  68
  69 private:
  70
  71     std::unique_ptr<BitmapBuffer> mpDIB;
  72     mutable std::unique_ptr<ImplSalDDB> mpDDB;
  73     bool            mbGrey;
  74
  75 public:
  76
  77     SAL_DLLPRIVATE bool         ImplCreateFromDrawable(
  78                                     Drawable aDrawable,
  79                                     SalX11Screen nXScreen,
  80                                     long nDrawableDepth,
  81                                     long nX,
  82                                     long nY,
  83                                     long nWidth,
  84                                     long nHeight
  85                                 );
  86
  87     SAL_DLLPRIVATE XImage*      ImplCreateXImage(
  88                                     SalDisplay const * pSalDisp,
  89                                     SalX11Screen nXScreen,
  90                                     long nDepth,
  91                                     const SalTwoRect& rTwoRect
  92                                 ) const;
  93
  94     SAL_DLLPRIVATE ImplSalDDB*  ImplGetDDB(
  95                                     Drawable,
  96                                     SalX11Screen nXScreen,
  97                                     long nDrawableDepth,
  98                                     const SalTwoRect&
  99                                 ) const;
 100
 101     void                        ImplDraw(
 102                                     Drawable aDrawable,
 103                                     SalX11Screen nXScreen,
 104                                     long nDrawableDepth,
 105                                     const SalTwoRect& rTwoRect,
 106                                     const GC& rGC
 107                                 ) const;
 108
 109 public:
 110
 111                                 X11SalBitmap();
 112     virtual                     ~X11SalBitmap() override;
 113
 114     // override pure virtual methods
 115     virtual bool                Create(
 116                                     const Size& rSize,
 117                                     sal_uInt16 nBitCount,
 118                                     const BitmapPalette& rPal
 119                                 ) override;
 120
 121     virtual bool                Create( const SalBitmap& rSalBmp ) override;
 122     virtual bool                Create(
 123                                     const SalBitmap& rSalBmp,
 124                                     SalGraphics* pGraphics
 125                                 ) override;
 126
 127     virtual bool                Create(
 128                                     const SalBitmap& rSalBmp,
 129                                     sal_uInt16 nNewBitCount
 130                                 ) override;
 131
 132     virtual bool                Create(
 133                                     const css::uno::Reference< css::rendering::XBitmapCanvas >& rBitmapCanvas,
 134                                     Size& rSize,
 135                                     bool bMask = false
 136                                 ) override;
 137
 138     virtual void                Destroy() override;
 139
 140     virtual Size                GetSize() const override;
 141     virtual sal_uInt16          GetBitCount() const override;
 142
 143     virtual BitmapBuffer*       AcquireBuffer( BitmapAccessMode nMode ) override;
 144     virtual void                ReleaseBuffer( BitmapBuffer* pBuffer, BitmapAccessMode nMode ) override;
 145     virtual bool                GetSystemData( BitmapSystemData& rData ) override;
 146
 147     virtual bool                ScalingSupported() const override;
 148     virtual bool                Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag ) override;
 149     virtual bool                Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uInt8 nTol ) override;
 150 };
 151
 152
 153 class ImplSalDDB
 154 {
 155 private:
 156
 157     Pixmap          maPixmap;
 158     SalTwoRect      maTwoRect;
 159     long const            mnDepth;
 160     SalX11Screen const    mnXScreen;
 161
 162     static void     ImplDraw(
 163                         Drawable aSrcDrawable,
 164                         long nSrcDrawableDepth,
 165                         Drawable aDstDrawable,
 166                         long nSrcX,
 167                         long nSrcY,
 168                         long nDestWidth,
 169                         long nDestHeight,
 170                         long nDestX,
 171                         long nDestY,
 172                         const GC& rGC
 173                     );
 174
 175 public:
 176
 177                     ImplSalDDB(
 178                         XImage* pImage,
 179                         Drawable aDrawable,
 180                         SalX11Screen nXScreen,
 181                         const SalTwoRect& rTwoRect
 182                     );
 183
 184                     ImplSalDDB(
 185                         Drawable aDrawable,
 186                         SalX11Screen nXScreen,
 187                         long nDrawableDepth,
 188                         long nX,
 189                         long nY,
 190                         long nWidth,
 191                         long nHeight
 192                     );
 193
 194                     ~ImplSalDDB();
 195
 196     Pixmap          ImplGetPixmap() const { return maPixmap; }
 197     long            ImplGetWidth() const { return maTwoRect.mnDestWidth; }
 198     long            ImplGetHeight() const { return maTwoRect.mnDestHeight; }
 199     long            ImplGetDepth() const { return mnDepth; }
 200     const SalX11Screen& ImplGetScreen() const { return mnXScreen; }
 201
 202     bool            ImplMatches( SalX11Screen nXScreen, long nDepth, const SalTwoRect& rTwoRect ) const;
 203
 204     void            ImplDraw(
 205                         Drawable aDrawable,
 206                         const SalTwoRect& rTwoRect,
 207                         const GC& rGC
 208                     ) const;
 209 };
 210
 211
 212 class X11SalBitmap;
 213
 214 class ImplSalBitmapCache
 215 {
 216 private:
 217     std::vector<X11SalBitmap*>  maBmpList;
 218
 219 public:
 220
 221                     ImplSalBitmapCache();
 222                     ~ImplSalBitmapCache();
 223
 224     void            ImplAdd( X11SalBitmap* pBmp );
 225     void            ImplRemove( X11SalBitmap const * pBmp );
 226     void            ImplClear();
 227 };
 228
 229 #endif // INCLUDED_VCL_INC_UNX_SALBMP_H
 230
 231 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */