include/vcl/bmpacc.hxx

   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_BMPACC_HXX
  21 #define INCLUDED_VCL_BMPACC_HXX
  22
  23 #include <tools/solar.h>
  24 #include <vcl/dllapi.h>
  25 #include <vcl/salbtype.hxx>
  26 #include <vcl/bitmap.hxx>
  27
  28 // - Access functions -
  29 typedef BitmapColor (*FncGetPixel)(ConstScanline pScanline, long nX, const ColorMask& rMask);
  30 typedef void (*FncSetPixel)(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
  31
  32 // - BitmapInfoAccess -
  33 class VCL_DLLPUBLIC BitmapInfoAccess
  34 {
  35     friend class BitmapReadAccess;
  36
  37 public:
  38     BitmapInfoAccess(Bitmap& rBitmap);
  39     virtual ~BitmapInfoAccess();
  40
  41     inline bool operator!() const;
  42
  43     inline long Width() const;
  44     inline long Height() const;
  45     inline Point TopLeft() const;
  46     inline Point BottomRight() const;
  47
  48     inline bool  IsTopDown() const;
  49     inline bool  IsBottomUp() const;
  50
  51     inline sal_uLong GetScanlineFormat() const;
  52     inline sal_uLong GetScanlineSize() const;
  53
  54     inline sal_uInt16 GetBitCount() const;
  55     inline BitmapColor GetBestMatchingColor(const BitmapColor& rBitmapColor);
  56
  57     inline bool HasPalette() const;
  58     inline const BitmapPalette& GetPalette() const;
  59     inline sal_uInt16 GetPaletteEntryCount() const;
  60     inline const BitmapColor& GetPaletteColor(sal_uInt16 nColor) const;
  61     inline const BitmapColor& GetBestPaletteColor(const BitmapColor& rBitmapColor) const;
  62     sal_uInt16 GetBestPaletteIndex(const BitmapColor& rBitmapColor) const;
  63
  64     inline bool                 HasColorMask() const;
  65     inline ColorMask&           GetColorMask() const;
  66
  67 private:
  68     BitmapInfoAccess()
  69     {}
  70
  71     BitmapInfoAccess(const BitmapInfoAccess&)
  72     {}
  73
  74     BitmapInfoAccess& operator=(const BitmapInfoAccess&)
  75     {
  76         return *this;
  77     }
  78
  79 protected:
  80     Bitmap maBitmap;
  81     BitmapBuffer* mpBuffer;
  82     ColorMask maColorMask;
  83     BitmapAccessMode mnAccessMode;
  84
  85     SAL_DLLPRIVATE void ImplCreate(Bitmap& rBitmap);
  86     SAL_DLLPRIVATE void ImplDestroy();
  87
  88 protected:
  89     BitmapInfoAccess(Bitmap& rBitmap, BitmapAccessMode nMode);
  90 };
  91
  92 // - BitmapReadAccess -
  93 class VCL_DLLPUBLIC BitmapReadAccess : public BitmapInfoAccess
  94 {
  95     friend class BitmapWriteAccess;
  96
  97 public:
  98     BitmapReadAccess(Bitmap& rBitmap);
  99     virtual ~BitmapReadAccess();
 100
 101     inline Scanline GetBuffer() const;
 102     inline Scanline GetScanline( long nY ) const;
 103
 104     inline BitmapColor GetPixelFromData( const sal_uInt8* pData, long nX ) const;
 105     inline void SetPixelOnData( sal_uInt8* pData, long nX, const BitmapColor& rBitmapColor );
 106
 107     inline BitmapColor GetPixel( long nY, long nX ) const;
 108     inline BitmapColor GetColor( long nY, long nX ) const;
 109     inline sal_uInt8 GetPixelIndex( long nY, long nX ) const;
 110     inline sal_uInt8 GetLuminance( long nY, long nX ) const;
 111
 112     /** Get the interpolated color at coordinates fY, fX; if outside, return rFallback */
 113     BitmapColor GetInterpolatedColorWithFallback( double fY, double fX, const BitmapColor& rFallback ) const;
 114
 115     /** Get the color at coordinates fY, fX; if outside, return rFallback. Automatically does the correct
 116         inside/outside checks, e.g. static_cast< sal_uInt32 >(-0.25) *is* 0, not -1 and has to be outside */
 117     BitmapColor GetColorWithFallback( double fY, double fX, const BitmapColor& rFallback ) const;
 118
 119 private:
 120
 121     BitmapReadAccess()
 122     {}
 123
 124     BitmapReadAccess(const BitmapReadAccess&)
 125         : BitmapInfoAccess()
 126     {}
 127
 128     BitmapReadAccess& operator=(const BitmapReadAccess&)
 129     {
 130         return *this;
 131     }
 132
 133 protected:
 134     Scanline*   mpScanBuf;
 135     FncGetPixel mFncGetPixel;
 136     FncSetPixel mFncSetPixel;
 137
 138     SAL_DLLPRIVATE void ImplInitScanBuffer( Bitmap& rBitmap );
 139     SAL_DLLPRIVATE void ImplClearScanBuffer();
 140     SAL_DLLPRIVATE bool ImplSetAccessPointers( sal_uLong nFormat );
 141
 142 public:
 143
 144     SAL_DLLPRIVATE void ImplZeroInitUnusedBits();
 145     SAL_DLLPRIVATE BitmapBuffer* ImplGetBitmapBuffer() const
 146     {
 147         return mpBuffer;
 148     }
 149
 150     static BitmapColor GetPixelFor_1BIT_MSB_PAL(ConstScanline pScanline, long nX, const ColorMask& rMask);
 151     static BitmapColor GetPixelFor_1BIT_LSB_PAL(ConstScanline pScanline, long nX, const ColorMask& rMask);
 152     static BitmapColor GetPixelFor_4BIT_MSN_PAL(ConstScanline pScanline, long nX, const ColorMask& rMask);
 153     static BitmapColor GetPixelFor_4BIT_LSN_PAL(ConstScanline pScanline, long nX, const ColorMask& rMask);
 154     static BitmapColor GetPixelFor_8BIT_PAL(ConstScanline pScanline, long nX, const ColorMask& rMask);
 155     static BitmapColor GetPixelFor_8BIT_TC_MASK(ConstScanline pScanline, long nX, const ColorMask& rMask);
 156     static BitmapColor GetPixelFor_16BIT_TC_MSB_MASK(ConstScanline pScanline, long nX, const ColorMask& rMask);
 157     static BitmapColor GetPixelFor_16BIT_TC_LSB_MASK(ConstScanline pScanline, long nX, const ColorMask& rMask);
 158     static BitmapColor GetPixelFor_24BIT_TC_BGR(ConstScanline pScanline, long nX, const ColorMask& rMask);
 159     static BitmapColor GetPixelFor_24BIT_TC_RGB(ConstScanline pScanline, long nX, const ColorMask& rMask);
 160     static BitmapColor GetPixelFor_24BIT_TC_MASK(ConstScanline pScanline, long nX, const ColorMask& rMask);
 161     static BitmapColor GetPixelFor_32BIT_TC_ABGR(ConstScanline pScanline, long nX, const ColorMask& rMask);
 162     static BitmapColor GetPixelFor_32BIT_TC_ARGB(ConstScanline pScanline, long nX, const ColorMask& rMask);
 163     static BitmapColor GetPixelFor_32BIT_TC_BGRA(ConstScanline pScanline, long nX, const ColorMask& rMask);
 164     static BitmapColor GetPixelFor_32BIT_TC_RGBA(ConstScanline pScanline, long nX, const ColorMask& rMask);
 165     static BitmapColor GetPixelFor_32BIT_TC_MASK(ConstScanline pScanline, long nX, const ColorMask& rMask);
 166
 167     static void SetPixelFor_1BIT_MSB_PAL(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 168     static void SetPixelFor_1BIT_LSB_PAL(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 169     static void SetPixelFor_4BIT_MSN_PAL(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 170     static void SetPixelFor_4BIT_LSN_PAL(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 171     static void SetPixelFor_8BIT_PAL(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 172     static void SetPixelFor_8BIT_TC_MASK(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 173     static void SetPixelFor_16BIT_TC_MSB_MASK(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 174     static void SetPixelFor_16BIT_TC_LSB_MASK(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 175     static void SetPixelFor_24BIT_TC_BGR(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 176     static void SetPixelFor_24BIT_TC_RGB(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 177     static void SetPixelFor_24BIT_TC_MASK(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 178     static void SetPixelFor_32BIT_TC_ABGR(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 179     static void SetPixelFor_32BIT_TC_ARGB(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 180     static void SetPixelFor_32BIT_TC_BGRA(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 181     static void SetPixelFor_32BIT_TC_RGBA(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 182     static void SetPixelFor_32BIT_TC_MASK(Scanline pScanline, long nX, const BitmapColor& rBitmapColor, const ColorMask& rMask);
 183
 184 protected:
 185     BitmapReadAccess(Bitmap& rBitmap, BitmapAccessMode nMode);
 186 };
 187
 188 // - BitmapWriteAccess -
 189 class VCL_DLLPUBLIC BitmapWriteAccess : public BitmapReadAccess
 190 {
 191 public:
 192     BitmapWriteAccess(Bitmap& rBitmap);
 193     virtual ~BitmapWriteAccess();
 194
 195     void CopyScanline(long nY, const BitmapReadAccess& rReadAcc);
 196     void CopyScanline(long nY,
 197                       ConstScanline aSrcScanline,
 198                       sal_uLong nSrcScanlineFormat,
 199                       sal_uLong nSrcScanlineSize);
 200
 201     void CopyBuffer( const BitmapReadAccess& rReadAcc );
 202
 203     inline void SetPalette(const BitmapPalette& rPalette);
 204     inline void SetPaletteEntryCount(sal_uInt16 nCount);
 205     inline void SetPaletteColor(sal_uInt16 nColor, const BitmapColor& rBitmapColor);
 206
 207     inline void SetPixel(long nY, long nX, const BitmapColor& rBitmapColor);
 208     inline void SetPixelIndex(long nY, long nX, sal_uInt8 cIndex);
 209
 210     void SetLineColor(const Color& rColor);
 211
 212     void SetFillColor();
 213     void SetFillColor(const Color& rColor);
 214
 215     void Erase(const Color& rColor);
 216
 217     void DrawLine(const Point& rStart, const Point& rEnd);
 218
 219     void FillRect(const Rectangle& rRect);
 220     void DrawRect(const Rectangle& rRect);
 221
 222 private:
 223
 224     std::unique_ptr<BitmapColor> mpLineColor;
 225     std::unique_ptr<BitmapColor> mpFillColor;
 226
 227     BitmapWriteAccess()
 228     {}
 229
 230     BitmapWriteAccess(const BitmapWriteAccess&)
 231         : BitmapReadAccess()
 232     {}
 233
 234     BitmapWriteAccess& operator=(const BitmapWriteAccess&)
 235     {
 236         return *this;
 237     }
 238 };
 239
 240 // - Inlines -
 241 inline bool BitmapInfoAccess::operator!() const
 242 {
 243     return mpBuffer == NULL;
 244 }
 245
 246 inline long BitmapInfoAccess::Width() const
 247 {
 248     return mpBuffer ? mpBuffer->mnWidth : 0L;
 249 }
 250
 251 inline long BitmapInfoAccess::Height() const
 252 {
 253     return mpBuffer ? mpBuffer->mnHeight : 0L;
 254 }
 255
 256 inline Point BitmapInfoAccess::TopLeft() const
 257 {
 258     return Point();
 259 }
 260
 261 inline Point BitmapInfoAccess::BottomRight() const
 262 {
 263     return Point(Width() - 1L, Height() - 1L);
 264 }
 265
 266 inline bool BitmapInfoAccess::IsTopDown() const
 267 {
 268     assert(mpBuffer && "Access is not valid!");
 269
 270     return mpBuffer && (BMP_SCANLINE_ADJUSTMENT(mpBuffer->mnFormat) == BMP_FORMAT_TOP_DOWN);
 271 }
 272
 273 inline bool BitmapInfoAccess::IsBottomUp() const
 274 {
 275     return !IsTopDown();
 276 }
 277
 278 inline sal_uLong BitmapInfoAccess::GetScanlineFormat() const
 279 {
 280     assert(mpBuffer && "Access is not valid!");
 281
 282     return mpBuffer ? BMP_SCANLINE_FORMAT(mpBuffer->mnFormat) : 0UL;
 283 }
 284
 285 inline sal_uLong BitmapInfoAccess::GetScanlineSize() const
 286 {
 287     assert(mpBuffer && "Access is not valid!");
 288
 289     return mpBuffer ? mpBuffer->mnScanlineSize : 0UL;
 290 }
 291
 292 inline sal_uInt16  BitmapInfoAccess::GetBitCount() const
 293 {
 294     assert(mpBuffer && "Access is not valid!");
 295
 296     return mpBuffer ? mpBuffer->mnBitCount : 0;
 297 }
 298
 299 inline BitmapColor BitmapInfoAccess::GetBestMatchingColor(const BitmapColor& rBitmapColor)
 300 {
 301     if (HasPalette())
 302         return BitmapColor((sal_uInt8) GetBestPaletteIndex(rBitmapColor));
 303     else
 304         return rBitmapColor;
 305 }
 306
 307 inline bool BitmapInfoAccess::HasPalette() const
 308 {
 309     assert(mpBuffer && "Access is not valid!");
 310
 311     return mpBuffer && !!mpBuffer->maPalette;
 312 }
 313
 314 inline const BitmapPalette& BitmapInfoAccess::GetPalette() const
 315 {
 316     assert(mpBuffer && "Access is not valid!");
 317
 318     return mpBuffer->maPalette;
 319 }
 320
 321 inline sal_uInt16 BitmapInfoAccess::GetPaletteEntryCount() const
 322 {
 323     assert(HasPalette() && "Bitmap has no palette!");
 324
 325     return HasPalette() ? mpBuffer->maPalette.GetEntryCount() : 0;
 326 }
 327
 328 inline const BitmapColor& BitmapInfoAccess::GetPaletteColor( sal_uInt16 nColor ) const
 329 {
 330     assert(mpBuffer && "Access is not valid!");
 331     assert(HasPalette() && "Bitmap has no palette!");
 332
 333     return mpBuffer->maPalette[nColor];
 334 }
 335
 336 inline const BitmapColor& BitmapInfoAccess::GetBestPaletteColor(const BitmapColor& rBitmapColor) const
 337 {
 338     return GetPaletteColor(GetBestPaletteIndex(rBitmapColor));
 339 }
 340
 341 inline bool BitmapInfoAccess::HasColorMask() const
 342 {
 343     assert(mpBuffer && "Access is not valid!");
 344
 345     const sal_uLong nFormat = BMP_SCANLINE_FORMAT(mpBuffer->mnFormat);
 346
 347     return nFormat == BMP_FORMAT_8BIT_TC_MASK  ||
 348            nFormat == BMP_FORMAT_16BIT_TC_MSB_MASK ||
 349            nFormat == BMP_FORMAT_16BIT_TC_LSB_MASK ||
 350            nFormat == BMP_FORMAT_24BIT_TC_MASK ||
 351            nFormat == BMP_FORMAT_32BIT_TC_MASK;
 352 }
 353
 354 inline ColorMask& BitmapInfoAccess::GetColorMask() const
 355 {
 356     assert(mpBuffer && "Access is not valid!");
 357
 358     return mpBuffer->maColorMask;
 359 }
 360
 361 inline Scanline BitmapReadAccess::GetBuffer() const
 362 {
 363     assert(mpBuffer && "Access is not valid!");
 364
 365     return mpBuffer ? mpBuffer->mpBits : NULL;
 366 }
 367
 368 inline Scanline BitmapReadAccess::GetScanline(long nY) const
 369 {
 370     assert(mpBuffer && mpScanBuf && "Access is not valid!");
 371     assert(nY < mpBuffer->mnHeight && "y-coordinate out of range!");
 372
 373     return mpScanBuf[nY];
 374 }
 375
 376 inline BitmapColor BitmapReadAccess::GetPixel(long nY, long nX) const
 377 {
 378     assert(mpBuffer && mpScanBuf && "Access is not valid!");
 379     assert(nX < mpBuffer->mnWidth && "x-coordinate out of range!");
 380     assert(nY < mpBuffer->mnHeight && "y-coordinate out of range!");
 381
 382     return mFncGetPixel(mpScanBuf[nY], nX, maColorMask );
 383 }
 384
 385 inline sal_uInt8 BitmapReadAccess::GetPixelIndex(long nY, long nX) const
 386 {
 387     return GetPixel(nY, nX).GetBlueOrIndex();
 388 }
 389
 390 inline BitmapColor BitmapReadAccess::GetPixelFromData(const sal_uInt8* pData, long nX) const
 391 {
 392     assert(pData && "Access is not valid!");
 393
 394     return mFncGetPixel( pData, nX, maColorMask );
 395 }
 396
 397 inline void BitmapReadAccess::SetPixelOnData(sal_uInt8* pData, long nX, const BitmapColor& rBitmapColor)
 398 {
 399     assert(pData && "Access is not valid!");
 400
 401     mFncSetPixel(pData, nX, rBitmapColor, maColorMask);
 402 }
 403
 404 inline BitmapColor BitmapReadAccess::GetColor(long nY, long nX) const
 405 {
 406     if (HasPalette())
 407         return mpBuffer->maPalette[GetPixelIndex(nY, nX)];
 408     else
 409         return GetPixel(nY, nX);
 410 }
 411
 412 inline sal_uInt8 BitmapReadAccess::GetLuminance(long nY, long nX) const
 413 {
 414     return GetColor(nY, nX).GetLuminance();
 415 }
 416
 417 inline void BitmapWriteAccess::SetPalette(const BitmapPalette& rPalette)
 418 {
 419     assert(mpBuffer && "Access is not valid!");
 420
 421     mpBuffer->maPalette = rPalette;
 422 }
 423
 424 inline void BitmapWriteAccess::SetPaletteEntryCount(sal_uInt16 nCount)
 425 {
 426     assert(mpBuffer && "Access is not valid!");
 427
 428     mpBuffer->maPalette.SetEntryCount(nCount);
 429 }
 430
 431 inline void BitmapWriteAccess::SetPaletteColor(sal_uInt16 nColor, const BitmapColor& rBitmapColor)
 432 {
 433     assert(mpBuffer && "Access is not valid!");
 434     assert(HasPalette() && "Bitmap has no palette!");
 435
 436     mpBuffer->maPalette[nColor] = rBitmapColor;
 437 }
 438
 439 inline void BitmapWriteAccess::SetPixel(long nY, long nX, const BitmapColor& rBitmapColor)
 440 {
 441     assert(mpBuffer && "Access is not valid!");
 442     assert(nX < mpBuffer->mnWidth && "x-coordinate out of range!");
 443     assert(nY < mpBuffer->mnHeight && "y-coordinate out of range!");
 444
 445     mFncSetPixel(mpScanBuf[nY], nX, rBitmapColor, maColorMask);
 446 }
 447
 448 inline void BitmapWriteAccess::SetPixelIndex(long nY, long nX, sal_uInt8 cIndex)
 449 {
 450     SetPixel(nY, nX, BitmapColor(cIndex));
 451 }
 452
 453 #endif // INCLUDED_VCL_BMPACC_HXX
 454
 455 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */