include/vcl/salbtype.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_SALBTYPE_HXX
  21 #define INCLUDED_VCL_SALBTYPE_HXX
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <tools/debug.hxx>
  26 #include <vcl/salgtype.hxx>
  27 #include <tools/color.hxx>
  28 #include <tools/helpers.hxx>
  29 #include <tools/solar.h>
  30 #include <vcl/dllapi.h>
  31
  32
  33 // - Memory -
  34
  35 typedef sal_uInt8*        HPBYTE;
  36 typedef HPBYTE            Scanline;
  37 typedef const sal_uInt8*  ConstHPBYTE;
  38 typedef ConstHPBYTE       ConstScanline;
  39
  40
  41 // - Bitmap formats -
  42
  43 #define BMP_FORMAT_BOTTOM_UP                        0x00000000UL
  44 #define BMP_FORMAT_TOP_DOWN                         0x80000000UL
  45
  46 #define BMP_FORMAT_1BIT_MSB_PAL                     0x00000001UL
  47 #define BMP_FORMAT_1BIT_LSB_PAL                     0x00000002UL
  48
  49 #define BMP_FORMAT_4BIT_MSN_PAL                     0x00000004UL
  50 #define BMP_FORMAT_4BIT_LSN_PAL                     0x00000008UL
  51
  52 #define BMP_FORMAT_8BIT_PAL                         0x00000010UL
  53 #define BMP_FORMAT_8BIT_TC_MASK                     0x00000020UL
  54
  55 #define BMP_FORMAT_24BIT_TC_BGR                     0x00000080UL
  56 #define BMP_FORMAT_24BIT_TC_RGB                     0x00000100UL
  57 #define BMP_FORMAT_24BIT_TC_MASK                    0x00000200UL
  58
  59 #define BMP_FORMAT_32BIT_TC_ABGR                    0x00000400UL
  60 #define BMP_FORMAT_32BIT_TC_ARGB                    0x00000800UL
  61 #define BMP_FORMAT_32BIT_TC_BGRA                    0x00001000UL
  62 #define BMP_FORMAT_32BIT_TC_RGBA                    0x00002000UL
  63 #define BMP_FORMAT_32BIT_TC_MASK                    0x00004000UL
  64
  65 #define BMP_FORMAT_16BIT_TC_MSB_MASK                0x00008000UL
  66 #define BMP_FORMAT_16BIT_TC_LSB_MASK                0x00010000UL
  67
  68 #define BMP_SCANLINE_ADJUSTMENT( Mac_nBmpFormat )   ( (Mac_nBmpFormat) & 0x80000000UL )
  69 #define BMP_SCANLINE_FORMAT( Mac_nBmpFormat )       ( (Mac_nBmpFormat) & 0x7FFFFFFFUL )
  70
  71
  72
  73 #define MASK_TO_COLOR( d_nVal, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_Col )                          \
  74 sal_uLong _def_cR = (sal_uInt8) ( d_RS < 0L ? ( (d_nVal) & d_RM ) << -d_RS : ( (d_nVal) & d_RM ) >> d_RS ); \
  75 sal_uLong _def_cG = (sal_uInt8) ( d_GS < 0L ? ( (d_nVal) & d_GM ) << -d_GS : ( (d_nVal) & d_GM ) >> d_GS ); \
  76 sal_uLong _def_cB = (sal_uInt8) ( d_BS < 0L ? ( (d_nVal) & d_BM ) << -d_BS : ( (d_nVal) & d_BM ) >> d_BS ); \
  77 d_Col = BitmapColor( (sal_uInt8) ( _def_cR | ( ( _def_cR & mnROr ) >> mnROrShift ) ),                   \
  78                      (sal_uInt8) ( _def_cG | ( ( _def_cG & mnGOr ) >> mnGOrShift ) ),                   \
  79                      (sal_uInt8) ( _def_cB | ( ( _def_cB & mnBOr ) >> mnBOrShift ) ) );
  80
  81
  82
  83 #define COLOR_TO_MASK( d_rCol, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_ALPHA ) \
  84 ( ( ( ( d_RS < 0L ) ? ( (sal_uInt32) (d_rCol).GetRed() >> -d_RS ) :     \
  85     ( (sal_uInt32) (d_rCol).GetRed() << d_RS ) ) & d_RM ) |             \
  86   ( ( ( d_GS < 0L ) ? ( (sal_uInt32) (d_rCol).GetGreen() >> -d_GS ) :   \
  87     ( (sal_uInt32) (d_rCol).GetGreen() << d_GS ) ) & d_GM ) |           \
  88   ( ( ( d_BS < 0L ) ? ( (sal_uInt32) (d_rCol).GetBlue() >> -d_BS ) :    \
  89     ( (sal_uInt32) (d_rCol).GetBlue() << d_BS ) ) & d_BM ) | \
  90     d_ALPHA )
  91
  92 // - BitmapColor -
  93
  94 class Color;
  95
  96 class VCL_DLLPUBLIC BitmapColor
  97 {
  98 private:
  99
 100 // ATTENTION:
 101 //   Because the members of this class are accessed via memcpy,
 102 //   you MUST NOT CHANGE the order of the members or the size of this class!
 103     sal_uInt8               mcBlueOrIndex;
 104     sal_uInt8               mcGreen;
 105     sal_uInt8               mcRed;
 106     sal_uInt8               mbIndex; // should be bool, but see above warning
 107
 108 public:
 109
 110     inline              BitmapColor();
 111     inline              BitmapColor( const BitmapColor& rBitmapColor );
 112     inline              BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue );
 113     inline              BitmapColor( const Color& rColor );
 114     explicit inline     BitmapColor( sal_uInt8 cIndex );
 115
 116     inline              ~BitmapColor() {};
 117
 118     inline bool         operator==( const BitmapColor& rBitmapColor ) const;
 119     inline bool         operator!=( const BitmapColor& rBitmapColor ) const;
 120     inline BitmapColor& operator=( const BitmapColor& rBitmapColor );
 121
 122     inline bool         IsIndex() const;
 123
 124     inline sal_uInt8    GetRed() const;
 125     inline void         SetRed( sal_uInt8 cRed );
 126
 127     inline sal_uInt8    GetGreen() const;
 128     inline void         SetGreen( sal_uInt8 cGreen );
 129
 130     inline sal_uInt8    GetBlue() const;
 131     inline void         SetBlue( sal_uInt8 cBlue );
 132
 133     inline sal_uInt8    GetIndex() const;
 134     inline void         SetIndex( sal_uInt8 cIndex );
 135
 136     operator            Color() const;
 137
 138     inline sal_uInt8    GetBlueOrIndex() const;
 139
 140     inline BitmapColor& Invert();
 141
 142     inline sal_uInt8    GetLuminance() const;
 143     inline BitmapColor& IncreaseLuminance( sal_uInt8 cGreyInc );
 144     inline BitmapColor& DecreaseLuminance( sal_uInt8 cGreyDec );
 145
 146     inline BitmapColor& Merge( const BitmapColor& rColor, sal_uInt8 cTransparency );
 147     inline BitmapColor& Merge( sal_uInt8 cR, sal_uInt8 cG, sal_uInt8 cB, sal_uInt8 cTransparency );
 148
 149     inline sal_uLong    GetColorError( const BitmapColor& rBitmapColor ) const;
 150 };
 151
 152 // - BitmapPalette -
 153 class Palette;
 154
 155 class VCL_DLLPUBLIC BitmapPalette
 156 {
 157     friend class SalBitmap;
 158     friend class BitmapAccess;
 159
 160 private:
 161
 162     BitmapColor*                mpBitmapColor;
 163     sal_uInt16                  mnCount;
 164
 165 public:
 166
 167     SAL_DLLPRIVATE inline BitmapColor* ImplGetColorBuffer() const;
 168
 169
 170 public:
 171
 172     inline                      BitmapPalette();
 173     inline                      BitmapPalette( const BitmapPalette& rBitmapPalette );
 174     inline                      BitmapPalette( sal_uInt16 nCount );
 175     inline                      ~BitmapPalette();
 176
 177     inline BitmapPalette&       operator=( const BitmapPalette& rBitmapPalette );
 178     inline bool                 operator==( const BitmapPalette& rBitmapPalette ) const;
 179     inline bool                 operator!=( const BitmapPalette& rBitmapPalette ) const;
 180     inline bool                 operator!();
 181
 182     inline sal_uInt16           GetEntryCount() const;
 183     inline void                 SetEntryCount( sal_uInt16 nCount );
 184
 185     inline const BitmapColor&   operator[]( sal_uInt16 nIndex ) const;
 186     inline BitmapColor&         operator[]( sal_uInt16 nIndex );
 187
 188     inline sal_uInt16           GetBestIndex( const BitmapColor& rCol ) const;
 189     bool                        IsGreyPalette() const;
 190 };
 191
 192 // - ColorMask -
 193 class VCL_DLLPUBLIC ColorMask
 194 {
 195     sal_uLong               mnRMask;
 196     sal_uLong               mnGMask;
 197     sal_uLong               mnBMask;
 198     long                    mnRShift;
 199     long                    mnGShift;
 200     long                    mnBShift;
 201     sal_uLong               mnROrShift;
 202     sal_uLong               mnGOrShift;
 203     sal_uLong               mnBOrShift;
 204     sal_uLong               mnROr;
 205     sal_uLong               mnGOr;
 206     sal_uLong               mnBOr;
 207     sal_uLong               mnAlphaChannel;
 208
 209     SAL_DLLPRIVATE inline long ImplCalcMaskShift( sal_uLong nMask, sal_uLong& rOr, sal_uLong& rOrShift ) const;
 210
 211 public:
 212
 213     inline              ColorMask( sal_uLong nRedMask = 0UL,
 214                                    sal_uLong nGreenMask = 0UL,
 215                                    sal_uLong nBlueMask = 0UL,
 216                                    sal_uLong nAlphaChannel = 0UL );
 217     inline              ~ColorMask() {}
 218
 219     inline sal_uLong    GetRedMask() const;
 220     inline sal_uLong    GetGreenMask() const;
 221     inline sal_uLong    GetBlueMask() const;
 222
 223     inline void         GetColorFor8Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
 224     inline void         SetColorFor8Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
 225
 226     inline void         GetColorFor16BitMSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
 227     inline void         SetColorFor16BitMSB( const BitmapColor& rColor, HPBYTE pPixel ) const;
 228     inline void         GetColorFor16BitLSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
 229     inline void         SetColorFor16BitLSB( const BitmapColor& rColor, HPBYTE pPixel ) const;
 230
 231     inline void         GetColorFor24Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
 232     inline void         SetColorFor24Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
 233
 234     inline void         GetColorFor32Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
 235     inline void         GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, ConstHPBYTE pPixel ) const;
 236     inline void         SetColorFor32Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
 237 };
 238
 239 // - BitmapBuffer -
 240 struct VCL_DLLPUBLIC BitmapBuffer
 241 {
 242     sal_uLong       mnFormat;
 243     long            mnWidth;
 244     long            mnHeight;
 245     long            mnScanlineSize;
 246     sal_uInt16      mnBitCount;
 247     ColorMask       maColorMask;
 248     BitmapPalette   maPalette;
 249     sal_uInt8*      mpBits;
 250
 251                     BitmapBuffer(){}
 252                     ~BitmapBuffer() {}
 253 };
 254
 255 // - Access modes -
 256 typedef enum
 257 {
 258     BITMAP_INFO_ACCESS,
 259     BITMAP_READ_ACCESS,
 260     BITMAP_WRITE_ACCESS
 261 }
 262 BitmapAccessMode;
 263
 264 // - StretchAndConvert -
 265 VCL_DLLPUBLIC BitmapBuffer* StretchAndConvert(
 266     const BitmapBuffer& rSrcBuffer, const SalTwoRect& rTwoRect,
 267     sal_uLong nDstBitmapFormat, const BitmapPalette* pDstPal = NULL, const ColorMask* pDstMask = NULL );
 268
 269 inline BitmapColor::BitmapColor() :
 270             mcBlueOrIndex   ( 0 ),
 271             mcGreen         ( 0 ),
 272             mcRed           ( 0 ),
 273             mbIndex         ( sal_uInt8(false) )
 274 {
 275 }
 276
 277 inline BitmapColor::BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue ) :
 278             mcBlueOrIndex   ( cBlue ),
 279             mcGreen         ( cGreen ),
 280             mcRed           ( cRed ),
 281             mbIndex         ( sal_uInt8(false) )
 282 {
 283 }
 284
 285 inline BitmapColor::BitmapColor( const BitmapColor& rBitmapColor ) :
 286             mcBlueOrIndex   ( rBitmapColor.mcBlueOrIndex ),
 287             mcGreen         ( rBitmapColor.mcGreen ),
 288             mcRed           ( rBitmapColor.mcRed ),
 289             mbIndex         ( rBitmapColor.mbIndex )
 290 {
 291 }
 292
 293 inline BitmapColor::BitmapColor( const Color& rColor ) :
 294             mcBlueOrIndex   ( rColor.GetBlue() ),
 295             mcGreen         ( rColor.GetGreen() ),
 296             mcRed           ( rColor.GetRed() ),
 297             mbIndex         ( sal_uInt8(false) )
 298 {
 299 }
 300
 301 inline BitmapColor::BitmapColor( sal_uInt8 cIndex ) :
 302             mcBlueOrIndex   ( cIndex ),
 303             mcGreen         ( 0 ),
 304             mcRed           ( 0 ),
 305             mbIndex         ( sal_uInt8(true) )
 306 {
 307 }
 308
 309 inline bool BitmapColor::operator==( const BitmapColor& rBitmapColor ) const
 310 {
 311     return( ( mcBlueOrIndex == rBitmapColor.mcBlueOrIndex ) &&
 312             ( mbIndex ? bool(rBitmapColor.mbIndex) :
 313             ( mcGreen == rBitmapColor.mcGreen && mcRed == rBitmapColor.mcRed ) ) );
 314 }
 315
 316 inline bool BitmapColor::operator!=( const BitmapColor& rBitmapColor ) const
 317 {
 318     return !( *this == rBitmapColor );
 319 }
 320
 321 inline BitmapColor& BitmapColor::operator=( const BitmapColor& rBitmapColor )
 322 {
 323     mcBlueOrIndex = rBitmapColor.mcBlueOrIndex;
 324     mcGreen = rBitmapColor.mcGreen;
 325     mcRed = rBitmapColor.mcRed;
 326     mbIndex = rBitmapColor.mbIndex;
 327
 328     return *this;
 329 }
 330
 331 inline bool BitmapColor::IsIndex() const
 332 {
 333     return mbIndex;
 334 }
 335
 336 inline sal_uInt8 BitmapColor::GetRed() const
 337 {
 338     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 339     return mcRed;
 340 }
 341
 342 inline void BitmapColor::SetRed( sal_uInt8 cRed )
 343 {
 344     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 345     mcRed = cRed;
 346 }
 347
 348 inline sal_uInt8 BitmapColor::GetGreen() const
 349 {
 350     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 351     return mcGreen;
 352 }
 353
 354 inline void BitmapColor::SetGreen( sal_uInt8 cGreen )
 355 {
 356     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 357     mcGreen = cGreen;
 358 }
 359
 360 inline sal_uInt8 BitmapColor::GetBlue() const
 361 {
 362     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 363     return mcBlueOrIndex;
 364 }
 365
 366 inline void BitmapColor::SetBlue( sal_uInt8 cBlue )
 367 {
 368     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 369     mcBlueOrIndex = cBlue;
 370 }
 371
 372 inline sal_uInt8 BitmapColor::GetIndex() const
 373 {
 374     DBG_ASSERT( mbIndex, "Pixel represents color values!" );
 375     return mcBlueOrIndex;
 376 }
 377
 378 inline void BitmapColor::SetIndex( sal_uInt8 cIndex )
 379 {
 380     DBG_ASSERT( mbIndex, "Pixel represents color values!" );
 381     mcBlueOrIndex = cIndex;
 382 }
 383
 384 inline BitmapColor::operator Color() const
 385 {
 386     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 387     return Color( mcRed, mcGreen, mcBlueOrIndex );
 388 }
 389
 390 inline sal_uInt8 BitmapColor::GetBlueOrIndex() const
 391 {
 392     // #i47518# Yield a value regardless of mbIndex
 393     return mcBlueOrIndex;
 394 }
 395
 396 inline BitmapColor& BitmapColor::Invert()
 397 {
 398     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 399     mcBlueOrIndex = ~mcBlueOrIndex, mcGreen = ~mcGreen, mcRed = ~mcRed;
 400
 401     return *this;
 402 }
 403
 404 inline sal_uInt8 BitmapColor::GetLuminance() const
 405 {
 406     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 407     return (static_cast<unsigned long>(mcBlueOrIndex) * 28UL + static_cast<unsigned long>(mcGreen) * 151UL + static_cast<unsigned long>(mcRed) * 77UL) >> 8;
 408 }
 409
 410 inline BitmapColor& BitmapColor::IncreaseLuminance( sal_uInt8 cGreyInc )
 411 {
 412     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 413     mcBlueOrIndex = (sal_uInt8) MinMax( (long) mcBlueOrIndex + cGreyInc, 0L, 255L );
 414     mcGreen = (sal_uInt8) MinMax( (long) mcGreen + cGreyInc, 0L, 255L );
 415     mcRed = (sal_uInt8) MinMax( (long) mcRed + cGreyInc, 0L, 255L );
 416
 417     return *this;
 418 }
 419
 420 inline BitmapColor& BitmapColor::DecreaseLuminance( sal_uInt8 cGreyDec )
 421 {
 422     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 423     mcBlueOrIndex = (sal_uInt8) MinMax( (long) mcBlueOrIndex - cGreyDec, 0L, 255L );
 424     mcGreen = (sal_uInt8) MinMax( (long) mcGreen - cGreyDec, 0L, 255L );
 425     mcRed = (sal_uInt8) MinMax( (long) mcRed - cGreyDec, 0L, 255L );
 426
 427     return *this;
 428 }
 429
 430 inline BitmapColor& BitmapColor::Merge( const BitmapColor& rBitmapColor, sal_uInt8 cTransparency )
 431 {
 432     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 433     DBG_ASSERT( !rBitmapColor.mbIndex, "Pixel represents index into colortable!" );
 434     mcBlueOrIndex = COLOR_CHANNEL_MERGE( mcBlueOrIndex, rBitmapColor.mcBlueOrIndex, cTransparency );
 435     mcGreen = COLOR_CHANNEL_MERGE( mcGreen, rBitmapColor.mcGreen, cTransparency );
 436     mcRed = COLOR_CHANNEL_MERGE( mcRed, rBitmapColor.mcRed, cTransparency );
 437
 438     return *this;
 439 }
 440
 441 inline BitmapColor& BitmapColor::Merge( sal_uInt8 cR, sal_uInt8 cG, sal_uInt8 cB, sal_uInt8 cTransparency )
 442 {
 443     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 444     mcBlueOrIndex = COLOR_CHANNEL_MERGE( mcBlueOrIndex, cB, cTransparency );
 445     mcGreen = COLOR_CHANNEL_MERGE( mcGreen, cG, cTransparency );
 446     mcRed = COLOR_CHANNEL_MERGE( mcRed, cR, cTransparency );
 447
 448     return *this;
 449 }
 450
 451 inline sal_uLong BitmapColor::GetColorError( const BitmapColor& rBitmapColor ) const
 452 {
 453     DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
 454     DBG_ASSERT( !rBitmapColor.mbIndex, "Pixel represents index into colortable!" );
 455     return( (sal_uLong) ( labs( mcBlueOrIndex - rBitmapColor.mcBlueOrIndex ) +
 456                       labs( mcGreen - rBitmapColor.mcGreen ) +
 457                       labs( mcRed - rBitmapColor.mcRed ) ) );
 458 }
 459
 460 inline BitmapPalette::BitmapPalette() :
 461             mpBitmapColor   ( NULL ),
 462             mnCount         ( 0 )
 463 {
 464 }
 465
 466 inline BitmapPalette::BitmapPalette( const BitmapPalette& rBitmapPalette ) :
 467             mnCount( rBitmapPalette.mnCount )
 468 {
 469     if( mnCount )
 470     {
 471         const sal_uLong nSize = mnCount * sizeof( BitmapColor );
 472         mpBitmapColor = reinterpret_cast<BitmapColor*>(new sal_uInt8[ nSize ]);
 473         memcpy( mpBitmapColor, rBitmapPalette.mpBitmapColor, nSize );
 474     }
 475     else
 476         mpBitmapColor = NULL;
 477 }
 478
 479 inline BitmapPalette::BitmapPalette( sal_uInt16 nCount ) :
 480             mnCount( nCount )
 481 {
 482     if( mnCount )
 483     {
 484         const sal_uLong nSize = mnCount * sizeof( BitmapColor );
 485         mpBitmapColor = reinterpret_cast<BitmapColor*>(new sal_uInt8[ nSize ]);
 486         memset( mpBitmapColor, 0, nSize );
 487     }
 488     else
 489         mpBitmapColor = NULL;
 490 }
 491
 492 inline BitmapPalette::~BitmapPalette()
 493 {
 494     delete[] reinterpret_cast<sal_uInt8*>(mpBitmapColor);
 495 }
 496
 497 inline BitmapPalette& BitmapPalette::operator=( const BitmapPalette& rBitmapPalette )
 498 {
 499     delete[] reinterpret_cast<sal_uInt8*>(mpBitmapColor);
 500     mnCount = rBitmapPalette.mnCount;
 501
 502     if( mnCount )
 503     {
 504         const sal_uLong nSize = mnCount * sizeof( BitmapColor );
 505         mpBitmapColor = reinterpret_cast<BitmapColor*>(new sal_uInt8[ nSize ]);
 506         memcpy( mpBitmapColor, rBitmapPalette.mpBitmapColor, nSize );
 507     }
 508     else
 509         mpBitmapColor = NULL;
 510
 511     return *this;
 512 }
 513
 514 inline bool BitmapPalette::operator==( const BitmapPalette& rBitmapPalette ) const
 515 {
 516     bool bRet = false;
 517
 518     if( rBitmapPalette.mnCount == mnCount )
 519     {
 520         bRet = true;
 521
 522         for( sal_uInt16 i = 0; i < mnCount; i++ )
 523         {
 524             if( mpBitmapColor[ i ] != rBitmapPalette.mpBitmapColor[ i ] )
 525             {
 526                 bRet = false;
 527                 break;
 528             }
 529         }
 530     }
 531
 532     return bRet;
 533 }
 534
 535 inline bool BitmapPalette::operator!=( const BitmapPalette& rBitmapPalette ) const
 536 {
 537     return !( *this == rBitmapPalette );
 538 }
 539
 540 inline bool BitmapPalette::operator!()
 541 {
 542     return( !mnCount || !mpBitmapColor );
 543 }
 544
 545 inline sal_uInt16 BitmapPalette::GetEntryCount() const
 546 {
 547     return mnCount;
 548 }
 549
 550 inline void BitmapPalette::SetEntryCount( sal_uInt16 nCount )
 551 {
 552     if( !nCount )
 553     {
 554         delete[] reinterpret_cast<sal_uInt8*>(mpBitmapColor);
 555         mpBitmapColor = NULL;
 556         mnCount = 0;
 557     }
 558     else if( nCount != mnCount )
 559     {
 560         const sal_uLong nNewSize = nCount * sizeof( BitmapColor );
 561         const sal_uLong nMinSize = std::min( mnCount, nCount ) * sizeof( BitmapColor );
 562         sal_uInt8*      pNewColor = new sal_uInt8[ nNewSize ];
 563
 564         if ( nMinSize && mpBitmapColor )
 565             memcpy( pNewColor, mpBitmapColor, nMinSize );
 566         delete[] reinterpret_cast<sal_uInt8*>(mpBitmapColor);
 567         memset( pNewColor + nMinSize, 0, nNewSize - nMinSize );
 568         mpBitmapColor = reinterpret_cast<BitmapColor*>(pNewColor);
 569         mnCount = nCount;
 570     }
 571 }
 572
 573 inline const BitmapColor& BitmapPalette::operator[]( sal_uInt16 nIndex ) const
 574 {
 575     DBG_ASSERT( nIndex < mnCount, "Palette index is out of range!" );
 576     return mpBitmapColor[ nIndex ];
 577 }
 578
 579 inline BitmapColor& BitmapPalette::operator[]( sal_uInt16 nIndex )
 580 {
 581     DBG_ASSERT( nIndex < mnCount, "Palette index is out of range!" );
 582     return mpBitmapColor[ nIndex ];
 583 }
 584
 585 inline BitmapColor* BitmapPalette::ImplGetColorBuffer() const
 586 {
 587     DBG_ASSERT( mpBitmapColor, "No color buffer available!" );
 588     return mpBitmapColor;
 589 }
 590
 591 inline sal_uInt16 BitmapPalette::GetBestIndex( const BitmapColor& rCol ) const
 592 {
 593     sal_uInt16 nRetIndex = 0;
 594
 595     if( mpBitmapColor && mnCount )
 596     {
 597         bool bFound = false;
 598
 599         for( long j = 0L; ( j < mnCount ) && !bFound; j++ )
 600             if( rCol == mpBitmapColor[ j ] )
 601                 nRetIndex = ( (sal_uInt16) j ), bFound = true;
 602
 603         if( !bFound )
 604         {
 605             long nActErr, nLastErr = rCol.GetColorError( mpBitmapColor[ nRetIndex = mnCount - 1 ] );
 606
 607             for( long i = nRetIndex - 1; i >= 0L; i-- )
 608                 if ( ( nActErr = rCol.GetColorError( mpBitmapColor[ i ] ) ) < nLastErr )
 609                     nLastErr = nActErr, nRetIndex = (sal_uInt16) i;
 610         }
 611     }
 612
 613     return nRetIndex;
 614 }
 615
 616 inline ColorMask::ColorMask( sal_uLong nRedMask,
 617                              sal_uLong nGreenMask,
 618                              sal_uLong nBlueMask,
 619                              sal_uLong nAlphaChannel ) :
 620             mnRMask( nRedMask ),
 621             mnGMask( nGreenMask ),
 622             mnBMask( nBlueMask ),
 623             mnROrShift( 0L ),
 624             mnGOrShift( 0L ),
 625             mnBOrShift( 0L ),
 626             mnROr( 0L ),
 627             mnGOr( 0L ),
 628             mnBOr( 0L ),
 629             mnAlphaChannel( nAlphaChannel )
 630 {
 631     mnRShift = ( mnRMask ? ImplCalcMaskShift( mnRMask, mnROr, mnROrShift ) : 0L );
 632     mnGShift = ( mnGMask ? ImplCalcMaskShift( mnGMask, mnGOr, mnGOrShift ) : 0L );
 633     mnBShift = ( mnBMask ? ImplCalcMaskShift( mnBMask, mnBOr, mnBOrShift ) : 0L );
 634 }
 635
 636 inline long ColorMask::ImplCalcMaskShift( sal_uLong nMask, sal_uLong& rOr, sal_uLong& rOrShift ) const
 637 {
 638     long    nShift;
 639     long    nRet;
 640     sal_uLong   nLen = 0UL;
 641
 642     // from which bit starts the mask?
 643     for( nShift = 31L; ( nShift >= 0L ) && !( nMask & ( (sal_uLong)1 << (sal_uLong) nShift ) ); nShift-- )
 644     {}
 645
 646     nRet = nShift;
 647
 648     // XXX determine number of bits set => walk right until null
 649     while( ( nShift >= 0L ) && ( nMask & ( (sal_uLong)1 << (sal_uLong) nShift ) ) )
 650     {
 651         nShift--;
 652         nLen++;
 653     }
 654
 655     assert( nLen <= 8 ); // mask length must be 8 bits or less
 656     rOrShift = 8UL - nLen;
 657     rOr = (sal_uInt8) ( ( 0xffUL >> nLen ) << rOrShift );
 658
 659     return( nRet -= 7 );
 660 }
 661
 662 inline sal_uLong ColorMask::GetRedMask() const
 663 {
 664     return mnRMask;
 665 }
 666
 667 inline sal_uLong ColorMask::GetGreenMask() const
 668 {
 669     return mnGMask;
 670 }
 671
 672 inline sal_uLong ColorMask::GetBlueMask() const
 673 {
 674     return mnBMask;
 675 }
 676
 677 inline void ColorMask::GetColorFor8Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
 678 {
 679     const sal_uInt32 nVal = *pPixel;
 680     MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
 681 }
 682
 683 inline void ColorMask::SetColorFor8Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
 684 {
 685     *pPixel = (sal_uInt8) COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
 686 }
 687
 688 inline void ColorMask::GetColorFor16BitMSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const
 689 {
 690     const sal_uInt32 nVal = pPixel[ 1 ] | ( (sal_uInt32) pPixel[ 0 ] << 8UL );
 691
 692     MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
 693 }
 694
 695 inline void ColorMask::SetColorFor16BitMSB( const BitmapColor& rColor, HPBYTE pPixel ) const
 696 {
 697     const sal_uInt16 nVal = (sal_uInt16)COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
 698
 699     pPixel[ 0 ] = (sal_uInt8)(nVal >> 8U);
 700     pPixel[ 1 ] = (sal_uInt8) nVal;
 701 }
 702
 703 inline void ColorMask::GetColorFor16BitLSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const
 704 {
 705     const sal_uInt32 nVal = pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL );
 706
 707     MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
 708 }
 709
 710 inline void ColorMask::SetColorFor16BitLSB( const BitmapColor& rColor, HPBYTE pPixel ) const
 711 {
 712     const sal_uInt16 nVal = (sal_uInt16)COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
 713
 714     pPixel[ 0 ] = (sal_uInt8) nVal;
 715     pPixel[ 1 ] = (sal_uInt8)(nVal >> 8U);
 716 }
 717
 718 inline void ColorMask::GetColorFor24Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
 719 {
 720     const sal_uInt32 nVal = pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) | ( (sal_uInt32) pPixel[ 2 ] << 16UL );
 721     MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
 722 }
 723
 724 inline void ColorMask::SetColorFor24Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
 725 {
 726     const sal_uInt32 nVal = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
 727     pPixel[ 0 ] = (sal_uInt8) nVal; pPixel[ 1 ] = (sal_uInt8) ( nVal >> 8UL ); pPixel[ 2 ] = (sal_uInt8) ( nVal >> 16UL );
 728 }
 729
 730 inline void ColorMask::GetColorFor32Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
 731 {
 732     const sal_uInt32 nVal = (sal_uInt32) pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) |
 733                         ( (sal_uInt32) pPixel[ 2 ] << 16UL ) | ( (sal_uInt32) pPixel[ 3 ] << 24UL );
 734
 735     MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
 736 }
 737
 738 inline void ColorMask::GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, ConstHPBYTE pPixel ) const
 739 {
 740     const sal_uInt32 nVal = (sal_uInt32) pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) |
 741                         ( (sal_uInt32) pPixel[ 2 ] << 16UL ) | ( (sal_uInt32) pPixel[ 3 ] << 24UL );
 742     rAlpha = (sal_uInt8)(nVal >> 24);
 743
 744     MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
 745 }
 746
 747 inline void ColorMask::SetColorFor32Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
 748 {
 749     const sal_uInt32 nVal = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
 750     pPixel[ 0 ] = (sal_uInt8) nVal; pPixel[ 1 ] = (sal_uInt8) ( nVal >> 8UL );
 751     pPixel[ 2 ] = (sal_uInt8) ( nVal >> 16UL ); pPixel[ 3 ] = (sal_uInt8) ( nVal >> 24UL );
 752 }
 753
 754 #endif // INCLUDED_VCL_SALBTYPE_HXX
 755
 756 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */