summaryrefslogtreecommitdiff
path: root/canvas/source/directx/dx_canvashelper_texturefill.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'canvas/source/directx/dx_canvashelper_texturefill.cxx')
-rwxr-xr-xcanvas/source/directx/dx_canvashelper_texturefill.cxx627
1 files changed, 627 insertions, 0 deletions
diff --git a/canvas/source/directx/dx_canvashelper_texturefill.cxx b/canvas/source/directx/dx_canvashelper_texturefill.cxx
new file mode 100755
index 000000000000..60d62dad338a
--- /dev/null
+++ b/canvas/source/directx/dx_canvashelper_texturefill.cxx
@@ -0,0 +1,627 @@
+/*************************************************************************
+ *
+ * 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 <rtl/math.hxx>
+
+#include <com/sun/star/rendering/TexturingMode.hpp>
+
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/range/b2drectangle.hxx>
+#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/tools/tools.hxx>
+#include <basegfx/tools/lerp.hxx>
+#include <basegfx/tools/keystoplerp.hxx>
+#include <basegfx/tools/canvastools.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+
+#include <canvas/parametricpolypolygon.hxx>
+
+#include "dx_spritecanvas.hxx"
+#include "dx_canvashelper.hxx"
+#include "dx_impltools.hxx"
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/bind.hpp>
+#include <boost/tuple/tuple.hpp>
+
+
+using namespace ::com::sun::star;
+
+namespace dxcanvas
+{
+ namespace
+ {
+ typedef ::boost::shared_ptr< Gdiplus::PathGradientBrush > PathGradientBrushSharedPtr;
+
+ bool fillLinearGradient( GraphicsSharedPtr& rGraphics,
+ const ::canvas::ParametricPolyPolygon::Values& /*rValues*/,
+ const std::vector< Gdiplus::Color >& rColors,
+ const std::vector< Gdiplus::REAL >& rStops,
+ const GraphicsPathSharedPtr& rFillPath,
+ const rendering::Texture& texture )
+ {
+ // setup a linear gradient with given colors
+ // -----------------------------------------
+
+ Gdiplus::LinearGradientBrush aBrush(
+ Gdiplus::PointF(0.0f,
+ 0.5f),
+ Gdiplus::PointF(1.0f,
+ 0.5f),
+ rColors[0],
+ rColors[1] );
+
+ aBrush.SetInterpolationColors(&rColors[0],
+ &rStops[0],
+ rColors.size());
+
+ // render background color, as LinearGradientBrush does not
+ // properly support the WrapModeClamp repeat mode
+ Gdiplus::SolidBrush aBackgroundBrush( rColors[0] );
+ rGraphics->FillPath( &aBackgroundBrush, rFillPath.get() );
+
+ // TODO(F2): This does not yet support other repeat modes
+ // except clamp, and probably also no multi-texturing
+
+ // calculate parallelogram of gradient in object space, extend
+ // top and bottom of it such that they cover the whole fill
+ // path bound area
+ ::basegfx::B2DHomMatrix aTextureTransform;
+ ::basegfx::unotools::homMatrixFromAffineMatrix( aTextureTransform,
+ texture.AffineTransform );
+
+ ::basegfx::B2DPoint aLeftTop( 0.0, 0.0 );
+ ::basegfx::B2DPoint aLeftBottom( 0.0, 1.0 );
+ ::basegfx::B2DPoint aRightTop( 1.0, 0.0 );
+ ::basegfx::B2DPoint aRightBottom( 1.0, 1.0 );
+
+ aLeftTop *= aTextureTransform;
+ aLeftBottom *= aTextureTransform;
+ aRightTop *= aTextureTransform;
+ aRightBottom*= aTextureTransform;
+
+ Gdiplus::RectF aBounds;
+ rFillPath->GetBounds( &aBounds, NULL, NULL );
+
+ // now, we potentially have to enlarge our gradient area
+ // atop and below the transformed [0,1]x[0,1] unit rect,
+ // for the gradient to fill the complete bound rect.
+ ::basegfx::tools::infiniteLineFromParallelogram( aLeftTop,
+ aLeftBottom,
+ aRightTop,
+ aRightBottom,
+ tools::b2dRangeFromGdiPlusRectF( aBounds ) );
+
+ // calc length of bound rect diagonal
+ const double nDiagonalLength(
+ hypot( aBounds.Width,
+ aBounds.Height ) );
+
+ // generate a path which covers the 'right' side of the
+ // gradient, extending two times the bound rect diagonal to
+ // the right (and thus covering the whole half plane 'right'
+ // of the gradient). Take the middle of the gradient as the
+ // 'left' side of the polygon, to not fall victim to rounding
+ // errors at the edge.
+ ::basegfx::B2DVector aDirection( aLeftTop - aLeftBottom );
+ aDirection = ::basegfx::getNormalizedPerpendicular( aDirection );
+ aDirection *= nDiagonalLength;
+
+ const ::basegfx::B2DPoint aHalfPlaneLeftTop( (aLeftTop + aRightTop) * 0.5 );
+ const ::basegfx::B2DPoint aHalfPlaneLeftBottom( (aLeftBottom + aRightBottom) * 0.5 );
+ const ::basegfx::B2DPoint aHalfPlaneRightTop( aRightTop + aDirection );
+ const ::basegfx::B2DPoint aHalfPlaneRightBottom( aRightBottom + aDirection );
+
+ Gdiplus::GraphicsPath aSolidFillPath;
+ aSolidFillPath.AddLine( static_cast<Gdiplus::REAL>(aHalfPlaneLeftTop.getX()),
+ static_cast<Gdiplus::REAL>(aHalfPlaneLeftTop.getY()),
+ static_cast<Gdiplus::REAL>(aHalfPlaneRightTop.getX()),
+ static_cast<Gdiplus::REAL>(aHalfPlaneRightTop.getY()) );
+ aSolidFillPath.AddLine( static_cast<Gdiplus::REAL>(aHalfPlaneRightBottom.getX()),
+ static_cast<Gdiplus::REAL>(aHalfPlaneRightBottom.getY()),
+ static_cast<Gdiplus::REAL>(aHalfPlaneLeftBottom.getX()),
+ static_cast<Gdiplus::REAL>(aHalfPlaneLeftBottom.getY()) );
+ aSolidFillPath.CloseFigure();
+
+ // limit output to fill path, we've just generated a path that
+ // might be substantially larger
+ if( Gdiplus::Ok != rGraphics->SetClip( rFillPath.get(),
+ Gdiplus::CombineModeIntersect ) )
+ {
+ return false;
+ }
+
+ Gdiplus::SolidBrush aBackgroundBrush2( rColors.back() );
+ rGraphics->FillPath( &aBackgroundBrush2, &aSolidFillPath );
+
+ // generate clip polygon from the extended parallelogram
+ // (exploit the feature that distinct lines in a figure are
+ // automatically closed by a straight line)
+ Gdiplus::GraphicsPath aClipPath;
+ aClipPath.AddLine( static_cast<Gdiplus::REAL>(aLeftTop.getX()),
+ static_cast<Gdiplus::REAL>(aLeftTop.getY()),
+ static_cast<Gdiplus::REAL>(aRightTop.getX()),
+ static_cast<Gdiplus::REAL>(aRightTop.getY()) );
+ aClipPath.AddLine( static_cast<Gdiplus::REAL>(aRightBottom.getX()),
+ static_cast<Gdiplus::REAL>(aRightBottom.getY()),
+ static_cast<Gdiplus::REAL>(aLeftBottom.getX()),
+ static_cast<Gdiplus::REAL>(aLeftBottom.getY()) );
+ aClipPath.CloseFigure();
+
+ // limit output to a _single_ strip of the gradient (have to
+ // clip here, since GDI+ wrapmode clamp does not work here)
+ if( Gdiplus::Ok != rGraphics->SetClip( &aClipPath,
+ Gdiplus::CombineModeIntersect ) )
+ {
+ return false;
+ }
+
+ // now, finally, output the gradient
+ Gdiplus::Matrix aMatrix;
+ tools::gdiPlusMatrixFromAffineMatrix2D( aMatrix,
+ texture.AffineTransform );
+ aBrush.SetTransform( &aMatrix );
+
+ rGraphics->FillRectangle( &aBrush, aBounds );
+
+ return true;
+ }
+
+ int numColorSteps( const Gdiplus::Color& rColor1, const Gdiplus::Color& rColor2 )
+ {
+ return ::std::max(
+ labs( rColor1.GetRed() - rColor2.GetRed() ),
+ ::std::max(
+ labs( rColor1.GetGreen() - rColor2.GetGreen() ),
+ labs( rColor1.GetBlue() - rColor2.GetBlue() ) ) );
+ }
+
+ bool fillPolygonalGradient( const ::canvas::ParametricPolyPolygon::Values& rValues,
+ const std::vector< Gdiplus::Color >& rColors,
+ const std::vector< Gdiplus::REAL >& rStops,
+ GraphicsSharedPtr& rGraphics,
+ const GraphicsPathSharedPtr& rPath,
+ const rendering::ViewState& viewState,
+ const rendering::RenderState& renderState,
+ const rendering::Texture& texture )
+ {
+ // copy original fill path object, might have to change it
+ // below
+ GraphicsPathSharedPtr pFillPath( rPath );
+ const ::basegfx::B2DPolygon& rGradientPoly( rValues.maGradientPoly );
+
+ PathGradientBrushSharedPtr pGradientBrush;
+
+ // fill background uniformly with end color
+ Gdiplus::SolidBrush aBackgroundBrush( rColors[0] );
+ rGraphics->FillPath( &aBackgroundBrush, pFillPath.get() );
+
+ // scale focus according to aspect ratio: for wider-than-tall
+ // bounds (nAspectRatio > 1.0), the focus must have non-zero
+ // width. Specifically, a bound rect twice as wide as tall has
+ // a focus of half it's width.
+ if( !::rtl::math::approxEqual(rValues.mnAspectRatio,
+ 1.0) )
+ {
+ // KLUDGE 1:
+ //
+ // And here comes the greatest shortcoming of the GDI+
+ // gradients ever: SetFocusScales completely ignores
+ // transformations, both when set at the PathGradientBrush
+ // and for the world coordinate system. Thus, to correctly
+ // display anisotrophic path gradients, we have to render
+ // them by hand. WTF.
+
+ // TODO(F2): This does not yet support other repeat modes
+ // except clamp, and probably also no multi-texturing
+
+ // limit output to to-be-filled polygon
+ if( Gdiplus::Ok != rGraphics->SetClip( pFillPath.get(),
+ Gdiplus::CombineModeIntersect ) )
+ {
+ return false;
+ }
+
+ // disable anti-aliasing, if any
+ const Gdiplus::SmoothingMode eOldAAMode( rGraphics->GetSmoothingMode() );
+ rGraphics->SetSmoothingMode( Gdiplus::SmoothingModeHighSpeed );
+
+
+ // determine number of steps to use
+ // --------------------------------
+
+ // TODO(Q2): Unify step calculations with VCL canvas
+ int nColorSteps = 0;
+ for( size_t i=0; i<rColors.size()-1; ++i )
+ nColorSteps += numColorSteps(rColors[i],rColors[i+1]);
+ ::basegfx::B2DHomMatrix aTotalTransform;
+ const int nStepCount=
+ ::canvas::tools::calcGradientStepCount(aTotalTransform,
+ viewState,
+ renderState,
+ texture,
+ nColorSteps);
+
+ ::basegfx::B2DHomMatrix aTextureTransform;
+ ::basegfx::unotools::homMatrixFromAffineMatrix( aTextureTransform,
+ texture.AffineTransform );
+ // determine overall transformation for inner polygon (might
+ // have to be prefixed by anisotrophic scaling)
+ ::basegfx::B2DHomMatrix aInnerPolygonTransformMatrix;
+
+ // For performance reasons, we create a temporary VCL polygon
+ // here, keep it all the way and only change the vertex values
+ // in the loop below (as ::Polygon is a pimpl class, creating
+ // one every loop turn would really stress the mem allocator)
+ ::basegfx::B2DPolygon aOuterPoly( rGradientPoly );
+ ::basegfx::B2DPolygon aInnerPoly;
+
+ // subdivide polygon _before_ rendering, would otherwise have
+ // to be performed on every loop turn.
+ if( aOuterPoly.areControlPointsUsed() )
+ aOuterPoly = ::basegfx::tools::adaptiveSubdivideByAngle(aOuterPoly);
+
+ aInnerPoly = aOuterPoly;
+ aOuterPoly.transform(aTextureTransform);
+
+
+ // apply scaling (possibly anisotrophic) to inner polygon
+ // ------------------------------------------------------
+
+ // scale inner polygon according to aspect ratio: for
+ // wider-than-tall bounds (nAspectRatio > 1.0), the inner
+ // polygon, representing the gradient focus, must have
+ // non-zero width. Specifically, a bound rect twice as wide as
+ // tall has a focus polygon of half it's width.
+ const double nAspectRatio( rValues.mnAspectRatio );
+ if( nAspectRatio > 1.0 )
+ {
+ // width > height case
+ aInnerPolygonTransformMatrix.scale( 1.0 - 1.0/nAspectRatio,
+ 0.0 );
+ }
+ else if( nAspectRatio < 1.0 )
+ {
+ // width < height case
+ aInnerPolygonTransformMatrix.scale( 0.0,
+ 1.0 - nAspectRatio );
+ }
+ else
+ {
+ // isotrophic case
+ aInnerPolygonTransformMatrix.scale( 0.0, 0.0 );
+ }
+
+ // and finally, add texture transform to it.
+ aInnerPolygonTransformMatrix *= aTextureTransform;
+
+ // apply final matrix to polygon
+ aInnerPoly.transform( aInnerPolygonTransformMatrix );
+
+ Gdiplus::GraphicsPath aCurrPath;
+ Gdiplus::SolidBrush aFillBrush( rColors[0] );
+ const sal_uInt32 nNumPoints( aOuterPoly.count() );
+ basegfx::tools::KeyStopLerp aLerper(rValues.maStops);
+ for( int i=1; i<nStepCount; ++i )
+ {
+ std::ptrdiff_t nIndex;
+ double fAlpha;
+ const double fT( i/double(nStepCount) );
+ boost::tuples::tie(nIndex,fAlpha)=aLerper.lerp(fT);
+
+ const Gdiplus::Color aFillColor(
+ static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetRed(),rColors[nIndex+1].GetRed(),fAlpha) ),
+ static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetGreen(),rColors[nIndex+1].GetGreen(),fAlpha) ),
+ static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetBlue(),rColors[nIndex+1].GetBlue(),fAlpha) ) );
+
+ aFillBrush.SetColor( aFillColor );
+ aCurrPath.Reset(); aCurrPath.StartFigure();
+ for( unsigned int p=1; p<nNumPoints; ++p )
+ {
+ const ::basegfx::B2DPoint& rOuterPoint1( aOuterPoly.getB2DPoint(p-1) );
+ const ::basegfx::B2DPoint& rInnerPoint1( aInnerPoly.getB2DPoint(p-1) );
+ const ::basegfx::B2DPoint& rOuterPoint2( aOuterPoly.getB2DPoint(p) );
+ const ::basegfx::B2DPoint& rInnerPoint2( aInnerPoly.getB2DPoint(p) );
+
+ aCurrPath.AddLine(
+ Gdiplus::REAL(fT*rInnerPoint1.getX() + (1-fT)*rOuterPoint1.getX()),
+ Gdiplus::REAL(fT*rInnerPoint1.getY() + (1-fT)*rOuterPoint1.getY()),
+ Gdiplus::REAL(fT*rInnerPoint2.getX() + (1-fT)*rOuterPoint2.getX()),
+ Gdiplus::REAL(fT*rInnerPoint2.getY() + (1-fT)*rOuterPoint2.getY()));
+ }
+ aCurrPath.CloseFigure();
+
+ rGraphics->FillPath( &aFillBrush, &aCurrPath );
+ }
+
+ // reset to old anti-alias mode
+ rGraphics->SetSmoothingMode( eOldAAMode );
+ }
+ else
+ {
+ // KLUDGE 2:
+ //
+ // We're generating a PathGradientBrush from scratch here,
+ // and put in a transformed GraphicsPath (transformed with
+ // the texture transform). This is because the
+ // straight-forward approach to store a Brush pointer at
+ // this class and set a texture transform via
+ // PathGradientBrush::SetTransform() is spoiled by MS: it
+ // seems that _either_ the texture transform, _or_ the
+ // transform at the Graphics can be set, but not both. If
+ // one sets both, only the translational components of the
+ // texture is respected.
+
+ Gdiplus::Matrix aMatrix;
+ tools::gdiPlusMatrixFromAffineMatrix2D( aMatrix,
+ texture.AffineTransform );
+ GraphicsPathSharedPtr pGradientPath(
+ tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ));
+ pGradientPath->Transform( &aMatrix );
+
+ pGradientBrush.reset(
+ new Gdiplus::PathGradientBrush( pGradientPath.get() ) );
+ pGradientBrush->SetInterpolationColors( &rColors[0],
+ &rStops[0],
+ rStops.size() );
+
+ // explicitely setup center point. Since the center of GDI+
+ // gradients are by default the _centroid_ of the path
+ // (i.e. the weighted sum of edge points), it will not
+ // necessarily coincide with our notion of center.
+ Gdiplus::PointF aCenterPoint(0, 0);
+ aMatrix.TransformPoints( &aCenterPoint );
+ pGradientBrush->SetCenterPoint( aCenterPoint );
+
+ const bool bTileX( texture.RepeatModeX != rendering::TexturingMode::CLAMP );
+ const bool bTileY( texture.RepeatModeY != rendering::TexturingMode::CLAMP );
+
+ if( bTileX && bTileY )
+ pGradientBrush->SetWrapMode( Gdiplus::WrapModeTile );
+ else
+ {
+ OSL_ENSURE( bTileY == bTileX,
+ "ParametricPolyPolygon::fillPolygonalGradient(): Cannot have repeat x and repeat y differ!" );
+
+ pGradientBrush->SetWrapMode( Gdiplus::WrapModeClamp );
+ }
+
+ // render actual gradient
+ rGraphics->FillPath( pGradientBrush.get(), pFillPath.get() );
+ }
+
+#if defined(VERBOSE) && defined(DBG_UTIL)
+ rGraphics->MultiplyTransform( &aMatrix );
+
+ Gdiplus::Pen aPen( Gdiplus::Color( 255, 255, 0, 0 ),
+ 0.0001f );
+
+ rGraphics->DrawRectangle( &aPen,
+ Gdiplus::RectF( 0.0f, 0.0f,
+ 1.0f, 1.0f ) );
+#endif
+
+ return true;
+ }
+
+ bool fillGradient( const ::canvas::ParametricPolyPolygon::Values& rValues,
+ const std::vector< Gdiplus::Color >& rColors,
+ const std::vector< Gdiplus::REAL >& rStops,
+ GraphicsSharedPtr& rGraphics,
+ const GraphicsPathSharedPtr& rPath,
+ const rendering::ViewState& viewState,
+ const rendering::RenderState& renderState,
+ const rendering::Texture& texture )
+ {
+ switch( rValues.meType )
+ {
+ case ::canvas::ParametricPolyPolygon::GRADIENT_LINEAR:
+ fillLinearGradient( rGraphics,
+ rValues,
+ rColors,
+ rStops,
+ rPath,
+ texture );
+ break;
+
+ case ::canvas::ParametricPolyPolygon::GRADIENT_ELLIPTICAL:
+ // FALLTHROUGH intended
+ case ::canvas::ParametricPolyPolygon::GRADIENT_RECTANGULAR:
+ fillPolygonalGradient( rValues,
+ rColors,
+ rStops,
+ rGraphics,
+ rPath,
+ viewState,
+ renderState,
+ texture );
+ break;
+
+ default:
+ ENSURE_OR_THROW( false,
+ "CanvasHelper::fillGradient(): Unexpected case" );
+ }
+
+ return true;
+ }
+
+ void fillBitmap( const uno::Reference< rendering::XBitmap >& xBitmap,
+ GraphicsSharedPtr& rGraphics,
+ const GraphicsPathSharedPtr& rPath,
+ const rendering::Texture& rTexture )
+ {
+ OSL_ENSURE( rTexture.RepeatModeX ==
+ rTexture.RepeatModeY,
+ "CanvasHelper::fillBitmap(): GDI+ cannot handle differing X/Y repeat mode." );
+
+ const bool bClamp( rTexture.RepeatModeX == rendering::TexturingMode::NONE &&
+ rTexture.RepeatModeY == rendering::TexturingMode::NONE );
+
+ const geometry::IntegerSize2D aBmpSize( xBitmap->getSize() );
+ ENSURE_ARG_OR_THROW( aBmpSize.Width != 0 &&
+ aBmpSize.Height != 0,
+ "CanvasHelper::fillBitmap(): zero-sized texture bitmap" );
+
+ // TODO(P3): Detect case that path is rectangle and
+ // bitmap is just scaled into that. Then, we can
+ // render directly, without generating a temporary
+ // GDI+ bitmap (this is significant, because drawing
+ // layer presents background object bitmap in that
+ // way!)
+ BitmapSharedPtr pBitmap(
+ tools::bitmapFromXBitmap( xBitmap ) );
+
+ TextureBrushSharedPtr pBrush;
+ if( ::rtl::math::approxEqual( rTexture.Alpha,
+ 1.0 ) )
+ {
+ pBrush.reset(
+ new Gdiplus::TextureBrush(
+ pBitmap.get(),
+ bClamp ? Gdiplus::WrapModeClamp : Gdiplus::WrapModeTile ) );
+ }
+ else
+ {
+ Gdiplus::ImageAttributes aImgAttr;
+
+ tools::setModulateImageAttributes( aImgAttr,
+ 1.0,
+ 1.0,
+ 1.0,
+ rTexture.Alpha );
+
+ Gdiplus::Rect aRect(0,0,
+ aBmpSize.Width,
+ aBmpSize.Height);
+ pBrush.reset(
+ new Gdiplus::TextureBrush(
+ pBitmap.get(),
+ aRect,
+ &aImgAttr ) );
+
+ pBrush->SetWrapMode(
+ bClamp ? Gdiplus::WrapModeClamp : Gdiplus::WrapModeTile );
+ }
+
+ Gdiplus::Matrix aTextureTransform;
+ tools::gdiPlusMatrixFromAffineMatrix2D( aTextureTransform,
+ rTexture.AffineTransform );
+
+ // scale down bitmap to [0,1]x[0,1] rect, as required
+ // from the XCanvas interface.
+ pBrush->MultiplyTransform( &aTextureTransform );
+ pBrush->ScaleTransform( static_cast< Gdiplus::REAL >(1.0/aBmpSize.Width),
+ static_cast< Gdiplus::REAL >(1.0/aBmpSize.Height) );
+
+ // TODO(F1): FillRule
+ ENSURE_OR_THROW(
+ Gdiplus::Ok == rGraphics->FillPath( pBrush.get(),
+ rPath.get() ),
+ "CanvasHelper::fillTexturedPolyPolygon(): GDI+ call failed" );
+ }
+ }
+
+ // -------------------------------------------------------------
+
+ uno::Reference< rendering::XCachedPrimitive > CanvasHelper::fillTexturedPolyPolygon( const rendering::XCanvas* /*pCanvas*/,
+ const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
+ const rendering::ViewState& viewState,
+ const rendering::RenderState& renderState,
+ const uno::Sequence< rendering::Texture >& textures )
+ {
+ ENSURE_OR_THROW( xPolyPolygon.is(),
+ "CanvasHelper::fillTexturedPolyPolygon: polygon is NULL");
+ ENSURE_OR_THROW( textures.getLength(),
+ "CanvasHelper::fillTexturedPolyPolygon: empty texture sequence");
+
+ if( needOutput() )
+ {
+ GraphicsSharedPtr pGraphics( mpGraphicsProvider->getGraphics() );
+
+ setupGraphicsState( pGraphics, viewState, renderState );
+
+ // TODO(F1): Multi-texturing
+ if( textures[0].Gradient.is() )
+ {
+ // try to cast XParametricPolyPolygon2D reference to
+ // our implementation class.
+ ::canvas::ParametricPolyPolygon* pGradient =
+ dynamic_cast< ::canvas::ParametricPolyPolygon* >( textures[0].Gradient.get() );
+
+ if( pGradient )
+ {
+ const ::canvas::ParametricPolyPolygon::Values& rValues(
+ pGradient->getValues() );
+
+ OSL_ASSERT(rValues.maColors.getLength() == rValues.maStops.getLength()
+ && rValues.maColors.getLength() > 1);
+
+ std::vector< Gdiplus::Color > aColors(rValues.maColors.getLength());
+ std::transform(&rValues.maColors[0],
+ &rValues.maColors[0]+rValues.maColors.getLength(),
+ aColors.begin(),
+ boost::bind(
+ (Gdiplus::ARGB (*)( const uno::Sequence< double >& ))(
+ &tools::sequenceToArgb),
+ _1));
+ std::vector< Gdiplus::REAL > aStops;
+ comphelper::sequenceToContainer(aStops,rValues.maStops);
+
+ // TODO(E1): Return value
+ // TODO(F1): FillRule
+ fillGradient( rValues,
+ aColors,
+ aStops,
+ pGraphics,
+ tools::graphicsPathFromXPolyPolygon2D( xPolyPolygon ),
+ viewState,
+ renderState,
+ textures[0] );
+ }
+ }
+ else if( textures[0].Bitmap.is() )
+ {
+ // TODO(E1): Return value
+ // TODO(F1): FillRule
+ fillBitmap( textures[0].Bitmap,
+ pGraphics,
+ tools::graphicsPathFromXPolyPolygon2D( xPolyPolygon ),
+ textures[0] );
+ }
+ }
+
+ // TODO(P1): Provide caching here.
+ return uno::Reference< rendering::XCachedPrimitive >(NULL);
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-25 09:08:54 +0000