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