| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_cppcanvas.hxx" | |
| #include <rtl/logfile.hxx> | |
| #include <com/sun/star/rendering/XCanvas.hpp> | |
| #include <com/sun/star/rendering/TexturingMode.hpp> | |
| #include <tools/gen.hxx> | |
| #include <vcl/canvastools.hxx> | |
| #include <basegfx/range/b2drectangle.hxx> | |
| #include <basegfx/tools/canvastools.hxx> | |
| #include <basegfx/polygon/b2dpolypolygon.hxx> | |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> | |
| #include <basegfx/matrix/b2dhommatrix.hxx> | |
| #include <canvas/canvastools.hxx> | |
| #include <boost/utility.hpp> | |
| #include "cachedprimitivebase.hxx" | |
| #include "polypolyaction.hxx" | |
| #include "outdevstate.hxx" | |
| #include "mtftools.hxx" | |
| using namespace ::com::sun::star; | |
| namespace cppcanvas | |
| { | |
| namespace internal | |
| { | |
| namespace | |
| { | |
| class PolyPolyAction : public CachedPrimitiveBase | |
| { | |
| public: | |
| PolyPolyAction( const ::basegfx::B2DPolyPolygon&, | |
| const CanvasSharedPtr&, | |
| const OutDevState&, | |
| bool bFill, | |
| bool bStroke ); | |
| PolyPolyAction( const ::basegfx::B2DPolyPolygon&, | |
| const CanvasSharedPtr&, | |
| const OutDevState&, | |
| bool bFill, | |
| bool bStroke, | |
| int nTransparency ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual sal_Int32 getActionCount() const; | |
| private: | |
| using Action::render; | |
| virtual bool render( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive, | |
| const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| const uno::Reference< rendering::XPolyPolygon2D > mxPolyPoly; | |
| const ::basegfx::B2DRange maBounds; | |
| const CanvasSharedPtr mpCanvas; | |
| // stroke color is now implicit: the maState.DeviceColor member | |
| rendering::RenderState maState; | |
| uno::Sequence< double > maFillColor; | |
| }; | |
| PolyPolyAction::PolyPolyAction( const ::basegfx::B2DPolyPolygon& rPolyPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| bool bFill, | |
| bool bStroke ) : | |
| CachedPrimitiveBase( rCanvas, false ), | |
| mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ), | |
| maBounds( ::basegfx::tools::getRange(rPolyPoly) ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maFillColor() | |
| { | |
| tools::initRenderState(maState,rState); | |
| if( bFill ) | |
| maFillColor = rState.fillColor; | |
| if( bStroke ) | |
| maState.DeviceColor = rState.lineColor; | |
| } | |
| PolyPolyAction::PolyPolyAction( const ::basegfx::B2DPolyPolygon& rPolyPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| bool bFill, | |
| bool bStroke, | |
| int nTransparency ) : | |
| CachedPrimitiveBase( rCanvas, false ), | |
| mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ), | |
| maBounds( ::basegfx::tools::getRange(rPolyPoly) ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maFillColor() | |
| { | |
| tools::initRenderState(maState,rState); | |
| if( bFill ) | |
| { | |
| maFillColor = rState.fillColor; | |
| if( maFillColor.getLength() < 4 ) | |
| maFillColor.realloc( 4 ); | |
| // TODO(F1): Color management | |
| // adapt fill color transparency | |
| maFillColor[3] = 1.0 - nTransparency / 100.0; | |
| } | |
| if( bStroke ) | |
| { | |
| maState.DeviceColor = rState.lineColor; | |
| if( maState.DeviceColor.getLength() < 4 ) | |
| maState.DeviceColor.realloc( 4 ); | |
| // TODO(F1): Color management | |
| // adapt fill color transparency | |
| maState.DeviceColor[3] = 1.0 - nTransparency / 100.0; | |
| } | |
| } | |
| bool PolyPolyAction::render( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive, | |
| const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::PolyPolyAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::PolyPolyAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| #ifdef SPECIAL_DEBUG | |
| aLocalState.Clip.clear(); | |
| aLocalState.DeviceColor = | |
| ::vcl::unotools::colorToDoubleSequence( mpCanvas->getUNOCanvas()->getDevice(), | |
| ::Color( 0x80FF0000 ) ); | |
| if( maState.Clip.is() ) | |
| mpCanvas->getUNOCanvas()->fillPolyPolygon( maState.Clip, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| aLocalState.DeviceColor = maState.DeviceColor; | |
| #endif | |
| if( maFillColor.getLength() ) | |
| { | |
| // TODO(E3): Use DBO's finalizer here, | |
| // fillPolyPolygon() might throw | |
| const uno::Sequence< double > aTmpColor( aLocalState.DeviceColor ); | |
| aLocalState.DeviceColor = maFillColor; | |
| rCachedPrimitive = mpCanvas->getUNOCanvas()->fillPolyPolygon( mxPolyPoly, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| aLocalState.DeviceColor = aTmpColor; | |
| } | |
| if( aLocalState.DeviceColor.getLength() ) | |
| { | |
| rCachedPrimitive = mpCanvas->getUNOCanvas()->drawPolyPolygon( mxPolyPoly, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| return true; | |
| } | |
| bool PolyPolyAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| // polygon only contains a single action, fail if subset | |
| // requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return false; | |
| return CachedPrimitiveBase::render( rTransformation ); | |
| } | |
| ::basegfx::B2DRange PolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return tools::calcDevicePixelBounds( | |
| maBounds, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| ::basegfx::B2DRange PolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| // polygon only contains a single action, empty bounds | |
| // if subset requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return ::basegfx::B2DRange(); | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 PolyPolyAction::getActionCount() const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| return 1; | |
| } | |
| // ------------------------------------------------------------------------------- | |
| class TexturedPolyPolyAction : public CachedPrimitiveBase | |
| { | |
| public: | |
| TexturedPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const rendering::Texture& rTexture ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual sal_Int32 getActionCount() const; | |
| private: | |
| using Action::render; | |
| virtual bool render( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive, | |
| const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| const uno::Reference< rendering::XPolyPolygon2D > mxPolyPoly; | |
| const ::basegfx::B2DRectangle maBounds; | |
| const CanvasSharedPtr mpCanvas; | |
| // stroke color is now implicit: the maState.DeviceColor member | |
| rendering::RenderState maState; | |
| const rendering::Texture maTexture; | |
| }; | |
| TexturedPolyPolyAction::TexturedPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPolyPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const rendering::Texture& rTexture ) : | |
| CachedPrimitiveBase( rCanvas, true ), | |
| mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ), | |
| maBounds( ::basegfx::tools::getRange(rPolyPoly) ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTexture( rTexture ) | |
| { | |
| tools::initRenderState(maState,rState); | |
| } | |
| bool TexturedPolyPolyAction::render( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive, | |
| const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::PolyPolyAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::PolyPolyAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| uno::Sequence< rendering::Texture > aSeq(1); | |
| aSeq[0] = maTexture; | |
| rCachedPrimitive = mpCanvas->getUNOCanvas()->fillTexturedPolyPolygon( mxPolyPoly, | |
| mpCanvas->getViewState(), | |
| aLocalState, | |
| aSeq ); | |
| return true; | |
| } | |
| bool TexturedPolyPolyAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| // polygon only contains a single action, fail if subset | |
| // requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return false; | |
| return CachedPrimitiveBase::render( rTransformation ); | |
| } | |
| ::basegfx::B2DRange TexturedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return tools::calcDevicePixelBounds( | |
| maBounds, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| ::basegfx::B2DRange TexturedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| // polygon only contains a single action, empty bounds | |
| // if subset requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return ::basegfx::B2DRange(); | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 TexturedPolyPolyAction::getActionCount() const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| return 1; | |
| } | |
| // ------------------------------------------------------------------------------- | |
| class StrokedPolyPolyAction : public CachedPrimitiveBase | |
| { | |
| public: | |
| StrokedPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const rendering::StrokeAttributes& rStrokeAttributes ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual sal_Int32 getActionCount() const; | |
| private: | |
| using Action::render; | |
| virtual bool render( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive, | |
| const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| const uno::Reference< rendering::XPolyPolygon2D > mxPolyPoly; | |
| const ::basegfx::B2DRectangle maBounds; | |
| const CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| const rendering::StrokeAttributes maStrokeAttributes; | |
| }; | |
| StrokedPolyPolyAction::StrokedPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPolyPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const rendering::StrokeAttributes& rStrokeAttributes ) : | |
| CachedPrimitiveBase( rCanvas, false ), | |
| mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ), | |
| maBounds( ::basegfx::tools::getRange(rPolyPoly) ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maStrokeAttributes( rStrokeAttributes ) | |
| { | |
| tools::initRenderState(maState,rState); | |
| maState.DeviceColor = rState.lineColor; | |
| } | |
| bool StrokedPolyPolyAction::render( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive, | |
| const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::PolyPolyAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::PolyPolyAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| rCachedPrimitive = mpCanvas->getUNOCanvas()->strokePolyPolygon( mxPolyPoly, | |
| mpCanvas->getViewState(), | |
| aLocalState, | |
| maStrokeAttributes ); | |
| return true; | |
| } | |
| bool StrokedPolyPolyAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| // polygon only contains a single action, fail if subset | |
| // requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return false; | |
| return CachedPrimitiveBase::render( rTransformation ); | |
| } | |
| ::basegfx::B2DRange StrokedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return tools::calcDevicePixelBounds( | |
| maBounds, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| ::basegfx::B2DRange StrokedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| // polygon only contains a single action, empty bounds | |
| // if subset requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return ::basegfx::B2DRange(); | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 StrokedPolyPolyAction::getActionCount() const | |
| { | |
| // TODO(F1): Split up poly-polygon into polygons, or even | |
| // line segments, when subsets are requested. | |
| return 1; | |
| } | |
| } | |
| ActionSharedPtr PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) | |
| { | |
| OSL_ENSURE( rState.isLineColorSet || rState.isFillColorSet, | |
| "PolyPolyActionFactory::createPolyPolyAction() with empty line and fill color" ); | |
| return ActionSharedPtr( new PolyPolyAction( rPoly, rCanvas, rState, | |
| rState.isFillColorSet, | |
| rState.isLineColorSet ) ); | |
| } | |
| ActionSharedPtr PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const rendering::Texture& rTexture ) | |
| { | |
| return ActionSharedPtr( new TexturedPolyPolyAction( rPoly, rCanvas, rState, rTexture ) ); | |
| } | |
| ActionSharedPtr PolyPolyActionFactory::createLinePolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) | |
| { | |
| OSL_ENSURE( rState.isLineColorSet, | |
| "PolyPolyActionFactory::createLinePolyPolyAction() called with empty line color" ); | |
| return ActionSharedPtr( new PolyPolyAction( rPoly, rCanvas, rState, | |
| false, | |
| rState.isLineColorSet ) ); | |
| } | |
| ActionSharedPtr PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const rendering::StrokeAttributes& rStrokeAttributes ) | |
| { | |
| OSL_ENSURE( rState.isLineColorSet, | |
| "PolyPolyActionFactory::createPolyPolyAction() for strokes called with empty line color" ); | |
| return ActionSharedPtr( new StrokedPolyPolyAction( rPoly, rCanvas, rState, rStrokeAttributes ) ); | |
| } | |
| ActionSharedPtr PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| int nTransparency ) | |
| { | |
| OSL_ENSURE( rState.isLineColorSet || rState.isFillColorSet, | |
| "PolyPolyActionFactory::createPolyPolyAction() with empty line and fill color" ); | |
| return ActionSharedPtr( new PolyPolyAction( rPoly, rCanvas, rState, | |
| rState.isFillColorSet, | |
| rState.isLineColorSet, | |
| nTransparency ) ); | |
| } | |
| } | |
| } |