9bb96049ad
(cherry picked from commit b2cc0de3fc9adee90787ca760e86869f9255b380) Conflicts: canvas/source/vcl/spritecanvashelper.cxx drawinglayer/Library_drawinglayer.mk drawinglayer/source/processor2d/vclhelperbitmaprender.cxx drawinglayer/source/processor2d/vclhelperbitmaprender.hxx drawinglayer/source/processor2d/vclhelperbitmaptransform.cxx drawinglayer/source/processor2d/vclhelperbitmaptransform.hxx drawinglayer/source/processor2d/vclprocessor2d.cxx officecfg/registry/schema/org/openoffice/Office/Draw.xcs svx/source/svdraw/svdograf.cxx vcl/aqua/source/gdi/salgdi.cxx vcl/inc/aqua/salgdi.h vcl/inc/os2/salgdi.h vcl/inc/salgdi.hxx vcl/inc/unx/pspgraphics.h vcl/inc/vcl/bitmapex.hxx vcl/inc/vcl/outdev.hxx vcl/inc/vcl/salbtype.hxx vcl/os2/source/gdi/salgdi2.cxx vcl/source/gdi/bitmapex.cxx vcl/source/gdi/outdev2.cxx vcl/source/gdi/salgdilayout.cxx vcl/source/gdi/salmisc.cxx vcl/unx/generic/gdi/pspgraphics.cxx vcl/unx/generic/gdi/salgdi2.cxx vcl/unx/headless/svpgdi.cxx vcl/unx/headless/svpgdi.hxx vcl/unx/headless/svppspgraphics.cxx vcl/unx/headless/svppspgraphics.hxx vcl/win/source/gdi/salbmp.cxx vcl/win/source/gdi/salgdi.cxx vcl/win/source/gdi/salgdi3.cxx vcl/win/source/gdi/salgdi_gdiplus.cxx vcl/win/source/gdi/winlayout.cxx Change-Id: I871d1d107b019758f3913e5eb63bc9bc0ba403fd Do not name unused arguments to prevent compiler warnings. (cherry picked from commit f3118889a0cd941f193e9b6557c0792015d77a34) Change-Id: I482d1f96d695c7bf9912ec464bb39e7fdd14adef Related: #i121534# fix graphite-enabled windows build (cherry picked from commit c90a6ca92b1239d01a2892e15488e4a183a88b1a) Conflicts: vcl/win/source/gdi/winlayout.cxx Change-Id: I95fd41ad6f7187f34ba9474674a471fb4fc65314
896 lines
29 KiB
C++
896 lines
29 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#ifndef _SV_SALBTYPE_HXX
|
|
#define _SV_SALBTYPE_HXX
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <osl/endian.h>
|
|
#include <tools/debug.hxx>
|
|
#include <vcl/salgtype.hxx>
|
|
#include <tools/color.hxx>
|
|
#include <tools/helpers.hxx>
|
|
#include <tools/solar.h>
|
|
#include <vcl/dllapi.h>
|
|
|
|
// ----------
|
|
// - Memory -
|
|
// ----------
|
|
|
|
typedef sal_uInt8* HPBYTE;
|
|
typedef HPBYTE Scanline;
|
|
typedef const sal_uInt8* ConstHPBYTE;
|
|
typedef ConstHPBYTE ConstScanline;
|
|
|
|
// ------------------
|
|
// - Bitmap formats -
|
|
// ------------------
|
|
|
|
#define BMP_FORMAT_BOTTOM_UP 0x00000000UL
|
|
#define BMP_FORMAT_TOP_DOWN 0x80000000UL
|
|
|
|
#define BMP_FORMAT_1BIT_MSB_PAL 0x00000001UL
|
|
#define BMP_FORMAT_1BIT_LSB_PAL 0x00000002UL
|
|
|
|
#define BMP_FORMAT_4BIT_MSN_PAL 0x00000004UL
|
|
#define BMP_FORMAT_4BIT_LSN_PAL 0x00000008UL
|
|
|
|
#define BMP_FORMAT_8BIT_PAL 0x00000010UL
|
|
#define BMP_FORMAT_8BIT_TC_MASK 0x00000020UL
|
|
|
|
// #define BMP_FORMAT_16BIT_TC_MASK 0x00000040UL
|
|
|
|
#define BMP_FORMAT_24BIT_TC_BGR 0x00000080UL
|
|
#define BMP_FORMAT_24BIT_TC_RGB 0x00000100UL
|
|
#define BMP_FORMAT_24BIT_TC_MASK 0x00000200UL
|
|
|
|
#define BMP_FORMAT_32BIT_TC_ABGR 0x00000400UL
|
|
#define BMP_FORMAT_32BIT_TC_ARGB 0x00000800UL
|
|
#define BMP_FORMAT_32BIT_TC_BGRA 0x00001000UL
|
|
#define BMP_FORMAT_32BIT_TC_RGBA 0x00002000UL
|
|
#define BMP_FORMAT_32BIT_TC_MASK 0x00004000UL
|
|
|
|
#define BMP_FORMAT_16BIT_TC_MSB_MASK 0x00008000UL
|
|
#define BMP_FORMAT_16BIT_TC_LSB_MASK 0x00010000UL
|
|
|
|
#define BMP_SCANLINE_ADJUSTMENT( Mac_nBmpFormat ) ( (Mac_nBmpFormat) & 0x80000000UL )
|
|
#define BMP_SCANLINE_FORMAT( Mac_nBmpFormat ) ( (Mac_nBmpFormat) & 0x7FFFFFFFUL )
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
#define MASK_TO_COLOR( d_nVal, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_Col ) \
|
|
sal_uLong _def_cR = (sal_uInt8) ( d_RS < 0L ? ( (d_nVal) & d_RM ) << -d_RS : ( (d_nVal) & d_RM ) >> d_RS ); \
|
|
sal_uLong _def_cG = (sal_uInt8) ( d_GS < 0L ? ( (d_nVal) & d_GM ) << -d_GS : ( (d_nVal) & d_GM ) >> d_GS ); \
|
|
sal_uLong _def_cB = (sal_uInt8) ( d_BS < 0L ? ( (d_nVal) & d_BM ) << -d_BS : ( (d_nVal) & d_BM ) >> d_BS ); \
|
|
d_Col = BitmapColor( (sal_uInt8) ( _def_cR | ( ( _def_cR & mnROr ) >> mnROrShift ) ), \
|
|
(sal_uInt8) ( _def_cG | ( ( _def_cG & mnGOr ) >> mnGOrShift ) ), \
|
|
(sal_uInt8) ( _def_cB | ( ( _def_cB & mnBOr ) >> mnBOrShift ) ) );
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
#define COLOR_TO_MASK( d_rCol, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS ) \
|
|
( ( ( ( d_RS < 0L ) ? ( (sal_uInt32) (d_rCol).GetRed() >> -d_RS ) : \
|
|
( (sal_uInt32) (d_rCol).GetRed() << d_RS ) ) & d_RM ) | \
|
|
( ( ( d_GS < 0L ) ? ( (sal_uInt32) (d_rCol).GetGreen() >> -d_GS ) : \
|
|
( (sal_uInt32) (d_rCol).GetGreen() << d_GS ) ) & d_GM ) | \
|
|
( ( ( d_BS < 0L ) ? ( (sal_uInt32) (d_rCol).GetBlue() >> -d_BS ) : \
|
|
( (sal_uInt32) (d_rCol).GetBlue() << d_BS ) ) & d_BM ) )
|
|
|
|
// ---------------
|
|
// - BitmapColor -
|
|
// ---------------
|
|
|
|
class Color;
|
|
|
|
class VCL_DLLPUBLIC BitmapColor
|
|
{
|
|
private:
|
|
|
|
// ATTENTION:
|
|
// Because the members of this class are accessed via memcpy,
|
|
// you MUST NOT CHANGE the order of the members or the size of this class!
|
|
sal_uInt8 mcBlueOrIndex;
|
|
sal_uInt8 mcGreen;
|
|
sal_uInt8 mcRed;
|
|
sal_uInt8 mbIndex;
|
|
|
|
public:
|
|
|
|
inline BitmapColor();
|
|
inline BitmapColor( const BitmapColor& rBitmapColor );
|
|
inline BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue );
|
|
inline BitmapColor( const Color& rColor );
|
|
explicit inline BitmapColor( sal_uInt8 cIndex );
|
|
|
|
inline ~BitmapColor() {};
|
|
|
|
inline sal_Bool operator==( const BitmapColor& rBitmapColor ) const;
|
|
inline sal_Bool operator!=( const BitmapColor& rBitmapColor ) const;
|
|
inline BitmapColor& operator=( const BitmapColor& rBitmapColor );
|
|
|
|
inline sal_Bool IsIndex() const;
|
|
|
|
inline sal_uInt8 GetRed() const;
|
|
inline void SetRed( sal_uInt8 cRed );
|
|
|
|
inline sal_uInt8 GetGreen() const;
|
|
inline void SetGreen( sal_uInt8 cGreen );
|
|
|
|
inline sal_uInt8 GetBlue() const;
|
|
inline void SetBlue( sal_uInt8 cBlue );
|
|
|
|
inline sal_uInt8 GetIndex() const;
|
|
inline void SetIndex( sal_uInt8 cIndex );
|
|
|
|
operator Color() const;
|
|
|
|
inline sal_uInt8 GetBlueOrIndex() const;
|
|
|
|
inline BitmapColor& Invert();
|
|
|
|
inline sal_uInt8 GetLuminance() const;
|
|
inline BitmapColor& IncreaseLuminance( sal_uInt8 cGreyInc );
|
|
inline BitmapColor& DecreaseLuminance( sal_uInt8 cGreyDec );
|
|
|
|
inline BitmapColor& Merge( const BitmapColor& rColor, sal_uInt8 cTransparency );
|
|
inline BitmapColor& Merge( sal_uInt8 cR, sal_uInt8 cG, sal_uInt8 cB, sal_uInt8 cTransparency );
|
|
|
|
inline sal_uLong GetColorError( const BitmapColor& rBitmapColor ) const;
|
|
};
|
|
|
|
// ---------------
|
|
// - BitmapPalette -
|
|
// ---------------
|
|
|
|
class Palette;
|
|
|
|
class VCL_DLLPUBLIC BitmapPalette
|
|
{
|
|
friend class SalBitmap;
|
|
friend class BitmapAccess;
|
|
|
|
private:
|
|
|
|
BitmapColor* mpBitmapColor;
|
|
sal_uInt16 mnCount;
|
|
|
|
public:
|
|
|
|
SAL_DLLPRIVATE inline BitmapColor* ImplGetColorBuffer() const;
|
|
|
|
|
|
public:
|
|
|
|
inline BitmapPalette();
|
|
inline BitmapPalette( const BitmapPalette& rBitmapPalette );
|
|
inline BitmapPalette( sal_uInt16 nCount );
|
|
inline ~BitmapPalette();
|
|
|
|
inline BitmapPalette& operator=( const BitmapPalette& rBitmapPalette );
|
|
inline sal_Bool operator==( const BitmapPalette& rBitmapPalette ) const;
|
|
inline sal_Bool operator!=( const BitmapPalette& rBitmapPalette ) const;
|
|
inline sal_Bool operator!();
|
|
|
|
inline sal_uInt16 GetEntryCount() const;
|
|
inline void SetEntryCount( sal_uInt16 nCount );
|
|
|
|
inline const BitmapColor& operator[]( sal_uInt16 nIndex ) const;
|
|
inline BitmapColor& operator[]( sal_uInt16 nIndex );
|
|
|
|
inline sal_uInt16 GetBestIndex( const BitmapColor& rCol ) const;
|
|
bool IsGreyPalette() const;
|
|
};
|
|
|
|
// ---------------
|
|
// - ColorMask -
|
|
// ---------------
|
|
|
|
class VCL_DLLPUBLIC ColorMask
|
|
{
|
|
sal_uLong mnRMask;
|
|
sal_uLong mnGMask;
|
|
sal_uLong mnBMask;
|
|
long mnRShift;
|
|
long mnGShift;
|
|
long mnBShift;
|
|
sal_uLong mnROrShift;
|
|
sal_uLong mnGOrShift;
|
|
sal_uLong mnBOrShift;
|
|
sal_uLong mnROr;
|
|
sal_uLong mnGOr;
|
|
sal_uLong mnBOr;
|
|
|
|
SAL_DLLPRIVATE inline long ImplCalcMaskShift( sal_uLong nMask, sal_uLong& rOr, sal_uLong& rOrShift ) const;
|
|
|
|
public:
|
|
|
|
inline ColorMask( sal_uLong nRedMask = 0UL, sal_uLong nGreenMask = 0UL, sal_uLong nBlueMask = 0UL );
|
|
inline ~ColorMask() {}
|
|
|
|
inline sal_uLong GetRedMask() const;
|
|
inline sal_uLong GetGreenMask() const;
|
|
inline sal_uLong GetBlueMask() const;
|
|
|
|
inline void GetColorFor8Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
|
|
inline void SetColorFor8Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
|
|
|
|
inline void GetColorFor16BitMSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
|
|
inline void SetColorFor16BitMSB( const BitmapColor& rColor, HPBYTE pPixel ) const;
|
|
inline void GetColorFor16BitLSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
|
|
inline void SetColorFor16BitLSB( const BitmapColor& rColor, HPBYTE pPixel ) const;
|
|
|
|
inline void GetColorFor24Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
|
|
inline void SetColorFor24Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
|
|
|
|
inline void GetColorFor32Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
|
|
inline void GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, ConstHPBYTE pPixel ) const;
|
|
inline void SetColorFor32Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
|
|
};
|
|
|
|
// ---------------
|
|
// - BitmapBuffer -
|
|
// ---------------
|
|
|
|
struct VCL_DLLPUBLIC BitmapBuffer
|
|
{
|
|
sal_uLong mnFormat;
|
|
long mnWidth;
|
|
long mnHeight;
|
|
long mnScanlineSize;
|
|
sal_uInt16 mnBitCount;
|
|
ColorMask maColorMask;
|
|
BitmapPalette maPalette;
|
|
sal_uInt8* mpBits;
|
|
|
|
BitmapBuffer(){}
|
|
~BitmapBuffer() {}
|
|
};
|
|
|
|
// ---------------------
|
|
// - StretchAndConvert -
|
|
// ---------------------
|
|
|
|
VCL_DLLPUBLIC BitmapBuffer* StretchAndConvert(
|
|
const BitmapBuffer& rSrcBuffer, const SalTwoRect& rTwoRect,
|
|
sal_uLong nDstBitmapFormat, const BitmapPalette* pDstPal = NULL, const ColorMask* pDstMask = NULL );
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor::BitmapColor() :
|
|
mcBlueOrIndex ( 0 ),
|
|
mcGreen ( 0 ),
|
|
mcRed ( 0 ),
|
|
mbIndex ( sal_False )
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor::BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue ) :
|
|
mcBlueOrIndex ( cBlue ),
|
|
mcGreen ( cGreen ),
|
|
mcRed ( cRed ),
|
|
mbIndex ( sal_False )
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor::BitmapColor( const BitmapColor& rBitmapColor ) :
|
|
mcBlueOrIndex ( rBitmapColor.mcBlueOrIndex ),
|
|
mcGreen ( rBitmapColor.mcGreen ),
|
|
mcRed ( rBitmapColor.mcRed ),
|
|
mbIndex ( rBitmapColor.mbIndex )
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor::BitmapColor( const Color& rColor ) :
|
|
mcBlueOrIndex ( rColor.GetBlue() ),
|
|
mcGreen ( rColor.GetGreen() ),
|
|
mcRed ( rColor.GetRed() ),
|
|
mbIndex ( 0 )
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor::BitmapColor( sal_uInt8 cIndex ) :
|
|
mcBlueOrIndex ( cIndex ),
|
|
mcGreen ( 0 ),
|
|
mcRed ( 0 ),
|
|
mbIndex ( sal_True )
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_Bool BitmapColor::operator==( const BitmapColor& rBitmapColor ) const
|
|
{
|
|
return( ( mcBlueOrIndex == rBitmapColor.mcBlueOrIndex ) &&
|
|
( mbIndex ? rBitmapColor.mbIndex :
|
|
( mcGreen == rBitmapColor.mcGreen && mcRed == rBitmapColor.mcRed ) ) );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_Bool BitmapColor::operator!=( const BitmapColor& rBitmapColor ) const
|
|
{
|
|
return !( *this == rBitmapColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapColor::operator=( const BitmapColor& rBitmapColor )
|
|
{
|
|
mcBlueOrIndex = rBitmapColor.mcBlueOrIndex;
|
|
mcGreen = rBitmapColor.mcGreen;
|
|
mcRed = rBitmapColor.mcRed;
|
|
mbIndex = rBitmapColor.mbIndex;
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_Bool BitmapColor::IsIndex() const
|
|
{
|
|
return mbIndex;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt8 BitmapColor::GetRed() const
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
return mcRed;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void BitmapColor::SetRed( sal_uInt8 cRed )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcRed = cRed;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt8 BitmapColor::GetGreen() const
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
return mcGreen;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void BitmapColor::SetGreen( sal_uInt8 cGreen )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcGreen = cGreen;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt8 BitmapColor::GetBlue() const
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
return mcBlueOrIndex;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void BitmapColor::SetBlue( sal_uInt8 cBlue )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcBlueOrIndex = cBlue;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt8 BitmapColor::GetIndex() const
|
|
{
|
|
DBG_ASSERT( mbIndex, "Pixel represents color values!" );
|
|
return mcBlueOrIndex;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void BitmapColor::SetIndex( sal_uInt8 cIndex )
|
|
{
|
|
DBG_ASSERT( mbIndex, "Pixel represents color values!" );
|
|
mcBlueOrIndex = cIndex;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor::operator Color() const
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
return Color( mcRed, mcGreen, mcBlueOrIndex );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt8 BitmapColor::GetBlueOrIndex() const
|
|
{
|
|
// #i47518# Yield a value regardless of mbIndex
|
|
return mcBlueOrIndex;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapColor::Invert()
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcBlueOrIndex = ~mcBlueOrIndex, mcGreen = ~mcGreen, mcRed = ~mcRed;
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt8 BitmapColor::GetLuminance() const
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
return( (sal_uInt8) ( ( mcBlueOrIndex * 28UL + mcGreen * 151UL + mcRed * 77UL ) >> 8UL ) );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapColor::IncreaseLuminance( sal_uInt8 cGreyInc )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcBlueOrIndex = (sal_uInt8) MinMax( (long) mcBlueOrIndex + cGreyInc, 0L, 255L );
|
|
mcGreen = (sal_uInt8) MinMax( (long) mcGreen + cGreyInc, 0L, 255L );
|
|
mcRed = (sal_uInt8) MinMax( (long) mcRed + cGreyInc, 0L, 255L );
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapColor::DecreaseLuminance( sal_uInt8 cGreyDec )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcBlueOrIndex = (sal_uInt8) MinMax( (long) mcBlueOrIndex - cGreyDec, 0L, 255L );
|
|
mcGreen = (sal_uInt8) MinMax( (long) mcGreen - cGreyDec, 0L, 255L );
|
|
mcRed = (sal_uInt8) MinMax( (long) mcRed - cGreyDec, 0L, 255L );
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapColor::Merge( const BitmapColor& rBitmapColor, sal_uInt8 cTransparency )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
DBG_ASSERT( !rBitmapColor.mbIndex, "Pixel represents index into colortable!" );
|
|
mcBlueOrIndex = COLOR_CHANNEL_MERGE( mcBlueOrIndex, rBitmapColor.mcBlueOrIndex, cTransparency );
|
|
mcGreen = COLOR_CHANNEL_MERGE( mcGreen, rBitmapColor.mcGreen, cTransparency );
|
|
mcRed = COLOR_CHANNEL_MERGE( mcRed, rBitmapColor.mcRed, cTransparency );
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapColor::Merge( sal_uInt8 cR, sal_uInt8 cG, sal_uInt8 cB, sal_uInt8 cTransparency )
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
mcBlueOrIndex = COLOR_CHANNEL_MERGE( mcBlueOrIndex, cB, cTransparency );
|
|
mcGreen = COLOR_CHANNEL_MERGE( mcGreen, cG, cTransparency );
|
|
mcRed = COLOR_CHANNEL_MERGE( mcRed, cR, cTransparency );
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uLong BitmapColor::GetColorError( const BitmapColor& rBitmapColor ) const
|
|
{
|
|
DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
|
|
DBG_ASSERT( !rBitmapColor.mbIndex, "Pixel represents index into colortable!" );
|
|
return( (sal_uLong) ( labs( mcBlueOrIndex - rBitmapColor.mcBlueOrIndex ) +
|
|
labs( mcGreen - rBitmapColor.mcGreen ) +
|
|
labs( mcRed - rBitmapColor.mcRed ) ) );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapPalette::BitmapPalette() :
|
|
mpBitmapColor ( NULL ),
|
|
mnCount ( 0 )
|
|
{
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapPalette::BitmapPalette( const BitmapPalette& rBitmapPalette ) :
|
|
mnCount( rBitmapPalette.mnCount )
|
|
{
|
|
if( mnCount )
|
|
{
|
|
const sal_uLong nSize = mnCount * sizeof( BitmapColor );
|
|
mpBitmapColor = (BitmapColor*) new sal_uInt8[ nSize ];
|
|
memcpy( mpBitmapColor, rBitmapPalette.mpBitmapColor, nSize );
|
|
}
|
|
else
|
|
mpBitmapColor = NULL;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapPalette::BitmapPalette( sal_uInt16 nCount ) :
|
|
mnCount( nCount )
|
|
{
|
|
if( mnCount )
|
|
{
|
|
const sal_uLong nSize = mnCount * sizeof( BitmapColor );
|
|
mpBitmapColor = (BitmapColor*) new sal_uInt8[ nSize ];
|
|
memset( mpBitmapColor, 0, nSize );
|
|
}
|
|
else
|
|
mpBitmapColor = NULL;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapPalette::~BitmapPalette()
|
|
{
|
|
delete[] (sal_uInt8*) mpBitmapColor;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapPalette& BitmapPalette::operator=( const BitmapPalette& rBitmapPalette )
|
|
{
|
|
delete[] (sal_uInt8*) mpBitmapColor;
|
|
mnCount = rBitmapPalette.mnCount;
|
|
|
|
if( mnCount )
|
|
{
|
|
const sal_uLong nSize = mnCount * sizeof( BitmapColor );
|
|
mpBitmapColor = (BitmapColor*) new sal_uInt8[ nSize ];
|
|
memcpy( mpBitmapColor, rBitmapPalette.mpBitmapColor, nSize );
|
|
}
|
|
else
|
|
mpBitmapColor = NULL;
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_Bool BitmapPalette::operator==( const BitmapPalette& rBitmapPalette ) const
|
|
{
|
|
sal_Bool bRet = sal_False;
|
|
|
|
if( rBitmapPalette.mnCount == mnCount )
|
|
{
|
|
bRet = sal_True;
|
|
|
|
for( sal_uInt16 i = 0; i < mnCount; i++ )
|
|
{
|
|
if( mpBitmapColor[ i ] != rBitmapPalette.mpBitmapColor[ i ] )
|
|
{
|
|
bRet = sal_False;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_Bool BitmapPalette::operator!=( const BitmapPalette& rBitmapPalette ) const
|
|
{
|
|
return !( *this == rBitmapPalette );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_Bool BitmapPalette::operator!()
|
|
{
|
|
return( !mnCount || !mpBitmapColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt16 BitmapPalette::GetEntryCount() const
|
|
{
|
|
return mnCount;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void BitmapPalette::SetEntryCount( sal_uInt16 nCount )
|
|
{
|
|
if( !nCount )
|
|
{
|
|
delete[] (sal_uInt8*) mpBitmapColor;
|
|
mpBitmapColor = NULL;
|
|
mnCount = 0;
|
|
}
|
|
else if( nCount != mnCount )
|
|
{
|
|
const sal_uLong nNewSize = nCount * sizeof( BitmapColor );
|
|
const sal_uLong nMinSize = std::min( mnCount, nCount ) * sizeof( BitmapColor );
|
|
sal_uInt8* pNewColor = new sal_uInt8[ nNewSize ];
|
|
|
|
if ( nMinSize && mpBitmapColor )
|
|
memcpy( pNewColor, mpBitmapColor, nMinSize );
|
|
delete[] (sal_uInt8*) mpBitmapColor;
|
|
memset( pNewColor + nMinSize, 0, nNewSize - nMinSize );
|
|
mpBitmapColor = (BitmapColor*) pNewColor;
|
|
mnCount = nCount;
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline const BitmapColor& BitmapPalette::operator[]( sal_uInt16 nIndex ) const
|
|
{
|
|
DBG_ASSERT( nIndex < mnCount, "Palette index is out of range!" );
|
|
return mpBitmapColor[ nIndex ];
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor& BitmapPalette::operator[]( sal_uInt16 nIndex )
|
|
{
|
|
DBG_ASSERT( nIndex < mnCount, "Palette index is out of range!" );
|
|
return mpBitmapColor[ nIndex ];
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline BitmapColor* BitmapPalette::ImplGetColorBuffer() const
|
|
{
|
|
DBG_ASSERT( mpBitmapColor, "No color buffer available!" );
|
|
return mpBitmapColor;
|
|
}
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uInt16 BitmapPalette::GetBestIndex( const BitmapColor& rCol ) const
|
|
{
|
|
sal_uInt16 nRetIndex = 0;
|
|
|
|
if( mpBitmapColor && mnCount )
|
|
{
|
|
sal_Bool bFound = sal_False;
|
|
|
|
for( long j = 0L; ( j < mnCount ) && !bFound; j++ )
|
|
if( rCol == mpBitmapColor[ j ] )
|
|
nRetIndex = ( (sal_uInt16) j ), bFound = sal_True;
|
|
|
|
if( !bFound )
|
|
{
|
|
long nActErr, nLastErr = rCol.GetColorError( mpBitmapColor[ nRetIndex = mnCount - 1 ] );
|
|
|
|
for( long i = nRetIndex - 1; i >= 0L; i-- )
|
|
if ( ( nActErr = rCol.GetColorError( mpBitmapColor[ i ] ) ) < nLastErr )
|
|
nLastErr = nActErr, nRetIndex = (sal_uInt16) i;
|
|
}
|
|
}
|
|
|
|
return nRetIndex;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline ColorMask::ColorMask( sal_uLong nRedMask, sal_uLong nGreenMask, sal_uLong nBlueMask ) :
|
|
mnRMask( nRedMask ),
|
|
mnGMask( nGreenMask ),
|
|
mnBMask( nBlueMask ),
|
|
mnROrShift( 0L ),
|
|
mnGOrShift( 0L ),
|
|
mnBOrShift( 0L ),
|
|
mnROr( 0L ),
|
|
mnGOr( 0L ),
|
|
mnBOr( 0L )
|
|
{
|
|
mnRShift = ( mnRMask ? ImplCalcMaskShift( mnRMask, mnROr, mnROrShift ) : 0L );
|
|
mnGShift = ( mnGMask ? ImplCalcMaskShift( mnGMask, mnGOr, mnGOrShift ) : 0L );
|
|
mnBShift = ( mnBMask ? ImplCalcMaskShift( mnBMask, mnBOr, mnBOrShift ) : 0L );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline long ColorMask::ImplCalcMaskShift( sal_uLong nMask, sal_uLong& rOr, sal_uLong& rOrShift ) const
|
|
{
|
|
long nShift;
|
|
long nRet;
|
|
sal_uLong nLen = 0UL;
|
|
|
|
// from which bit starts the mask?
|
|
for( nShift = 31L; ( nShift >= 0L ) && !( nMask & ( 1 << (sal_uLong) nShift ) ); nShift-- )
|
|
{}
|
|
|
|
nRet = nShift;
|
|
|
|
// XXX determine number of bits set => walk right until null
|
|
while( ( nShift >= 0L ) && ( nMask & ( 1 << (sal_uLong) nShift ) ) )
|
|
{
|
|
nShift--;
|
|
nLen++;
|
|
}
|
|
|
|
rOrShift = 8L - nLen;
|
|
rOr = (sal_uInt8) ( ( 0xffUL >> nLen ) << rOrShift );
|
|
|
|
return( nRet -= 7 );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uLong ColorMask::GetRedMask() const
|
|
{
|
|
return mnRMask;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uLong ColorMask::GetGreenMask() const
|
|
{
|
|
return mnGMask;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline sal_uLong ColorMask::GetBlueMask() const
|
|
{
|
|
return mnBMask;
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::GetColorFor8Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
|
|
{
|
|
const sal_uInt32 nVal = *pPixel;
|
|
MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::SetColorFor8Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
|
|
{
|
|
*pPixel = (sal_uInt8) COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::GetColorFor16BitMSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const
|
|
{
|
|
#ifdef OSL_BIGENDIAN
|
|
const sal_uInt32 nVal = *(sal_uInt16*) pPixel;
|
|
#else
|
|
const sal_uInt32 nVal = pPixel[ 1 ] | ( (sal_uInt32) pPixel[ 0 ] << 8UL );
|
|
#endif
|
|
|
|
MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::SetColorFor16BitMSB( const BitmapColor& rColor, HPBYTE pPixel ) const
|
|
{
|
|
const sal_uInt16 nVal = (sal_uInt16)COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift );
|
|
|
|
#ifdef OSL_BIGENDIAN
|
|
*(sal_uInt16*) pPixel = nVal;
|
|
#else
|
|
pPixel[ 0 ] = (sal_uInt8)(nVal >> 8U);
|
|
pPixel[ 1 ] = (sal_uInt8) nVal;
|
|
#endif
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::GetColorFor16BitLSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const
|
|
{
|
|
#ifdef OSL_BIGENDIAN
|
|
const sal_uInt32 nVal = pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL );
|
|
#else
|
|
const sal_uInt32 nVal = *(sal_uInt16*) pPixel;
|
|
#endif
|
|
|
|
MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::SetColorFor16BitLSB( const BitmapColor& rColor, HPBYTE pPixel ) const
|
|
{
|
|
const sal_uInt16 nVal = (sal_uInt16)COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift );
|
|
|
|
#ifdef OSL_BIGENDIAN
|
|
pPixel[ 0 ] = (sal_uInt8) nVal;
|
|
pPixel[ 1 ] = (sal_uInt8)(nVal >> 8U);
|
|
#else
|
|
*(sal_uInt16*) pPixel = nVal;
|
|
#endif
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::GetColorFor24Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
|
|
{
|
|
const sal_uInt32 nVal = pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) | ( (sal_uInt32) pPixel[ 2 ] << 16UL );
|
|
MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::SetColorFor24Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
|
|
{
|
|
const sal_uInt32 nVal = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift );
|
|
pPixel[ 0 ] = (sal_uInt8) nVal; pPixel[ 1 ] = (sal_uInt8) ( nVal >> 8UL ); pPixel[ 2 ] = (sal_uInt8) ( nVal >> 16UL );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::GetColorFor32Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
|
|
{
|
|
#ifdef OSL_BIGENDIAN
|
|
const sal_uInt32 nVal = (sal_uInt32) pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) |
|
|
( (sal_uInt32) pPixel[ 2 ] << 16UL ) | ( (sal_uInt32) pPixel[ 3 ] << 24UL );
|
|
#else
|
|
const sal_uInt32 nVal = *(sal_uInt32*) pPixel;
|
|
#endif
|
|
|
|
MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, ConstHPBYTE pPixel ) const
|
|
{
|
|
#ifdef OSL_BIGENDIAN
|
|
const sal_uInt32 nVal = (sal_uInt32) pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) |
|
|
( (sal_uInt32) pPixel[ 2 ] << 16UL ) | ( (sal_uInt32) pPixel[ 3 ] << 24UL );
|
|
#else
|
|
const sal_uInt32 nVal = *(sal_uInt32*) pPixel;
|
|
#endif
|
|
rAlpha = (sal_uInt8)(nVal >> 24);
|
|
|
|
MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
|
|
}
|
|
|
|
// ------------------------------------------------------------------
|
|
|
|
inline void ColorMask::SetColorFor32Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
|
|
{
|
|
#ifdef OSL_BIGENDIAN
|
|
const sal_uInt32 nVal = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift );
|
|
pPixel[ 0 ] = (sal_uInt8) nVal; pPixel[ 1 ] = (sal_uInt8) ( nVal >> 8UL );
|
|
pPixel[ 2 ] = (sal_uInt8) ( nVal >> 16UL ); pPixel[ 3 ] = (sal_uInt8) ( nVal >> 24UL );
|
|
#else
|
|
*(sal_uInt32*) pPixel = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift );
|
|
#endif
|
|
}
|
|
|
|
#endif // _SV_SALBTYPE_HXX
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|