summaryrefslogtreecommitdiff
path: root/canvas/source
diff options
context:
space:
mode:
authorRene Engelhard <rene@debian.org>2010-10-27 20:29:29 +0200
committerRene Engelhard <rene@debian.org>2010-10-29 18:27:37 +0200
commit5b4d4af3e8bc3b5fb07bceecefc2a47d8e4b8b18 (patch)
tree7bff465a6344a325af6cb327be6469611c74cf97 /canvas/source
parent2e43d2389888828130b2e61cb8dc3cd0ebc1c94e (diff)
bin agg
Diffstat (limited to 'canvas/source')
-rw-r--r--canvas/source/tools/bitmap.cxx841
-rw-r--r--canvas/source/tools/canvastools.flt1
-rw-r--r--canvas/source/tools/image.cxx2397
-rw-r--r--canvas/source/tools/image.hxx301
-rw-r--r--canvas/source/tools/image_sysprereq.h104
-rw-r--r--canvas/source/tools/makefile.mk10
6 files changed, 0 insertions, 3654 deletions
diff --git a/canvas/source/tools/bitmap.cxx b/canvas/source/tools/bitmap.cxx
deleted file mode 100644
index e29d24a347c4..000000000000
--- a/canvas/source/tools/bitmap.cxx
+++ /dev/null
@@ -1,841 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-// MARKER(update_precomp.py): autogen include statement, do not remove
-#include "precompiled_canvas.hxx"
-
-#include <canvas/debug.hxx>
-#include <tools/diagnose_ex.h>
-#include <canvas/rendering/bitmap.hxx>
-#include <canvas/rendering/isurfaceproxy.hxx>
-#include <basegfx/vector/b2isize.hxx>
-#include "image.hxx"
-#include <algorithm>
-#include <iterator>
-
-
-using namespace ::com::sun::star;
-
-namespace canvas
-{
- class ImplBitmap
- {
- public:
- ImplBitmap( const ::basegfx::B2IVector& rSize,
- const ISurfaceProxyManagerSharedPtr& rMgr,
- bool bWithAlpha ) :
- mpImage(),
- mpSurfaceProxy(),
- mbIsSurfaceDirty( true )
- {
- ENSURE_OR_THROW( rMgr,
- "Bitmap::Bitmap(): Invalid surface proxy manager" );
-
- Image::Description desc;
-
- desc.eFormat = bWithAlpha ? Image::FMT_A8R8G8B8 : Image::FMT_R8G8B8;
- desc.nWidth = rSize.getX();
- desc.nHeight = rSize.getY();
- desc.nStride = 0;
- desc.pBuffer = NULL;
-
- mpImage.reset( new Image(desc) );
-
- // clear the surface [fill with opaque black]
- mpImage->clear(0,255,255,255);
-
- // create a (possibly hardware accelerated) mirror surface.
- mpSurfaceProxy = rMgr->createSurfaceProxy( mpImage );
- }
-
- bool hasAlpha() const
- {
- if( !mpImage )
- return false;
-
- return (mpImage->getDescription().eFormat == Image::FMT_A8R8G8B8);
- }
-
- ::basegfx::B2IVector getSize() const
- {
- return ::basegfx::B2IVector( mpImage->getWidth(),
- mpImage->getHeight() );
- }
-
- ::com::sun::star::uno::Sequence< sal_Int8 > getData( ::com::sun::star::rendering::IntegerBitmapLayout& /*bitmapLayout*/,
- const ::com::sun::star::geometry::IntegerRectangle2D& rect )
- {
- const IColorBuffer::Format format = mpImage->getFormat();
- const sal_uInt32 dwNumBytesPerPixel = getNumBytes(format);
- const sal_uInt32 dwPitch = mpImage->getWidth()*dwNumBytesPerPixel;
-
- if(!(dwNumBytesPerPixel))
- return uno::Sequence< sal_Int8 >();
-
- const sal_uInt32 dwWidth = rect.X2-rect.X1;
- const sal_uInt32 dwHeight = rect.Y2-rect.Y1;
-
- uno::Sequence< sal_Int8 > aRes(dwWidth*dwHeight*4);
- sal_uInt8 *pDst = reinterpret_cast<sal_uInt8 *>(aRes.getArray());
-
- const sal_uInt8 *pSrc = mpImage->lock()+(rect.Y1*dwPitch)+(rect.X1*dwNumBytesPerPixel);
- const sal_uInt32 dwSpanSizeInBytes = dwNumBytesPerPixel*dwWidth;
- for(sal_uInt32 y=0; y<dwHeight; ++y)
- {
- rtl_copyMemory(pDst,pSrc,dwSpanSizeInBytes);
- pDst += dwSpanSizeInBytes;
- pSrc += dwPitch;
- }
- mpImage->unlock();
-
- return aRes;
- }
-
- void setData( const ::com::sun::star::uno::Sequence< sal_Int8 >& data,
- const ::com::sun::star::rendering::IntegerBitmapLayout& /*bitmapLayout*/,
- const ::com::sun::star::geometry::IntegerRectangle2D& rect )
- {
- const IColorBuffer::Format format = mpImage->getFormat();
- const sal_uInt32 dwNumBytesPerPixel = getNumBytes(format);
- const sal_uInt32 dwPitch = mpImage->getWidth()*dwNumBytesPerPixel;
-
- if(!(dwNumBytesPerPixel))
- return;
-
- const sal_uInt32 dwWidth = rect.X2-rect.X1;
- const sal_uInt32 dwHeight = rect.Y2-rect.Y1;
- const sal_uInt8 *pSrc = reinterpret_cast<const sal_uInt8 *>(data.getConstArray());
-
- sal_uInt8 *pDst = mpImage->lock()+(rect.Y1*dwPitch)+(rect.X1*dwNumBytesPerPixel);
- const sal_uInt32 dwSpanSizeInBytes = dwNumBytesPerPixel*dwWidth;
- for(sal_uInt32 y=0; y<dwHeight; ++y)
- {
- rtl_copyMemory(pDst,pSrc,dwSpanSizeInBytes);
- pSrc += dwSpanSizeInBytes;
- pDst += dwPitch;
- }
- mpImage->unlock();
- }
-
- void setPixel( const ::com::sun::star::uno::Sequence< sal_Int8 >& color,
- const ::com::sun::star::rendering::IntegerBitmapLayout& /*bitmapLayout*/,
- const ::com::sun::star::geometry::IntegerPoint2D& pos )
- {
- struct ARGBColor
- {
- sal_uInt8 a;
- sal_uInt8 r;
- sal_uInt8 g;
- sal_uInt8 b;
- };
-
- union ARGB
- {
- ARGBColor Color;
- sal_uInt32 color;
-
- inline ARGB( sal_uInt32 _color ) : color(_color) {}
- };
-
- ARGB argb(0xFFFFFFFF);
-
- if(color.getLength() > 2)
- {
- argb.Color.r = static_cast<sal_uInt8>(color[0]);
- argb.Color.g = static_cast<sal_uInt8>(color[1]);
- argb.Color.b = static_cast<sal_uInt8>(color[2]);
- if(color.getLength() > 3)
- argb.Color.a = static_cast<sal_uInt8>(255.0f*color[3]);
- }
-
- const IColorBuffer::Format format = mpImage->getFormat();
- const sal_uInt32 dwNumBytesPerPixel = getNumBytes(format);
- const sal_uInt32 dwPitch = mpImage->getWidth()*dwNumBytesPerPixel;
-
- if(!(dwNumBytesPerPixel))
- return;
-
- sal_uInt8 *pDst = mpImage->lock()+(pos.Y*dwPitch)+(pos.X*dwNumBytesPerPixel);
-
- switch(format)
- {
- case IColorBuffer::FMT_R8G8B8:
- pDst[0] = argb.Color.r;
- pDst[1] = argb.Color.g;
- pDst[2] = argb.Color.b;
- break;
- case IColorBuffer::FMT_A8R8G8B8:
- case IColorBuffer::FMT_X8R8G8B8:
- pDst[0] = argb.Color.a;
- pDst[1] = argb.Color.r;
- pDst[2] = argb.Color.g;
- pDst[3] = argb.Color.b;
- break;
- default:
- break;
- }
-
- mpImage->unlock();
- }
-
- uno::Sequence< sal_Int8 > getPixel( ::com::sun::star::rendering::IntegerBitmapLayout& /*bitmapLayout*/,
- const ::com::sun::star::geometry::IntegerPoint2D& pos )
- {
- const IColorBuffer::Format format = mpImage->getFormat();
- const sal_uInt32 dwNumBytesPerPixel = getNumBytes(format);
- const sal_uInt32 dwPitch = mpImage->getWidth()*dwNumBytesPerPixel;
-
- if(!(dwNumBytesPerPixel))
- return uno::Sequence< sal_Int8 >();
-
- uno::Sequence< sal_Int8 > aRet(dwNumBytesPerPixel);
- const sal_uInt8 *pSrc = mpImage->lock()+(pos.Y*dwPitch)+(pos.X*dwNumBytesPerPixel);
-
- switch(format)
- {
- case IColorBuffer::FMT_R8G8B8:
- aRet[0] = pSrc[0];
- aRet[1] = pSrc[1];
- aRet[2] = pSrc[2];
- break;
- case IColorBuffer::FMT_A8R8G8B8:
- case IColorBuffer::FMT_X8R8G8B8:
- aRet[0] = pSrc[1];
- aRet[1] = pSrc[2];
- aRet[2] = pSrc[3];
- aRet[3] = pSrc[0];
- break;
- default:
- break;
- }
-
- mpImage->unlock();
-
- return aRet;
- }
-
- // the IColorBuffer interface
- // ==========================
-
- bool draw( double fAlpha,
- const ::basegfx::B2DPoint& rPos,
- const ::basegfx::B2DHomMatrix& rTransform )
- {
- if( mbIsSurfaceDirty )
- {
- mpSurfaceProxy->setColorBufferDirty();
- mbIsSurfaceDirty = false;
- }
-
- return mpSurfaceProxy->draw( fAlpha, rPos, rTransform );
- }
-
- bool draw( double fAlpha,
- const ::basegfx::B2DPoint& rPos,
- const ::basegfx::B2DRange& rArea,
- const ::basegfx::B2DHomMatrix& rTransform )
- {
- if( mbIsSurfaceDirty )
- {
- mpSurfaceProxy->setColorBufferDirty();
- mbIsSurfaceDirty = false;
- }
-
- return mpSurfaceProxy->draw( fAlpha, rPos, rArea, rTransform );
- }
-
-
- bool draw( double fAlpha,
- const ::basegfx::B2DPoint& rPos,
- const ::basegfx::B2DPolyPolygon& rClipPoly,
- const ::basegfx::B2DHomMatrix& rTransform )
- {
- if( mbIsSurfaceDirty )
- {
- mpSurfaceProxy->setColorBufferDirty();
- mbIsSurfaceDirty = false;
- }
-
- return mpSurfaceProxy->draw( fAlpha, rPos, rClipPoly, rTransform );
- }
-
- void clear( const uno::Sequence< double >& color )
- {
- if(color.getLength() > 2)
- {
- mbIsSurfaceDirty = true;
-
- if(color.getLength() > 3)
- {
- mpImage->clear( static_cast<sal_uInt8>(255.0f*color[0]),
- static_cast<sal_uInt8>(255.0f*color[1]),
- static_cast<sal_uInt8>(255.0f*color[2]),
- static_cast<sal_uInt8>(255.0f*color[3]) );
- }
- else
- {
- mpImage->clear( static_cast<sal_uInt8>(255.0f*color[0]),
- static_cast<sal_uInt8>(255.0f*color[1]),
- static_cast<sal_uInt8>(255.0f*color[2]),
- 255 );
- }
- }
- }
-
- void fillB2DPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- mpImage->fillB2DPolyPolygon( rPolyPolygon,
- viewState,
- renderState );
- }
-
-
- // the XCanvas-render interface
- // ============================
-
- void drawPoint( const geometry::RealPoint2D& aPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- mpImage->drawPoint( aPoint, viewState, renderState );
- }
-
- void drawLine( const geometry::RealPoint2D& aStartPoint,
- const geometry::RealPoint2D& aEndPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- mpImage->drawLine( aStartPoint, aEndPoint, viewState, renderState );
- }
-
- void drawBezier( const geometry::RealBezierSegment2D& aBezierSegment,
- const geometry::RealPoint2D& aEndPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- mpImage->drawBezier( aBezierSegment, aEndPoint, viewState, renderState );
- }
-
- ICachedPrimitiveSharedPtr drawPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->drawPolyPolygon( xPolyPolygon, viewState, renderState ) );
- }
-
- ICachedPrimitiveSharedPtr strokePolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const rendering::StrokeAttributes& strokeAttributes )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->strokePolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- strokeAttributes ) );
- }
-
- ICachedPrimitiveSharedPtr strokeTexturedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations,
- const rendering::StrokeAttributes& strokeAttributes )
- {
- mbIsSurfaceDirty = true;
-
- ::std::vector< ImageSharedPtr > aTextureAnnotations;
- convertTextureAnnotations( aTextureAnnotations,
- textureAnnotations );
-
- return setupCachedPrimitive(
- mpImage->strokeTexturedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- aTextureAnnotations,
- strokeAttributes ) );
- }
-
- ICachedPrimitiveSharedPtr strokeTextureMappedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations,
- const uno::Reference< geometry::XMapping2D >& xMapping,
- const rendering::StrokeAttributes& strokeAttributes )
- {
- mbIsSurfaceDirty = true;
-
- ::std::vector< ImageSharedPtr > aTextureAnnotations;
- convertTextureAnnotations( aTextureAnnotations,
- textureAnnotations );
-
- return setupCachedPrimitive(
- mpImage->strokeTextureMappedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- aTextureAnnotations,
- xMapping,
- strokeAttributes ) );
- }
-
-
- ICachedPrimitiveSharedPtr fillPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->fillPolyPolygon( xPolyPolygon,
- viewState,
- renderState ) );
- }
-
- ICachedPrimitiveSharedPtr fillTexturedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations )
- {
- mbIsSurfaceDirty = true;
-
- ::std::vector< ImageSharedPtr > aTextureAnnotations;
- convertTextureAnnotations( aTextureAnnotations,
- textureAnnotations );
-
- return setupCachedPrimitive(
- mpImage->fillTexturedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- aTextureAnnotations ) );
- }
-
-
- ICachedPrimitiveSharedPtr fillTextureMappedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations,
- const uno::Reference< geometry::XMapping2D >& xMapping )
- {
- mbIsSurfaceDirty = true;
-
- ::std::vector< ImageSharedPtr > aTextureAnnotations;
- convertTextureAnnotations( aTextureAnnotations,
- textureAnnotations );
-
- return setupCachedPrimitive(
- mpImage->fillTextureMappedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- aTextureAnnotations,
- xMapping ) );
- }
-
- ICachedPrimitiveSharedPtr drawBitmap(
- const uno::Reference< rendering::XBitmap >& xBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->drawBitmap( xBitmap,
- viewState,
- renderState ) );
- }
-
- ICachedPrimitiveSharedPtr drawBitmap(
- const ::boost::shared_ptr<Bitmap>& rImage,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->drawBitmap( rImage->mpImpl->mpImage,
- viewState,
- renderState ) );
- }
-
- ICachedPrimitiveSharedPtr drawBitmapModulated(
- const uno::Reference< rendering::XBitmap >& xBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->drawBitmapModulated( xBitmap,
- viewState,
- renderState ) );
- }
-
-
- ICachedPrimitiveSharedPtr drawBitmapModulated(
- const ::boost::shared_ptr<Bitmap>& rImage,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mbIsSurfaceDirty = true;
-
- return setupCachedPrimitive(
- mpImage->drawBitmapModulated( rImage->mpImpl->mpImage,
- viewState,
- renderState ) );
- }
-
- private:
- ICachedPrimitiveSharedPtr setupCachedPrimitive(
- const ImageCachedPrimitiveSharedPtr& rCachedPrimitive ) const
- {
- if( rCachedPrimitive )
- rCachedPrimitive->setImage( mpImage );
-
- return rCachedPrimitive;
- }
-
- void convertTextureAnnotations( ::std::vector< ImageSharedPtr >& o_rTextureAnnotations,
- const ::std::vector< BitmapSharedPtr >& textureAnnotations )
- {
- ::std::vector< BitmapSharedPtr >::const_iterator aCurr( textureAnnotations.begin() );
- const ::std::vector< BitmapSharedPtr >::const_iterator aEnd( textureAnnotations.end() );
- while( aCurr != aEnd )
- {
- if( aCurr->get() != NULL )
- o_rTextureAnnotations.push_back( (*aCurr)->mpImpl->mpImage );
- else
- o_rTextureAnnotations.push_back( ImageSharedPtr() );
-
- ++aCurr;
- }
- }
-
- sal_uInt32 getNumBytes( IColorBuffer::Format format )
- {
- switch(format)
- {
- case IColorBuffer::FMT_R8G8B8:
- return 3;
- case IColorBuffer::FMT_A8R8G8B8:
- case IColorBuffer::FMT_X8R8G8B8:
- return 4;
- default:
- return 0;
- }
- }
-
- ImageSharedPtr mpImage;
- ISurfaceProxySharedPtr mpSurfaceProxy;
- bool mbIsSurfaceDirty;
- };
-
-
- /////////////////////////////////////////////////////////////////
- // Actual Bitmap pimpl forwarding functions
- /////////////////////////////////////////////////////////////////
-
- Bitmap::Bitmap( const ::basegfx::B2IVector& rSize,
- const ISurfaceProxyManagerSharedPtr& rMgr,
- bool bWithAlpha ) :
- mpImpl( new ImplBitmap( rSize,
- rMgr,
- bWithAlpha ) )
- {
- }
-
- Bitmap::~Bitmap()
- {
- // outline destructor is _necessary_, because ImplBitmap is an
- // incomplete type outside this file.
- }
-
- // forward all methods to ImplBitmap
- // ==================================================
-
- bool Bitmap::hasAlpha() const
- {
- return mpImpl->hasAlpha();
- }
-
- ::basegfx::B2IVector Bitmap::getSize() const
- {
- return mpImpl->getSize();
- }
-
- ::com::sun::star::uno::Sequence< sal_Int8 > Bitmap::getData(
- ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
- const ::com::sun::star::geometry::IntegerRectangle2D& rect )
- {
- return mpImpl->getData(bitmapLayout,rect);
- }
-
- void Bitmap::setData(
- const ::com::sun::star::uno::Sequence< sal_Int8 >& data,
- const ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
- const ::com::sun::star::geometry::IntegerRectangle2D& rect )
- {
- mpImpl->setData(data,bitmapLayout,rect);
- }
-
- void Bitmap::setPixel(
- const ::com::sun::star::uno::Sequence< sal_Int8 >& color,
- const ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
- const ::com::sun::star::geometry::IntegerPoint2D& pos )
- {
- mpImpl->setPixel(color,bitmapLayout,pos);
- }
-
- uno::Sequence< sal_Int8 > Bitmap::getPixel(
- ::com::sun::star::rendering::IntegerBitmapLayout& bitmapLayout,
- const ::com::sun::star::geometry::IntegerPoint2D& pos )
- {
- return mpImpl->getPixel(bitmapLayout,pos);
- }
-
- bool Bitmap::draw( double fAlpha,
- const ::basegfx::B2DPoint& rPos,
- const ::basegfx::B2DHomMatrix& rTransform )
- {
- return mpImpl->draw( fAlpha, rPos, rTransform );
- }
-
- bool Bitmap::draw( double fAlpha,
- const ::basegfx::B2DPoint& rPos,
- const ::basegfx::B2DRange& rArea,
- const ::basegfx::B2DHomMatrix& rTransform )
- {
- return mpImpl->draw( fAlpha, rPos, rArea, rTransform );
- }
-
-
- bool Bitmap::draw( double fAlpha,
- const ::basegfx::B2DPoint& rPos,
- const ::basegfx::B2DPolyPolygon& rClipPoly,
- const ::basegfx::B2DHomMatrix& rTransform )
- {
- return mpImpl->draw( fAlpha, rPos, rClipPoly, rTransform );
- }
-
- void Bitmap::clear( const uno::Sequence< double >& color )
- {
- mpImpl->clear( color );
- }
-
- void Bitmap::fillB2DPolyPolygon(
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- mpImpl->fillB2DPolyPolygon( rPolyPolygon, viewState, renderState );
- }
-
- void Bitmap::drawPoint( const geometry::RealPoint2D& aPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawPoint( aPoint, viewState, renderState );
- }
-
- void Bitmap::drawLine( const geometry::RealPoint2D& aStartPoint,
- const geometry::RealPoint2D& aEndPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawLine( aStartPoint, aEndPoint, viewState, renderState );
- }
-
- void Bitmap::drawBezier( const geometry::RealBezierSegment2D& aBezierSegment,
- const geometry::RealPoint2D& aEndPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawBezier( aBezierSegment, aEndPoint, viewState, renderState );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::drawPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawPolyPolygon( xPolyPolygon, viewState, renderState );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::strokePolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const rendering::StrokeAttributes& strokeAttributes )
- {
- return mpImpl->strokePolyPolygon( xPolyPolygon, viewState, renderState, strokeAttributes );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::strokeTexturedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations,
- const rendering::StrokeAttributes& strokeAttributes )
- {
- return mpImpl->strokeTexturedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- textureAnnotations,
- strokeAttributes );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::strokeTextureMappedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations,
- const uno::Reference< geometry::XMapping2D >& xMapping,
- const rendering::StrokeAttributes& strokeAttributes )
- {
- return mpImpl->strokeTextureMappedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- textureAnnotations,
- xMapping,
- strokeAttributes );
- }
-
-
- ICachedPrimitiveSharedPtr Bitmap::fillPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->fillPolyPolygon( xPolyPolygon,
- viewState,
- renderState );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::fillTexturedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations )
- {
- return mpImpl->fillTexturedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- textureAnnotations );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::fillTextureMappedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Bitmap> >& textureAnnotations,
- const uno::Reference< geometry::XMapping2D >& xMapping )
- {
- return mpImpl->fillTextureMappedPolyPolygon( xPolyPolygon,
- viewState,
- renderState,
- textures,
- textureAnnotations,
- xMapping );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::drawBitmap(
- const uno::Reference< rendering::XBitmap >& xBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawBitmap( xBitmap,
- viewState,
- renderState );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::drawBitmap(
- const ::boost::shared_ptr<Bitmap>& rImage,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawBitmap( rImage,
- viewState,
- renderState );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::drawBitmapModulated(
- const uno::Reference< rendering::XBitmap >& xBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawBitmapModulated( xBitmap,
- viewState,
- renderState );
- }
-
- ICachedPrimitiveSharedPtr Bitmap::drawBitmapModulated(
- const ::boost::shared_ptr<Bitmap>& rImage,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- return mpImpl->drawBitmapModulated( rImage,
- viewState,
- renderState );
- }
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/source/tools/canvastools.flt b/canvas/source/tools/canvastools.flt
index a230939309da..67e713474bf1 100644
--- a/canvas/source/tools/canvastools.flt
+++ b/canvas/source/tools/canvastools.flt
@@ -1,4 +1,3 @@
__CT
__real
internal
-agg \ No newline at end of file
diff --git a/canvas/source/tools/image.cxx b/canvas/source/tools/image.cxx
deleted file mode 100644
index cb9c4e7c1490..000000000000
--- a/canvas/source/tools/image.cxx
+++ /dev/null
@@ -1,2397 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-// MARKER(update_precomp.py): autogen include statement, do not remove
-#include "precompiled_canvas.hxx"
-
-#include <canvas/debug.hxx>
-#include <tools/diagnose_ex.h>
-
-#include <canvas/canvastools.hxx>
-#include <canvas/parametricpolypolygon.hxx>
-
-#include <com/sun/star/rendering/RepaintResult.hpp>
-#include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
-
-#include <vcl/canvastools.hxx>
-#include <vcl/bitmapex.hxx>
-#include <vcl/bmpacc.hxx>
-
-#include <basegfx/range/b2drange.hxx>
-#include <basegfx/point/b2dpoint.hxx>
-#include <basegfx/matrix/b2dhommatrix.hxx>
-#include <basegfx/polygon/b2dpolygon.hxx>
-#include <basegfx/polygon/b2dpolypolygon.hxx>
-#include <basegfx/polygon/b2dpolygoncutandtouch.hxx>
-#include <basegfx/polygon/b2dpolygontriangulator.hxx>
-#include <basegfx/polygon/b2dpolypolygontools.hxx>
-#include <basegfx/polygon/b2dpolygontools.hxx>
-#include <basegfx/polygon/b2dpolygonclipper.hxx>
-#include <basegfx/tools/canvastools.hxx>
-#include <basegfx/polygon/b2dpolypolygoncutter.hxx>
-#include <basegfx/polygon/b2dpolygonclipper.hxx>
-
-#include "image.hxx"
-
-#define CANVAS_IMAGE_CXX
-#include "image_sysprereq.h"
-
-//////////////////////////////////////////////////////////////////////////////////
-// platform-dependend includes [wrapped into their own namepsaces]
-//////////////////////////////////////////////////////////////////////////////////
-
-#if defined(WNT)
-# if defined _MSC_VER
-# pragma warning(push,1)
-# endif
-
- namespace win32
- {
- #undef DECLARE_HANDLE
- #undef WB_LEFT
- #undef WB_RIGHT
- #undef APIENTRY
- #define WIN32_LEAN_AND_MEAN
- #define NOMINMAX
- #include <windows.h>
- }
-
-# if defined _MSC_VER
-# pragma warning(pop)
-# endif
-#elif defined(OS2)
- namespace os2
- {
- #include <svpm.h>
- }
-#else
-#if !defined(QUARTZ)
- namespace unx
- {
- #include <X11/Xlib.h>
- }
-#endif
-#endif
-
-#include <algorithm>
-
-using namespace ::com::sun::star;
-
-namespace canvas { namespace
-{
- //////////////////////////////////////////////////////////////////////////////////
- // TransAffineFromAffineMatrix
- //////////////////////////////////////////////////////////////////////////////////
-
- ::agg::trans_affine transAffineFromAffineMatrix( const geometry::AffineMatrix2D& m )
- {
- return agg::trans_affine(m.m00,
- m.m10,
- m.m01,
- m.m11,
- m.m02,
- m.m12);
- }
-
- //////////////////////////////////////////////////////////////////////////////////
- // TransAffineFromB2DHomMatrix
- //////////////////////////////////////////////////////////////////////////////////
-
- ::agg::trans_affine transAffineFromB2DHomMatrix( const ::basegfx::B2DHomMatrix& m )
- {
- return agg::trans_affine(m.get(0,0),
- m.get(1,0),
- m.get(0,1),
- m.get(1,1),
- m.get(0,2),
- m.get(1,2));
- }
-
- //////////////////////////////////////////////////////////////////////////////////
- // ARGB
- //////////////////////////////////////////////////////////////////////////////////
-
- struct ARGBColor
- {
- sal_uInt8 a;
- sal_uInt8 r;
- sal_uInt8 g;
- sal_uInt8 b;
- };
-
- /// ARGB color
- union ARGB
- {
- ARGBColor Color;
- sal_uInt32 color;
-
- ARGB() :
- color(0)
- {
- }
-
- explicit ARGB( sal_uInt32 _color ) :
- color(_color)
- {
- }
-
- ARGB( sal_uInt8 _a,
- sal_uInt8 _r,
- sal_uInt8 _g,
- sal_uInt8 _b )
- {
- Color.a = _a;
- Color.r = _r;
- Color.g = _g;
- Color.b = _b;
- }
-
- ARGB( sal_uInt32 default_color,
- const ::com::sun::star::uno::Sequence< double >& sequence ) :
- color(default_color)
- {
- if(sequence.getLength() > 2)
- {
- Color.r = static_cast<sal_uInt8>(255.0f*sequence[0]);
- Color.g = static_cast<sal_uInt8>(255.0f*sequence[1]);
- Color.b = static_cast<sal_uInt8>(255.0f*sequence[2]);
- if(sequence.getLength() > 3)
- Color.a = static_cast<sal_uInt8>(255.0f*sequence[3]);
- }
- }
-
- ARGB( const ARGB& rhs ) :
- color( rhs.color )
- {
- }
-
- ARGB &operator=( const ARGB &rhs )
- {
- color=rhs.color;
- return *this;
- }
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // setupState
- //////////////////////////////////////////////////////////////////////////////////
-
- /// Calc common output state from XCanvas parameters
- void setupState( ::basegfx::B2DHomMatrix& o_rViewTransform,
- ::basegfx::B2DHomMatrix& o_rRenderTransform,
- ::std::auto_ptr< ::basegfx::B2DPolyPolygon >& o_rViewClip,
- ::std::auto_ptr< ::basegfx::B2DPolyPolygon >& o_rRenderClip,
- ARGB& o_rRenderColor,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- ::basegfx::unotools::homMatrixFromAffineMatrix(o_rRenderTransform,
- renderState.AffineTransform);
- ::basegfx::unotools::homMatrixFromAffineMatrix(o_rViewTransform,
- viewState.AffineTransform);
-
- o_rRenderColor = ARGB(0xFFFFFFFF,
- renderState.DeviceColor);
-
- // TODO(F3): handle compositing modes
-
- if( viewState.Clip.is() )
- {
- ::basegfx::B2DPolyPolygon aViewClip(
- ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( viewState.Clip ));
-
- if(aViewClip.areControlPointsUsed())
- aViewClip = ::basegfx::tools::adaptiveSubdivideByAngle(aViewClip);
-
- o_rViewClip.reset( new ::basegfx::B2DPolyPolygon( aViewClip ) );
- }
-
- if( renderState.Clip.is() )
- {
- ::basegfx::B2DPolyPolygon aRenderClip(
- ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( viewState.Clip ) );
-
- if(aRenderClip.areControlPointsUsed())
- aRenderClip = ::basegfx::tools::adaptiveSubdivideByAngle(aRenderClip);
-
- o_rRenderClip.reset( new ::basegfx::B2DPolyPolygon( aRenderClip ) );
- }
- }
-
- //////////////////////////////////////////////////////////////////////////////////
- // clipAndTransformPolygon
- //////////////////////////////////////////////////////////////////////////////////
-
- /** Clip and transform given polygon
-
- @param io_rClippee
- Polygon to clip
-
- @param bIsFilledPolyPolygon
- When true, the polygon is clipped as if it was to be rendered
- with fill, when false, the polygon is clipped as if it was to
- be rendered with stroking.
- */
- void clipAndTransformPolygon( ::basegfx::B2DPolyPolygon& io_rClippee,
- bool bIsFilledPolyPolygon,
- const ::basegfx::B2DHomMatrix& rViewTransform,
- const ::basegfx::B2DHomMatrix& rRenderTransform,
- const ::basegfx::B2DPolyPolygon* pViewClip,
- const ::basegfx::B2DPolyPolygon* pRenderClip )
- {
- ::basegfx::B2DPolyPolygon aPolyPolygon(io_rClippee);
- io_rClippee.clear();
-
- // clip contour against renderclip
- if( pRenderClip )
- {
- // AW: Simplified
- aPolyPolygon = basegfx::tools::clipPolyPolygonOnPolyPolygon(
- aPolyPolygon, *pRenderClip, true, !bIsFilledPolyPolygon);
- }
-
- if( !aPolyPolygon.count() )
- return;
-
- // transform result into view space
- aPolyPolygon.transform(rRenderTransform);
-
- // clip contour against viewclip
- if( pViewClip )
- {
- // AW: Simplified
- aPolyPolygon = basegfx::tools::clipPolyPolygonOnPolyPolygon(
- aPolyPolygon, *pViewClip, true, !bIsFilledPolyPolygon);
- }
-
- if(!(aPolyPolygon.count()))
- return;
-
- // transform result into device space
- aPolyPolygon.transform(rViewTransform);
-
- io_rClippee = aPolyPolygon;
- }
-
- //////////////////////////////////////////////////////////////////////////////////
- // setupPolyPolygon
- //////////////////////////////////////////////////////////////////////////////////
-
- void setupPolyPolygon( ::basegfx::B2DPolyPolygon& io_rClippee,
- bool bIsFilledPolyPolygon,
- ARGB& o_rRenderColor,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
- {
- ::basegfx::B2DHomMatrix aViewTransform;
- ::basegfx::B2DHomMatrix aRenderTransform;
- ::std::auto_ptr< ::basegfx::B2DPolyPolygon > pViewClip;
- ::std::auto_ptr< ::basegfx::B2DPolyPolygon > pRenderClip;
-
- setupState( aViewTransform,
- aRenderTransform,
- pViewClip,
- pRenderClip,
- o_rRenderColor,
- viewState,
- renderState );
-
- clipAndTransformPolygon( io_rClippee,
- bIsFilledPolyPolygon,
- aViewTransform,
- aRenderTransform,
- pViewClip.get(),
- pRenderClip.get() );
- }
-
- //////////////////////////////////////////////////////////////////////////////////
- // RawABGRBitmap
- //////////////////////////////////////////////////////////////////////////////////
-
- // Raw ABGR [AABBGGRR] 32bit continous
- struct RawABGRBitmap
- {
- sal_Int32 mnWidth;
- sal_Int32 mnHeight;
- sal_uInt8* mpBitmapData;
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // vclBitmapEx2Raw
- //////////////////////////////////////////////////////////////////////////////////
-
- void vclBitmapEx2Raw( const ::BitmapEx& rBmpEx, RawABGRBitmap& rBmpData )
- {
- Bitmap aBitmap( rBmpEx.GetBitmap() );
-
- ScopedBitmapReadAccess pReadAccess( aBitmap.AcquireReadAccess(),
- aBitmap );
-
- const sal_Int32 nWidth( rBmpData.mnWidth );
- const sal_Int32 nHeight( rBmpData.mnHeight );
-
- ENSURE_OR_THROW( pReadAccess.get() != NULL,
- "vclBitmapEx2Raw(): "
- "Unable to acquire read acces to bitmap" );
-
- if( rBmpEx.IsTransparent())
- {
- if( rBmpEx.IsAlpha() )
- {
- // 8bit alpha mask
- Bitmap aAlpha( rBmpEx.GetAlpha().GetBitmap() );
-
- ScopedBitmapReadAccess pAlphaReadAccess( aAlpha.AcquireReadAccess(),
- aAlpha );
-
- // By convention, the access buffer always has
- // one of the following formats:
- //
- // BMP_FORMAT_1BIT_MSB_PAL
- // BMP_FORMAT_4BIT_MSN_PAL
- // BMP_FORMAT_8BIT_PAL
- // BMP_FORMAT_16BIT_TC_LSB_MASK
- // BMP_FORMAT_24BIT_TC_BGR
- // BMP_FORMAT_32BIT_TC_MASK
- //
- // and is always BMP_FORMAT_BOTTOM_UP
- //
- // This is the way
- // WinSalBitmap::AcquireBuffer() sets up the
- // buffer
-
- ENSURE_OR_THROW( pAlphaReadAccess.get() != NULL,
- "vclBitmapEx2Raw(): "
- "Unable to acquire read acces to alpha" );
-
- ENSURE_OR_THROW( pAlphaReadAccess->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL ||
- pAlphaReadAccess->GetScanlineFormat() == BMP_FORMAT_8BIT_TC_MASK,
- "vclBitmapEx2Raw(): "
- "Unsupported alpha scanline format" );
-
- BitmapColor aCol;
- sal_uInt8* pCurrOutput( rBmpData.mpBitmapData );
- int x, y;
-
- for( y=0; y<nHeight; ++y )
- {
- switch( pReadAccess->GetScanlineFormat() )
- {
- case BMP_FORMAT_8BIT_PAL:
- {
- Scanline pScan = pReadAccess->GetScanline( y );
- Scanline pAScan = pAlphaReadAccess->GetScanline( y );
-
- for( x=0; x<nWidth; ++x )
- {
- aCol = pReadAccess->GetPaletteColor( *pScan++ );
-
- *pCurrOutput++ = aCol.GetBlue();
- *pCurrOutput++ = aCol.GetGreen();
- *pCurrOutput++ = aCol.GetRed();
-
- // out notion of alpha is
- // different from the rest
- // of the world's
- *pCurrOutput++ = 255 - (BYTE)*pAScan++;
- }
- }
- break;
-
- case BMP_FORMAT_24BIT_TC_BGR:
- {
- Scanline pScan = pReadAccess->GetScanline( y );
- Scanline pAScan = pAlphaReadAccess->GetScanline( y );
-
- for( x=0; x<nWidth; ++x )
- {
- // store as RGBA
- *pCurrOutput++ = *pScan++;
- *pCurrOutput++ = *pScan++;
- *pCurrOutput++ = *pScan++;
-
- // out notion of alpha is
- // different from the rest
- // of the world's
- *pCurrOutput++ = 255 - (BYTE)*pAScan++;
- }
- }
- break;
-
- // TODO(P2): Might be advantageous
- // to hand-formulate the following
- // formats, too.
- case BMP_FORMAT_1BIT_MSB_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_4BIT_MSN_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_16BIT_TC_LSB_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_MASK:
- {
- Scanline pAScan = pAlphaReadAccess->GetScanline( y );
-
- // using fallback for those
- // seldom formats
- for( x=0; x<nWidth; ++x )
- {
- // yes. x and y are swapped on Get/SetPixel
- aCol = pReadAccess->GetColor(y,x);
-
- *pCurrOutput++ = aCol.GetBlue();
- *pCurrOutput++ = aCol.GetGreen();
- *pCurrOutput++ = aCol.GetRed();
-
- // out notion of alpha is
- // different from the rest
- // of the world's
- *pCurrOutput++ = 255 - (BYTE)*pAScan++;
- }
- }
- break;
-
- case BMP_FORMAT_1BIT_LSB_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_4BIT_LSN_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_8BIT_TC_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_24BIT_TC_RGB:
- // FALLTHROUGH intended
- case BMP_FORMAT_24BIT_TC_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_16BIT_TC_MSB_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_ABGR:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_ARGB:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_BGRA:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_RGBA:
- // FALLTHROUGH intended
- default:
- ENSURE_OR_THROW( false,
- "vclBitmapEx2Raw(): "
- "Unexpected scanline format - has "
- "WinSalBitmap::AcquireBuffer() changed?" );
- }
- }
- }
- else
- {
- // 1bit alpha mask
- Bitmap aMask( rBmpEx.GetMask() );
-
- ScopedBitmapReadAccess pMaskReadAccess( aMask.AcquireReadAccess(),
- aMask );
-
- // By convention, the access buffer always has
- // one of the following formats:
- //
- // BMP_FORMAT_1BIT_MSB_PAL
- // BMP_FORMAT_4BIT_MSN_PAL
- // BMP_FORMAT_8BIT_PAL
- // BMP_FORMAT_16BIT_TC_LSB_MASK
- // BMP_FORMAT_24BIT_TC_BGR
- // BMP_FORMAT_32BIT_TC_MASK
- //
- // and is always BMP_FORMAT_BOTTOM_UP
- //
- // This is the way
- // WinSalBitmap::AcquireBuffer() sets up the
- // buffer
-
- ENSURE_OR_THROW( pMaskReadAccess.get() != NULL,
- "vclBitmapEx2Raw(): "
- "Unable to acquire read acces to mask" );
-
- ENSURE_OR_THROW( pMaskReadAccess->GetScanlineFormat() == BMP_FORMAT_1BIT_MSB_PAL,
- "vclBitmapEx2Raw(): "
- "Unsupported mask scanline format" );
-
- BitmapColor aCol;
- int nCurrBit;
- const int nMask( 1L );
- const int nInitialBit(7);
- sal_uInt32 *pBuffer = reinterpret_cast<sal_uInt32 *>(rBmpData.mpBitmapData);
- int x, y;
-
- // mapping table, to get from mask index color to
- // alpha value (which depends on the mask's palette)
- sal_uInt8 aColorMap[2];
-
- const BitmapColor& rCol0( pMaskReadAccess->GetPaletteColor( 0 ) );
- const BitmapColor& rCol1( pMaskReadAccess->GetPaletteColor( 1 ) );
-
- // shortcut for true luminance calculation
- // (assumes that palette is grey-level). Note the
- // swapped the indices here, to account for the
- // fact that VCL's notion of alpha is inverted to
- // the rest of the world's.
- aColorMap[0] = rCol1.GetRed();
- aColorMap[1] = rCol0.GetRed();
-
- for( y=0; y<nHeight; ++y )
- {
- switch( pReadAccess->GetScanlineFormat() )
- {
- case BMP_FORMAT_8BIT_PAL:
- {
- Scanline pScan = pReadAccess->GetScanline( y );
- Scanline pMScan = pMaskReadAccess->GetScanline( y );
-
- for( x=0, nCurrBit=nInitialBit; x<nWidth; ++x )
- {
- aCol = pReadAccess->GetPaletteColor( *pScan++ );
-
- // RGB -> ABGR
- unsigned int color = aCol.GetRed();
- color |= aCol.GetGreen()<<8;
- color |= aCol.GetBlue()<<16;
- color |= aColorMap[ (pMScan[ (x & ~7L) >> 3L ] >> nCurrBit ) & nMask ]<<24;
- *pBuffer++ = color;
- nCurrBit = ((nCurrBit - 1) % 8L) & 7L;
- }
- }
- break;
-
- case BMP_FORMAT_24BIT_TC_BGR:
- {
- Scanline pScan = pReadAccess->GetScanline( y );
- Scanline pMScan = pMaskReadAccess->GetScanline( y );
-
- for( x=0, nCurrBit=nInitialBit; x<nWidth; ++x )
- {
- // BGR -> ABGR
- unsigned int color = (*pScan++)<<16;
- color |= (*pScan++)<<8;
- color |= (*pScan++);
- color |= (aColorMap[ (pMScan[ (x & ~7L) >> 3L ] >> nCurrBit ) & nMask ])<<24;
- *pBuffer++ = color;
- nCurrBit = ((nCurrBit - 1) % 8L) & 7L;
- }
- }
- break;
-
- // TODO(P2): Might be advantageous
- // to hand-formulate the following
- // formats, too.
- case BMP_FORMAT_1BIT_MSB_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_4BIT_MSN_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_16BIT_TC_LSB_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_MASK:
- {
- Scanline pMScan = pMaskReadAccess->GetScanline( y );
-
- // using fallback for those
- // seldom formats
- for( x=0, nCurrBit=nInitialBit; x<nWidth; ++x )
- {
- // yes. x and y are swapped on Get/SetPixel
- aCol = pReadAccess->GetColor(y,x);
-
- // -> ABGR
- unsigned int color = aCol.GetBlue()<<16;
- color |= aCol.GetGreen()<<8;
- color |= aCol.GetRed();
- color |= (aColorMap[ (pMScan[ (x & ~7L) >> 3L ] >> nCurrBit ) & nMask ])<<24;
- *pBuffer++ = color;
- nCurrBit = ((nCurrBit - 1) % 8L) & 7L;
- }
- }
- break;
-
- case BMP_FORMAT_1BIT_LSB_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_4BIT_LSN_PAL:
- // FALLTHROUGH intended
- case BMP_FORMAT_8BIT_TC_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_24BIT_TC_RGB:
- // FALLTHROUGH intended
- case BMP_FORMAT_24BIT_TC_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_16BIT_TC_MSB_MASK:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_ABGR:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_ARGB:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_BGRA:
- // FALLTHROUGH intended
- case BMP_FORMAT_32BIT_TC_RGBA:
- // FALLTHROUGH intended
- default:
- ENSURE_OR_THROW( false,
- "vclBitmapEx2Raw(): "
- "Unexpected scanline format - has "
- "WinSalBitmap::AcquireBuffer() changed?" );
- }
- }
- }
- }
- else
- {
- // *no* alpha mask
- ULONG nFormat = pReadAccess->GetScanlineFormat();
- BYTE *pBuffer = reinterpret_cast<BYTE *>(rBmpData.mpBitmapData);
-
- switch(nFormat)
- {
- case BMP_FORMAT_24BIT_TC_BGR:
-
- {
- sal_Int32 height = pReadAccess->Height();
- for(sal_Int32 y=0; y<height; ++y)
- {
- BYTE *pScanline=pReadAccess->GetScanline(y);
- sal_Int32 width = pReadAccess->Width();
- for(sal_Int32 x=0; x<width; ++x)
- {
- // BGR -> RGB
- BYTE b(*pScanline++);
- BYTE g(*pScanline++);
- BYTE r(*pScanline++);
- *pBuffer++ = r;
- *pBuffer++ = g;
- *pBuffer++ = b;
- }
- }
- }
- break;
-
- case BMP_FORMAT_24BIT_TC_RGB:
-
- {
- sal_Int32 height = pReadAccess->Height();
- for(sal_Int32 y=0; y<height; ++y)
- {
- BYTE *pScanline=pReadAccess->GetScanline(y);
- sal_Int32 width = pReadAccess->Width();
- for(sal_Int32 x=0; x<width; ++x)
- {
- // RGB -> RGB
- BYTE r(*pScanline++);
- BYTE g(*pScanline++);
- BYTE b(*pScanline++);
- *pBuffer++ = r;
- *pBuffer++ = g;
- *pBuffer++ = b;
- }
- }
- }
- break;
-
- case BMP_FORMAT_1BIT_MSB_PAL:
- case BMP_FORMAT_1BIT_LSB_PAL:
- case BMP_FORMAT_4BIT_MSN_PAL:
- case BMP_FORMAT_4BIT_LSN_PAL:
- case BMP_FORMAT_8BIT_PAL:
-
- {
- sal_Int32 height = pReadAccess->Height();
- for(sal_Int32 y=0; y<height; ++y)
- {
- BYTE *pScanline=pReadAccess->GetScanline(y);
- sal_Int32 width = pReadAccess->Width();
- for(sal_Int32 x=0; x<width; ++x)
- {
- BitmapColor aCol(pReadAccess->GetPaletteColor(*pScanline++));
-
- *pBuffer++ = aCol.GetRed();
- *pBuffer++ = aCol.GetGreen();
- *pBuffer++ = aCol.GetBlue();
- }
- }
- }
- break;
- }
- }
- }
-
- //////////////////////////////////////////////////////////////////////////////////
- // color_generator_linear
- //////////////////////////////////////////////////////////////////////////////////
-
- template<typename T> struct color_generator_linear
- {
- typedef typename T::value_type value_type;
-
- color_generator_linear( const T &c1,
- const T &c2,
- unsigned int aSteps ) : maSteps(aSteps),
- maColor1(c1),
- maColor2(c2)
- {
- }
-
- unsigned size() const { return maSteps; }
- const T operator [] (unsigned v) const
- {
- const double w = double(v)/maSteps;
- return T( static_cast<value_type>(maColor1.r+(maColor2.r-maColor1.r)*w),
- static_cast<value_type>(maColor1.g+(maColor2.g-maColor1.g)*w),
- static_cast<value_type>(maColor1.b+(maColor2.b-maColor1.b)*w),
- static_cast<value_type>(maColor1.a+(maColor2.a-maColor1.a)*w));
- }
-
- unsigned int maSteps;
- const T maColor1;
- const T maColor2;
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // color_generator_axial
- //////////////////////////////////////////////////////////////////////////////////
-
- template<typename T> struct color_generator_axial
- {
- typedef typename T::value_type value_type;
-
- color_generator_axial( const T &c1,
- const T &c2,
- unsigned int aSteps ) : maSteps(aSteps),
- maColor1(c1),
- maColor2(c2)
- {
- }
-
- unsigned size() const { return maSteps; }
- const T operator [] (unsigned v) const
- {
- const double aHalfSteps = maSteps/2.0;
- const double w = (v >= aHalfSteps) ?
- 1.0-((double(v)-aHalfSteps)/aHalfSteps) :
- (double(v)*2.0)/maSteps;
- return T( static_cast<value_type>(maColor1.r+(maColor2.r-maColor1.r)*w),
- static_cast<value_type>(maColor1.g+(maColor2.g-maColor1.g)*w),
- static_cast<value_type>(maColor1.b+(maColor2.b-maColor1.b)*w),
- static_cast<value_type>(maColor1.a+(maColor2.a-maColor1.a)*w));
- }
-
- unsigned int maSteps;
- const T maColor1;
- const T maColor2;
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // color_generator_adaptor
- //////////////////////////////////////////////////////////////////////////////////
-
- template<typename T> struct color_generator_adaptor
- {
- color_generator_adaptor( const T &c1,
- const T &c2,
- unsigned int aSteps ) : linear_generator(c1,c2,aSteps),
- axial_generator(c1,c2,aSteps),
- mbLinear(true) {}
- void set_linear( bool bLinear ) { mbLinear=bLinear; }
- unsigned size() const { return mbLinear ? linear_generator.size() : axial_generator.size(); }
- const T operator [] (unsigned v) const
- {
- return mbLinear ?
- linear_generator.operator [] (v) :
- axial_generator.operator [] (v);
- }
-
- color_generator_linear<T> linear_generator;
- color_generator_axial<T> axial_generator;
- bool mbLinear;
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // gradient_polymorphic_wrapper_base
- //////////////////////////////////////////////////////////////////////////////////
-
- struct gradient_polymorphic_wrapper_base
- {
- virtual int calculate(int x, int y, int) const = 0;
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // gradient_polymorphic_wrapper
- //////////////////////////////////////////////////////////////////////////////////
-
- template<class GradientF> struct gradient_polymorphic_wrapper :
- public gradient_polymorphic_wrapper_base
- {
- virtual int calculate(int x, int y, int d) const
- {
- return m_gradient.calculate(x, y, d);
- }
- GradientF m_gradient;
- };
-
- //////////////////////////////////////////////////////////////////////////////////
- // gradient_rect
- //////////////////////////////////////////////////////////////////////////////////
-
- class gradient_rect
- {
- public:
-
- int width;
- int height;
-
- inline int calculate(int x, int y, int d) const
- {
- int ax = abs(x);
- int ay = abs(y);
- int clamp_x = height>width ? 0 : (width-height);
- int clamp_y = height>width ? (height-width) : 0;
- int value_x = (ax-clamp_x)*d/(width-clamp_x);
- int value_y = (ay-clamp_y)*d/(height-clamp_y);
- if(ax < (clamp_x))
- value_x = 0;
- if(ay < (clamp_y))
- value_y = 0;
- return value_x > value_y ? value_x : value_y;
- }
- };
-
- sal_uInt32 getBytesPerPixel( IColorBuffer::Format eFormat )
- {
- switch(eFormat)
- {
- default:
- OSL_ENSURE(false, "Unexpected pixel format");
- // FALLTHROUGH intended
- case IColorBuffer::FMT_R8G8B8:
- return 3L;
- case IColorBuffer::FMT_A8R8G8B8:
- return 4L;
- }
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawLinePolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-template<class pixel_format>
-void Image::drawLinePolyPolygonImpl( const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- double fStrokeWidth,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- ::basegfx::B2DPolyPolygon aPolyPolygon( rPolyPolygon );
- ARGB aRenderColor;
-
- setupPolyPolygon( aPolyPolygon, false, aRenderColor, viewState, renderState );
-
- if( !aPolyPolygon.count() )
- return;
-
- // Class template pixel_formats_rgb24 has full knowledge about this
- // particular pixel format in memory. The only template parameter
- // can be order_rgb24 or order_bgr24 that determines the order of color channels.
- //typedef agg::pixfmt_rgba32 pixel_format;
- pixel_format pixf(maRenderingBuffer);
-
- // There are two basic renderers with almost the same functionality:
- // renderer_base and renderer_mclip. The first one is used most often
- // and it performs low level clipping.
- // This simply adds clipping to the graphics buffer, the clip rect
- // will be initialized to the area of the framebuffer.
- typedef agg::renderer_base<pixel_format> renderer_base;
- agg::renderer_base<pixel_format> renb(pixf);
-
- // To draw Anti-Aliased primitives one shoud *rasterize* them first.
- // The primary rasterization technique in AGG is scanline based.
- // That is, a polygon is converted into a number of horizontal
- // scanlines and then the scanlines are being rendered one by one.
- // To transfer information from a rasterizer to the scanline renderer
- // there scanline containers are used. A scanline consists of a
- // number of horizontal, non-intersecting spans. All spans must be ordered by X.
- // --> *packed* scanline container
- agg::scanline_p8 sl;
-
- typedef agg::renderer_outline_aa<renderer_base> renderer_type;
- typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type;
- agg::line_profile_aa profile;
- profile.width(fStrokeWidth);
- renderer_type ren(renb, profile);
- rasterizer_type ras(ren);
-
- const agg::rgba8 fillcolor(aRenderColor.Color.r,
- aRenderColor.Color.g,
- aRenderColor.Color.b,
- aRenderColor.Color.a);
- ren.color(fillcolor);
-
- agg::path_storage path;
- agg::conv_curve<agg::path_storage> curve(path);
-
- for(sal_uInt32 nPolygon=0; nPolygon<aPolyPolygon.count(); ++nPolygon)
- {
- const basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(nPolygon));
- const sal_uInt32 nPointCount(aPolygon.count());
-
- if(nPointCount)
- {
- if(aPolygon.areControlPointsUsed())
- {
- // prepare edge-based loop
- basegfx::B2DPoint aCurrentPoint(aPolygon.getB2DPoint(0));
- const sal_uInt32 nEdgeCount(aPolygon.isClosed() ? nPointCount - 1 : nPointCount);
-
- // first vertex
- path.move_to(aCurrentPoint.getX(), aCurrentPoint.getY());
-
- for(sal_uInt32 a(0); a < nEdgeCount; a++)
- {
- // access next point
- const sal_uInt32 nNextIndex((a + 1) % nPointCount);
- const basegfx::B2DPoint aNextPoint(aPolygon.getB2DPoint(nNextIndex));
-
- // get control points
- const basegfx::B2DPoint aControlNext(aPolygon.getNextControlPoint(a));
- const basegfx::B2DPoint aControlPrev(aPolygon.getPrevControlPoint(nNextIndex));
-
- // specify first cp, second cp, next vertex
- path.curve4(
- aControlNext.getX(), aControlNext.getY(),
- aControlPrev.getX(), aControlPrev.getY(),
- aNextPoint.getX(), aNextPoint.getY());
-
- // prepare next step
- aCurrentPoint = aNextPoint;
- }
- }
- else
- {
- const basegfx::B2DPoint aStartPoint(aPolygon.getB2DPoint(0));
- ras.move_to_d(aStartPoint.getX(), aStartPoint.getY());
-
- for(sal_uInt32 a(1); a < nPointCount; a++)
- {
- const basegfx::B2DPoint aVertexPoint(aPolygon.getB2DPoint(a));
- ras.line_to_d(aVertexPoint.getX(), aVertexPoint.getY());
- }
-
- ras.render(aPolygon.isClosed());
- }
- }
- }
-
- ras.add_path(curve);
- ras.render(false);
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawLinePolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::drawLinePolyPolygon( const ::basegfx::B2DPolyPolygon& rPoly,
- double fStrokeWidth,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- switch(maDesc.eFormat)
- {
- case FMT_R8G8B8:
- drawLinePolyPolygonImpl<agg::pixfmt_rgb24>(rPoly,fStrokeWidth,viewState,renderState);
- break;
- case FMT_A8R8G8B8:
- drawLinePolyPolygonImpl<agg::pixfmt_rgba32>(rPoly,fStrokeWidth,viewState,renderState);
- break;
- default:
- OSL_ENSURE(false, "Unexpected pixel format");
- break;
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::implDrawBitmap
-//////////////////////////////////////////////////////////////////////////////////
-
-/** internal utility function to draw one image into another one.
- the source image will be drawn with respect to the given
- transform and clip settings.
- */
-ImageCachedPrimitiveSharedPtr Image::implDrawBitmap(
- const Image& rBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- ::basegfx::B2DPolyPolygon aPoly(
- ::basegfx::tools::createPolygonFromRect(
- ::basegfx::B2DRange(0.0, 0.0,
- rBitmap.maDesc.nWidth,
- rBitmap.maDesc.nHeight ) ) );
- ARGB aFillColor;
-
- setupPolyPolygon( aPoly, true, aFillColor, viewState, renderState );
-
- if( !aPoly.count() )
- return ImageCachedPrimitiveSharedPtr();
-
- ::basegfx::B2DHomMatrix aViewTransform;
- ::basegfx::B2DHomMatrix aRenderTransform;
- ::basegfx::B2DHomMatrix aTextureTransform;
-
- ::basegfx::unotools::homMatrixFromAffineMatrix(aRenderTransform,
- renderState.AffineTransform);
- ::basegfx::unotools::homMatrixFromAffineMatrix(aViewTransform,
- viewState.AffineTransform);
- aTextureTransform *= aRenderTransform;
-
- // TODO(F2): Fill in texture
- rendering::Texture aTexture;
-
- return fillTexturedPolyPolygon( rBitmap,
- aPoly,
- aTextureTransform,
- aViewTransform,
- aTexture );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// cachedPrimitiveFTPP [cachedPrimitive for [F]ill[T]extured[P]oly[P]olygon]
-//////////////////////////////////////////////////////////////////////////////////
-
-#if AGG_VERSION >= 2400
-template<class pixel_format_dst,class span_gen_type>
-#else
-template<class pixel_format,class span_gen_type>
-#endif
-class cachedPrimitiveFTPP : public ImageCachedPrimitive
-{
- public:
-
- cachedPrimitiveFTPP( const ::basegfx::B2DHomMatrix &rTransform,
- const ::basegfx::B2DHomMatrix &rViewTransform,
- agg::rendering_buffer &dst,
- const agg::rendering_buffer& src ) :
- aTransform(rTransform),
- inter(tm),
- filter(filter_kernel),
-#if AGG_VERSION >= 2400
- pixs(const_cast<agg::rendering_buffer&>(src)),
- source(pixs),
- sg(source,inter,filter),
- pixd(dst),
- rb(pixd),
- ren(rb,sa,sg)
-#else
- sg(sa,src,inter,filter),
- pixf(dst),
- rb(pixf),
- ren(rb,sg)
-#endif
- {
- ::basegfx::B2DHomMatrix aFinalTransform(aTransform);
- aFinalTransform *= rViewTransform;
- tm = transAffineFromB2DHomMatrix(aFinalTransform);
- tm.invert();
- }
-
- virtual void setImage( const ::boost::shared_ptr< class Image >& rTargetImage )
- {
- pImage=rTargetImage;
- }
-
- virtual sal_Int8 redraw( const ::com::sun::star::rendering::ViewState& aState ) const
- {
- ::basegfx::B2DHomMatrix aViewTransform;
- ::basegfx::unotools::homMatrixFromAffineMatrix(aViewTransform,aState.AffineTransform);
- ::basegfx::B2DHomMatrix aFinalTransform(aTransform);
- aFinalTransform *= aViewTransform;
- tm = transAffineFromB2DHomMatrix(aFinalTransform);
- tm.invert();
- redraw();
- return ::com::sun::star::rendering::RepaintResult::REDRAWN;
- }
-
- inline void redraw() const { agg::render_scanlines(ras, sl, ren); }
-
- mutable agg::rasterizer_scanline_aa<> ras;
-
- private:
-
- typedef agg::span_interpolator_linear<> interpolator_type;
-#if AGG_VERSION >= 2400
- typedef agg::renderer_base<pixel_format_dst> renderer_base;
- typedef agg::span_allocator< typename span_gen_type::color_type > span_alloc_type;
- typedef agg::renderer_scanline_aa<renderer_base, span_alloc_type, span_gen_type> renderer_type;
- typedef typename span_gen_type::source_type source_type;
- typedef typename span_gen_type::source_type::pixfmt_type pixel_format_src;
-#else
- typedef agg::renderer_base<pixel_format> renderer_base;
- typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> renderer_type;
-#endif
-
- ::basegfx::B2DHomMatrix aTransform;
- interpolator_type inter;
- agg::image_filter_bilinear filter_kernel;
- agg::image_filter_lut filter;
-#if AGG_VERSION >= 2400
- span_alloc_type sa;
- pixel_format_src pixs;
- source_type source;
-#else
- agg::span_allocator< typename span_gen_type::color_type > sa;
-#endif
- span_gen_type sg;
-#if AGG_VERSION >= 2400
- pixel_format_dst pixd;
-#else
- pixel_format pixf;
-#endif
- renderer_base rb;
- mutable renderer_type ren;
- mutable agg::scanline_p8 sl;
- mutable agg::trans_affine tm;
- ImageSharedPtr pImage;
-};
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillTexturedPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-template<class pixel_format,class span_gen_type>
-ImageCachedPrimitiveSharedPtr Image::fillTexturedPolyPolygonImpl(
- const Image& rTexture,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const ::basegfx::B2DHomMatrix& rViewTransform,
- const rendering::Texture& )
-{
- // calculate final overall transform.
- ::basegfx::B2DHomMatrix aOverallTransform(rOverallTransform);
- aOverallTransform *= rViewTransform;
-
- // instead of always using the full-blown solution we
- // first check to see if this is a simple rectangular
- // 1-to-1 copy from source to destination image.
- ::basegfx::B2DTuple aTranslate(aOverallTransform.get(0,2),aOverallTransform.get(1,2));
- ::basegfx::B2DTuple aSize(rTexture.maDesc.nWidth,rTexture.maDesc.nHeight);
- ::basegfx::B2DRange aRange(aTranslate,aTranslate+aSize);
- ::basegfx::B2DPolyPolygon aPolyPolygon(rPolyPolygon);
- aPolyPolygon.transform(aOverallTransform);
- if(::basegfx::tools::isPolyPolygonEqualRectangle(aPolyPolygon,aRange))
- {
- // yes, we can take the shortcut.
- // but we need to clip the destination rectangle
- // against the boundary of the destination image.
- sal_Int32 dwSrcX(0);
- sal_Int32 dwSrcY(0);
- sal_Int32 dwDstX(static_cast<sal_Int32>(aTranslate.getX()));
- sal_Int32 dwDstY(static_cast<sal_Int32>(aTranslate.getY()));
- sal_Int32 dwWidth(rTexture.maDesc.nWidth);
- sal_Int32 dwHeight(rTexture.maDesc.nHeight);
-
- // prevent fast copy if destination position is not an
- // integer coordinate. otherwise we would most probably
- // introduce visual glitches while combining this with
- // high-accuracy rendering stuff.
- if( ::basegfx::fTools::equalZero(aTranslate.getX()-dwDstX) &&
- ::basegfx::fTools::equalZero(aTranslate.getY()-dwDstY))
- {
- // clip against destination boundary. shrink size if
- // necessary, modify destination position if we need to.
- if(dwDstX < 0) { dwWidth-=dwDstX; dwSrcX=-dwDstX; dwDstX=0; }
- if(dwDstY < 0) { dwHeight-=dwDstY; dwSrcY=-dwDstY; dwDstY=0; }
- const sal_Int32 dwRight(dwDstX+dwWidth);
- const sal_Int32 dwBottom(dwDstY+dwHeight);
- if(dwRight > dwWidth)
- dwWidth -= dwRight-dwWidth;
- if(dwBottom > dwHeight)
- dwHeight -= dwBottom-dwHeight;
-
- // calculate source buffer
- const Description &srcDesc = rTexture.maDesc;
- const sal_uInt32 dwSrcBytesPerPixel(getBytesPerPixel(srcDesc.eFormat));
- const sal_uInt32 dwSrcPitch(srcDesc.nWidth*dwSrcBytesPerPixel+srcDesc.nStride);
- sal_uInt8 *pSrcBuffer = rTexture.maDesc.pBuffer+(dwSrcPitch*dwSrcX)+(dwSrcBytesPerPixel*dwSrcY);
-
- // calculate destination buffer
- const Description &dstDesc = maDesc;
- const sal_uInt32 dwDstBytesPerPixel(getBytesPerPixel(dstDesc.eFormat));
- const sal_uInt32 dwDstPitch(dstDesc.nWidth*dwDstBytesPerPixel+dstDesc.nStride);
- sal_uInt8 *pDstBuffer = maDesc.pBuffer+(dwDstPitch*dwDstY)+(dwDstBytesPerPixel*dwDstX);
-
- // if source and destination format match, we can simply
- // copy whole scanlines.
- if(srcDesc.eFormat == dstDesc.eFormat)
- {
- const sal_Size dwNumBytesPerScanline(dwSrcBytesPerPixel*dwWidth);
- for(sal_Int32 y=0; y<dwHeight; ++y)
- {
- rtl_copyMemory(pDstBuffer,pSrcBuffer,dwNumBytesPerScanline);
- pSrcBuffer += dwSrcPitch;
- pDstBuffer += dwDstPitch;
- }
- }
- else
- {
- // otherwise [formats do not match], we need to copy
- // each pixel one by one and convert from source to destination format.
- if(srcDesc.eFormat == FMT_A8R8G8B8 && dstDesc.eFormat == FMT_R8G8B8)
- {
- for(sal_Int32 y=0; y<dwHeight; ++y)
- {
- sal_uInt8 *pSrc=pSrcBuffer;
- sal_uInt8 *pDst=pDstBuffer;
- for(sal_Int32 x=0; x<dwWidth; ++x)
- {
- BYTE r(*pSrc++);
- BYTE g(*pSrc++);
- BYTE b(*pSrc++);
- BYTE Alpha(*pSrc++);
- BYTE OneMinusAlpha(0xFF-Alpha);
- *pDst=(((r*Alpha)+((*pDst)*OneMinusAlpha))/0xFF);
- ++pDst;
- *pDst=(((g*Alpha)+((*pDst)*OneMinusAlpha))/0xFF);
- ++pDst;
- *pDst=(((b*Alpha)+((*pDst)*OneMinusAlpha))/0xFF);
- ++pDst;
- }
- pSrcBuffer += dwSrcPitch;
- pDstBuffer += dwDstPitch;
- }
- }
- else if(srcDesc.eFormat == FMT_R8G8B8 && dstDesc.eFormat == FMT_A8R8G8B8)
- {
- for(sal_Int32 y=0; y<dwHeight; ++y)
- {
- sal_uInt8 *pSrc=pSrcBuffer;
- sal_uInt8 *pDst=pDstBuffer;
- for(sal_Int32 x=0; x<dwWidth; ++x)
- {
- BYTE r(*pSrc++);
- BYTE g(*pSrc++);
- BYTE b(*pSrc++);
- *pDst++=r;
- *pDst++=g;
- *pDst++=b;
- *pDst++=0xFF;
- }
- pSrcBuffer += dwSrcPitch;
- pDstBuffer += dwDstPitch;
- }
- }
- }
-
- return ImageCachedPrimitiveSharedPtr();
- }
- }
-
- typedef cachedPrimitiveFTPP<pixel_format,span_gen_type> cachedPrimitive_t;
- cachedPrimitive_t *pPrimitive = new cachedPrimitive_t( rOverallTransform,
- rViewTransform,
- maRenderingBuffer,
- rTexture.maRenderingBuffer);
-
- agg::path_storage path;
- agg::conv_curve<agg::path_storage> curve(path);
-
- for(sal_uInt32 nPolygon(0); nPolygon < rPolyPolygon.count(); nPolygon++)
- {
- const basegfx::B2DPolygon aPolygon(rPolyPolygon.getB2DPolygon(nPolygon));
- const sal_uInt32 nPointCount(aPolygon.count());
-
- if(nPointCount)
- {
- if(aPolygon.areControlPointsUsed())
- {
- // prepare edge-based loop
- basegfx::B2DPoint aCurrentPoint(aPolygon.getB2DPoint(0));
- const sal_uInt32 nEdgeCount(aPolygon.isClosed() ? nPointCount - 1 : nPointCount);
-
- // first vertex
- path.move_to(aCurrentPoint.getX(), aCurrentPoint.getY());
-
- for(sal_uInt32 a(0); a < nEdgeCount; a++)
- {
- // access next point
- const sal_uInt32 nNextIndex((a + 1) % nPointCount);
- const basegfx::B2DPoint aNextPoint(aPolygon.getB2DPoint(nNextIndex));
-
- // get control points
- const basegfx::B2DPoint aControlNext(aPolygon.getNextControlPoint(a));
- const basegfx::B2DPoint aControlPrev(aPolygon.getPrevControlPoint(nNextIndex));
-
- // specify first cp, second cp, next vertex
- path.curve4(
- aControlNext.getX(), aControlNext.getY(),
- aControlPrev.getX(), aControlPrev.getY(),
- aNextPoint.getX(), aNextPoint.getY());
-
- // prepare next step
- aCurrentPoint = aNextPoint;
- }
- }
- else
- {
- const basegfx::B2DPoint aPoint(aPolygon.getB2DPoint(0));
- pPrimitive->ras.move_to_d(aPoint.getX(), aPoint.getY());
-
- for(sal_uInt32 a(1); a < nPointCount; a++)
- {
- const basegfx::B2DPoint aVertexPoint(aPolygon.getB2DPoint(a));
- pPrimitive->ras.line_to_d(aVertexPoint.getX(), aVertexPoint.getY());
- }
-
- if(aPolygon.isClosed())
- {
- pPrimitive->ras.close_polygon();
- }
- }
- }
- }
-
- pPrimitive->ras.add_path(curve);
- pPrimitive->redraw();
-
- return ImageCachedPrimitiveSharedPtr(pPrimitive);
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillTexturedPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::fillTexturedPolyPolygon(
- const Image& rTexture,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const ::basegfx::B2DHomMatrix& rViewTransform,
- const rendering::Texture& texture )
-{
- typedef agg::wrap_mode_repeat wrap_x_type;
- typedef agg::wrap_mode_repeat wrap_y_type;
- typedef agg::pixfmt_rgb24 pixfmt_rgb24;
- typedef agg::pixfmt_rgba32 pixfmt_rgba32;
-#if AGG_VERSION >= 2400
- typedef agg::image_accessor_wrap< pixfmt_rgba32, wrap_x_type, wrap_y_type > img_source_type_rgba;
- typedef agg::image_accessor_wrap< pixfmt_rgb24, wrap_x_type, wrap_y_type > img_source_type_rgb;
-
- typedef agg::span_image_resample_rgba_affine< img_source_type_rgba > span_gen_type_rgba;
- typedef agg::span_image_resample_rgb_affine< img_source_type_rgb > span_gen_type_rgb;
-#else
- typedef agg::span_pattern_resample_rgba_affine< pixfmt_rgba32::color_type,
- pixfmt_rgba32::order_type,
- wrap_x_type,
- wrap_y_type> span_gen_type_rgba;
- typedef agg::span_pattern_resample_rgb_affine< pixfmt_rgb24::color_type,
- pixfmt_rgb24::order_type,
- wrap_x_type,
- wrap_y_type> span_gen_type_rgb;
-#endif
-
- const Format nDest = maDesc.eFormat;
- const Format nSource = rTexture.maDesc.eFormat;
-
- if(nDest == FMT_R8G8B8 && nSource == FMT_R8G8B8)
- {
- return fillTexturedPolyPolygonImpl< agg::pixfmt_rgb24,
- span_gen_type_rgb >(
- rTexture,
- rPolyPolygon,
- rOverallTransform,
- rViewTransform,
- texture );
- }
- else if(nDest == FMT_R8G8B8 && nSource == FMT_A8R8G8B8)
- {
- return fillTexturedPolyPolygonImpl< agg::pixfmt_rgb24,
- span_gen_type_rgba >(
- rTexture,
- rPolyPolygon,
- rOverallTransform,
- rViewTransform,
- texture );
- }
- else if(nDest == FMT_A8R8G8B8 && nSource == FMT_R8G8B8)
- {
- return fillTexturedPolyPolygonImpl< agg::pixfmt_rgba32,
- span_gen_type_rgb >(
- rTexture,
- rPolyPolygon,
- rOverallTransform,
- rViewTransform,
- texture );
- }
- else if(nDest == FMT_A8R8G8B8 && nSource == FMT_A8R8G8B8)
- {
- return fillTexturedPolyPolygonImpl< agg::pixfmt_rgba32,
- span_gen_type_rgba >(
- rTexture,
- rPolyPolygon,
- rOverallTransform,
- rViewTransform,
- texture );
- }
- else
- {
- OSL_ENSURE(false, "Unexpected pixel format");
- }
-
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillGradient
-//////////////////////////////////////////////////////////////////////////////////
-
-template<class pixel_format>
-void Image::fillGradientImpl( const ParametricPolyPolygon::Values& rValues,
- const uno::Sequence< double >& rUnoColor1,
- const uno::Sequence< double >& rUnoColor2,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const rendering::Texture& )
-{
- const ARGB aColor1(0xFFFFFFFF,
- rUnoColor1);
- const ARGB aColor2(0xFFFFFFFF,
- rUnoColor2);
-
- // first of all we need to provide the framebuffer we want to render to.
- // the properties of the framebuffer are
- // 1) memory & layout [width, height, stride]
- // 2) pixelformat
- // 3) clipping
-
- // Class template pixel_formats_rgb24 has full knowledge about this
- // particular pixel format in memory. The only template parameter
- // can be order_rgb24 or order_bgr24 that determines the order of color channels.
- pixel_format pixf(maRenderingBuffer);
-
- // There are two basic renderers with almost the same functionality:
- // renderer_base and renderer_mclip. The first one is used most often
- // and it performs low level clipping.
- // This simply adds clipping to the graphics buffer, the clip rect
- // will be initialized to the area of the framebuffer.
- typedef agg::renderer_base<pixel_format> renderer_base;
- renderer_base rb(pixf);
-
- // bounding rectangle of untransformed polypolygon
- const ::basegfx::B2DRange& rBounds(::basegfx::tools::getRange(rPolyPolygon));
-
- // the color generator produces a specific color from
- // some given interpolation value.
- // number of steps for color interpolation
- typedef typename pixel_format::color_type color_type;
- color_type color1(agg::rgba8(aColor1.Color.r,
- aColor1.Color.g,
- aColor1.Color.b,
- 255));
- color_type color2(agg::rgba8(aColor2.Color.r,
- aColor2.Color.g,
- aColor2.Color.b,
- 255));
- typedef color_generator_adaptor<color_type> color_generator_type;
- unsigned int dwNumSteps = static_cast<unsigned int>(rBounds.getWidth());
- color_generator_type colors(color1,color2,dwNumSteps);
- colors.set_linear(true);
-
- // color = f(x,y)
- gradient_polymorphic_wrapper<agg::gradient_x> gf_x;
- gradient_polymorphic_wrapper<agg::gradient_radial> gf_radial;
- gradient_polymorphic_wrapper<gradient_rect> gf_rectangular;
- gf_rectangular.m_gradient.width = static_cast<int>(rBounds.getWidth())<<4;
- gf_rectangular.m_gradient.height = static_cast<int>(rBounds.getHeight())<<4;
- const gradient_polymorphic_wrapper_base *gf[] = { &gf_x, // GRADIENT_LINEAR
- &gf_x, // GRADIENT_AXIAL
- &gf_radial, // GRADIENT_ELLIPTICAL
- &gf_rectangular // GRADIENT_RECTANGULAR
- };
-
- // how do texture coordinates change when the pixel coordinate change?
- typedef agg::span_interpolator_linear<> interpolator_type;
- agg::trans_affine tm;
- tm *= agg::trans_affine_scaling(1.0f/rBounds.getWidth(),
- 1.0f/rBounds.getHeight());
- if(rValues.meType == ParametricPolyPolygon::GRADIENT_ELLIPTICAL ||
- rValues.meType == ParametricPolyPolygon::GRADIENT_RECTANGULAR)
- {
- //tm *= trans_affine_scaling(mnAspectRatio,+1.0f);
- //const double fAspect = aBounds.getWidth()/aBounds.getHeight();
- //tm *= trans_affine_scaling(+0.5f,+0.5f*(1.0f/fAspect));
- //tm *= trans_affine_translation(+0.5f,+0.5f);
- tm *= agg::trans_affine_scaling(+0.5f,+0.5f);
- tm *= agg::trans_affine_translation(+0.5f,+0.5f);
- }
- tm *= transAffineFromB2DHomMatrix(rOverallTransform);
- tm.invert();
- interpolator_type inter(tm);
-
- // spanline allocators reserve memory for the color values
- // filled up by the spanline generators.
- typedef agg::span_allocator<color_type> gradient_span_alloc;
- gradient_span_alloc span_alloc;
-
- // scanline generators create the actual color values for
- // some specific coordinate range of a scanline.
- typedef agg::span_gradient<color_type,
- interpolator_type,
- gradient_polymorphic_wrapper_base,
- color_generator_type > gradient_span_gen;
-#if AGG_VERSION >= 2400
- gradient_span_gen span_gen(inter,
- *gf[rValues.meType],
- colors,
- 0,
- dwNumSteps);
-#else
- gradient_span_gen span_gen(span_alloc,
- inter,
- *gf[rValues.meType],
- colors,
- 0,
- dwNumSteps);
-#endif
-
- // To draw Anti-Aliased primitives one shoud *rasterize* them first.
- // The primary rasterization technique in AGG is scanline based.
- // That is, a polygon is converted into a number of horizontal
- // scanlines and then the scanlines are being rendered one by one.
- // To transfer information from a rasterizer to the scanline renderer
- // there scanline containers are used. A scanline consists of a
- // number of horizontal, non-intersecting spans. All spans must be ordered by X.
- // --> packed scanline container
- agg::scanline_p8 sl;
-
- // antialiased scanline renderer with pattern filling capability
- // [in contrast to solid renderers, that is]
- // the instance of this particular renderer combines the
- // renderbuffer [i.e. destination] and the spanline generator [i.e. source]
-#if AGG_VERSION >= 2400
- typedef agg::renderer_scanline_aa<renderer_base, gradient_span_alloc, gradient_span_gen> renderer_gradient;
- renderer_gradient r1(rb, span_alloc, span_gen);
-#else
- typedef agg::renderer_scanline_aa<renderer_base, gradient_span_gen> renderer_gradient;
- renderer_gradient r1(rb, span_gen);
-#endif
-
- // instantiate the rasterizer and feed the incoming polypolygon.
- agg::rasterizer_scanline_aa<> ras;
- agg::path_storage path;
- agg::conv_curve<agg::path_storage> curve(path);
-
- for(sal_uInt32 nPolygon(0); nPolygon < rPolyPolygon.count(); nPolygon++)
- {
- const basegfx::B2DPolygon aPolygon(rPolyPolygon.getB2DPolygon(nPolygon));
- const sal_uInt32 nPointCount(aPolygon.count());
-
- if(nPointCount)
- {
- if(aPolygon.areControlPointsUsed())
- {
- // prepare edge-based loop
- basegfx::B2DPoint aCurrentPoint(aPolygon.getB2DPoint(0));
- const sal_uInt32 nEdgeCount(aPolygon.isClosed() ? nPointCount - 1 : nPointCount);
-
- // first vertex
- path.move_to(aCurrentPoint.getX(), aCurrentPoint.getY());
-
- for(sal_uInt32 a(0); a < nEdgeCount; a++)
- {
- // access next point
- const sal_uInt32 nNextIndex((a + 1) % nPointCount);
- const basegfx::B2DPoint aNextPoint(aPolygon.getB2DPoint(nNextIndex));
-
- // get control points
- const basegfx::B2DPoint aControlNext(aPolygon.getNextControlPoint(a));
- const basegfx::B2DPoint aControlPrev(aPolygon.getPrevControlPoint(nNextIndex));
-
- // specify first cp, second cp, next vertex
- path.curve4(
- aControlNext.getX(), aControlNext.getY(),
- aControlPrev.getX(), aControlPrev.getY(),
- aNextPoint.getX(), aNextPoint.getY());
-
- // prepare next step
- aCurrentPoint = aNextPoint;
- }
- }
- else
- {
- const basegfx::B2DPoint aPoint(aPolygon.getB2DPoint(0));
- ras.move_to_d(aPoint.getX(), aPoint.getY());
-
- for(sal_uInt32 a(1); a < nPointCount; a++)
- {
- const basegfx::B2DPoint aVertexPoint(aPolygon.getB2DPoint(a));
- ras.line_to_d(aVertexPoint.getX(), aVertexPoint.getY());
- }
-
- if(aPolygon.isClosed())
- {
- ras.close_polygon();
- }
- }
- }
- }
-
- // everything is up and running, go...
- ras.add_path(curve);
- render_scanlines(ras,sl,r1);
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillGradient
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::fillGradient( const ParametricPolyPolygon::Values& rValues,
- const uno::Sequence< double >& rUnoColor1,
- const uno::Sequence< double >& rUnoColor2,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const rendering::Texture& texture )
-{
- switch(maDesc.eFormat)
- {
- case FMT_R8G8B8:
- fillGradientImpl<agg::pixfmt_rgb24>(rValues,rUnoColor1,rUnoColor2,rPolyPolygon,rOverallTransform,texture);
- break;
- case FMT_A8R8G8B8:
- fillGradientImpl<agg::pixfmt_rgba32>(rValues,rUnoColor1,rUnoColor2,rPolyPolygon,rOverallTransform,texture);
- break;
- default:
- OSL_ENSURE(false, "Unexpected pixel format");
- break;
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fromVCLBitmap
-//////////////////////////////////////////////////////////////////////////////////
-
-bool Image::fromVCLBitmap( ::BitmapEx& rBmpEx )
-{
- const ::Size aBmpSize( rBmpEx.GetSizePixel() );
- Image::Description desc;
- desc.eFormat = rBmpEx.IsTransparent() ? FMT_A8R8G8B8 : FMT_R8G8B8;
- desc.nWidth = aBmpSize.Width();
- desc.nHeight = aBmpSize.Height();
- desc.nStride = 0;
- const sal_uInt32 nPitch(desc.nWidth*getBytesPerPixel(desc.eFormat)+desc.nStride);
- desc.pBuffer = new sal_uInt8 [nPitch*desc.nHeight];
- maDesc = desc;
- mbBufferHasUserOwnership = false;
- maRenderingBuffer.attach(static_cast<agg::int8u *>(desc.pBuffer),
- desc.nWidth,
- desc.nHeight,
- nPitch);
- RawABGRBitmap aBmpData;
- aBmpData.mnWidth = aBmpSize.Width();
- aBmpData.mnHeight = aBmpSize.Height();
- aBmpData.mpBitmapData = static_cast<sal_uInt8 *>(desc.pBuffer);
- vclBitmapEx2Raw(rBmpEx,aBmpData);
-
- return true;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::Image
-//////////////////////////////////////////////////////////////////////////////////
-
-Image::Image( const Description& rDesc ) :
- maDesc( rDesc ),
- maRenderingBuffer(),
- mbBufferHasUserOwnership( rDesc.pBuffer != NULL )
-{
-#if defined(PROFILER)
- for(int i=0; i<TIMER_MAX; ++i)
- maElapsedTime[i]=0.0;
-#endif
-
- // allocate own buffer memory, if not provided
- sal_uInt8* pBuffer = maDesc.pBuffer;
- const sal_uInt32 nWidth(maDesc.nWidth);
- const sal_uInt32 nHeight(maDesc.nHeight);
- const sal_uInt32 nStride(maDesc.nStride);
- const sal_uInt32 nPitch(nWidth*getBytesPerPixel(maDesc.eFormat)
- + nStride);
-
- if( !pBuffer )
- pBuffer = new sal_uInt8 [nPitch*nHeight];
-
- maDesc.pBuffer = pBuffer;
-
- // attach graphics buffer
- maRenderingBuffer.attach(
- static_cast<agg::int8u *>(pBuffer),
- nWidth,
- nHeight,
- nPitch );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::Image
-//////////////////////////////////////////////////////////////////////////////////
-
-Image::Image( const uno::Reference< rendering::XBitmap >& xBitmap ) :
- maDesc(),
- maRenderingBuffer(),
- mbBufferHasUserOwnership( false )
-{
-#if defined(PROFILER)
- for(int i=0; i<TIMER_MAX; ++i)
- maElapsedTime[i]=0.0;
-#endif
-
- // TODO(F1): Add support for floating point bitmap formats
- uno::Reference<rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap,
- uno::UNO_QUERY_THROW);
- ::BitmapEx aBmpEx = ::vcl::unotools::bitmapExFromXBitmap(xIntBmp);
- if( !!aBmpEx )
- fromVCLBitmap(aBmpEx);
-
- // TODO(F2): Fallback to XIntegerBitmap interface for import
- OSL_ENSURE(false,
- "Image::Image(): Cannot retrieve bitmap data!" );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::~Image
-//////////////////////////////////////////////////////////////////////////////////
-
-Image::~Image()
-{
-#if defined(PROFILER)
-
- double aAccumulatedTime(0.0);
- for(int i=0; i<TIMER_MAX; ++i)
- aAccumulatedTime += maElapsedTime[i];
-
- OSL_TRACE("Image %d - %d %d %d %d %d\n",(int)(aAccumulatedTime*1000.0),
- (int)(maElapsedTime[TIMER_FILLTEXTUREDPOLYPOLYGON]*1000.0),
- (int)(maElapsedTime[TIMER_FILLB2DPOLYPOLYGON]*1000.0),
- (int)(maElapsedTime[TIMER_DRAWPOLYPOLYGON]*1000.0),
- (int)(maElapsedTime[TIMER_FILLPOLYPOLYGON]*1000.0),
- (int)(maElapsedTime[TIMER_DRAWBITMAP]*1000.0));
-
-#endif
-
- if( !mbBufferHasUserOwnership )
- delete [] maDesc.pBuffer;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::clear
-//////////////////////////////////////////////////////////////////////////////////
-
-template<class pixel_format>
-void Image::clearImpl( sal_uInt8 a,
- sal_uInt8 r,
- sal_uInt8 g,
- sal_uInt8 b )
-{
- pixel_format pixf(maRenderingBuffer);
- agg::renderer_base<pixel_format> renb(pixf);
-
- renb.clear(agg::rgba8(r,g,b,a));
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::clear
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::clear( sal_uInt8 a,
- sal_uInt8 r,
- sal_uInt8 g,
- sal_uInt8 b )
-{
- switch(maDesc.eFormat)
- {
- case FMT_R8G8B8:
- return clearImpl<agg::pixfmt_rgb24>(a,r,g,b);
- case FMT_A8R8G8B8:
- return clearImpl<agg::pixfmt_rgba32>(a,r,g,b);
- default:
- OSL_ENSURE(false, "Unexpected pixel format");
- break;
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillB2DPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::fillB2DPolyPolygon(
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
-#if defined(PROFILER)
- ScopeTimer aTimer(TIMER_FILLB2DPOLYPOLYGON,this);
-#endif
-
- switch(maDesc.eFormat)
- {
- case FMT_R8G8B8:
- fillPolyPolygonImpl<agg::pixfmt_rgb24>(rPolyPolygon,viewState,renderState);
- break;
- case FMT_A8R8G8B8:
- fillPolyPolygonImpl<agg::pixfmt_rgba32>(rPolyPolygon,viewState,renderState);
- break;
- default:
- OSL_ENSURE(false, "Unexpected pixel format");
- break;
- }
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::lock
-//////////////////////////////////////////////////////////////////////////////////
-
-sal_uInt8* Image::lock() const
-{
- return maDesc.pBuffer;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::unlock
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::unlock() const
-{
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::getWidth
-//////////////////////////////////////////////////////////////////////////////////
-
-sal_uInt32 Image::getWidth() const
-{
- return maDesc.nWidth;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::getHeight
-//////////////////////////////////////////////////////////////////////////////////
-
-sal_uInt32 Image::getHeight() const
-{
- return maDesc.nHeight;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::getStride
-//////////////////////////////////////////////////////////////////////////////////
-
-sal_uInt32 Image::getStride() const
-{
- return maDesc.nWidth*getBytesPerPixel(maDesc.eFormat)+maDesc.nStride;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::getFormat
-//////////////////////////////////////////////////////////////////////////////////
-
-IColorBuffer::Format Image::getFormat() const
-{
- return maDesc.eFormat;
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawPoint
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::drawPoint( const geometry::RealPoint2D& /*aPoint*/,
- const rendering::ViewState& /*viewState*/,
- const rendering::RenderState& /*renderState*/ )
-{
- OSL_ENSURE(false,
- "Image::drawPoint(): NYI" );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawLine
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::drawLine( const geometry::RealPoint2D& aStartPoint,
- const geometry::RealPoint2D& aEndPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- ::basegfx::B2DPolygon aLinePoly;
- aLinePoly.append(
- ::basegfx::unotools::b2DPointFromRealPoint2D( aStartPoint ) );
- aLinePoly.append(
- ::basegfx::unotools::b2DPointFromRealPoint2D( aEndPoint ) );
-
- drawLinePolyPolygon( ::basegfx::B2DPolyPolygon( aLinePoly ),
- 1.0,
- viewState,
- renderState );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawBezier
-//////////////////////////////////////////////////////////////////////////////////
-
-void Image::drawBezier( const geometry::RealBezierSegment2D& aBezierSegment,
- const geometry::RealPoint2D& aEndPoint,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- basegfx::B2DPolygon aBezierPoly;
-
- aBezierPoly.append(basegfx::B2DPoint(aBezierSegment.Px, aBezierSegment.Py));
- aBezierPoly.appendBezierSegment(
- basegfx::B2DPoint(aBezierSegment.C1x, aBezierSegment.C1y),
- basegfx::B2DPoint(aBezierSegment.C2x, aBezierSegment.C2y),
- basegfx::unotools::b2DPointFromRealPoint2D(aEndPoint));
-
- drawLinePolyPolygon( ::basegfx::B2DPolyPolygon( aBezierPoly ),
- 1.0,
- viewState,
- renderState );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::drawPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
-#if defined(PROFILER)
- ScopeTimer aTimer(TIMER_DRAWPOLYPOLYGON,this);
-#endif
-
- if( !xPolyPolygon.is() )
- return ImageCachedPrimitiveSharedPtr();
-
- drawLinePolyPolygon( ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( xPolyPolygon ),
- 1.0,
- viewState,
- renderState );
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::strokePolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::strokePolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const rendering::StrokeAttributes& strokeAttributes )
-{
- if( !xPolyPolygon.is() )
- return ImageCachedPrimitiveSharedPtr();
-
- drawLinePolyPolygon( ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( xPolyPolygon ),
- strokeAttributes.StrokeWidth,
- viewState,
- renderState );
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::strokeTexturedPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::strokeTexturedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
- const rendering::ViewState& /*viewState*/,
- const rendering::RenderState& /*renderState*/,
- const uno::Sequence< rendering::Texture >& /*textures*/,
- const ::std::vector< ::boost::shared_ptr<Image> >& /*textureAnnotations*/,
- const rendering::StrokeAttributes& /*strokeAttributes*/ )
-{
- OSL_ENSURE(false,
- "Image::strokeTexturedPolyPolygon(): NYI" );
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::strokeTextureMappedPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::strokeTextureMappedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
- const rendering::ViewState& /*viewState*/,
- const rendering::RenderState& /*renderState*/,
- const uno::Sequence< rendering::Texture >& /*textures*/,
- const ::std::vector< ::boost::shared_ptr<Image> >& /*textureAnnotations*/,
- const uno::Reference< geometry::XMapping2D >& /*xMapping*/,
- const rendering::StrokeAttributes& /*strokeAttributes*/ )
-{
- OSL_ENSURE(false,
- "Image::strokeTextureMappedPolyPolygon(): NYI" );
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-template<class pixel_format>
-ImageCachedPrimitiveSharedPtr Image::fillPolyPolygonImpl(
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
-#if defined(PROFILER)
- ScopeTimer aTimer(TIMER_FILLPOLYPOLYGON,this);
-#endif
-
- ARGB aFillColor;
-
- ::basegfx::B2DPolyPolygon aPolyPolygon(rPolyPolygon);
- setupPolyPolygon( aPolyPolygon, true, aFillColor, viewState, renderState );
-
- if( !aPolyPolygon.count() )
- return ImageCachedPrimitiveSharedPtr();
-
- pixel_format pixf(maRenderingBuffer);
- agg::renderer_base<pixel_format> renb(pixf);
-
- // Scanline renderer for solid filling.
- agg::renderer_scanline_aa_solid<agg::renderer_base<pixel_format> > ren(renb);
-
- // Rasterizer & scanline
- agg::rasterizer_scanline_aa<> ras;
- agg::scanline_p8 sl;
-
- agg::path_storage path;
- agg::conv_curve<agg::path_storage> curve(path);
-
- for(sal_uInt32 nPolygon(0); nPolygon < aPolyPolygon.count(); nPolygon++)
- {
- const basegfx::B2DPolygon aPolygon(aPolyPolygon.getB2DPolygon(nPolygon));
- const sal_uInt32 nPointCount(aPolygon.count());
-
- if(nPointCount)
- {
- if(aPolygon.areControlPointsUsed())
- {
- // prepare edge-based loop
- basegfx::B2DPoint aCurrentPoint(aPolygon.getB2DPoint(0));
- const sal_uInt32 nEdgeCount(aPolygon.isClosed() ? nPointCount - 1 : nPointCount);
-
- // first vertex
- path.move_to(aCurrentPoint.getX(), aCurrentPoint.getY());
-
- for(sal_uInt32 a(0); a < nEdgeCount; a++)
- {
- // access next point
- const sal_uInt32 nNextIndex((a + 1) % nPointCount);
- const basegfx::B2DPoint aNextPoint(aPolygon.getB2DPoint(nNextIndex));
-
- // get control points
- const basegfx::B2DPoint aControlNext(aPolygon.getNextControlPoint(a));
- const basegfx::B2DPoint aControlPrev(aPolygon.getPrevControlPoint(nNextIndex));
-
- // specify first cp, second cp, next vertex
- path.curve4(
- aControlNext.getX(), aControlNext.getY(),
- aControlPrev.getX(), aControlPrev.getY(),
- aNextPoint.getX(), aNextPoint.getY());
-
- // prepare next step
- aCurrentPoint = aNextPoint;
- }
- }
- else
- {
- const basegfx::B2DPoint aPoint(aPolygon.getB2DPoint(0));
- ras.move_to_d(aPoint.getX(), aPoint.getY());
-
- for(sal_uInt32 a(1); a < nPointCount; a++)
- {
- const basegfx::B2DPoint aVertexPoint(aPolygon.getB2DPoint(a));
- ras.line_to_d(aVertexPoint.getX(), aVertexPoint.getY());
- }
-
- if(aPolygon.isClosed())
- {
- ras.close_polygon();
- }
- }
- }
- }
-
- ras.add_path(curve);
- agg::rgba8 fillcolor(aFillColor.Color.r,aFillColor.Color.g,aFillColor.Color.b,aFillColor.Color.a);
- ren.color(fillcolor);
- agg::render_scanlines(ras, sl, ren);
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::fillPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- if( !xPolyPolygon.is() )
- return ImageCachedPrimitiveSharedPtr();
-
- ::basegfx::B2DPolyPolygon aPoly(
- ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( xPolyPolygon ) );
-
- switch(maDesc.eFormat)
- {
- case FMT_R8G8B8:
- return fillPolyPolygonImpl<agg::pixfmt_rgb24>(aPoly,viewState,renderState);
- case FMT_A8R8G8B8:
- return fillPolyPolygonImpl<agg::pixfmt_rgba32>(aPoly,viewState,renderState);
- default:
- OSL_ENSURE(false, "Unexpected pixel format");
- break;
- }
-
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillTexturedPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::fillTexturedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState,
- const uno::Sequence< rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Image> >& textureAnnotations )
-{
-#if defined(PROFILER)
- ScopeTimer aTimer(TIMER_FILLTEXTUREDPOLYPOLYGON,this);
-#endif
-
- if( !xPolyPolygon.is() )
- return ImageCachedPrimitiveSharedPtr();
-
- ::basegfx::B2DPolyPolygon aPoly(
- ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( xPolyPolygon ) );
- ARGB aFillColor;
-
- setupPolyPolygon( aPoly, true, aFillColor, viewState, renderState );
-
- if( !aPoly.count() )
- return ImageCachedPrimitiveSharedPtr();
-
- ::basegfx::B2DHomMatrix aViewTransform;
- ::basegfx::B2DHomMatrix aRenderTransform;
- ::basegfx::B2DHomMatrix aTextureTransform;
-
- ::basegfx::unotools::homMatrixFromAffineMatrix(aTextureTransform,
- textures[0].AffineTransform);
- ::basegfx::unotools::homMatrixFromAffineMatrix(aRenderTransform,
- renderState.AffineTransform);
- ::basegfx::unotools::homMatrixFromAffineMatrix(aViewTransform,
- viewState.AffineTransform);
- aTextureTransform *= aRenderTransform;
-
- // TODO(F1): Multi-texturing
- if( textures[0].Gradient.is() )
- {
- aTextureTransform *= aViewTransform;
-
- // try to cast XParametricPolyPolygon2D reference to
- // our implementation class.
- ::canvas::ParametricPolyPolygon* pGradient =
- dynamic_cast< ::canvas::ParametricPolyPolygon* >( textures[0].Gradient.get() );
-
- if( pGradient )
- {
- const ParametricPolyPolygon::Values& rValues(
- pGradient->getValues() );
-
- // TODO: use all the colors and place them on given positions/stops
- // TODO(E1): Return value
- // TODO(F1): FillRule
- fillGradient( rValues,
- rValues.maColors [0],
- rValues.maColors [rValues.maColors.getLength () - 1],
- aPoly,
- aTextureTransform,
- textures[0] );
- }
- }
- else if( textures[0].Bitmap.is() )
- {
- ImageSharedPtr pTexture;
-
- if( textureAnnotations[0].get() != NULL )
- pTexture = textureAnnotations[0];
- else
- pTexture.reset( new Image( textures[0].Bitmap ) );
-
- const sal_uInt32 nWidth(pTexture->maDesc.nWidth);
- const sal_uInt32 nHeight(pTexture->maDesc.nHeight);
-
- // scale texture into one-by-one unit rect.
- aTextureTransform.scale(1.0f/nWidth,
- 1.0f/nHeight);
-
- // TODO(E1): Return value
- // TODO(F1): FillRule
- return fillTexturedPolyPolygon( *pTexture,
- aPoly,
- aTextureTransform,
- aViewTransform,
- textures[0] );
- }
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::fillTextureMappedPolyPolygon
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::fillTextureMappedPolyPolygon(
- const uno::Reference< rendering::XPolyPolygon2D >& /*xPolyPolygon*/,
- const rendering::ViewState& /*viewState*/,
- const rendering::RenderState& /*renderState*/,
- const uno::Sequence< rendering::Texture >& /*textures*/,
- const ::std::vector< ::boost::shared_ptr<Image> >& /*textureAnnotations*/,
- const uno::Reference< geometry::XMapping2D >& /*xMapping*/ )
-{
- OSL_ENSURE(false,
- "Image::fillTextureMappedPolyPolygon(): NYI" );
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawBitmap
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::drawBitmap(
- const uno::Reference< rendering::XBitmap >& xBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
-#if defined(PROFILER)
- ScopeTimer aTimer(TIMER_DRAWBITMAP,this);
-#endif
-
- // TODO(P3): Implement bitmap caching
- if( !xBitmap.is() )
- return ImageCachedPrimitiveSharedPtr();
-/*
- XBitmapAccessor accessor( xBitmap );
- if(accessor.isValid())
- {
- Image aImage( accessor.getDesc() );
-
- implDrawBitmap( aImage,
- viewState,
- renderState );
-
- // TODO(F2): Implement sensible ImageCachedPrimitive
- return ImageCachedPrimitiveSharedPtr();
- }
-*/
- Image aImage( xBitmap );
-
- return implDrawBitmap( aImage,viewState,renderState );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawBitmap
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::drawBitmap(
- const ImageSharedPtr& rImage,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
-#if defined(PROFILER)
- ScopeTimer aTimer(TIMER_DRAWBITMAP,this);
-#endif
-
- // TODO(P3): Implement bitmap caching
- if( !rImage )
- return ImageCachedPrimitiveSharedPtr();
-
- return implDrawBitmap( *rImage,
- viewState,
- renderState );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawBitmapModulated
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::drawBitmapModulated(
- const uno::Reference< rendering::XBitmap >& xBitmap,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- // TODO(P3): Implement bitmap caching
- if( !xBitmap.is() )
- return ImageCachedPrimitiveSharedPtr();
-
- Image aImage( xBitmap );
-
- // TODO(F2): Distinguish modulated and unmodulated bitmap output
- return implDrawBitmap( aImage,viewState,renderState );
-}
-
-//////////////////////////////////////////////////////////////////////////////////
-// Image::drawBitmapModulated
-//////////////////////////////////////////////////////////////////////////////////
-
-ImageCachedPrimitiveSharedPtr Image::drawBitmapModulated(
- const ImageSharedPtr& rImage,
- const rendering::ViewState& viewState,
- const rendering::RenderState& renderState )
-{
- // TODO(P3): Implement bitmap caching
- if( !rImage )
- return ImageCachedPrimitiveSharedPtr();
-
- // TODO(F2): Distinguish modulated and unmodulated bitmap output
- return implDrawBitmap( *rImage,viewState,renderState );
-}
-
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/source/tools/image.hxx b/canvas/source/tools/image.hxx
deleted file mode 100644
index f617828111ec..000000000000
--- a/canvas/source/tools/image.hxx
+++ /dev/null
@@ -1,301 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-#ifndef INCLUDED_CANVAS_IMAGE_HXX
-#define INCLUDED_CANVAS_IMAGE_HXX
-
-#include <com/sun/star/uno/Reference.hxx>
-#include <com/sun/star/rendering/XCanvas.hpp>
-#include <canvas/rendering/icolorbuffer.hxx>
-#include <canvas/parametricpolypolygon.hxx>
-#include "imagecachedprimitive.hxx"
-
-#include <canvas/elapsedtime.hxx>
-
-#include "image_sysprereq.h"
-
-struct BitmapSystemData;
-class BitmapEx;
-
-namespace canvas
-{
- class Image : public IColorBuffer
- {
- public:
- /// The description of the image
- struct Description
- {
- IColorBuffer::Format eFormat;
- sal_uInt32 nWidth;
- sal_uInt32 nHeight;
- sal_uInt32 nStride;
- sal_uInt8* pBuffer;
- };
-
- /** Create a new image with the attributes passed as argument.
- */
- explicit Image( const Description& desc );
-
- /** Create a new image from the XBitmap passed as argument
- */
- explicit Image( const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XBitmap >& xBitmap );
-
-
- virtual ~Image();
-
- /** Retrieve desciption of image layout
- */
- const Description& getDescription() const { return maDesc; }
-
- /** Clear image with uniform color
- */
- void clear( sal_uInt8 a,
- sal_uInt8 r,
- sal_uInt8 g,
- sal_uInt8 b );
-
- void fillB2DPolyPolygon(
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
-
- // IColorBuffer interface implementation
- // =====================================
-
- virtual sal_uInt8* lock() const;
- virtual void unlock() const;
- virtual sal_uInt32 getWidth() const;
- virtual sal_uInt32 getHeight() const;
- virtual sal_uInt32 getStride() const;
- virtual Format getFormat() const;
-
-
- // High-level drawing operations (from the XCanvas interface)
- // ==========================================================
-
- void drawPoint( const ::com::sun::star::geometry::RealPoint2D& aPoint,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
- void drawLine( const ::com::sun::star::geometry::RealPoint2D& aStartPoint,
- const ::com::sun::star::geometry::RealPoint2D& aEndPoint,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
- void drawBezier( const ::com::sun::star::geometry::RealBezierSegment2D& aBezierSegment,
- const ::com::sun::star::geometry::RealPoint2D& aEndPoint,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
- ImageCachedPrimitiveSharedPtr drawPolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- ImageCachedPrimitiveSharedPtr strokePolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState,
- const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
- ImageCachedPrimitiveSharedPtr strokeTexturedPolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState,
- const ::com::sun::star::uno::Sequence<
- ::com::sun::star::rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Image> >& textureAnnotations,
- const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
- ImageCachedPrimitiveSharedPtr strokeTextureMappedPolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState,
- const ::com::sun::star::uno::Sequence<
- ::com::sun::star::rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Image> >& textureAnnotations,
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::geometry::XMapping2D >& xMapping,
- const ::com::sun::star::rendering::StrokeAttributes& strokeAttributes );
- ImageCachedPrimitiveSharedPtr fillPolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
- ImageCachedPrimitiveSharedPtr fillTexturedPolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState,
- const ::com::sun::star::uno::Sequence<
- ::com::sun::star::rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Image> >& textureAnnotations );
- ImageCachedPrimitiveSharedPtr fillTextureMappedPolyPolygon(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XPolyPolygon2D >& xPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState,
- const ::com::sun::star::uno::Sequence<
- ::com::sun::star::rendering::Texture >& textures,
- const ::std::vector< ::boost::shared_ptr<Image> >& textureAnnotations,
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::geometry::XMapping2D >& xMapping );
-
- ImageCachedPrimitiveSharedPtr drawBitmap(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XBitmap >& xBitmap,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
- ImageCachedPrimitiveSharedPtr drawBitmap(
- const ::boost::shared_ptr<Image>& rImage,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- ImageCachedPrimitiveSharedPtr drawBitmapModulated(
- const ::com::sun::star::uno::Reference<
- ::com::sun::star::rendering::XBitmap >& xBitmap,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
- ImageCachedPrimitiveSharedPtr drawBitmapModulated(
- const ::boost::shared_ptr<Image>& rImage,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- private:
- void drawLinePolyPolygon( const ::basegfx::B2DPolyPolygon& rPoly,
- double fStrokeWidth,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- ImageCachedPrimitiveSharedPtr implDrawBitmap(
- const Image& rBitmap,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- ImageCachedPrimitiveSharedPtr fillTexturedPolyPolygon(
- const Image& rTexture,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const ::basegfx::B2DHomMatrix& rViewTransform,
- const ::com::sun::star::rendering::Texture& texture );
-
- void fillGradient( const ParametricPolyPolygon::Values& rValues,
- const ::com::sun::star::uno::Sequence< double >& rColor1,
- const ::com::sun::star::uno::Sequence< double >& rColor2,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const ::com::sun::star::rendering::Texture& texture );
- bool fromVCLBitmap( ::BitmapEx& rBmpEx );
-
- template<class pixel_format>
- void drawLinePolyPolygonImpl( const ::basegfx::B2DPolyPolygon& rPoly,
- double fStrokeWidth,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- template<class pixel_format,class span_gen_type>
- ImageCachedPrimitiveSharedPtr fillTexturedPolyPolygonImpl(
- const Image& rTexture,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const ::basegfx::B2DHomMatrix& rViewTransform,
- const ::com::sun::star::rendering::Texture& texture );
-
- template<class pixel_format>
- void fillGradientImpl( const ParametricPolyPolygon::Values& rValues,
- const ::com::sun::star::uno::Sequence< double >& rUnoColor1,
- const ::com::sun::star::uno::Sequence< double >& rUnoColor2,
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::basegfx::B2DHomMatrix& rOverallTransform,
- const ::com::sun::star::rendering::Texture& texture );
-
- template<class pixel_format>
- ImageCachedPrimitiveSharedPtr fillPolyPolygonImpl(
- const ::basegfx::B2DPolyPolygon& rPolyPolygon,
- const ::com::sun::star::rendering::ViewState& viewState,
- const ::com::sun::star::rendering::RenderState& renderState );
-
- template<class pixel_format> void clearImpl( sal_uInt8 a,
- sal_uInt8 r,
- sal_uInt8 g,
- sal_uInt8 b );
-
- /** Image description
- */
- Description maDesc;
-
- /** the graphics buffer is a simple array
- where each element points to the start
- of a scanline in consecutive order.
- */
- agg::rendering_buffer maRenderingBuffer;
-
- /// Whether maRenderingBuffer is owned by the client of this object
- bool mbBufferHasUserOwnership;
-
-#if defined(PROFILER)
-
- enum constant
- {
- TIMER_FILLTEXTUREDPOLYPOLYGON,
- TIMER_FILLB2DPOLYPOLYGON,
- TIMER_DRAWPOLYPOLYGON,
- TIMER_FILLPOLYPOLYGON,
- TIMER_DRAWBITMAP,
- TIMER_MAX
- };
-
- double maElapsedTime[TIMER_MAX];
-
- struct ScopeTimer
- {
- ScopeTimer( constant aConstant, Image *pImage ) :
- maConstant(aConstant),mpImage(pImage)
- {}
-
- ~ScopeTimer()
- {
- mpImage->maElapsedTime[maConstant] += maTimer.getElapsedTime();
- }
-
- constant maConstant;
- Image* mpImage;
- ::canvas::tools::ElapsedTime maTimer;
- };
-
-#endif
- };
-
- typedef ::boost::shared_ptr< Image > ImageSharedPtr;
-
-}
-
-#endif /* INCLUDED_CANVAS_IMAGE_HXX */
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/source/tools/image_sysprereq.h b/canvas/source/tools/image_sysprereq.h
deleted file mode 100644
index 83cac87326d4..000000000000
--- a/canvas/source/tools/image_sysprereq.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-#if defined __GNUC__
-#pragma GCC system_header
-#elif defined __SUNPRO_CC
-#pragma disable_warn
-#elif defined _MSC_VER
-#pragma warning(push, 1)
-#endif
-
-#include <agg2/agg_rendering_buffer.h>
-
-#ifdef CANVAS_IMAGE_CXX
-
-//////////////////////////////////////////////////////////////////////////////////
-// includes from antigrain [i would love to write this stuff by myself]
-//////////////////////////////////////////////////////////////////////////////////
-
-#include <agg2/agg_rendering_buffer.h>
-#include <agg2/agg_pixfmt_rgb.h>
-#include <agg2/agg_pixfmt_rgba.h>
-#include <agg2/agg_renderer_base.h>
-#include <agg2/agg_color_rgba.h>
-#include <agg2/agg_rasterizer_outline_aa.h>
-#include <agg2/agg_rasterizer_scanline_aa.h>
-#include <agg2/agg_scanline_p.h>
-#include <agg2/agg_scanline_u.h>
-#include <agg2/agg_renderer_scanline.h>
-#include <agg2/agg_renderer_outline_aa.h>
-#include <agg2/agg_renderer_primitives.h>
-#include <agg2/agg_path_storage.h>
-#if AGG_VERSION == 2300
-#include <agg2/agg_span_pattern.h>
-#endif
-#include <agg2/agg_span_pattern_rgba.h>
-#if AGG_VERSION >= 2400
-#include <agg2/agg_span_image_filter_rgb.h>
-#include <agg2/agg_span_image_filter_rgba.h>
-#else
-#include <agg2/agg_span_pattern_resample_rgb.h>
-#include <agg2/agg_span_pattern_resample_rgba.h>
-#endif
-#include <agg2/agg_span_interpolator_linear.h>
-#include <agg2/agg_span_gradient.h>
-#if AGG_VERSION == 2300
-#include <agg2/agg_span_image_resample_rgb.h>
-#include <agg2/agg_span_image_resample_rgba.h>
-#endif
-#if AGG_VERSION >= 2400
-#include <agg2/agg_span_allocator.h>
-#endif
-#include <agg2/agg_image_filters.h>
-#if AGG_VERSION >= 2400
-#include <agg2/agg_image_accessors.h>
-#endif
-#include <agg2/agg_dda_line.h>
-#include <agg2/agg_scanline_storage_aa.h>
-#include <agg2/agg_scanline_storage_bin.h>
-#include <agg2/agg_scanline_bin.h>
-#include <agg2/agg_path_storage_integer.h>
-#include <agg2/agg_conv_contour.h>
-#include <agg2/agg_conv_curve.h>
-#include <agg2/agg_conv_stroke.h>
-#include <agg2/agg_conv_transform.h>
-#include <agg2/agg_trans_affine.h>
-#include <agg2/agg_font_cache_manager.h>
-#include <agg2/agg_bitset_iterator.h>
-#include <agg2/agg_path_storage.h>
-
-#endif // CANVAS_IMAGE_CXX
-
-#if defined __SUNPRO_CC
-#pragma enable_warn
-#elif defined _MSC_VER
-#pragma warning(pop)
-#endif
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/source/tools/makefile.mk b/canvas/source/tools/makefile.mk
index 9d9e5ba002bf..d51053d1d491 100644
--- a/canvas/source/tools/makefile.mk
+++ b/canvas/source/tools/makefile.mk
@@ -68,16 +68,6 @@ SHL1TARGET= $(TARGET)$(DLLPOSTFIX)
SHL1IMPLIB= i$(TARGET)
SHL1STDLIBS= $(SALLIB) $(CPPULIB) $(BASEGFXLIB) $(CPPUHELPERLIB) $(COMPHELPERLIB) $(VCLLIB) $(TKLIB) $(TOOLSLIB)
-.IF "$(ENABLE_AGG)"=="YES"
- SLOFILES += $(SLO)$/bitmap.obj \
- $(SLO)$/image.obj
-
- .IF "$(AGG_VERSION)"!=""
- CDEFS += -DAGG_VERSION=$(AGG_VERSION)
- .ENDIF
- SHL1STDLIBS += $(AGGLIB)
-.ENDIF
-
SHL1LIBS= $(SLB)$/$(TARGET).lib
SHL1DEF= $(MISC)$/$(SHL1TARGET).def
generated by cgit (git 2.34.1) at 2025-01-10 13:18:58 +0000