| /************************************************************** | |
| * | |
| * 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 <canvas/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <canvas/verbosetrace.hxx> | |
| #include <rtl/logfile.hxx> | |
| #include <com/sun/star/rendering/PathCapType.hpp> | |
| #include <com/sun/star/rendering/PathJoinType.hpp> | |
| #include <com/sun/star/rendering/XCanvas.hpp> | |
| #include <com/sun/star/rendering/XCanvasFont.hpp> | |
| #include <basegfx/numeric/ftools.hxx> | |
| #include <basegfx/matrix/b2dhommatrix.hxx> | |
| #include <basegfx/range/b2drectangle.hxx> | |
| #include <basegfx/vector/b2dsize.hxx> | |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> | |
| #include <basegfx/polygon/b2dpolygontools.hxx> | |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> | |
| #include <tools/gen.hxx> | |
| #include <vcl/canvastools.hxx> | |
| #include <vcl/virdev.hxx> | |
| #include <basegfx/tools/canvastools.hxx> | |
| #include <canvas/canvastools.hxx> | |
| #include <boost/scoped_array.hpp> | |
| #include <boost/bind.hpp> | |
| #include <boost/utility.hpp> | |
| #include "textaction.hxx" | |
| #include "outdevstate.hxx" | |
| #include "mtftools.hxx" | |
| using namespace ::com::sun::star; | |
| namespace cppcanvas | |
| { | |
| namespace internal | |
| { | |
| namespace | |
| { | |
| void init( rendering::RenderState& o_rRenderState, | |
| const ::basegfx::B2DPoint& rStartPoint, | |
| const OutDevState& rState, | |
| const CanvasSharedPtr& rCanvas ) | |
| { | |
| tools::initRenderState(o_rRenderState,rState); | |
| // #i36950# Offset clip back to origin (as it's also moved | |
| // by rStartPoint) | |
| // #i53964# Also take VCL font rotation into account, | |
| // since this, opposed to the FontMatrix rotation | |
| // elsewhere, _does_ get incorporated into the render | |
| // state transform. | |
| tools::modifyClip( o_rRenderState, | |
| rState, | |
| rCanvas, | |
| rStartPoint, | |
| NULL, | |
| &rState.fontRotation ); | |
| basegfx::B2DHomMatrix aLocalTransformation(basegfx::tools::createRotateB2DHomMatrix(rState.fontRotation)); | |
| aLocalTransformation.translate( rStartPoint.getX(), | |
| rStartPoint.getY() ); | |
| ::canvas::tools::appendToRenderState( o_rRenderState, | |
| aLocalTransformation ); | |
| o_rRenderState.DeviceColor = rState.textColor; | |
| } | |
| void init( rendering::RenderState& o_rRenderState, | |
| const ::basegfx::B2DPoint& rStartPoint, | |
| const OutDevState& rState, | |
| const CanvasSharedPtr& rCanvas, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) | |
| { | |
| init( o_rRenderState, rStartPoint, rState, rCanvas ); | |
| // TODO(F2): Also inversely-transform clip with | |
| // rTextTransform (which is actually rather hard, as the | |
| // text transform is _prepended_ to the render state)! | |
| // prepend extra font transform to render state | |
| // (prepend it, because it's interpreted in the unit | |
| // rect coordinate space) | |
| ::canvas::tools::prependToRenderState( o_rRenderState, | |
| rTextTransform ); | |
| } | |
| void init( rendering::RenderState& o_rRenderState, | |
| uno::Reference< rendering::XCanvasFont >& o_rFont, | |
| const ::basegfx::B2DPoint& rStartPoint, | |
| const OutDevState& rState, | |
| const CanvasSharedPtr& rCanvas ) | |
| { | |
| // ensure that o_rFont is valid. It is possible that | |
| // text actions are generated without previously | |
| // setting a font. Then, just take a default font | |
| if( !o_rFont.is() ) | |
| { | |
| // Use completely default FontRequest | |
| const rendering::FontRequest aFontRequest; | |
| geometry::Matrix2D aFontMatrix; | |
| ::canvas::tools::setIdentityMatrix2D( aFontMatrix ); | |
| o_rFont = rCanvas->getUNOCanvas()->createFont( | |
| aFontRequest, | |
| uno::Sequence< beans::PropertyValue >(), | |
| aFontMatrix ); | |
| } | |
| init( o_rRenderState, | |
| rStartPoint, | |
| rState, | |
| rCanvas ); | |
| } | |
| void init( rendering::RenderState& o_rRenderState, | |
| uno::Reference< rendering::XCanvasFont >& o_rFont, | |
| const ::basegfx::B2DPoint& rStartPoint, | |
| const OutDevState& rState, | |
| const CanvasSharedPtr& rCanvas, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) | |
| { | |
| init( o_rRenderState, o_rFont, rStartPoint, rState, rCanvas ); | |
| // TODO(F2): Also inversely-transform clip with | |
| // rTextTransform (which is actually rather hard, as the | |
| // text transform is _prepended_ to the render state)! | |
| // prepend extra font transform to render state | |
| // (prepend it, because it's interpreted in the unit | |
| // rect coordinate space) | |
| ::canvas::tools::prependToRenderState( o_rRenderState, | |
| rTextTransform ); | |
| } | |
| ::basegfx::B2DPolyPolygon textLinesFromLogicalOffsets( const uno::Sequence< double >& rOffsets, | |
| const tools::TextLineInfo& rTextLineInfo ) | |
| { | |
| return tools::createTextLinesPolyPolygon( | |
| 0.0, | |
| // extract character cell furthest to the right | |
| *(::std::max_element( | |
| rOffsets.getConstArray(), | |
| rOffsets.getConstArray() + rOffsets.getLength() )), | |
| rTextLineInfo ); | |
| } | |
| uno::Sequence< double > setupDXArray( const sal_Int32* pCharWidths, | |
| sal_Int32 nLen, | |
| const OutDevState& rState ) | |
| { | |
| // convert character widths from logical units | |
| uno::Sequence< double > aCharWidthSeq( nLen ); | |
| double* pOutputWidths( aCharWidthSeq.getArray() ); | |
| // #143885# maintain (nearly) full precision of DX | |
| // array, by circumventing integer-based | |
| // OutDev-mapping | |
| const double nScale( rState.mapModeTransform.get(0,0) ); | |
| for( int i = 0; i < nLen; ++i ) | |
| { | |
| // TODO(F2): use correct scale direction | |
| *pOutputWidths++ = *pCharWidths++ * nScale; | |
| } | |
| return aCharWidthSeq; | |
| } | |
| uno::Sequence< double > setupDXArray( const ::String& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| VirtualDevice& rVDev, | |
| const OutDevState& rState ) | |
| { | |
| // no external DX array given, create one from given | |
| // string | |
| ::boost::scoped_array< sal_Int32 > pCharWidths( new sal_Int32[nLen] ); | |
| rVDev.GetTextArray( rText, pCharWidths.get(), | |
| static_cast<sal_uInt16>(nStartPos), | |
| static_cast<sal_uInt16>(nLen) ); | |
| return setupDXArray( pCharWidths.get(), nLen, rState ); | |
| } | |
| ::basegfx::B2DPoint adaptStartPoint( const ::basegfx::B2DPoint& rStartPoint, | |
| const OutDevState& rState, | |
| const uno::Sequence< double >& rOffsets ) | |
| { | |
| ::basegfx::B2DPoint aLocalPoint( rStartPoint ); | |
| if( rState.textAlignment ) | |
| { | |
| // text origin is right, not left. Modify start point | |
| // accordingly, because XCanvas::drawTextLayout() | |
| // always aligns left! | |
| const double nOffset( rOffsets[ rOffsets.getLength()-1 ] ); | |
| // correct start point for rotated text: rotate around | |
| // former start point | |
| aLocalPoint.setX( aLocalPoint.getX() + cos( rState.fontRotation )*nOffset ); | |
| aLocalPoint.setY( aLocalPoint.getY() + sin( rState.fontRotation )*nOffset ); | |
| } | |
| return aLocalPoint; | |
| } | |
| /** Perform common setup for array text actions | |
| This method creates the XTextLayout object and | |
| initializes it, e.g. with the logical advancements. | |
| */ | |
| void initArrayAction( rendering::RenderState& o_rRenderState, | |
| uno::Reference< rendering::XTextLayout >& o_rTextLayout, | |
| const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix* pTextTransform ) | |
| { | |
| ENSURE_OR_THROW( rOffsets.getLength(), | |
| "::cppcanvas::internal::initArrayAction(): zero-length DX array" ); | |
| const ::basegfx::B2DPoint aLocalStartPoint( | |
| adaptStartPoint( rStartPoint, rState, rOffsets ) ); | |
| uno::Reference< rendering::XCanvasFont > xFont( rState.xFont ); | |
| if( pTextTransform ) | |
| init( o_rRenderState, xFont, aLocalStartPoint, rState, rCanvas, *pTextTransform ); | |
| else | |
| init( o_rRenderState, xFont, aLocalStartPoint, rState, rCanvas ); | |
| o_rTextLayout = xFont->createTextLayout( | |
| rendering::StringContext( rText, nStartPos, nLen ), | |
| rState.textDirection, | |
| 0 ); | |
| ENSURE_OR_THROW( o_rTextLayout.is(), | |
| "::cppcanvas::internal::initArrayAction(): Invalid font" ); | |
| o_rTextLayout->applyLogicalAdvancements( rOffsets ); | |
| } | |
| double getLineWidth( ::VirtualDevice& rVDev, | |
| const OutDevState& rState, | |
| const rendering::StringContext& rStringContext ) | |
| { | |
| // TODO(F2): use correct scale direction | |
| const ::basegfx::B2DSize aSize( rVDev.GetTextWidth( rStringContext.Text, | |
| static_cast<sal_uInt16>(rStringContext.StartPosition), | |
| static_cast<sal_uInt16>(rStringContext.Length) ), | |
| 0 ); | |
| return (rState.mapModeTransform * aSize).getX(); | |
| } | |
| uno::Sequence< double > | |
| calcSubsetOffsets( rendering::RenderState& io_rRenderState, | |
| double& o_rMinPos, | |
| double& o_rMaxPos, | |
| const uno::Reference< rendering::XTextLayout >& rOrigTextLayout, | |
| const ::cppcanvas::internal::Action::Subset& rSubset ) | |
| { | |
| ENSURE_OR_THROW( rSubset.mnSubsetEnd > rSubset.mnSubsetBegin, | |
| "::cppcanvas::internal::calcSubsetOffsets(): invalid subset range range" ); | |
| uno::Sequence< double > aOrigOffsets( rOrigTextLayout->queryLogicalAdvancements() ); | |
| const double* pOffsets( aOrigOffsets.getConstArray() ); | |
| ENSURE_OR_THROW( aOrigOffsets.getLength() >= rSubset.mnSubsetEnd, | |
| "::cppcanvas::internal::calcSubsetOffsets(): invalid subset range range" ); | |
| // TODO(F3): It currently seems that for RTL text, the | |
| // DX offsets are nevertheless increasing in logical | |
| // text order (I'd expect they are decreasing, | |
| // mimicking the fact that the text is output | |
| // right-to-left). This breaks text effects for ALL | |
| // RTL languages. | |
| // determine leftmost position in given subset range - | |
| // as the DX array contains the output positions | |
| // starting with the second character (the first is | |
| // assumed to have output position 0), correct begin | |
| // iterator. | |
| const double nMinPos( rSubset.mnSubsetBegin <= 0 ? 0 : | |
| *(::std::min_element( pOffsets+rSubset.mnSubsetBegin-1, | |
| pOffsets+rSubset.mnSubsetEnd )) ); | |
| // determine rightmost position in given subset range | |
| // - as the DX array contains the output positions | |
| // starting with the second character (the first is | |
| // assumed to have output position 0), correct begin | |
| // iterator. | |
| const double nMaxPos( | |
| *(::std::max_element( pOffsets + (rSubset.mnSubsetBegin <= 0 ? | |
| 0 : rSubset.mnSubsetBegin-1), | |
| pOffsets + rSubset.mnSubsetEnd )) ); | |
| // adapt render state, to move text output to given offset | |
| // ------------------------------------------------------- | |
| // TODO(F1): Strictly speaking, we also have to adapt | |
| // the clip here, which normally should _not_ move | |
| // with the output offset. Neglected for now, as it | |
| // does not matter for drawing layer output | |
| if( rSubset.mnSubsetBegin > 0 ) | |
| { | |
| ::basegfx::B2DHomMatrix aTranslation; | |
| if( rOrigTextLayout->getFont()->getFontRequest().FontDescription.IsVertical ) | |
| { | |
| // vertical text -> offset in y direction | |
| aTranslation.translate( 0.0, nMinPos ); | |
| } | |
| else | |
| { | |
| // horizontal text -> offset in x direction | |
| aTranslation.translate( nMinPos, 0.0 ); | |
| } | |
| ::canvas::tools::appendToRenderState( io_rRenderState, | |
| aTranslation ); | |
| } | |
| // reduce DX array to given substring | |
| // ---------------------------------- | |
| const sal_Int32 nNewElements( rSubset.mnSubsetEnd - rSubset.mnSubsetBegin ); | |
| uno::Sequence< double > aAdaptedOffsets( nNewElements ); | |
| double* pAdaptedOffsets( aAdaptedOffsets.getArray() ); | |
| // move to new output position (subtract nMinPos, | |
| // which is the new '0' position), copy only the range | |
| // as given by rSubset. | |
| ::std::transform( pOffsets + rSubset.mnSubsetBegin, | |
| pOffsets + rSubset.mnSubsetEnd, | |
| pAdaptedOffsets, | |
| ::boost::bind( ::std::minus<double>(), | |
| _1, | |
| nMinPos ) ); | |
| o_rMinPos = nMinPos; | |
| o_rMaxPos = nMaxPos; | |
| return aAdaptedOffsets; | |
| } | |
| uno::Reference< rendering::XTextLayout > | |
| createSubsetLayout( const rendering::StringContext& rOrigContext, | |
| const ::cppcanvas::internal::Action::Subset& rSubset, | |
| const uno::Reference< rendering::XTextLayout >& rOrigTextLayout ) | |
| { | |
| // create temporary new text layout with subset string | |
| // --------------------------------------------------- | |
| const sal_Int32 nNewStartPos( rOrigContext.StartPosition + ::std::min( | |
| rSubset.mnSubsetBegin, rOrigContext.Length-1 ) ); | |
| const sal_Int32 nNewLength( ::std::max( | |
| ::std::min( | |
| rSubset.mnSubsetEnd - rSubset.mnSubsetBegin, | |
| rOrigContext.Length ), | |
| sal_Int32( 0 ) ) ); | |
| const rendering::StringContext aContext( rOrigContext.Text, | |
| nNewStartPos, | |
| nNewLength ); | |
| uno::Reference< rendering::XTextLayout > xTextLayout( | |
| rOrigTextLayout->getFont()->createTextLayout( aContext, | |
| rOrigTextLayout->getMainTextDirection(), | |
| 0 ), | |
| uno::UNO_QUERY_THROW ); | |
| return xTextLayout; | |
| } | |
| /** Setup subset text layout | |
| @param io_rTextLayout | |
| Must contain original (full set) text layout on input, | |
| will contain subsetted text layout (or empty | |
| reference, for empty subsets) on output. | |
| @param io_rRenderState | |
| Must contain original render state on input, will | |
| contain shifted render state concatenated with | |
| rTransformation on output. | |
| @param rTransformation | |
| Additional transformation, to be prepended to render | |
| state | |
| @param rSubset | |
| Subset to prepare | |
| */ | |
| void createSubsetLayout( uno::Reference< rendering::XTextLayout >& io_rTextLayout, | |
| rendering::RenderState& io_rRenderState, | |
| double& o_rMinPos, | |
| double& o_rMaxPos, | |
| const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Action::Subset& rSubset ) | |
| { | |
| ::canvas::tools::prependToRenderState(io_rRenderState, rTransformation); | |
| if( rSubset.mnSubsetBegin == rSubset.mnSubsetEnd ) | |
| { | |
| // empty range, empty layout | |
| io_rTextLayout.clear(); | |
| return; | |
| } | |
| ENSURE_OR_THROW( io_rTextLayout.is(), | |
| "createSubsetLayout(): Invalid input layout" ); | |
| const rendering::StringContext& rOrigContext( io_rTextLayout->getText() ); | |
| if( rSubset.mnSubsetBegin == 0 && | |
| rSubset.mnSubsetEnd == rOrigContext.Length ) | |
| { | |
| // full range, no need for subsetting | |
| return; | |
| } | |
| uno::Reference< rendering::XTextLayout > xTextLayout( | |
| createSubsetLayout( rOrigContext, rSubset, io_rTextLayout ) ); | |
| if( xTextLayout.is() ) | |
| { | |
| xTextLayout->applyLogicalAdvancements( | |
| calcSubsetOffsets( io_rRenderState, | |
| o_rMinPos, | |
| o_rMaxPos, | |
| io_rTextLayout, | |
| rSubset ) ); | |
| } | |
| io_rTextLayout = xTextLayout; | |
| } | |
| /** Interface for renderEffectText functor below. | |
| This is interface is used from the renderEffectText() | |
| method below, to call the client implementation. | |
| */ | |
| class TextRenderer | |
| { | |
| public: | |
| virtual ~TextRenderer() {} | |
| /// Render text with given RenderState | |
| virtual bool operator()( const rendering::RenderState& rRenderState ) const = 0; | |
| }; | |
| /** Render effect text. | |
| @param rRenderer | |
| Functor object, will be called to render the actual | |
| part of the text effect (the text itself and the means | |
| to render it are unknown to this method) | |
| */ | |
| bool renderEffectText( const TextRenderer& rRenderer, | |
| const rendering::RenderState& rRenderState, | |
| const rendering::ViewState& /*rViewState*/, | |
| const uno::Reference< rendering::XCanvas >& xCanvas, | |
| const ::Color& rShadowColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rReliefOffset ) | |
| { | |
| ::Color aEmptyColor( COL_AUTO ); | |
| uno::Reference<rendering::XColorSpace> xColorSpace( | |
| xCanvas->getDevice()->getDeviceColorSpace() ); | |
| // draw shadow text, if enabled | |
| if( rShadowColor != aEmptyColor ) | |
| { | |
| rendering::RenderState aShadowState( rRenderState ); | |
| ::basegfx::B2DHomMatrix aTranslate; | |
| aTranslate.translate( rShadowOffset.getX(), | |
| rShadowOffset.getY() ); | |
| ::canvas::tools::appendToRenderState(aShadowState, aTranslate); | |
| aShadowState.DeviceColor = | |
| ::vcl::unotools::colorToDoubleSequence( rShadowColor, | |
| xColorSpace ); | |
| rRenderer( aShadowState ); | |
| } | |
| // draw relief text, if enabled | |
| if( rReliefColor != aEmptyColor ) | |
| { | |
| rendering::RenderState aReliefState( rRenderState ); | |
| ::basegfx::B2DHomMatrix aTranslate; | |
| aTranslate.translate( rReliefOffset.getX(), | |
| rReliefOffset.getY() ); | |
| ::canvas::tools::appendToRenderState(aReliefState, aTranslate); | |
| aReliefState.DeviceColor = | |
| ::vcl::unotools::colorToDoubleSequence( rReliefColor, | |
| xColorSpace ); | |
| rRenderer( aReliefState ); | |
| } | |
| // draw normal text | |
| rRenderer( rRenderState ); | |
| return true; | |
| } | |
| ::basegfx::B2DRange calcEffectTextBounds( const ::basegfx::B2DRange& rTextBounds, | |
| const ::basegfx::B2DRange& rLineBounds, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const rendering::RenderState& rRenderState, | |
| const rendering::ViewState& rViewState ) | |
| { | |
| ::basegfx::B2DRange aBounds( rTextBounds ); | |
| // add extends of text lines | |
| aBounds.expand( rLineBounds ); | |
| // TODO(Q3): Provide this functionality at the B2DRange | |
| ::basegfx::B2DRange aTotalBounds( aBounds ); | |
| aTotalBounds.expand( | |
| ::basegfx::B2DRange( aBounds.getMinX() + rReliefOffset.getX(), | |
| aBounds.getMinY() + rReliefOffset.getY(), | |
| aBounds.getMaxX() + rReliefOffset.getX(), | |
| aBounds.getMaxY() + rReliefOffset.getY() ) ); | |
| aTotalBounds.expand( | |
| ::basegfx::B2DRange( aBounds.getMinX() + rShadowOffset.getX(), | |
| aBounds.getMinY() + rShadowOffset.getY(), | |
| aBounds.getMaxX() + rShadowOffset.getX(), | |
| aBounds.getMaxY() + rShadowOffset.getY() ) ); | |
| return tools::calcDevicePixelBounds( aTotalBounds, | |
| rViewState, | |
| rRenderState ); | |
| } | |
| void initEffectLinePolyPolygon( ::basegfx::B2DSize& o_rOverallSize, | |
| uno::Reference< rendering::XPolyPolygon2D >& o_rTextLines, | |
| const CanvasSharedPtr& rCanvas, | |
| const uno::Sequence< double >& rOffsets, | |
| const tools::TextLineInfo rLineInfo ) | |
| { | |
| const ::basegfx::B2DPolyPolygon aPoly( | |
| textLinesFromLogicalOffsets( | |
| rOffsets, | |
| rLineInfo ) ); | |
| o_rOverallSize = ::basegfx::tools::getRange( aPoly ).getRange(); | |
| o_rTextLines = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| aPoly ); | |
| } | |
| void initEffectLinePolyPolygon( ::basegfx::B2DSize& o_rOverallSize, | |
| uno::Reference< rendering::XPolyPolygon2D >& o_rTextLines, | |
| const CanvasSharedPtr& rCanvas, | |
| double nLineWidth, | |
| const tools::TextLineInfo rLineInfo ) | |
| { | |
| const ::basegfx::B2DPolyPolygon aPoly( | |
| tools::createTextLinesPolyPolygon( 0.0, nLineWidth, | |
| rLineInfo ) ); | |
| o_rOverallSize = ::basegfx::tools::getRange( aPoly ).getRange(); | |
| o_rTextLines = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| aPoly ); | |
| } | |
| // ------------------------------------------------------------------------- | |
| class TextAction : public Action, private ::boost::noncopyable | |
| { | |
| public: | |
| TextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| TextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| 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: | |
| // TODO(P2): This is potentially a real mass object | |
| // (every character might be a separate TextAction), | |
| // thus, make it as lightweight as possible. For | |
| // example, share common RenderState among several | |
| // TextActions, maybe using maOffsets for the | |
| // translation. | |
| uno::Reference< rendering::XCanvasFont > mxFont; | |
| const rendering::StringContext maStringContext; | |
| const CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| const sal_Int8 maTextDirection; | |
| }; | |
| TextAction::TextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mxFont( rState.xFont ), | |
| maStringContext( rString, nStartPos, nLen ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTextDirection( rState.textDirection ) | |
| { | |
| init( maState, mxFont, | |
| rStartPoint, | |
| rState, rCanvas ); | |
| ENSURE_OR_THROW( mxFont.is(), | |
| "::cppcanvas::internal::TextAction(): Invalid font" ); | |
| } | |
| TextAction::TextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) : | |
| mxFont( rState.xFont ), | |
| maStringContext( rString, nStartPos, nLen ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTextDirection( rState.textDirection ) | |
| { | |
| init( maState, mxFont, | |
| rStartPoint, | |
| rState, rCanvas, rTextTransform ); | |
| ENSURE_OR_THROW( mxFont.is(), | |
| "::cppcanvas::internal::TextAction(): Invalid font" ); | |
| } | |
| bool TextAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::TextAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::TextAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| mpCanvas->getUNOCanvas()->drawText( maStringContext, mxFont, | |
| mpCanvas->getViewState(), aLocalState, maTextDirection ); | |
| return true; | |
| } | |
| bool TextAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& /*rSubset*/ ) const | |
| { | |
| OSL_ENSURE( false, | |
| "TextAction::render(): Subset not supported by this object" ); | |
| // TODO(P1): Retrieve necessary font metric info for | |
| // TextAction from XCanvas. Currently, the | |
| // TextActionFactory does not generate this object for | |
| // _subsettable_ text | |
| return render( rTransformation ); | |
| } | |
| ::basegfx::B2DRange TextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| // create XTextLayout, to have the | |
| // XTextLayout::queryTextBounds() method available | |
| uno::Reference< rendering::XTextLayout > xTextLayout( | |
| mxFont->createTextLayout( | |
| maStringContext, | |
| maTextDirection, | |
| 0 ) ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return tools::calcDevicePixelBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D( | |
| xTextLayout->queryTextBounds() ), | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| ::basegfx::B2DRange TextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& /*rSubset*/ ) const | |
| { | |
| OSL_ENSURE( false, | |
| "TextAction::getBounds(): Subset not supported by this object" ); | |
| // TODO(P1): Retrieve necessary font metric info for | |
| // TextAction from XCanvas. Currently, the | |
| // TextActionFactory does not generate this object for | |
| // _subsettable_ text | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 TextAction::getActionCount() const | |
| { | |
| // TODO(P1): Retrieve necessary font metric info for | |
| // TextAction from XCanvas. Currently, the | |
| // TextActionFactory does not generate this object for | |
| // _subsettable_ text | |
| return 1; | |
| } | |
| // ------------------------------------------------------------------------- | |
| class EffectTextAction : | |
| public Action, | |
| public TextRenderer, | |
| private ::boost::noncopyable | |
| { | |
| public: | |
| EffectTextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| EffectTextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| 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: | |
| /// Interface TextRenderer | |
| virtual bool operator()( const rendering::RenderState& rRenderState ) const; | |
| // TODO(P2): This is potentially a real mass object | |
| // (every character might be a separate TextAction), | |
| // thus, make it as lightweight as possible. For | |
| // example, share common RenderState among several | |
| // TextActions, maybe using maOffsets for the | |
| // translation. | |
| uno::Reference< rendering::XCanvasFont > mxFont; | |
| const rendering::StringContext maStringContext; | |
| const CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| const tools::TextLineInfo maTextLineInfo; | |
| ::basegfx::B2DSize maLinesOverallSize; | |
| const double mnLineWidth; | |
| uno::Reference< rendering::XPolyPolygon2D > mxTextLines; | |
| const ::basegfx::B2DSize maReliefOffset; | |
| const ::Color maReliefColor; | |
| const ::basegfx::B2DSize maShadowOffset; | |
| const ::Color maShadowColor; | |
| const sal_Int8 maTextDirection; | |
| }; | |
| EffectTextAction::EffectTextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mxFont( rState.xFont ), | |
| maStringContext( rText, nStartPos, nLen ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ), | |
| maLinesOverallSize(), | |
| mnLineWidth( getLineWidth( rVDev, rState, maStringContext ) ), | |
| mxTextLines(), | |
| maReliefOffset( rReliefOffset ), | |
| maReliefColor( rReliefColor ), | |
| maShadowOffset( rShadowOffset ), | |
| maShadowColor( rShadowColor ), | |
| maTextDirection( rState.textDirection ) | |
| { | |
| initEffectLinePolyPolygon( maLinesOverallSize, | |
| mxTextLines, | |
| rCanvas, | |
| mnLineWidth, | |
| maTextLineInfo ); | |
| init( maState, mxFont, | |
| rStartPoint, | |
| rState, rCanvas ); | |
| ENSURE_OR_THROW( mxFont.is() && mxTextLines.is(), | |
| "::cppcanvas::internal::EffectTextAction(): Invalid font or lines" ); | |
| } | |
| EffectTextAction::EffectTextAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) : | |
| mxFont( rState.xFont ), | |
| maStringContext( rText, nStartPos, nLen ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ), | |
| maLinesOverallSize(), | |
| mnLineWidth( getLineWidth( rVDev, rState, maStringContext ) ), | |
| mxTextLines(), | |
| maReliefOffset( rReliefOffset ), | |
| maReliefColor( rReliefColor ), | |
| maShadowOffset( rShadowOffset ), | |
| maShadowColor( rShadowColor ), | |
| maTextDirection( rState.textDirection ) | |
| { | |
| initEffectLinePolyPolygon( maLinesOverallSize, | |
| mxTextLines, | |
| rCanvas, | |
| mnLineWidth, | |
| maTextLineInfo ); | |
| init( maState, mxFont, | |
| rStartPoint, | |
| rState, rCanvas, rTextTransform ); | |
| ENSURE_OR_THROW( mxFont.is() && mxTextLines.is(), | |
| "::cppcanvas::internal::EffectTextAction(): Invalid font or lines" ); | |
| } | |
| bool EffectTextAction::operator()( const rendering::RenderState& rRenderState ) const | |
| { | |
| const rendering::ViewState& rViewState( mpCanvas->getViewState() ); | |
| const uno::Reference< rendering::XCanvas >& rCanvas( mpCanvas->getUNOCanvas() ); | |
| rCanvas->fillPolyPolygon( mxTextLines, | |
| rViewState, | |
| rRenderState ); | |
| rCanvas->drawText( maStringContext, mxFont, | |
| rViewState, | |
| rRenderState, | |
| maTextDirection ); | |
| return true; | |
| } | |
| bool EffectTextAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::EffectTextAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::EffectTextAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return renderEffectText( *this, | |
| aLocalState, | |
| mpCanvas->getViewState(), | |
| mpCanvas->getUNOCanvas(), | |
| maShadowColor, | |
| maShadowOffset, | |
| maReliefColor, | |
| maReliefOffset ); | |
| } | |
| bool EffectTextAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& /*rSubset*/ ) const | |
| { | |
| OSL_ENSURE( false, | |
| "EffectTextAction::render(): Subset not supported by this object" ); | |
| // TODO(P1): Retrieve necessary font metric info for | |
| // TextAction from XCanvas. Currently, the | |
| // TextActionFactory does not generate this object for | |
| // subsettable text | |
| return render( rTransformation ); | |
| } | |
| ::basegfx::B2DRange EffectTextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| // create XTextLayout, to have the | |
| // XTextLayout::queryTextBounds() method available | |
| uno::Reference< rendering::XTextLayout > xTextLayout( | |
| mxFont->createTextLayout( | |
| maStringContext, | |
| maTextDirection, | |
| 0 ) ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return calcEffectTextBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D( | |
| xTextLayout->queryTextBounds() ), | |
| ::basegfx::B2DRange( 0,0, | |
| maLinesOverallSize.getX(), | |
| maLinesOverallSize.getY() ), | |
| maReliefOffset, | |
| maShadowOffset, | |
| aLocalState, | |
| mpCanvas->getViewState() ); | |
| } | |
| ::basegfx::B2DRange EffectTextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& /*rSubset*/ ) const | |
| { | |
| OSL_ENSURE( false, | |
| "EffectTextAction::getBounds(): Subset not supported by this object" ); | |
| // TODO(P1): Retrieve necessary font metric info for | |
| // TextAction from XCanvas. Currently, the | |
| // TextActionFactory does not generate this object for | |
| // _subsettable_ text | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 EffectTextAction::getActionCount() const | |
| { | |
| // TODO(P1): Retrieve necessary font metric info for | |
| // TextAction from XCanvas. Currently, the | |
| // TextActionFactory does not generate this object for | |
| // subsettable text | |
| return 1; | |
| } | |
| // ------------------------------------------------------------------------- | |
| class TextArrayAction : public Action, private ::boost::noncopyable | |
| { | |
| public: | |
| TextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| TextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| 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: | |
| // TODO(P2): This is potentially a real mass object | |
| // (every character might be a separate TextAction), | |
| // thus, make it as lightweight as possible. For | |
| // example, share common RenderState among several | |
| // TextActions, maybe using maOffsets for the | |
| // translation. | |
| uno::Reference< rendering::XTextLayout > mxTextLayout; | |
| const CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| }; | |
| TextArrayAction::TextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mxTextLayout(), | |
| mpCanvas( rCanvas ), | |
| maState() | |
| { | |
| initArrayAction( maState, | |
| mxTextLayout, | |
| rStartPoint, | |
| rString, | |
| nStartPos, | |
| nLen, | |
| rOffsets, | |
| rCanvas, | |
| rState, NULL ); | |
| } | |
| TextArrayAction::TextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::rtl::OUString& rString, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) : | |
| mxTextLayout(), | |
| mpCanvas( rCanvas ), | |
| maState() | |
| { | |
| initArrayAction( maState, | |
| mxTextLayout, | |
| rStartPoint, | |
| rString, | |
| nStartPos, | |
| nLen, | |
| rOffsets, | |
| rCanvas, | |
| rState, | |
| &rTextTransform ); | |
| } | |
| bool TextArrayAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::TextArrayAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::TextArrayAction: 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()->drawPolyPolygon( maState.Clip, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| aLocalState.DeviceColor = maState.DeviceColor; | |
| #endif | |
| mpCanvas->getUNOCanvas()->drawTextLayout( mxTextLayout, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| return true; | |
| } | |
| bool TextArrayAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::TextArrayAction::render( subset )" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::TextArrayAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| uno::Reference< rendering::XTextLayout > xTextLayout( mxTextLayout ); | |
| double nDummy0, nDummy1; | |
| createSubsetLayout( xTextLayout, | |
| aLocalState, | |
| nDummy0, | |
| nDummy1, | |
| rTransformation, | |
| rSubset ); | |
| if( !xTextLayout.is() ) | |
| return true; // empty layout, render nothing | |
| mpCanvas->getUNOCanvas()->drawTextLayout( xTextLayout, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| return true; | |
| } | |
| ::basegfx::B2DRange TextArrayAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return tools::calcDevicePixelBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D( | |
| mxTextLayout->queryTextBounds() ), | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| ::basegfx::B2DRange TextArrayAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::TextArrayAction::getBounds( subset )" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::TextArrayAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| uno::Reference< rendering::XTextLayout > xTextLayout( mxTextLayout ); | |
| double nDummy0, nDummy1; | |
| createSubsetLayout( xTextLayout, | |
| aLocalState, | |
| nDummy0, | |
| nDummy1, | |
| rTransformation, | |
| rSubset ); | |
| if( !xTextLayout.is() ) | |
| return ::basegfx::B2DRange(); // empty layout, empty bounds | |
| return tools::calcDevicePixelBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D( | |
| xTextLayout->queryTextBounds() ), | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| sal_Int32 TextArrayAction::getActionCount() const | |
| { | |
| const rendering::StringContext& rOrigContext( mxTextLayout->getText() ); | |
| return rOrigContext.Length; | |
| } | |
| // ------------------------------------------------------------------------- | |
| class EffectTextArrayAction : | |
| public Action, | |
| public TextRenderer, | |
| private ::boost::noncopyable | |
| { | |
| public: | |
| EffectTextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| EffectTextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| 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: | |
| // TextRenderer interface | |
| virtual bool operator()( const rendering::RenderState& rRenderState ) const; | |
| // TODO(P2): This is potentially a real mass object | |
| // (every character might be a separate TextAction), | |
| // thus, make it as lightweight as possible. For | |
| // example, share common RenderState among several | |
| // TextActions, maybe using maOffsets for the | |
| // translation. | |
| uno::Reference< rendering::XTextLayout > mxTextLayout; | |
| const CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| const tools::TextLineInfo maTextLineInfo; | |
| ::basegfx::B2DSize maLinesOverallSize; | |
| uno::Reference< rendering::XPolyPolygon2D > mxTextLines; | |
| const ::basegfx::B2DSize maReliefOffset; | |
| const ::Color maReliefColor; | |
| const ::basegfx::B2DSize maShadowOffset; | |
| const ::Color maShadowColor; | |
| }; | |
| EffectTextArrayAction::EffectTextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mxTextLayout(), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ), | |
| maLinesOverallSize(), | |
| mxTextLines(), | |
| maReliefOffset( rReliefOffset ), | |
| maReliefColor( rReliefColor ), | |
| maShadowOffset( rShadowOffset ), | |
| maShadowColor( rShadowColor ) | |
| { | |
| initEffectLinePolyPolygon( maLinesOverallSize, | |
| mxTextLines, | |
| rCanvas, | |
| rOffsets, | |
| maTextLineInfo ); | |
| initArrayAction( maState, | |
| mxTextLayout, | |
| rStartPoint, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| rOffsets, | |
| rCanvas, | |
| rState, NULL ); | |
| } | |
| EffectTextArrayAction::EffectTextArrayAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::rtl::OUString& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) : | |
| mxTextLayout(), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ), | |
| maLinesOverallSize(), | |
| mxTextLines(), | |
| maReliefOffset( rReliefOffset ), | |
| maReliefColor( rReliefColor ), | |
| maShadowOffset( rShadowOffset ), | |
| maShadowColor( rShadowColor ) | |
| { | |
| initEffectLinePolyPolygon( maLinesOverallSize, | |
| mxTextLines, | |
| rCanvas, | |
| rOffsets, | |
| maTextLineInfo ); | |
| initArrayAction( maState, | |
| mxTextLayout, | |
| rStartPoint, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| rOffsets, | |
| rCanvas, | |
| rState, | |
| &rTextTransform ); | |
| } | |
| bool EffectTextArrayAction::operator()( const rendering::RenderState& rRenderState ) const | |
| { | |
| const rendering::ViewState& rViewState( mpCanvas->getViewState() ); | |
| const uno::Reference< rendering::XCanvas >& rCanvas( mpCanvas->getUNOCanvas() ); | |
| rCanvas->fillPolyPolygon( mxTextLines, | |
| rViewState, | |
| rRenderState ); | |
| rCanvas->drawTextLayout( mxTextLayout, | |
| rViewState, | |
| rRenderState ); | |
| return true; | |
| } | |
| bool EffectTextArrayAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::EffectTextArrayAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::EffectTextArrayAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return renderEffectText( *this, | |
| aLocalState, | |
| mpCanvas->getViewState(), | |
| mpCanvas->getUNOCanvas(), | |
| maShadowColor, | |
| maShadowOffset, | |
| maReliefColor, | |
| maReliefOffset ); | |
| } | |
| class EffectTextArrayRenderHelper : public TextRenderer | |
| { | |
| public: | |
| EffectTextArrayRenderHelper( const uno::Reference< rendering::XCanvas >& rCanvas, | |
| const uno::Reference< rendering::XTextLayout >& rTextLayout, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rLinePolygon, | |
| const rendering::ViewState& rViewState ) : | |
| mrCanvas( rCanvas ), | |
| mrTextLayout( rTextLayout ), | |
| mrLinePolygon( rLinePolygon ), | |
| mrViewState( rViewState ) | |
| { | |
| } | |
| // TextRenderer interface | |
| virtual bool operator()( const rendering::RenderState& rRenderState ) const | |
| { | |
| mrCanvas->fillPolyPolygon( mrLinePolygon, | |
| mrViewState, | |
| rRenderState ); | |
| mrCanvas->drawTextLayout( mrTextLayout, | |
| mrViewState, | |
| rRenderState ); | |
| return true; | |
| } | |
| private: | |
| const uno::Reference< rendering::XCanvas >& mrCanvas; | |
| const uno::Reference< rendering::XTextLayout >& mrTextLayout; | |
| const uno::Reference< rendering::XPolyPolygon2D >& mrLinePolygon; | |
| const rendering::ViewState& mrViewState; | |
| }; | |
| bool EffectTextArrayAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::EffectTextArrayAction::render( subset )" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::EffectTextArrayAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| uno::Reference< rendering::XTextLayout > xTextLayout( mxTextLayout ); | |
| const geometry::RealRectangle2D aTextBounds( mxTextLayout->queryTextBounds() ); | |
| double nMinPos(0.0); | |
| double nMaxPos(aTextBounds.X2 - aTextBounds.X1); | |
| createSubsetLayout( xTextLayout, | |
| aLocalState, | |
| nMinPos, | |
| nMaxPos, | |
| rTransformation, | |
| rSubset ); | |
| if( !xTextLayout.is() ) | |
| return true; // empty layout, render nothing | |
| // create and setup local line polygon | |
| // =================================== | |
| uno::Reference< rendering::XCanvas > xCanvas( mpCanvas->getUNOCanvas() ); | |
| const rendering::ViewState& rViewState( mpCanvas->getViewState() ); | |
| uno::Reference< rendering::XPolyPolygon2D > xTextLines( | |
| ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| xCanvas->getDevice(), | |
| tools::createTextLinesPolyPolygon( | |
| 0.0, nMaxPos - nMinPos, | |
| maTextLineInfo ) ) ); | |
| // render everything | |
| // ================= | |
| return renderEffectText( | |
| EffectTextArrayRenderHelper( xCanvas, | |
| xTextLayout, | |
| xTextLines, | |
| rViewState ), | |
| aLocalState, | |
| rViewState, | |
| xCanvas, | |
| maShadowColor, | |
| maShadowOffset, | |
| maReliefColor, | |
| maReliefOffset ); | |
| } | |
| ::basegfx::B2DRange EffectTextArrayAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return calcEffectTextBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D( | |
| mxTextLayout->queryTextBounds() ), | |
| ::basegfx::B2DRange( 0,0, | |
| maLinesOverallSize.getX(), | |
| maLinesOverallSize.getY() ), | |
| maReliefOffset, | |
| maShadowOffset, | |
| aLocalState, | |
| mpCanvas->getViewState() ); | |
| } | |
| ::basegfx::B2DRange EffectTextArrayAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::EffectTextArrayAction::getBounds( subset )" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::EffectTextArrayAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| uno::Reference< rendering::XTextLayout > xTextLayout( mxTextLayout ); | |
| const geometry::RealRectangle2D aTextBounds( mxTextLayout->queryTextBounds() ); | |
| double nMinPos(0.0); | |
| double nMaxPos(aTextBounds.X2 - aTextBounds.X1); | |
| createSubsetLayout( xTextLayout, | |
| aLocalState, | |
| nMinPos, | |
| nMaxPos, | |
| rTransformation, | |
| rSubset ); | |
| if( !xTextLayout.is() ) | |
| return ::basegfx::B2DRange(); // empty layout, empty bounds | |
| // create and setup local line polygon | |
| // =================================== | |
| const ::basegfx::B2DPolyPolygon aPoly( | |
| tools::createTextLinesPolyPolygon( | |
| 0.0, nMaxPos - nMinPos, | |
| maTextLineInfo ) ); | |
| return calcEffectTextBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D( | |
| xTextLayout->queryTextBounds() ), | |
| ::basegfx::tools::getRange( aPoly ), | |
| maReliefOffset, | |
| maShadowOffset, | |
| aLocalState, | |
| mpCanvas->getViewState() ); | |
| } | |
| sal_Int32 EffectTextArrayAction::getActionCount() const | |
| { | |
| const rendering::StringContext& rOrigContext( mxTextLayout->getText() ); | |
| return rOrigContext.Length; | |
| } | |
| // ------------------------------------------------------------------------- | |
| class OutlineAction : | |
| public Action, | |
| public TextRenderer, | |
| private ::boost::noncopyable | |
| { | |
| public: | |
| OutlineAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::basegfx::B2DRectangle& rOutlineBounds, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rTextPoly, | |
| const ::std::vector< sal_Int32 >& rPolygonGlyphMap, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| OutlineAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::basegfx::B2DRectangle& rOutlineBounds, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rTextPoly, | |
| const ::std::vector< sal_Int32 >& rPolygonGlyphMap, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| 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: | |
| // TextRenderer interface | |
| virtual bool operator()( const rendering::RenderState& rRenderState ) const; | |
| // TODO(P2): This is potentially a real mass object | |
| // (every character might be a separate TextAction), | |
| // thus, make it as lightweight as possible. For | |
| // example, share common RenderState among several | |
| // TextActions, maybe using maOffsets for the | |
| // translation. | |
| uno::Reference< rendering::XPolyPolygon2D > mxTextPoly; | |
| /** This vector denotes the index of the start polygon | |
| for the respective glyph sequence. | |
| To get a polygon index range for a given character | |
| index i, take [ maPolygonGlyphMap[i], | |
| maPolygonGlyphMap[i+1] ). Note that this is wrong | |
| for BiDi | |
| */ | |
| const ::std::vector< sal_Int32 > maPolygonGlyphMap; | |
| const uno::Sequence< double > maOffsets; | |
| const CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| double mnOutlineWidth; | |
| const uno::Sequence< double > maFillColor; | |
| const tools::TextLineInfo maTextLineInfo; | |
| ::basegfx::B2DSize maLinesOverallSize; | |
| const ::basegfx::B2DRectangle maOutlineBounds; | |
| uno::Reference< rendering::XPolyPolygon2D > mxTextLines; | |
| const ::basegfx::B2DSize maReliefOffset; | |
| const ::Color maReliefColor; | |
| const ::basegfx::B2DSize maShadowOffset; | |
| const ::Color maShadowColor; | |
| }; | |
| double calcOutlineWidth( const OutDevState& rState, | |
| VirtualDevice& rVDev ) | |
| { | |
| const ::basegfx::B2DSize aFontSize( 0, | |
| rVDev.GetFont().GetHeight() / 64.0 ); | |
| const double nOutlineWidth( | |
| (rState.mapModeTransform * aFontSize).getY() ); | |
| return nOutlineWidth < 1.0 ? 1.0 : nOutlineWidth; | |
| } | |
| OutlineAction::OutlineAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::basegfx::B2DRectangle& rOutlineBounds, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rTextPoly, | |
| const ::std::vector< sal_Int32 >& rPolygonGlyphMap, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mxTextPoly( rTextPoly ), | |
| maPolygonGlyphMap( rPolygonGlyphMap ), | |
| maOffsets( rOffsets ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| mnOutlineWidth( calcOutlineWidth(rState,rVDev) ), | |
| maFillColor( | |
| ::vcl::unotools::colorToDoubleSequence( | |
| ::Color( COL_WHITE ), | |
| rCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() )), | |
| maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ), | |
| maLinesOverallSize(), | |
| maOutlineBounds( rOutlineBounds ), | |
| mxTextLines(), | |
| maReliefOffset( rReliefOffset ), | |
| maReliefColor( rReliefColor ), | |
| maShadowOffset( rShadowOffset ), | |
| maShadowColor( rShadowColor ) | |
| { | |
| initEffectLinePolyPolygon( maLinesOverallSize, | |
| mxTextLines, | |
| rCanvas, | |
| rOffsets, | |
| maTextLineInfo ); | |
| init( maState, | |
| rStartPoint, | |
| rState, | |
| rCanvas ); | |
| } | |
| OutlineAction::OutlineAction( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const ::basegfx::B2DRectangle& rOutlineBounds, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rTextPoly, | |
| const ::std::vector< sal_Int32 >& rPolygonGlyphMap, | |
| const uno::Sequence< double >& rOffsets, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const ::basegfx::B2DHomMatrix& rTextTransform ) : | |
| mxTextPoly( rTextPoly ), | |
| maPolygonGlyphMap( rPolygonGlyphMap ), | |
| maOffsets( rOffsets ), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| mnOutlineWidth( calcOutlineWidth(rState,rVDev) ), | |
| maFillColor( | |
| ::vcl::unotools::colorToDoubleSequence( | |
| ::Color( COL_WHITE ), | |
| rCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() )), | |
| maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ), | |
| maLinesOverallSize(), | |
| maOutlineBounds( rOutlineBounds ), | |
| mxTextLines(), | |
| maReliefOffset( rReliefOffset ), | |
| maReliefColor( rReliefColor ), | |
| maShadowOffset( rShadowOffset ), | |
| maShadowColor( rShadowColor ) | |
| { | |
| initEffectLinePolyPolygon( maLinesOverallSize, | |
| mxTextLines, | |
| rCanvas, | |
| rOffsets, | |
| maTextLineInfo ); | |
| init( maState, | |
| rStartPoint, | |
| rState, | |
| rCanvas, | |
| rTextTransform ); | |
| } | |
| bool OutlineAction::operator()( const rendering::RenderState& rRenderState ) const | |
| { | |
| const rendering::ViewState& rViewState( mpCanvas->getViewState() ); | |
| const uno::Reference< rendering::XCanvas >& rCanvas( mpCanvas->getUNOCanvas() ); | |
| rendering::StrokeAttributes aStrokeAttributes; | |
| aStrokeAttributes.StrokeWidth = mnOutlineWidth; | |
| aStrokeAttributes.MiterLimit = 1.0; | |
| aStrokeAttributes.StartCapType = rendering::PathCapType::BUTT; | |
| aStrokeAttributes.EndCapType = rendering::PathCapType::BUTT; | |
| aStrokeAttributes.JoinType = rendering::PathJoinType::MITER; | |
| rendering::RenderState aLocalState( rRenderState ); | |
| aLocalState.DeviceColor = maFillColor; | |
| // TODO(P1): implement caching | |
| // background of text | |
| rCanvas->fillPolyPolygon( mxTextPoly, | |
| rViewState, | |
| aLocalState ); | |
| // border line of text | |
| rCanvas->strokePolyPolygon( mxTextPoly, | |
| rViewState, | |
| rRenderState, | |
| aStrokeAttributes ); | |
| // underlines/strikethrough - background | |
| rCanvas->fillPolyPolygon( mxTextLines, | |
| rViewState, | |
| aLocalState ); | |
| // underlines/strikethrough - border | |
| rCanvas->strokePolyPolygon( mxTextLines, | |
| rViewState, | |
| rRenderState, | |
| aStrokeAttributes ); | |
| return true; | |
| } | |
| bool OutlineAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::EffectTextArrayAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::EffectTextArrayAction: 0x%X", this ); | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return renderEffectText( *this, | |
| aLocalState, | |
| mpCanvas->getViewState(), | |
| mpCanvas->getUNOCanvas(), | |
| maShadowColor, | |
| maShadowOffset, | |
| maReliefColor, | |
| maReliefOffset ); | |
| } | |
| class OutlineTextArrayRenderHelper : public TextRenderer | |
| { | |
| public: | |
| OutlineTextArrayRenderHelper( const uno::Reference< rendering::XCanvas >& rCanvas, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rTextPolygon, | |
| const uno::Reference< rendering::XPolyPolygon2D >& rLinePolygon, | |
| const rendering::ViewState& rViewState, | |
| double nOutlineWidth ) : | |
| maFillColor( | |
| ::vcl::unotools::colorToDoubleSequence( | |
| ::Color( COL_WHITE ), | |
| rCanvas->getDevice()->getDeviceColorSpace() )), | |
| mnOutlineWidth( nOutlineWidth ), | |
| mrCanvas( rCanvas ), | |
| mrTextPolygon( rTextPolygon ), | |
| mrLinePolygon( rLinePolygon ), | |
| mrViewState( rViewState ) | |
| { | |
| } | |
| // TextRenderer interface | |
| virtual bool operator()( const rendering::RenderState& rRenderState ) const | |
| { | |
| rendering::StrokeAttributes aStrokeAttributes; | |
| aStrokeAttributes.StrokeWidth = mnOutlineWidth; | |
| aStrokeAttributes.MiterLimit = 1.0; | |
| aStrokeAttributes.StartCapType = rendering::PathCapType::BUTT; | |
| aStrokeAttributes.EndCapType = rendering::PathCapType::BUTT; | |
| aStrokeAttributes.JoinType = rendering::PathJoinType::MITER; | |
| rendering::RenderState aLocalState( rRenderState ); | |
| aLocalState.DeviceColor = maFillColor; | |
| // TODO(P1): implement caching | |
| // background of text | |
| mrCanvas->fillPolyPolygon( mrTextPolygon, | |
| mrViewState, | |
| aLocalState ); | |
| // border line of text | |
| mrCanvas->strokePolyPolygon( mrTextPolygon, | |
| mrViewState, | |
| rRenderState, | |
| aStrokeAttributes ); | |
| // underlines/strikethrough - background | |
| mrCanvas->fillPolyPolygon( mrLinePolygon, | |
| mrViewState, | |
| aLocalState ); | |
| // underlines/strikethrough - border | |
| mrCanvas->strokePolyPolygon( mrLinePolygon, | |
| mrViewState, | |
| rRenderState, | |
| aStrokeAttributes ); | |
| return true; | |
| } | |
| private: | |
| const uno::Sequence< double > maFillColor; | |
| double mnOutlineWidth; | |
| const uno::Reference< rendering::XCanvas >& mrCanvas; | |
| const uno::Reference< rendering::XPolyPolygon2D >& mrTextPolygon; | |
| const uno::Reference< rendering::XPolyPolygon2D >& mrLinePolygon; | |
| const rendering::ViewState& mrViewState; | |
| }; | |
| bool OutlineAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::OutlineAction::render( subset )" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::OutlineAction: 0x%X", this ); | |
| if( rSubset.mnSubsetBegin == rSubset.mnSubsetEnd ) | |
| return true; // empty range, render nothing | |
| #if 1 | |
| // TODO(F3): Subsetting NYI for outline text! | |
| return render( rTransformation ); | |
| #else | |
| const rendering::StringContext rOrigContext( mxTextLayout->getText() ); | |
| if( rSubset.mnSubsetBegin == 0 && | |
| rSubset.mnSubsetEnd == rOrigContext.Length ) | |
| { | |
| // full range, no need for subsetting | |
| return render( rTransformation ); | |
| } | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| // create and setup local Text polygon | |
| // =================================== | |
| uno::Reference< rendering::XPolyPolygon2D > xTextPolygon(); | |
| // TODO(P3): Provide an API method for that! | |
| if( !xTextLayout.is() ) | |
| return false; | |
| // render everything | |
| // ================= | |
| return renderEffectText( | |
| OutlineTextArrayRenderHelper( | |
| xCanvas, | |
| mnOutlineWidth, | |
| xTextLayout, | |
| xTextLines, | |
| rViewState ), | |
| aLocalState, | |
| rViewState, | |
| xCanvas, | |
| maShadowColor, | |
| maShadowOffset, | |
| maReliefColor, | |
| maReliefOffset ); | |
| #endif | |
| } | |
| ::basegfx::B2DRange OutlineAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return calcEffectTextBounds( maOutlineBounds, | |
| ::basegfx::B2DRange( 0,0, | |
| maLinesOverallSize.getX(), | |
| maLinesOverallSize.getY() ), | |
| maReliefOffset, | |
| maShadowOffset, | |
| aLocalState, | |
| mpCanvas->getViewState() ); | |
| } | |
| ::basegfx::B2DRange OutlineAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& /*rSubset*/ ) const | |
| { | |
| OSL_ENSURE( false, | |
| "OutlineAction::getBounds(): Subset not yet supported by this object" ); | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 OutlineAction::getActionCount() const | |
| { | |
| // TODO(F3): Subsetting NYI for outline text! | |
| return maOffsets.getLength(); | |
| } | |
| // ====================================================================== | |
| // | |
| // Action factory methods | |
| // | |
| // ====================================================================== | |
| /** Create an outline action | |
| This method extracts the polygonal outline from the | |
| text, and creates a properly setup OutlineAction from | |
| it. | |
| */ | |
| ActionSharedPtr createOutline( const ::basegfx::B2DPoint& rStartPoint, | |
| const ::basegfx::B2DSize& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::basegfx::B2DSize& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const String& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const sal_Int32* pDXArray, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const Renderer::Parameters& rParms ) | |
| { | |
| // operate on raw DX array here (in logical coordinate | |
| // system), to have a higher resolution | |
| // PolyPolygon. That polygon is then converted to | |
| // device coordinate system. | |
| // #i68512# Temporarily switch off font rotation | |
| // (which is already contained in the render state | |
| // transformation matrix - otherwise, glyph polygons | |
| // will be rotated twice) | |
| const ::Font aOrigFont( rVDev.GetFont() ); | |
| ::Font aUnrotatedFont( aOrigFont ); | |
| aUnrotatedFont.SetOrientation(0); | |
| rVDev.SetFont( aUnrotatedFont ); | |
| // TODO(F3): Don't understand parameter semantics of | |
| // GetTextOutlines() | |
| ::basegfx::B2DPolyPolygon aResultingPolyPolygon; | |
| PolyPolyVector aVCLPolyPolyVector; | |
| const bool bHaveOutlines( rVDev.GetTextOutlines( aVCLPolyPolyVector, rText, | |
| static_cast<sal_uInt16>(nStartPos), | |
| static_cast<sal_uInt16>(nStartPos), | |
| static_cast<sal_uInt16>(nLen), | |
| sal_True, 0, pDXArray ) ); | |
| rVDev.SetFont(aOrigFont); | |
| if( !bHaveOutlines ) | |
| return ActionSharedPtr(); | |
| ::std::vector< sal_Int32 > aPolygonGlyphMap; | |
| // first glyph starts at polygon index 0 | |
| aPolygonGlyphMap.push_back( 0 ); | |
| // remove offsetting from mapmode transformation | |
| // (outline polygons must stay at origin, only need to | |
| // be scaled) | |
| ::basegfx::B2DHomMatrix aMapModeTransform( | |
| rState.mapModeTransform ); | |
| aMapModeTransform.set(0,2, 0.0); | |
| aMapModeTransform.set(1,2, 0.0); | |
| PolyPolyVector::const_iterator aIter( aVCLPolyPolyVector.begin() ); | |
| const PolyPolyVector::const_iterator aEnd( aVCLPolyPolyVector.end() ); | |
| for( ; aIter!= aEnd; ++aIter ) | |
| { | |
| ::basegfx::B2DPolyPolygon aPolyPolygon; | |
| aPolyPolygon = aIter->getB2DPolyPolygon(); | |
| aPolyPolygon.transform( aMapModeTransform ); | |
| // append result to collecting polypoly | |
| for( sal_uInt32 i=0; i<aPolyPolygon.count(); ++i ) | |
| { | |
| // #i47795# Ensure closed polygons (since | |
| // FreeType returns the glyph outlines | |
| // open) | |
| const ::basegfx::B2DPolygon& rPoly( aPolyPolygon.getB2DPolygon( i ) ); | |
| const sal_uInt32 nCount( rPoly.count() ); | |
| if( nCount<3 || | |
| rPoly.isClosed() ) | |
| { | |
| // polygon either degenerate, or | |
| // already closed. | |
| aResultingPolyPolygon.append( rPoly ); | |
| } | |
| else | |
| { | |
| ::basegfx::B2DPolygon aPoly(rPoly); | |
| aPoly.setClosed(true); | |
| aResultingPolyPolygon.append( aPoly ); | |
| } | |
| } | |
| // TODO(F3): Depending on the semantics of | |
| // GetTextOutlines(), this here is wrong! | |
| // calc next glyph index | |
| aPolygonGlyphMap.push_back( aResultingPolyPolygon.count() ); | |
| } | |
| const uno::Sequence< double > aCharWidthSeq( | |
| pDXArray ? | |
| setupDXArray( pDXArray, nLen, rState ) : | |
| setupDXArray( rText, | |
| nStartPos, | |
| nLen, | |
| rVDev, | |
| rState )); | |
| const uno::Reference< rendering::XPolyPolygon2D > xTextPoly( | |
| ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| aResultingPolyPolygon ) ); | |
| if( rParms.maTextTransformation.is_initialized() ) | |
| { | |
| return ActionSharedPtr( | |
| new OutlineAction( | |
| rStartPoint, | |
| rReliefOffset, | |
| rReliefColor, | |
| rShadowOffset, | |
| rShadowColor, | |
| ::basegfx::tools::getRange(aResultingPolyPolygon), | |
| xTextPoly, | |
| aPolygonGlyphMap, | |
| aCharWidthSeq, | |
| rVDev, | |
| rCanvas, | |
| rState, | |
| *rParms.maTextTransformation ) ); | |
| } | |
| else | |
| { | |
| return ActionSharedPtr( | |
| new OutlineAction( | |
| rStartPoint, | |
| rReliefOffset, | |
| rReliefColor, | |
| rShadowOffset, | |
| rShadowColor, | |
| ::basegfx::tools::getRange(aResultingPolyPolygon), | |
| xTextPoly, | |
| aPolygonGlyphMap, | |
| aCharWidthSeq, | |
| rVDev, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| } | |
| } // namespace | |
| // --------------------------------------------------------------------------------- | |
| ActionSharedPtr TextActionFactory::createTextAction( const ::Point& rStartPoint, | |
| const ::Size& rReliefOffset, | |
| const ::Color& rReliefColor, | |
| const ::Size& rShadowOffset, | |
| const ::Color& rShadowColor, | |
| const String& rText, | |
| sal_Int32 nStartPos, | |
| sal_Int32 nLen, | |
| const sal_Int32* pDXArray, | |
| VirtualDevice& rVDev, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState, | |
| const Renderer::Parameters& rParms, | |
| bool bSubsettable ) | |
| { | |
| const ::Size aBaselineOffset( tools::getBaselineOffset( rState, | |
| rVDev ) ); | |
| // #143885# maintain (nearly) full precision positioning, | |
| // by circumventing integer-based OutDev-mapping | |
| const ::basegfx::B2DPoint aStartPoint( | |
| rState.mapModeTransform * | |
| ::basegfx::B2DPoint(rStartPoint.X() + aBaselineOffset.Width(), | |
| rStartPoint.Y() + aBaselineOffset.Height()) ); | |
| const ::basegfx::B2DSize aReliefOffset( | |
| rState.mapModeTransform * ::vcl::unotools::b2DSizeFromSize( rReliefOffset ) ); | |
| const ::basegfx::B2DSize aShadowOffset( | |
| rState.mapModeTransform * ::vcl::unotools::b2DSizeFromSize( rShadowOffset ) ); | |
| if( rState.isTextOutlineModeSet ) | |
| { | |
| return createOutline( | |
| aStartPoint, | |
| aReliefOffset, | |
| rReliefColor, | |
| aShadowOffset, | |
| rShadowColor, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| pDXArray, | |
| rVDev, | |
| rCanvas, | |
| rState, | |
| rParms ); | |
| } | |
| // convert DX array to device coordinate system (and | |
| // create it in the first place, if pDXArray is NULL) | |
| const uno::Sequence< double > aCharWidths( | |
| pDXArray ? | |
| setupDXArray( pDXArray, nLen, rState ) : | |
| setupDXArray( rText, | |
| nStartPos, | |
| nLen, | |
| rVDev, | |
| rState )); | |
| // determine type of text action to create | |
| // ======================================= | |
| const ::Color aEmptyColor( COL_AUTO ); | |
| // no DX array, and no need to subset - no need to store | |
| // DX array, then. | |
| if( !pDXArray && !bSubsettable ) | |
| { | |
| // effects, or not? | |
| if( !rState.textOverlineStyle && | |
| !rState.textUnderlineStyle && | |
| !rState.textStrikeoutStyle && | |
| rReliefColor == aEmptyColor && | |
| rShadowColor == aEmptyColor ) | |
| { | |
| // nope | |
| if( rParms.maTextTransformation.is_initialized() ) | |
| { | |
| return ActionSharedPtr( new TextAction( | |
| aStartPoint, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| rCanvas, | |
| rState, | |
| *rParms.maTextTransformation ) ); | |
| } | |
| else | |
| { | |
| return ActionSharedPtr( new TextAction( | |
| aStartPoint, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| } | |
| else | |
| { | |
| // at least one of the effects requested | |
| if( rParms.maTextTransformation.is_initialized() ) | |
| return ActionSharedPtr( new EffectTextAction( | |
| aStartPoint, | |
| aReliefOffset, | |
| rReliefColor, | |
| aShadowOffset, | |
| rShadowColor, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| rVDev, | |
| rCanvas, | |
| rState, | |
| *rParms.maTextTransformation ) ); | |
| else | |
| return ActionSharedPtr( new EffectTextAction( | |
| aStartPoint, | |
| aReliefOffset, | |
| rReliefColor, | |
| aShadowOffset, | |
| rShadowColor, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| rVDev, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| } | |
| else | |
| { | |
| // DX array necessary - any effects? | |
| if( !rState.textOverlineStyle && | |
| !rState.textUnderlineStyle && | |
| !rState.textStrikeoutStyle && | |
| rReliefColor == aEmptyColor && | |
| rShadowColor == aEmptyColor ) | |
| { | |
| // nope | |
| if( rParms.maTextTransformation.is_initialized() ) | |
| return ActionSharedPtr( new TextArrayAction( | |
| aStartPoint, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| aCharWidths, | |
| rCanvas, | |
| rState, | |
| *rParms.maTextTransformation ) ); | |
| else | |
| return ActionSharedPtr( new TextArrayAction( | |
| aStartPoint, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| aCharWidths, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| else | |
| { | |
| // at least one of the effects requested | |
| if( rParms.maTextTransformation.is_initialized() ) | |
| return ActionSharedPtr( new EffectTextArrayAction( | |
| aStartPoint, | |
| aReliefOffset, | |
| rReliefColor, | |
| aShadowOffset, | |
| rShadowColor, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| aCharWidths, | |
| rVDev, | |
| rCanvas, | |
| rState, | |
| *rParms.maTextTransformation ) ); | |
| else | |
| return ActionSharedPtr( new EffectTextArrayAction( | |
| aStartPoint, | |
| aReliefOffset, | |
| rReliefColor, | |
| aShadowOffset, | |
| rShadowColor, | |
| rText, | |
| nStartPos, | |
| nLen, | |
| aCharWidths, | |
| rVDev, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| } | |
| #if defined __GNUC__ | |
| #if __GNUC__ == 4 && __GNUC_MINOR__ >= 1 | |
| // Unreachable; to avoid bogus warning: | |
| return ActionSharedPtr(); | |
| #endif | |
| #endif | |
| } | |
| } | |
| } |