24 #include <com/sun/star/graphic/SvgTools.hpp>
25 #include <com/sun/star/graphic/Primitive2DTools.hpp>
29 #include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
35 #if ENABLE_CAIRO_CANVAS
66 SAL_WARN_IF(!bSuccess,
"vcl",
"vcl::bitmap::loadFromName : could not load image " << rFileName <<
" via icon theme " << aIconTheme);
74 const uno::Reference<graphic::XSvgParser> xSvgParser = graphic::SvgTools::create(xContext);
77 std::vector<sal_Int8>
aBuffer(nSize + 1);
81 uno::Sequence<sal_Int8>
aData(aBuffer.data(), nSize + 1);
84 const Primitive2DSequence aPrimitiveSequence = xSvgParser->getDecomposition(aInputStream, sPath);
86 if (!aPrimitiveSequence.hasElements())
89 uno::Sequence<beans::PropertyValue> aViewParameters;
91 geometry::RealRectangle2D aRealRect;
97 aRealRect = xReference->
getRange(aViewParameters);
102 aRealRect.X1 = aRange.
getMinX();
103 aRealRect.Y1 = aRange.
getMinY();
104 aRealRect.X2 = aRange.
getMaxX();
105 aRealRect.Y2 = aRange.
getMaxY();
107 double nDPI = 96 * fScalingFactor;
109 const css::uno::Reference<css::graphic::XPrimitive2DRenderer> xPrimitive2DRenderer = css::graphic::Primitive2DTools::create(xContext);
110 const css::uno::Reference<css::rendering::XBitmap> xBitmap(
111 xPrimitive2DRenderer->rasterize(aPrimitiveSequence, aViewParameters, nDPI, nDPI, aRealRect, 256*256));
115 const css::uno::Reference<css::rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap, uno::UNO_QUERY_THROW);
131 auto nBitCount = sal_uInt16(ePixelFormat);
136 Bitmap aBmp(
Size(nWidth, nHeight), ePixelFormat);
142 std::unique_ptr<AlphaMask> pAlphaMask;
153 Scanline pScanline = pWrite->GetScanline(
y);
157 int bitIndex = (
y * nStride) % 8;
158 pWrite->SetPixelOnData(pScanline,
x,
BitmapColor((*p >> bitIndex) & 1));
167 Scanline pScanline = pWrite->GetScanline(
y);
171 pWrite->SetPixelOnData(pScanline,
x, col);
176 p = pData + (
y * nStride) + 3;
177 Scanline pMaskScanLine = xMaskAcc->GetScanline(
y);
180 xMaskAcc->SetPixelOnData(pMaskScanLine,
x,
BitmapColor(*p));
197 auto nBitCount = rawBitmap.GetBitCount();
209 Bitmap aBmp(rawBitmap.maSize, ePixelFormat);
215 std::unique_ptr<AlphaMask> pAlphaMask;
223 auto nHeight = rawBitmap.maSize.getHeight();
224 auto nWidth = rawBitmap.maSize.getWidth();
228 sal_uInt8 const *
p = rawBitmap.mpData.get() + (
y * nStride);
229 Scanline pScanline = pWrite->GetScanline(
y);
233 pWrite->SetPixelOnData(pScanline,
x, col);
238 p = rawBitmap.mpData.get() + (
y * nStride) + 3;
239 Scanline pMaskScanLine = xMaskAcc->GetScanline(
y);
242 xMaskAcc->SetPixelOnData(pMaskScanLine,
x,
BitmapColor(255 - *p));
253 #if ENABLE_CAIRO_CANVAS
259 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
260 cairo_surface_t *pPixels = cairo_surface_create_similar_image(pSurface,
264 CAIRO_FORMAT_ARGB32, aSize.
Width(), aSize.
Height());
265 cairo_t *pCairo = cairo_create( pPixels );
266 if( !pPixels || !pCairo || cairo_status(pCairo) != CAIRO_STATUS_SUCCESS )
272 cairo_set_source_surface( pCairo, pSurface, 0, 0 );
273 cairo_set_operator( pCairo, CAIRO_OPERATOR_SOURCE );
274 cairo_paint( pCairo );
289 cairo_surface_flush(pPixels);
290 unsigned char *pSrc = cairo_image_surface_get_data( pPixels );
291 unsigned int nStride = cairo_image_surface_get_stride( pPixels );
295 sal_uInt32 *pPix =
reinterpret_cast<sal_uInt32 *
>(pSrc + nStride *
y);
298 #if defined OSL_BIGENDIAN
309 if( nAlpha != 0 && nAlpha != 255 )
312 nR = unpremultiply_table[nAlpha][nR];
313 nG = unpremultiply_table[nAlpha][nG];
314 nB = unpremultiply_table[nAlpha][nB];
316 pRGBWrite->SetPixel( y, x,
BitmapColor( nR, nG, nB ) );
317 pMaskWrite->SetPixelIndex( y, x, 255 - nAlpha );
325 ::BitmapEx *pBitmapEx = new ::BitmapEx( aRGB, aMask );
327 cairo_destroy( pCairo );
328 cairo_surface_destroy( pPixels );
334 const ::basegfx::B2DHomMatrix& rTransform,
354 aSrcAlpha.AcquireReadAccess() :
358 if( pReadAccess.
get() ==
nullptr ||
359 (pAlphaReadAccess.get() ==
nullptr && rBitmap.
IsTransparent()) )
363 "transformBitmap(): could not access source bitmap" );
386 const BitmapColor& rCol0( pAlphaReadAccess->GetPaletteColor( 0 ) );
387 const BitmapColor& rCol1( pAlphaReadAccess->GetPaletteColor( 1 ) );
391 aAlphaMap[0] = rCol0.
GetRed();
392 aAlphaMap[1] = rCol1.GetRed();
403 Bitmap aDstBitmap(aDestBmpSize, aSrcBitmap.getPixelFormat(), &pReadAccess->
GetPalette());
416 if( pWriteAccess.
get() !=
nullptr &&
417 pAlphaWriteAccess.
get() !=
nullptr &&
418 rTransform.isInvertible() )
433 Scanline pScan = pWriteAccess->GetScanline(
y );
434 Scanline pScanAlpha = pAlphaWriteAccess->GetScanline(
y );
439 aPoint *= aTransform;
443 if( nSrcX < 0 || nSrcX >= aBmpSize.Width() ||
444 nSrcY < 0 || nSrcY >= aBmpSize.Height() )
446 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(255) );
450 const sal_uInt8 cAlphaIdx = pAlphaReadAccess->GetPixelIndex( nSrcY, nSrcX );
451 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(aAlphaMap[ cAlphaIdx ]) );
452 pWriteAccess->SetPixelOnData( pScan,
x, pReadAccess->
GetPixel( nSrcY, nSrcX ) );
458 Scanline pScan = pWriteAccess->GetScanline(
y );
459 Scanline pScanAlpha = pAlphaWriteAccess->GetScanline(
y );
463 aPoint *= aTransform;
467 if( nSrcX < 0 || nSrcX >= aBmpSize.Width() ||
468 nSrcY < 0 || nSrcY >= aBmpSize.Height() )
470 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(255) );
474 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(0) );
475 pWriteAccess->SetPixelOnData( pScan,
x, pReadAccess->
GetPixel( nSrcY,
486 "transformBitmap(): could not access bitmap" );
505 aOldMask = rBitmapEx.
GetMask();
511 assert(pOld &&
"Got no access to old alpha mask (!)");
513 const double fFactor(1.0 / 255.0);
515 if(bFixedTransparence)
517 const double fOpNew(1.0 - fTransparence);
521 Scanline pScanline = pOld->GetScanline(
y );
524 const double fOpOld(1.0 - (pOld->GetIndexFromData(pScanline,
x) * fFactor));
535 assert(pNew &&
"Got no access to new alpha mask (!)");
537 assert(pOld->Width() == pNew->Width() && pOld->Height() == pNew->Height() &&
538 "Alpha masks have different sizes (!)");
542 Scanline pScanline = pOld->GetScanline(
y );
545 const double fOpOld(1.0 - (pOld->GetIndexFromData(pScanline,
x) * fFactor));
546 const double fOpNew(1.0 - (pNew->GetIndexFromData(pScanline,
x) * fFactor));
564 MapMode aMapMode( MapUnit::Map100thMM );
566 const Size aOutputSizePixel( pVDev->LogicToPixel( rSize, aMapMode ) );
568 if ( aOutputSizePixel.Width() && aOutputSizePixel.Height() )
571 aMapMode.
SetScaleY(
Fraction( aSizePixel.Height(), aOutputSizePixel.Height() ) );
573 pVDev->SetMapMode( aMapMode );
574 pVDev->SetOutputSizePixel( aSizePixel );
577 pVDev->DrawPolyPolygon( aClip );
580 pVDev->EnableMapMode(
false );
581 const Bitmap aVDevMask(pVDev->GetBitmap(
Point(), aSizePixel));
597 const tools::Long nWidth(std::min(pR->Width(), pW->Width()));
598 const tools::Long nHeight(std::min(pR->Height(), pW->Height()));
602 Scanline pScanlineR = pR->GetScanline( nY );
603 Scanline pScanlineW = pW->GetScanline( nY );
606 const sal_uInt8 nIndR(pR->GetIndexFromData(pScanlineR, nX));
607 const sal_uInt8 nIndW(pW->GetIndexFromData(pScanlineW, nX));
612 const sal_uInt8 nCombined(0x00ff - (((0x00ff - nIndR) * (0x00ff - nIndW)) >> 8));
614 pW->SetPixelOnData(pScanlineW, nX,
BitmapColor(nCombined));
648 return css::uno::Sequence< sal_Int8 >(
static_cast<sal_Int8 const *
>(aMem.
GetData()), aMem.
Tell() );
654 return css::uno::Sequence< sal_Int8 >(
static_cast<sal_Int8 const *
>(aMem.
GetData()), aMem.
Tell() );
657 return css::uno::Sequence< sal_Int8 >();
662 bool bIsAlpha =
false;
673 for( nX = 0; nX < nWidth; nX++ )
678 nAlpha = data[ nOff ] = 255 - rColor.
GetIndex();
685 SAL_INFO(
"canvas.cairo",
"fallback to GetColor for alpha - slow, format: " << static_cast<int>(pAlphaReadAcc->
GetScanlineFormat()) );
686 for( nX = 0; nX < nWidth; nX++ )
713 bool bIsAlpha =
false;
718 data =
static_cast<unsigned char*
>(malloc( nWidth*nHeight*4 ));
722 unsigned int nAlpha = 255;
725 for( nY = 0; nY < nHeight; nY++ )
734 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
737 for( nX = 0; nX < nWidth; nX++ )
741 nAlpha = data[ nOff++ ];
743 nAlpha = data[ nOff++ ] = 255;
746 nAlpha = data[ nOff + 3 ];
748 nAlpha = data[ nOff + 3 ] = 255;
753 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
754 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
755 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
757 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
758 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
759 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
767 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
770 for( nX = 0; nX < nWidth; nX++ )
774 nAlpha = data[ nOff ];
776 nAlpha = data[ nOff ] = 255;
777 data[ nOff + 3 ] = premultiply_table[nAlpha][*pReadScan++];
778 data[ nOff + 2 ] = premultiply_table[nAlpha][*pReadScan++];
779 data[ nOff + 1 ] = premultiply_table[nAlpha][*pReadScan++];
783 nAlpha = data[ nOff + 3 ];
785 nAlpha = data[ nOff + 3 ] = 255;
786 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
787 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
788 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
796 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
799 for( nX = 0; nX < nWidth; nX++ )
803 nAlpha = data[ nOff++ ];
805 nAlpha = data[ nOff++ ] = 255;
806 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
807 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
808 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
811 nAlpha = data[ nOff + 3 ];
813 nAlpha = data[ nOff + 3 ] = 255;
814 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
815 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
816 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
825 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
828 for( nX = 0; nX < nWidth; nX++ )
832 nAlpha = data[ nOff++ ];
834 nAlpha = data[ nOff++ ] = 255;
835 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
836 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
837 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
841 nAlpha = data[ nOff + 3 ];
843 nAlpha = data[ nOff + 3 ] = 255;
844 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
845 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
846 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
855 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
858 for( nX = 0; nX < nWidth; nX++ )
862 nAlpha = data[ nOff ++ ];
864 nAlpha = data[ nOff ++ ] = 255;
865 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
866 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
867 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
871 nAlpha = data[ nOff + 3 ];
873 nAlpha = data[ nOff + 3 ] = 255;
874 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
875 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
876 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
883 SAL_INFO(
"canvas.cairo",
"fallback to GetColor - slow, format: " << static_cast<int>(pBitmapReadAcc->
GetScanlineFormat()) );
886 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
889 for( nX = 0; nX < nWidth; nX++ )
891 aColor = pBitmapReadAcc->
GetColor( nY, nX );
897 nAlpha = data[ nOff++ ];
899 nAlpha = data[ nOff++ ] = 255;
900 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
901 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
902 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
905 nAlpha = data[ nOff + 3 ];
907 nAlpha = data[ nOff + 3 ] = 255;
908 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
909 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
910 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
921 bHasAlpha = bIsAlpha;
932 nullptr : aAlpha.AcquireReadAccess(),
938 const Size aBmpSize( aBitmap.GetSizePixel() );
941 uno::Sequence< sal_Int8 > aRes( 4*aBmpSize.Width()*aBmpSize.Height() );
946 y<aBmpSize.Height() &&
y<rect.Y2;
949 if( pAlphaReadAccess.get() != nullptr )
951 Scanline pScanlineReadAlpha = pAlphaReadAccess->GetScanline(
y );
953 x<aBmpSize.Width() &&
x<rect.X2;
956 pRes[ nCurrPos++ ] = pReadAccess->GetColor(
y,
x ).GetRed();
957 pRes[ nCurrPos++ ] = pReadAccess->GetColor(
y,
x ).GetGreen();
958 pRes[ nCurrPos++ ] = pReadAccess->GetColor(
y,
x ).GetBlue();
959 pRes[ nCurrPos++ ] = pAlphaReadAccess->GetIndexFromData( pScanlineReadAlpha,
x );
965 x<aBmpSize.Width() &&
x<rect.X2;
968 pRes[ nCurrPos++ ] = pReadAccess->GetColor(
y,
x ).GetRed();
969 pRes[ nCurrPos++ ] = pReadAccess->GetColor(
y,
x ).GetGreen();
970 pRes[ nCurrPos++ ] = pReadAccess->GetColor(
y,
x ).GetBlue();
988 for(sal_uInt16
a(0);
a < 8;
a++)
990 for(sal_uInt16 b(0); b < 8; b++)
992 if(pArray[(
a * 8) + b])
994 pContent->SetPixelIndex(
a, b, 1);
998 pContent->SetPixelIndex(
a, b, 0);
1014 if(8 == aBitmap.GetSizePixel().Width() && 8 == aBitmap.GetSizePixel().Height())
1028 o_rFront = rPalette[1];
1029 o_rBack = rPalette[0];
1050 return (a == 0) ? 0 : (c * 255 + a / 2) / a;
1060 return (c * a + 127) / 255;
1064 int a, std::integer_sequence<int, Is...>)
1070 std::integer_sequence<int, Is...>)
1078 std::make_integer_sequence<int, 256>{});
1079 return unpremultiply_table;
1083 int a, std::integer_sequence<int, Is...>)
1089 std::integer_sequence<int, Is...>)
1097 std::make_integer_sequence<int, 256>{});
1098 return premultiply_table;
1107 Size aSize = aBitmap.GetSizePixel();
1118 Scanline aResultScan = pResultBitmapAccess->GetScanline(nY);
1119 Scanline aResultScanAlpha = pResultAlphaAccess->GetScanline(nY);
1129 pResultBitmapAccess->SetPixelOnData(aResultScan, nX, aResultColor);
1130 pResultAlphaAccess->SetPixelOnData(aResultScanAlpha, nX, aResultColorAlpha);
1137 rResult =
BitmapEx(aResultBitmap, aResultAlpha);
PixelFormat
Pixel format of the bitmap in bits per pixel.
void loadFromSvg(SvStream &rStream, const OUString &sPath, BitmapEx &rBitmapEx, double fScalingFactor)
sal_uInt8 premultiply(sal_uInt8 c, sal_uInt8 a)
sal_uInt8 GetIndex() const
void expand(const B2DTuple &rTuple)
tools::Long Height() const
sal_uInt8 GetAlpha() const
OUString DetermineIconTheme() const
Determine which icon theme should be used.
void DrawAlphaBitmapAndAlphaGradient(BitmapEx &rBitmapEx, bool bFixedTransparence, float fTransparence, AlphaMask &rNewMask)
sal_uInt8 unpremultiply(sal_uInt8 c, sal_uInt8 a)
Bitmap const & GetBitmap() const
const StyleSettings & GetStyleSettings() const
static const AllSettings & GetSettings()
Gets the application's settings.
B2DVector getRange() const
BitmapReadAccess * AcquireReadAccess()
std::array< std::array< sal_uInt8, 256 >, 256 > lookup_table
This template handles BitmapAccess the RAII way.
static constexpr lookup_table make_unpremultiply_table_(std::integer_sequence< int, Is... >)
static constexpr lookup_table make_premultiply_table_(std::integer_sequence< int, Is... >)
constexpr tools::Long Width() const
static VCL_DLLPUBLIC ImageTree & get()
bool CombineSimple(const Bitmap &rMask, BmpCombine eCombine)
Perform boolean operations with another bitmap.
void DrawAndClipBitmap(const Point &rPos, const Size &rSize, const BitmapEx &rBitmap, BitmapEx &aBmpEx, basegfx::B2DPolyPolygon const &rClipPath)
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
Scanline GetScanline(tools::Long nY) const
sal_uInt64 remainingSize()
sal_uInt8 GetBlue() const
B2IRange fround(const B2DRange &rRange)
constexpr OUStringLiteral aData
css::uno::Sequence< Primitive2DReference > Primitive2DSequence
BitmapEx CreateFromData(RawBitmap &&rawBitmap)
Copy block of image data into the bitmap.
VCL_DLLPUBLIC bool loadImage(OUString const &name, OUString const &style, BitmapEx &bitmap, bool localized, const ImageLoadFlags eFlags=ImageLoadFlags::NONE)
void SetScaleX(const Fraction &rScaleX)
ScanlineFormat GetScanlineFormat() const
BitmapColor GetColor(tools::Long nY, tools::Long nX) const
void SetOrigin(const Point &rOrigin)
void CanvasCairoExtractBitmapData(BitmapEx const &aBmpEx, Bitmap &aBitmap, unsigned char *&data, bool &bHasAlpha, tools::Long &rnWidth, tools::Long &rnHeight)
tools::Long Width() const
::rtl::Reference< Content > pContent
TransparentType GetTransparentType() const
void SetScaleY(const Fraction &rScaleY)
bool isHistorical8x8(const BitmapEx &rBitmapEx, Color &o_rBack, Color &o_rFront)
css::uno::Sequence< sal_Int8 > GetMaskDIB(BitmapEx const &aBmpEx)
static void ReleaseAccess(BitmapInfoAccess *pAccess)
static constexpr std::array< sal_uInt8, 256 > make_unpremultiply_table_row_(int a, std::integer_sequence< int, Is... >)
uno::Sequence< sal_Int8 > CanvasExtractBitmapData(BitmapEx const &rBitmapEx, const geometry::IntegerRectangle2D &rect)
bool IsTransparent() const
Intended to be used to feed into CreateFromData to create a BitmapEx.
BitmapEx CanvasTransformBitmap(const BitmapEx &rBitmap, const ::basegfx::B2DHomMatrix &rTransform,::basegfx::B2DRectangle const &rDestRect,::basegfx::B2DHomMatrix const &rLocalTransform)
sal_uInt16 GetPaletteEntryCount() const
void ReleaseAccess(BitmapReadAccess *pAccess)
std::size_t ReadBytes(void *pData, std::size_t nSize)
Bitmap GetBitmap(Color aTransparentReplaceColor) const
sal_uInt8 GetGreen() const
BitmapEx createHistorical8x8FromArray(std::array< sal_uInt8, 64 > const &pArray, Color aColorPix, Color aColorBack)
#define ENSURE_OR_THROW(c, m)
lookup_table const & get_unpremultiply_table()
css::uno::Reference< css::graphic::XPrimitive2D > Primitive2DReference
vcl::ScopedBitmapAccess< BitmapWriteAccess, AlphaMask,&AlphaMask::AcquireAlphaWriteAccess > AlphaScopedWriteAccess
std::unique_ptr< char[]> aBuffer
AlphaMask GetAlpha() const
static constexpr sal_uInt8 unpremultiplyImpl(sal_uInt8 c, sal_uInt8 a)
#define SAL_WARN_IF(condition, area, stream)
constexpr tools::Long Height() const
static constexpr std::array< sal_uInt8, 256 > make_premultiply_table_row_(int a, std::integer_sequence< int, Is... >)
lookup_table const & get_premultiply_table()
static constexpr sal_uInt8 premultiplyImpl(sal_uInt8 c, sal_uInt8 a)
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_WHITE
const BitmapPalette & GetPalette() const
#define SAL_INFO(area, stream)
bool convertBitmap32To24Plus8(BitmapEx const &rInput, BitmapEx &rResult)
static bool readAlpha(BitmapReadAccess const *pAlphaReadAcc, tools::Long nY, const tools::Long nWidth, unsigned char *data, tools::Long nOff)
Reference< XComponentContext > getProcessComponentContext()
const ::std::vector< Color > ImpSvNumberformatScan::StandardColor COL_BLACK
BitmapColor GetPixelFromData(const sal_uInt8 *pData, tools::Long nX) const
BitmapEx loadFromName(const OUString &rFileName, const ImageLoadFlags eFlags)
const BitmapColor & GetPaletteColor(sal_uInt16 nColor) const
const Size & GetSizePixel() const
struct _cairo_surface cairo_surface_t
BitmapColor GetPixel(tools::Long nY, tools::Long nX) const