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