LCOV - code coverage report
Current view: top level - cppcanvas/source/mtfrenderer - textaction.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1 493 0.2 %
Date: 2015-06-13 12:38:46 Functions: 2 77 2.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <canvas/debug.hxx>
      22             : #include <tools/diagnose_ex.h>
      23             : #include <canvas/verbosetrace.hxx>
      24             : 
      25             : #include <com/sun/star/rendering/PathCapType.hpp>
      26             : #include <com/sun/star/rendering/PathJoinType.hpp>
      27             : #include <com/sun/star/rendering/XCanvas.hpp>
      28             : #include <com/sun/star/rendering/XCanvasFont.hpp>
      29             : 
      30             : #include <basegfx/numeric/ftools.hxx>
      31             : #include <basegfx/matrix/b2dhommatrix.hxx>
      32             : #include <basegfx/range/b2drectangle.hxx>
      33             : #include <basegfx/vector/b2dsize.hxx>
      34             : #include <basegfx/polygon/b2dpolypolygontools.hxx>
      35             : #include <basegfx/polygon/b2dpolygontools.hxx>
      36             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      37             : 
      38             : #include <tools/gen.hxx>
      39             : #include <vcl/canvastools.hxx>
      40             : #include <vcl/virdev.hxx>
      41             : 
      42             : #include <basegfx/tools/canvastools.hxx>
      43             : #include <canvas/canvastools.hxx>
      44             : 
      45             : #include <boost/scoped_array.hpp>
      46             : #include <boost/bind.hpp>
      47             : #include <boost/utility.hpp>
      48             : 
      49             : #include "textaction.hxx"
      50             : #include "outdevstate.hxx"
      51             : #include "mtftools.hxx"
      52             : 
      53             : 
      54             : using namespace ::com::sun::star;
      55             : 
      56             : namespace cppcanvas
      57             : {
      58             :     namespace internal
      59             :     {
      60             :         namespace
      61             :         {
      62           0 :             void init( rendering::RenderState&                  o_rRenderState,
      63             :                        const ::basegfx::B2DPoint&               rStartPoint,
      64             :                        const OutDevState&                       rState,
      65             :                        const CanvasSharedPtr&                   rCanvas      )
      66             :             {
      67           0 :                 tools::initRenderState(o_rRenderState,rState);
      68             : 
      69             :                 // #i36950# Offset clip back to origin (as it's also moved
      70             :                 // by rStartPoint)
      71             :                 // #i53964# Also take VCL font rotation into account,
      72             :                 // since this, opposed to the FontMatrix rotation
      73             :                 // elsewhere, _does_ get incorporated into the render
      74             :                 // state transform.
      75             :                 tools::modifyClip( o_rRenderState,
      76             :                                    rState,
      77             :                                    rCanvas,
      78             :                                    rStartPoint,
      79             :                                    NULL,
      80           0 :                                    &rState.fontRotation );
      81             : 
      82           0 :                 basegfx::B2DHomMatrix aLocalTransformation(basegfx::tools::createRotateB2DHomMatrix(rState.fontRotation));
      83             :                 aLocalTransformation.translate( rStartPoint.getX(),
      84           0 :                                                 rStartPoint.getY() );
      85             :                 ::canvas::tools::appendToRenderState( o_rRenderState,
      86           0 :                                                       aLocalTransformation );
      87             : 
      88           0 :                 o_rRenderState.DeviceColor = rState.textColor;
      89           0 :             }
      90             : 
      91           0 :             void init( rendering::RenderState&                  o_rRenderState,
      92             :                        const ::basegfx::B2DPoint&               rStartPoint,
      93             :                        const OutDevState&                       rState,
      94             :                        const CanvasSharedPtr&                   rCanvas,
      95             :                        const ::basegfx::B2DHomMatrix&           rTextTransform  )
      96             :             {
      97           0 :                 init( o_rRenderState, rStartPoint, rState, rCanvas );
      98             : 
      99             :                 // TODO(F2): Also inversely-transform clip with
     100             :                 // rTextTransform (which is actually rather hard, as the
     101             :                 // text transform is _prepended_ to the render state)!
     102             : 
     103             :                 // prepend extra font transform to render state
     104             :                 // (prepend it, because it's interpreted in the unit
     105             :                 // rect coordinate space)
     106             :                 ::canvas::tools::prependToRenderState( o_rRenderState,
     107           0 :                                                        rTextTransform );
     108           0 :             }
     109             : 
     110           0 :             void init( rendering::RenderState&                      o_rRenderState,
     111             :                        uno::Reference< rendering::XCanvasFont >&    o_rFont,
     112             :                        const ::basegfx::B2DPoint&                   rStartPoint,
     113             :                        const OutDevState&                           rState,
     114             :                        const CanvasSharedPtr&                       rCanvas      )
     115             :             {
     116             :                 // ensure that o_rFont is valid. It is possible that
     117             :                 // text actions are generated without previously
     118             :                 // setting a font. Then, just take a default font
     119           0 :                 if( !o_rFont.is() )
     120             :                 {
     121             :                     // Use completely default FontRequest
     122           0 :                     const rendering::FontRequest aFontRequest;
     123             : 
     124           0 :                     geometry::Matrix2D aFontMatrix;
     125           0 :                     ::canvas::tools::setIdentityMatrix2D( aFontMatrix );
     126             : 
     127           0 :                     o_rFont = rCanvas->getUNOCanvas()->createFont(
     128             :                         aFontRequest,
     129             :                         uno::Sequence< beans::PropertyValue >(),
     130           0 :                         aFontMatrix );
     131             :                 }
     132             : 
     133             :                 init( o_rRenderState,
     134             :                       rStartPoint,
     135             :                       rState,
     136           0 :                       rCanvas );
     137           0 :             }
     138             : 
     139           0 :             void init( rendering::RenderState&                      o_rRenderState,
     140             :                        uno::Reference< rendering::XCanvasFont >&    o_rFont,
     141             :                        const ::basegfx::B2DPoint&                   rStartPoint,
     142             :                        const OutDevState&                           rState,
     143             :                        const CanvasSharedPtr&                       rCanvas,
     144             :                        const ::basegfx::B2DHomMatrix&               rTextTransform  )
     145             :             {
     146           0 :                 init( o_rRenderState, o_rFont, rStartPoint, rState, rCanvas );
     147             : 
     148             :                 // TODO(F2): Also inversely-transform clip with
     149             :                 // rTextTransform (which is actually rather hard, as the
     150             :                 // text transform is _prepended_ to the render state)!
     151             : 
     152             :                 // prepend extra font transform to render state
     153             :                 // (prepend it, because it's interpreted in the unit
     154             :                 // rect coordinate space)
     155             :                 ::canvas::tools::prependToRenderState( o_rRenderState,
     156           0 :                                                        rTextTransform );
     157           0 :             }
     158             : 
     159           0 :             ::basegfx::B2DPolyPolygon textLinesFromLogicalOffsets( const uno::Sequence< double >&   rOffsets,
     160             :                                                                    const tools::TextLineInfo&       rTextLineInfo )
     161             :             {
     162             :                 return tools::createTextLinesPolyPolygon(
     163             :                     0.0,
     164             :                     // extract character cell furthest to the right
     165             :                     *(::std::max_element(
     166             :                           rOffsets.getConstArray(),
     167           0 :                           rOffsets.getConstArray() + rOffsets.getLength() )),
     168           0 :                     rTextLineInfo );
     169             :             }
     170             : 
     171           0 :             uno::Sequence< double > setupDXArray( const long*   pCharWidths,
     172             :                                                   sal_Int32          nLen,
     173             :                                                   const OutDevState& rState )
     174             :             {
     175             :                 // convert character widths from logical units
     176           0 :                 uno::Sequence< double > aCharWidthSeq( nLen );
     177           0 :                 double*                 pOutputWidths( aCharWidthSeq.getArray() );
     178             : 
     179             :                 // #143885# maintain (nearly) full precision of DX
     180             :                 // array, by circumventing integer-based
     181             :                 // OutDev-mapping
     182           0 :                 const double nScale( rState.mapModeTransform.get(0,0) );
     183           0 :                 for( int i = 0; i < nLen; ++i )
     184             :                 {
     185             :                     // TODO(F2): use correct scale direction
     186           0 :                     *pOutputWidths++ = *pCharWidths++ * nScale;
     187             :                 }
     188             : 
     189           0 :                 return aCharWidthSeq;
     190             :             }
     191             : 
     192           0 :             uno::Sequence< double > setupDXArray( const OUString&    rText,
     193             :                                                   sal_Int32          nStartPos,
     194             :                                                   sal_Int32          nLen,
     195             :                                                   VirtualDevice&     rVDev,
     196             :                                                   const OutDevState& rState )
     197             :             {
     198             :                 // no external DX array given, create one from given
     199             :                 // string
     200           0 :                 ::boost::scoped_array< long > pCharWidths( new long[nLen] );
     201             : 
     202             :                 rVDev.GetTextArray( rText, pCharWidths.get(),
     203           0 :                                     nStartPos, nLen );
     204             : 
     205           0 :                 return setupDXArray( pCharWidths.get(), nLen, rState );
     206             :             }
     207             : 
     208           0 :             ::basegfx::B2DPoint adaptStartPoint( const ::basegfx::B2DPoint&     rStartPoint,
     209             :                                                  const OutDevState&             rState,
     210             :                                                  const uno::Sequence< double >& rOffsets )
     211             :             {
     212           0 :                 ::basegfx::B2DPoint aLocalPoint( rStartPoint );
     213             : 
     214           0 :                 if( rState.textAlignment )
     215             :                 {
     216             :                     // text origin is right, not left. Modify start point
     217             :                     // accordingly, because XCanvas::drawTextLayout()
     218             :                     // always aligns left!
     219             : 
     220           0 :                     const double nOffset( rOffsets[ rOffsets.getLength()-1 ] );
     221             : 
     222             :                     // correct start point for rotated text: rotate around
     223             :                     // former start point
     224           0 :                     aLocalPoint.setX( aLocalPoint.getX() + cos( rState.fontRotation )*nOffset );
     225           0 :                     aLocalPoint.setY( aLocalPoint.getY() + sin( rState.fontRotation )*nOffset );
     226             :                 }
     227             : 
     228           0 :                 return aLocalPoint;
     229             :             }
     230             : 
     231             :             /** Perform common setup for array text actions
     232             : 
     233             :                 This method creates the XTextLayout object and
     234             :                 initializes it, e.g. with the logical advancements.
     235             :              */
     236           0 :             void initArrayAction( rendering::RenderState&                   o_rRenderState,
     237             :                                   uno::Reference< rendering::XTextLayout >& o_rTextLayout,
     238             :                                   const ::basegfx::B2DPoint&                rStartPoint,
     239             :                                   const OUString&                    rText,
     240             :                                   sal_Int32                                 nStartPos,
     241             :                                   sal_Int32                                 nLen,
     242             :                                   const uno::Sequence< double >&            rOffsets,
     243             :                                   const CanvasSharedPtr&                    rCanvas,
     244             :                                   const OutDevState&                        rState,
     245             :                                   const ::basegfx::B2DHomMatrix*            pTextTransform )
     246             :             {
     247           0 :                 ENSURE_OR_THROW( rOffsets.getLength(),
     248             :                                   "::cppcanvas::internal::initArrayAction(): zero-length DX array" );
     249             : 
     250             :                 const ::basegfx::B2DPoint aLocalStartPoint(
     251           0 :                     adaptStartPoint( rStartPoint, rState, rOffsets ) );
     252             : 
     253           0 :                 uno::Reference< rendering::XCanvasFont > xFont( rState.xFont );
     254             : 
     255           0 :                 if( pTextTransform )
     256           0 :                     init( o_rRenderState, xFont, aLocalStartPoint, rState, rCanvas, *pTextTransform );
     257             :                 else
     258           0 :                     init( o_rRenderState, xFont, aLocalStartPoint, rState, rCanvas );
     259             : 
     260           0 :                 o_rTextLayout = xFont->createTextLayout(
     261             :                     rendering::StringContext( rText, nStartPos, nLen ),
     262             :                     rState.textDirection,
     263           0 :                     0 );
     264             : 
     265           0 :                 ENSURE_OR_THROW( o_rTextLayout.is(),
     266             :                                   "::cppcanvas::internal::initArrayAction(): Invalid font" );
     267             : 
     268           0 :                 o_rTextLayout->applyLogicalAdvancements( rOffsets );
     269           0 :             }
     270             : 
     271           0 :             double getLineWidth( ::VirtualDevice&                rVDev,
     272             :                                  const OutDevState&              rState,
     273             :                                  const rendering::StringContext& rStringContext )
     274             :             {
     275             :                 // TODO(F2): use correct scale direction
     276             :                 const ::basegfx::B2DSize aSize( rVDev.GetTextWidth( rStringContext.Text,
     277             :                                                                     static_cast<sal_uInt16>(rStringContext.StartPosition),
     278           0 :                                                                     static_cast<sal_uInt16>(rStringContext.Length) ),
     279           0 :                                     0 );
     280             : 
     281           0 :                 return (rState.mapModeTransform * aSize).getX();
     282             :             }
     283             : 
     284             :             uno::Sequence< double >
     285           0 :                 calcSubsetOffsets( rendering::RenderState&                          io_rRenderState,
     286             :                                    double&                                          o_rMinPos,
     287             :                                    double&                                          o_rMaxPos,
     288             :                                    const uno::Reference< rendering::XTextLayout >&  rOrigTextLayout,
     289             :                                    const ::cppcanvas::internal::Action::Subset&     rSubset )
     290             :             {
     291           0 :                 ENSURE_OR_THROW( rSubset.mnSubsetEnd > rSubset.mnSubsetBegin,
     292             :                                   "::cppcanvas::internal::calcSubsetOffsets(): invalid subset range range" );
     293             : 
     294           0 :                 uno::Sequence< double > aOrigOffsets( rOrigTextLayout->queryLogicalAdvancements() );
     295           0 :                 const double*           pOffsets( aOrigOffsets.getConstArray() );
     296             : 
     297           0 :                 ENSURE_OR_THROW( aOrigOffsets.getLength() >= rSubset.mnSubsetEnd,
     298             :                                   "::cppcanvas::internal::calcSubsetOffsets(): invalid subset range range" );
     299             : 
     300             :                 // TODO(F3): It currently seems that for RTL text, the
     301             :                 // DX offsets are nevertheless increasing in logical
     302             :                 // text order (I'd expect they are decreasing,
     303             :                 // mimicking the fact that the text is output
     304             :                 // right-to-left). This breaks text effects for ALL
     305             :                 // RTL languages.
     306             : 
     307             :                 // determine leftmost position in given subset range -
     308             :                 // as the DX array contains the output positions
     309             :                 // starting with the second character (the first is
     310             :                 // assumed to have output position 0), correct begin
     311             :                 // iterator.
     312           0 :                 const double nMinPos( rSubset.mnSubsetBegin <= 0 ? 0 :
     313           0 :                                       *(::std::min_element( pOffsets+rSubset.mnSubsetBegin-1,
     314           0 :                                                             pOffsets+rSubset.mnSubsetEnd )) );
     315             : 
     316             :                 // determine rightmost position in given subset range
     317             :                 // - as the DX array contains the output positions
     318             :                 // starting with the second character (the first is
     319             :                 // assumed to have output position 0), correct begin
     320             :                 // iterator.
     321             :                 const double nMaxPos(
     322           0 :                     *(::std::max_element( pOffsets + (rSubset.mnSubsetBegin <= 0 ?
     323           0 :                                                       0 : rSubset.mnSubsetBegin-1),
     324           0 :                                           pOffsets + rSubset.mnSubsetEnd )) );
     325             : 
     326             : 
     327             :                 // adapt render state, to move text output to given offset
     328             : 
     329             : 
     330             :                 // TODO(F1): Strictly speaking, we also have to adapt
     331             :                 // the clip here, which normally should _not_ move
     332             :                 // with the output offset. Neglected for now, as it
     333             :                 // does not matter for drawing layer output
     334             : 
     335           0 :                 if( rSubset.mnSubsetBegin > 0 )
     336             :                 {
     337           0 :                     ::basegfx::B2DHomMatrix aTranslation;
     338           0 :                     if( rOrigTextLayout->getFont()->getFontRequest().FontDescription.IsVertical )
     339             :                     {
     340             :                         // vertical text -> offset in y direction
     341           0 :                         aTranslation.translate( 0.0, nMinPos );
     342             :                     }
     343             :                     else
     344             :                     {
     345             :                         // horizontal text -> offset in x direction
     346           0 :                         aTranslation.translate( nMinPos, 0.0 );
     347             :                     }
     348             : 
     349             :                     ::canvas::tools::appendToRenderState( io_rRenderState,
     350           0 :                                                           aTranslation );
     351             :                 }
     352             : 
     353             : 
     354             :                 // reduce DX array to given substring
     355             : 
     356             : 
     357           0 :                 const sal_Int32         nNewElements( rSubset.mnSubsetEnd - rSubset.mnSubsetBegin );
     358           0 :                 uno::Sequence< double > aAdaptedOffsets( nNewElements );
     359           0 :                 double*                 pAdaptedOffsets( aAdaptedOffsets.getArray() );
     360             : 
     361             :                 // move to new output position (subtract nMinPos,
     362             :                 // which is the new '0' position), copy only the range
     363             :                 // as given by rSubset.
     364             :                 ::std::transform( pOffsets + rSubset.mnSubsetBegin,
     365             :                                   pOffsets + rSubset.mnSubsetEnd,
     366             :                                   pAdaptedOffsets,
     367             :                                   ::boost::bind( ::std::minus<double>(),
     368             :                                                  _1,
     369           0 :                                                  nMinPos ) );
     370             : 
     371           0 :                 o_rMinPos = nMinPos;
     372           0 :                 o_rMaxPos = nMaxPos;
     373             : 
     374           0 :                 return aAdaptedOffsets;
     375             :             }
     376             : 
     377             :             uno::Reference< rendering::XTextLayout >
     378           0 :                 createSubsetLayout( const rendering::StringContext&                 rOrigContext,
     379             :                                     const ::cppcanvas::internal::Action::Subset&    rSubset,
     380             :                                     const uno::Reference< rendering::XTextLayout >& rOrigTextLayout )
     381             :             {
     382             :                 // create temporary new text layout with subset string
     383             : 
     384             : 
     385           0 :                 const sal_Int32 nNewStartPos( rOrigContext.StartPosition + ::std::min(
     386           0 :                                                   rSubset.mnSubsetBegin, rOrigContext.Length-1 ) );
     387             :                 const sal_Int32 nNewLength( ::std::max(
     388             :                                                 ::std::min(
     389           0 :                                                     rSubset.mnSubsetEnd - rSubset.mnSubsetBegin,
     390           0 :                                                     rOrigContext.Length ),
     391           0 :                                                 sal_Int32( 0 ) ) );
     392             : 
     393             :                 const rendering::StringContext aContext( rOrigContext.Text,
     394             :                                                          nNewStartPos,
     395           0 :                                                          nNewLength );
     396             : 
     397             :                 uno::Reference< rendering::XTextLayout > xTextLayout(
     398           0 :                     rOrigTextLayout->getFont()->createTextLayout( aContext,
     399           0 :                                                                   rOrigTextLayout->getMainTextDirection(),
     400           0 :                                                                   0 ),
     401           0 :                     uno::UNO_QUERY_THROW );
     402             : 
     403           0 :                 return xTextLayout;
     404             :             }
     405             : 
     406             :             /** Setup subset text layout
     407             : 
     408             :                 @param io_rTextLayout
     409             :                 Must contain original (full set) text layout on input,
     410             :                 will contain subsetted text layout (or empty
     411             :                 reference, for empty subsets) on output.
     412             : 
     413             :                 @param io_rRenderState
     414             :                 Must contain original render state on input, will
     415             :                 contain shifted render state concatenated with
     416             :                 rTransformation on output.
     417             : 
     418             :                 @param rTransformation
     419             :                 Additional transformation, to be prepended to render
     420             :                 state
     421             : 
     422             :                 @param rSubset
     423             :                 Subset to prepare
     424             :              */
     425           0 :             void createSubsetLayout( uno::Reference< rendering::XTextLayout >&  io_rTextLayout,
     426             :                                      rendering::RenderState&                    io_rRenderState,
     427             :                                      double&                                    o_rMinPos,
     428             :                                      double&                                    o_rMaxPos,
     429             :                                      const ::basegfx::B2DHomMatrix&             rTransformation,
     430             :                                      const Action::Subset&                      rSubset )
     431             :             {
     432           0 :                 ::canvas::tools::prependToRenderState(io_rRenderState, rTransformation);
     433             : 
     434           0 :                 if( rSubset.mnSubsetBegin == rSubset.mnSubsetEnd )
     435             :                 {
     436             :                      // empty range, empty layout
     437           0 :                     io_rTextLayout.clear();
     438             : 
     439           0 :                     return;
     440             :                 }
     441             : 
     442           0 :                 ENSURE_OR_THROW( io_rTextLayout.is(),
     443             :                                   "createSubsetLayout(): Invalid input layout" );
     444             : 
     445           0 :                 const rendering::StringContext& rOrigContext( io_rTextLayout->getText() );
     446             : 
     447           0 :                 if( rSubset.mnSubsetBegin == 0 &&
     448           0 :                     rSubset.mnSubsetEnd == rOrigContext.Length )
     449             :                 {
     450             :                     // full range, no need for subsetting
     451           0 :                     return;
     452             :                 }
     453             : 
     454             :                 uno::Reference< rendering::XTextLayout > xTextLayout(
     455           0 :                     createSubsetLayout( rOrigContext, rSubset, io_rTextLayout ) );
     456             : 
     457           0 :                 if( xTextLayout.is() )
     458             :                 {
     459           0 :                     xTextLayout->applyLogicalAdvancements(
     460             :                         calcSubsetOffsets( io_rRenderState,
     461             :                                            o_rMinPos,
     462             :                                            o_rMaxPos,
     463             :                                            io_rTextLayout,
     464           0 :                                            rSubset ) );
     465             :                 }
     466             : 
     467           0 :                 io_rTextLayout = xTextLayout;
     468             :             }
     469             : 
     470             : 
     471             :             /** Interface for renderEffectText functor below.
     472             : 
     473             :                 This is interface is used from the renderEffectText()
     474             :                 method below, to call the client implementation.
     475             :              */
     476           0 :             class TextRenderer
     477             :             {
     478             :             public:
     479           0 :                 virtual ~TextRenderer() {}
     480             : 
     481             :                 /// Render text with given RenderState
     482             :                 virtual bool operator()( const rendering::RenderState& rRenderState ) const = 0;
     483             :             };
     484             : 
     485             :             /** Render effect text.
     486             : 
     487             :                 @param rRenderer
     488             :                 Functor object, will be called to render the actual
     489             :                 part of the text effect (the text itself and the means
     490             :                 to render it are unknown to this method)
     491             :              */
     492           0 :             bool renderEffectText( const TextRenderer&                          rRenderer,
     493             :                                    const rendering::RenderState&                rRenderState,
     494             :                                    const rendering::ViewState&                  /*rViewState*/,
     495             :                                    const uno::Reference< rendering::XCanvas >&  xCanvas,
     496             :                                    const ::Color&                               rShadowColor,
     497             :                                    const ::basegfx::B2DSize&                    rShadowOffset,
     498             :                                    const ::Color&                               rReliefColor,
     499             :                                    const ::basegfx::B2DSize&                    rReliefOffset )
     500             :             {
     501           0 :                 ::Color aEmptyColor( COL_AUTO );
     502             :                 uno::Reference<rendering::XColorSpace> xColorSpace(
     503           0 :                     xCanvas->getDevice()->getDeviceColorSpace() );
     504             : 
     505             :                 // draw shadow text, if enabled
     506           0 :                 if( rShadowColor != aEmptyColor )
     507             :                 {
     508           0 :                     rendering::RenderState aShadowState( rRenderState );
     509           0 :                     ::basegfx::B2DHomMatrix aTranslate;
     510             : 
     511             :                     aTranslate.translate( rShadowOffset.getX(),
     512           0 :                                           rShadowOffset.getY() );
     513             : 
     514           0 :                     ::canvas::tools::appendToRenderState(aShadowState, aTranslate);
     515             : 
     516           0 :                     aShadowState.DeviceColor =
     517             :                         vcl::unotools::colorToDoubleSequence( rShadowColor,
     518           0 :                                                                 xColorSpace );
     519             : 
     520           0 :                     rRenderer( aShadowState );
     521             :                 }
     522             : 
     523             :                 // draw relief text, if enabled
     524           0 :                 if( rReliefColor != aEmptyColor )
     525             :                 {
     526           0 :                     rendering::RenderState aReliefState( rRenderState );
     527           0 :                     ::basegfx::B2DHomMatrix aTranslate;
     528             : 
     529             :                     aTranslate.translate( rReliefOffset.getX(),
     530           0 :                                           rReliefOffset.getY() );
     531             : 
     532           0 :                     ::canvas::tools::appendToRenderState(aReliefState, aTranslate);
     533             : 
     534           0 :                     aReliefState.DeviceColor =
     535             :                         vcl::unotools::colorToDoubleSequence( rReliefColor,
     536           0 :                                                                 xColorSpace );
     537             : 
     538           0 :                     rRenderer( aReliefState );
     539             :                 }
     540             : 
     541             :                 // draw normal text
     542           0 :                 rRenderer( rRenderState );
     543             : 
     544           0 :                 return true;
     545             :             }
     546             : 
     547             : 
     548           0 :             ::basegfx::B2DRange calcEffectTextBounds( const ::basegfx::B2DRange&    rTextBounds,
     549             :                                                       const ::basegfx::B2DRange&    rLineBounds,
     550             :                                                       const ::basegfx::B2DSize&     rReliefOffset,
     551             :                                                       const ::basegfx::B2DSize&     rShadowOffset,
     552             :                                                       const rendering::RenderState& rRenderState,
     553             :                                                       const rendering::ViewState&   rViewState )
     554             :             {
     555           0 :                 ::basegfx::B2DRange aBounds( rTextBounds );
     556             : 
     557             :                 // add extends of text lines
     558           0 :                 aBounds.expand( rLineBounds );
     559             : 
     560             :                 // TODO(Q3): Provide this functionality at the B2DRange
     561           0 :                 ::basegfx::B2DRange aTotalBounds( aBounds );
     562             :                 aTotalBounds.expand(
     563           0 :                     ::basegfx::B2DRange( aBounds.getMinX() + rReliefOffset.getX(),
     564           0 :                                          aBounds.getMinY() + rReliefOffset.getY(),
     565           0 :                                          aBounds.getMaxX() + rReliefOffset.getX(),
     566           0 :                                          aBounds.getMaxY() + rReliefOffset.getY() ) );
     567             :                 aTotalBounds.expand(
     568           0 :                     ::basegfx::B2DRange( aBounds.getMinX() + rShadowOffset.getX(),
     569           0 :                                          aBounds.getMinY() + rShadowOffset.getY(),
     570           0 :                                          aBounds.getMaxX() + rShadowOffset.getX(),
     571           0 :                                          aBounds.getMaxY() + rShadowOffset.getY() ) );
     572             : 
     573             :                 return tools::calcDevicePixelBounds( aTotalBounds,
     574             :                                                      rViewState,
     575           0 :                                                      rRenderState );
     576             :             }
     577             : 
     578           0 :             void initEffectLinePolyPolygon( ::basegfx::B2DSize&                             o_rOverallSize,
     579             :                                             uno::Reference< rendering::XPolyPolygon2D >&    o_rTextLines,
     580             :                                             const CanvasSharedPtr&                          rCanvas,
     581             :                                             const uno::Sequence< double >&                  rOffsets,
     582             :                                             const tools::TextLineInfo&                      rLineInfo   )
     583             :             {
     584             :                 const ::basegfx::B2DPolyPolygon aPoly(
     585             :                     textLinesFromLogicalOffsets(
     586             :                         rOffsets,
     587           0 :                         rLineInfo ) );
     588             : 
     589           0 :                 o_rOverallSize = ::basegfx::tools::getRange( aPoly ).getRange();
     590             : 
     591           0 :                 o_rTextLines = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
     592           0 :                     rCanvas->getUNOCanvas()->getDevice(),
     593           0 :                     aPoly );
     594           0 :             }
     595             : 
     596           0 :             void initEffectLinePolyPolygon( ::basegfx::B2DSize&                             o_rOverallSize,
     597             :                                             uno::Reference< rendering::XPolyPolygon2D >&    o_rTextLines,
     598             :                                             const CanvasSharedPtr&                          rCanvas,
     599             :                                             double                                          nLineWidth,
     600             :                                             const tools::TextLineInfo&                      rLineInfo   )
     601             :             {
     602             :                 const ::basegfx::B2DPolyPolygon aPoly(
     603             :                     tools::createTextLinesPolyPolygon( 0.0, nLineWidth,
     604           0 :                                                        rLineInfo ) );
     605             : 
     606           0 :                 o_rOverallSize = ::basegfx::tools::getRange( aPoly ).getRange();
     607             : 
     608           0 :                 o_rTextLines = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
     609           0 :                     rCanvas->getUNOCanvas()->getDevice(),
     610           0 :                     aPoly );
     611           0 :             }
     612             : 
     613             : 
     614             : 
     615             : 
     616           0 :             class TextAction : public Action, private ::boost::noncopyable
     617             :             {
     618             :             public:
     619             :                 TextAction( const ::basegfx::B2DPoint&  rStartPoint,
     620             :                             const OUString&      rString,
     621             :                             sal_Int32                   nStartPos,
     622             :                             sal_Int32                   nLen,
     623             :                             const CanvasSharedPtr&      rCanvas,
     624             :                             const OutDevState&          rState );
     625             : 
     626             :                 TextAction( const ::basegfx::B2DPoint&      rStartPoint,
     627             :                             const OUString&          rString,
     628             :                             sal_Int32                       nStartPos,
     629             :                             sal_Int32                       nLen,
     630             :                             const CanvasSharedPtr&          rCanvas,
     631             :                             const OutDevState&              rState,
     632             :                             const ::basegfx::B2DHomMatrix&  rTextTransform );
     633             : 
     634             :                 virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
     635             :                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
     636             :                                            const Subset&                  rSubset ) const SAL_OVERRIDE;
     637             : 
     638             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
     639             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
     640             :                                                        const Subset&                    rSubset ) const SAL_OVERRIDE;
     641             : 
     642             :                 virtual sal_Int32 getActionCount() const SAL_OVERRIDE;
     643             : 
     644             :             private:
     645             :                 // TODO(P2): This is potentially a real mass object
     646             :                 // (every character might be a separate TextAction),
     647             :                 // thus, make it as lightweight as possible. For
     648             :                 // example, share common RenderState among several
     649             :                 // TextActions, maybe using maOffsets for the
     650             :                 // translation.
     651             : 
     652             :                 uno::Reference< rendering::XCanvasFont >    mxFont;
     653             :                 const rendering::StringContext              maStringContext;
     654             :                 const CanvasSharedPtr                       mpCanvas;
     655             :                 rendering::RenderState                      maState;
     656             :                 const sal_Int8                              maTextDirection;
     657             :             };
     658             : 
     659           0 :             TextAction::TextAction( const ::basegfx::B2DPoint&  rStartPoint,
     660             :                                     const OUString&      rString,
     661             :                                     sal_Int32                   nStartPos,
     662             :                                     sal_Int32                   nLen,
     663             :                                     const CanvasSharedPtr&      rCanvas,
     664             :                                     const OutDevState&          rState  ) :
     665             :                 mxFont( rState.xFont ),
     666             :                 maStringContext( rString, nStartPos, nLen ),
     667             :                 mpCanvas( rCanvas ),
     668             :                 maState(),
     669           0 :                 maTextDirection( rState.textDirection )
     670             :             {
     671             :                 init( maState, mxFont,
     672             :                       rStartPoint,
     673           0 :                       rState, rCanvas );
     674             : 
     675           0 :                 ENSURE_OR_THROW( mxFont.is(),
     676             :                                   "::cppcanvas::internal::TextAction(): Invalid font" );
     677           0 :             }
     678             : 
     679           0 :             TextAction::TextAction( const ::basegfx::B2DPoint&      rStartPoint,
     680             :                                     const OUString&          rString,
     681             :                                     sal_Int32                       nStartPos,
     682             :                                     sal_Int32                       nLen,
     683             :                                     const CanvasSharedPtr&          rCanvas,
     684             :                                     const OutDevState&              rState,
     685             :                                     const ::basegfx::B2DHomMatrix&  rTextTransform ) :
     686             :                 mxFont( rState.xFont ),
     687             :                 maStringContext( rString, nStartPos, nLen ),
     688             :                 mpCanvas( rCanvas ),
     689             :                 maState(),
     690           0 :                 maTextDirection( rState.textDirection )
     691             :             {
     692             :                 init( maState, mxFont,
     693             :                       rStartPoint,
     694           0 :                       rState, rCanvas, rTextTransform );
     695             : 
     696           0 :                 ENSURE_OR_THROW( mxFont.is(),
     697             :                                   "::cppcanvas::internal::TextAction(): Invalid font" );
     698           0 :             }
     699             : 
     700           0 :             bool TextAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const
     701             :             {
     702             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextAction::render()" );
     703             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextAction: 0x" << std::hex << this );
     704             : 
     705           0 :                 rendering::RenderState aLocalState( maState );
     706           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
     707             : 
     708           0 :                 mpCanvas->getUNOCanvas()->drawText( maStringContext, mxFont,
     709           0 :                                                     mpCanvas->getViewState(), aLocalState, maTextDirection );
     710             : 
     711           0 :                 return true;
     712             :             }
     713             : 
     714           0 :             bool TextAction::renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
     715             :                                            const Subset&                  /*rSubset*/ ) const
     716             :             {
     717             :                 SAL_WARN( "cppcanvas.emf", "TextAction::renderSubset(): Subset not supported by this object" );
     718             : 
     719             :                 // TODO(P1): Retrieve necessary font metric info for
     720             :                 // TextAction from XCanvas. Currently, the
     721             :                 // TextActionFactory does not generate this object for
     722             :                 // _subsettable_ text
     723           0 :                 return render( rTransformation );
     724             :             }
     725             : 
     726           0 :             ::basegfx::B2DRange TextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const
     727             :             {
     728             :                 // create XTextLayout, to have the
     729             :                 // XTextLayout::queryTextBounds() method available
     730             :                 uno::Reference< rendering::XTextLayout > xTextLayout(
     731           0 :                     mxFont->createTextLayout(
     732             :                         maStringContext,
     733             :                         maTextDirection,
     734           0 :                         0 ) );
     735             : 
     736           0 :                 rendering::RenderState aLocalState( maState );
     737           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
     738             : 
     739             :                 return tools::calcDevicePixelBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D(
     740           0 :                                                          xTextLayout->queryTextBounds() ),
     741           0 :                                                      mpCanvas->getViewState(),
     742           0 :                                                      aLocalState );
     743             :             }
     744             : 
     745           0 :             ::basegfx::B2DRange TextAction::getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
     746             :                                                        const Subset&                    /*rSubset*/ ) const
     747             :             {
     748             :                 SAL_WARN( "cppcanvas.emf", "TextAction::getBounds(): Subset not supported by this object" );
     749             : 
     750             :                 // TODO(P1): Retrieve necessary font metric info for
     751             :                 // TextAction from XCanvas. Currently, the
     752             :                 // TextActionFactory does not generate this object for
     753             :                 // _subsettable_ text
     754           0 :                 return getBounds( rTransformation );
     755             :             }
     756             : 
     757           0 :             sal_Int32 TextAction::getActionCount() const
     758             :             {
     759             :                 // TODO(P1): Retrieve necessary font metric info for
     760             :                 // TextAction from XCanvas. Currently, the
     761             :                 // TextActionFactory does not generate this object for
     762             :                 // _subsettable_ text
     763           0 :                 return 1;
     764             :             }
     765             : 
     766             : 
     767             : 
     768             : 
     769           0 :             class EffectTextAction :
     770             :                 public Action,
     771             :                 public TextRenderer,
     772             :                 private ::boost::noncopyable
     773             :             {
     774             :             public:
     775             :                 EffectTextAction( const ::basegfx::B2DPoint& rStartPoint,
     776             :                                   const ::basegfx::B2DSize&  rReliefOffset,
     777             :                                   const ::Color&             rReliefColor,
     778             :                                   const ::basegfx::B2DSize&  rShadowOffset,
     779             :                                   const ::Color&             rShadowColor,
     780             :                                   const OUString&     rText,
     781             :                                   sal_Int32                  nStartPos,
     782             :                                   sal_Int32                  nLen,
     783             :                                   VirtualDevice&             rVDev,
     784             :                                   const CanvasSharedPtr&     rCanvas,
     785             :                                   const OutDevState&         rState );
     786             : 
     787             :                 EffectTextAction( const ::basegfx::B2DPoint&        rStartPoint,
     788             :                                   const ::basegfx::B2DSize&         rReliefOffset,
     789             :                                   const ::Color&                    rReliefColor,
     790             :                                   const ::basegfx::B2DSize&         rShadowOffset,
     791             :                                   const ::Color&                    rShadowColor,
     792             :                                   const OUString&            rText,
     793             :                                   sal_Int32                         nStartPos,
     794             :                                   sal_Int32                         nLen,
     795             :                                   VirtualDevice&                    rVDev,
     796             :                                   const CanvasSharedPtr&            rCanvas,
     797             :                                   const OutDevState&                rState,
     798             :                                   const ::basegfx::B2DHomMatrix&    rTextTransform );
     799             : 
     800             :                 virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
     801             :                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
     802             :                                            const Subset&                  rSubset ) const SAL_OVERRIDE;
     803             : 
     804             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
     805             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
     806             :                                                        const Subset&                    rSubset ) const SAL_OVERRIDE;
     807             : 
     808             :                 virtual sal_Int32 getActionCount() const SAL_OVERRIDE;
     809             : 
     810             :             private:
     811             :                 /// Interface TextRenderer
     812             :                 virtual bool operator()( const rendering::RenderState& rRenderState ) const SAL_OVERRIDE;
     813             : 
     814             :                 // TODO(P2): This is potentially a real mass object
     815             :                 // (every character might be a separate TextAction),
     816             :                 // thus, make it as lightweight as possible. For
     817             :                 // example, share common RenderState among several
     818             :                 // TextActions, maybe using maOffsets for the
     819             :                 // translation.
     820             : 
     821             :                 uno::Reference< rendering::XCanvasFont >    mxFont;
     822             :                 const rendering::StringContext              maStringContext;
     823             :                 const CanvasSharedPtr                       mpCanvas;
     824             :                 rendering::RenderState                      maState;
     825             :                 const tools::TextLineInfo                   maTextLineInfo;
     826             :                 ::basegfx::B2DSize                          maLinesOverallSize;
     827             :                 const double                                mnLineWidth;
     828             :                 uno::Reference< rendering::XPolyPolygon2D > mxTextLines;
     829             :                 const ::basegfx::B2DSize                    maReliefOffset;
     830             :                 const ::Color                               maReliefColor;
     831             :                 const ::basegfx::B2DSize                    maShadowOffset;
     832             :                 const ::Color                               maShadowColor;
     833             :                 const sal_Int8                              maTextDirection;
     834             :             };
     835             : 
     836           0 :             EffectTextAction::EffectTextAction( const ::basegfx::B2DPoint& rStartPoint,
     837             :                                                 const ::basegfx::B2DSize&  rReliefOffset,
     838             :                                                 const ::Color&             rReliefColor,
     839             :                                                 const ::basegfx::B2DSize&  rShadowOffset,
     840             :                                                 const ::Color&             rShadowColor,
     841             :                                                 const OUString&     rText,
     842             :                                                 sal_Int32                  nStartPos,
     843             :                                                 sal_Int32                  nLen,
     844             :                                                 VirtualDevice&             rVDev,
     845             :                                                 const CanvasSharedPtr&     rCanvas,
     846             :                                                 const OutDevState&         rState ) :
     847             :                 mxFont( rState.xFont ),
     848             :                 maStringContext( rText, nStartPos, nLen ),
     849             :                 mpCanvas( rCanvas ),
     850             :                 maState(),
     851             :                 maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ),
     852             :                 maLinesOverallSize(),
     853           0 :                 mnLineWidth( getLineWidth( rVDev, rState, maStringContext ) ),
     854             :                 mxTextLines(),
     855             :                 maReliefOffset( rReliefOffset ),
     856             :                 maReliefColor( rReliefColor ),
     857             :                 maShadowOffset( rShadowOffset ),
     858             :                 maShadowColor( rShadowColor ),
     859           0 :                 maTextDirection( rState.textDirection )
     860             :             {
     861             :                 initEffectLinePolyPolygon( maLinesOverallSize,
     862             :                                            mxTextLines,
     863             :                                            rCanvas,
     864             :                                            mnLineWidth,
     865           0 :                                            maTextLineInfo );
     866             : 
     867             :                 init( maState, mxFont,
     868             :                       rStartPoint,
     869           0 :                       rState, rCanvas );
     870             : 
     871           0 :                 ENSURE_OR_THROW( mxFont.is() && mxTextLines.is(),
     872             :                                   "::cppcanvas::internal::EffectTextAction(): Invalid font or lines" );
     873           0 :             }
     874             : 
     875           0 :             EffectTextAction::EffectTextAction( const ::basegfx::B2DPoint&      rStartPoint,
     876             :                                                 const ::basegfx::B2DSize&       rReliefOffset,
     877             :                                                 const ::Color&                  rReliefColor,
     878             :                                                 const ::basegfx::B2DSize&       rShadowOffset,
     879             :                                                 const ::Color&                  rShadowColor,
     880             :                                                 const OUString&          rText,
     881             :                                                 sal_Int32                       nStartPos,
     882             :                                                 sal_Int32                       nLen,
     883             :                                                 VirtualDevice&                  rVDev,
     884             :                                                 const CanvasSharedPtr&          rCanvas,
     885             :                                                 const OutDevState&              rState,
     886             :                                                 const ::basegfx::B2DHomMatrix&  rTextTransform ) :
     887             :                 mxFont( rState.xFont ),
     888             :                 maStringContext( rText, nStartPos, nLen ),
     889             :                 mpCanvas( rCanvas ),
     890             :                 maState(),
     891             :                 maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ),
     892             :                 maLinesOverallSize(),
     893           0 :                 mnLineWidth( getLineWidth( rVDev, rState, maStringContext ) ),
     894             :                 mxTextLines(),
     895             :                 maReliefOffset( rReliefOffset ),
     896             :                 maReliefColor( rReliefColor ),
     897             :                 maShadowOffset( rShadowOffset ),
     898             :                 maShadowColor( rShadowColor ),
     899           0 :                 maTextDirection( rState.textDirection )
     900             :             {
     901             :                 initEffectLinePolyPolygon( maLinesOverallSize,
     902             :                                            mxTextLines,
     903             :                                            rCanvas,
     904             :                                            mnLineWidth,
     905           0 :                                            maTextLineInfo );
     906             : 
     907             :                 init( maState, mxFont,
     908             :                       rStartPoint,
     909           0 :                       rState, rCanvas, rTextTransform );
     910             : 
     911           0 :                 ENSURE_OR_THROW( mxFont.is() && mxTextLines.is(),
     912             :                                   "::cppcanvas::internal::EffectTextAction(): Invalid font or lines" );
     913           0 :             }
     914             : 
     915           0 :             bool EffectTextAction::operator()( const rendering::RenderState& rRenderState ) const
     916             :             {
     917           0 :                 const rendering::ViewState& rViewState( mpCanvas->getViewState() );
     918           0 :                 const uno::Reference< rendering::XCanvas >& rCanvas( mpCanvas->getUNOCanvas() );
     919             : 
     920           0 :                 rCanvas->fillPolyPolygon( mxTextLines,
     921             :                                           rViewState,
     922           0 :                                           rRenderState );
     923             : 
     924           0 :                 rCanvas->drawText( maStringContext, mxFont,
     925             :                                    rViewState,
     926             :                                    rRenderState,
     927           0 :                                    maTextDirection );
     928             : 
     929           0 :                 return true;
     930             :             }
     931             : 
     932           0 :             bool EffectTextAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const
     933             :             {
     934             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextAction::render()" );
     935             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextAction: 0x" << std::hex << this );
     936             : 
     937           0 :                 rendering::RenderState aLocalState( maState );
     938           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
     939             : 
     940             :                 return renderEffectText( *this,
     941             :                                          aLocalState,
     942           0 :                                          mpCanvas->getViewState(),
     943           0 :                                          mpCanvas->getUNOCanvas(),
     944             :                                          maShadowColor,
     945             :                                          maShadowOffset,
     946             :                                          maReliefColor,
     947           0 :                                          maReliefOffset );
     948             :             }
     949             : 
     950           0 :             bool EffectTextAction::renderSubset( const ::basegfx::B2DHomMatrix&   rTransformation,
     951             :                                                  const Subset&                    /*rSubset*/ ) const
     952             :             {
     953             :                 SAL_WARN( "cppcanvas.emf", "EffectTextAction::renderSubset(): Subset not supported by this object" );
     954             : 
     955             :                 // TODO(P1): Retrieve necessary font metric info for
     956             :                 // TextAction from XCanvas. Currently, the
     957             :                 // TextActionFactory does not generate this object for
     958             :                 // subsettable text
     959           0 :                 return render( rTransformation );
     960             :             }
     961             : 
     962           0 :             ::basegfx::B2DRange EffectTextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const
     963             :             {
     964             :                 // create XTextLayout, to have the
     965             :                 // XTextLayout::queryTextBounds() method available
     966             :                 uno::Reference< rendering::XTextLayout > xTextLayout(
     967           0 :                     mxFont->createTextLayout(
     968             :                         maStringContext,
     969             :                         maTextDirection,
     970           0 :                         0 ) );
     971             : 
     972           0 :                 rendering::RenderState aLocalState( maState );
     973           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
     974             : 
     975             :                 return calcEffectTextBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D(
     976           0 :                                                  xTextLayout->queryTextBounds() ),
     977             :                                              ::basegfx::B2DRange( 0,0,
     978             :                                                                   maLinesOverallSize.getX(),
     979             :                                                                   maLinesOverallSize.getY() ),
     980             :                                              maReliefOffset,
     981             :                                              maShadowOffset,
     982             :                                              aLocalState,
     983           0 :                                              mpCanvas->getViewState() );
     984             :             }
     985             : 
     986           0 :             ::basegfx::B2DRange EffectTextAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation,
     987             :                                                              const Subset&                  /*rSubset*/ ) const
     988             :             {
     989             :                 SAL_WARN( "cppcanvas.emf", "EffectTextAction::getBounds(): Subset not supported by this object" );
     990             : 
     991             :                 // TODO(P1): Retrieve necessary font metric info for
     992             :                 // TextAction from XCanvas. Currently, the
     993             :                 // TextActionFactory does not generate this object for
     994             :                 // _subsettable_ text
     995           0 :                 return getBounds( rTransformation );
     996             :             }
     997             : 
     998           0 :             sal_Int32 EffectTextAction::getActionCount() const
     999             :             {
    1000             :                 // TODO(P1): Retrieve necessary font metric info for
    1001             :                 // TextAction from XCanvas. Currently, the
    1002             :                 // TextActionFactory does not generate this object for
    1003             :                 // subsettable text
    1004           0 :                 return 1;
    1005             :             }
    1006             : 
    1007             : 
    1008             : 
    1009             : 
    1010           0 :             class TextArrayAction : public Action, private ::boost::noncopyable
    1011             :             {
    1012             :             public:
    1013             :                 TextArrayAction( const ::basegfx::B2DPoint&     rStartPoint,
    1014             :                                  const OUString&         rString,
    1015             :                                  sal_Int32                      nStartPos,
    1016             :                                  sal_Int32                      nLen,
    1017             :                                  const uno::Sequence< double >& rOffsets,
    1018             :                                  const CanvasSharedPtr&         rCanvas,
    1019             :                                  const OutDevState&             rState );
    1020             : 
    1021             :                 TextArrayAction( const ::basegfx::B2DPoint&     rStartPoint,
    1022             :                                  const OUString&         rString,
    1023             :                                  sal_Int32                      nStartPos,
    1024             :                                  sal_Int32                      nLen,
    1025             :                                  const uno::Sequence< double >& rOffsets,
    1026             :                                  const CanvasSharedPtr&         rCanvas,
    1027             :                                  const OutDevState&             rState,
    1028             :                                  const ::basegfx::B2DHomMatrix& rTextTransform );
    1029             : 
    1030             :                 virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
    1031             :                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
    1032             :                                            const Subset&                  rSubset ) const SAL_OVERRIDE;
    1033             : 
    1034             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
    1035             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
    1036             :                                                        const Subset&                    rSubset ) const SAL_OVERRIDE;
    1037             : 
    1038             :                 virtual sal_Int32 getActionCount() const SAL_OVERRIDE;
    1039             : 
    1040             :             private:
    1041             :                 // TODO(P2): This is potentially a real mass object
    1042             :                 // (every character might be a separate TextAction),
    1043             :                 // thus, make it as lightweight as possible. For
    1044             :                 // example, share common RenderState among several
    1045             :                 // TextActions, maybe using maOffsets for the
    1046             :                 // translation.
    1047             : 
    1048             :                 uno::Reference< rendering::XTextLayout >    mxTextLayout;
    1049             :                 const CanvasSharedPtr                       mpCanvas;
    1050             :                 rendering::RenderState                      maState;
    1051             :             };
    1052             : 
    1053           0 :             TextArrayAction::TextArrayAction( const ::basegfx::B2DPoint&        rStartPoint,
    1054             :                                               const OUString&            rString,
    1055             :                                               sal_Int32                         nStartPos,
    1056             :                                               sal_Int32                         nLen,
    1057             :                                               const uno::Sequence< double >&    rOffsets,
    1058             :                                               const CanvasSharedPtr&            rCanvas,
    1059             :                                               const OutDevState&                rState ) :
    1060             :                 mxTextLayout(),
    1061             :                 mpCanvas( rCanvas ),
    1062           0 :                 maState()
    1063             :             {
    1064             :                 initArrayAction( maState,
    1065             :                                  mxTextLayout,
    1066             :                                  rStartPoint,
    1067             :                                  rString,
    1068             :                                  nStartPos,
    1069             :                                  nLen,
    1070             :                                  rOffsets,
    1071             :                                  rCanvas,
    1072           0 :                                  rState, NULL );
    1073           0 :             }
    1074             : 
    1075           0 :             TextArrayAction::TextArrayAction( const ::basegfx::B2DPoint&        rStartPoint,
    1076             :                                               const OUString&            rString,
    1077             :                                               sal_Int32                         nStartPos,
    1078             :                                               sal_Int32                         nLen,
    1079             :                                               const uno::Sequence< double >&    rOffsets,
    1080             :                                               const CanvasSharedPtr&            rCanvas,
    1081             :                                               const OutDevState&                rState,
    1082             :                                               const ::basegfx::B2DHomMatrix&    rTextTransform ) :
    1083             :                 mxTextLayout(),
    1084             :                 mpCanvas( rCanvas ),
    1085           0 :                 maState()
    1086             :             {
    1087             :                 initArrayAction( maState,
    1088             :                                  mxTextLayout,
    1089             :                                  rStartPoint,
    1090             :                                  rString,
    1091             :                                  nStartPos,
    1092             :                                  nLen,
    1093             :                                  rOffsets,
    1094             :                                  rCanvas,
    1095             :                                  rState,
    1096           0 :                                  &rTextTransform );
    1097           0 :             }
    1098             : 
    1099           0 :             bool TextArrayAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const
    1100             :             {
    1101             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextArrayAction::render()" );
    1102             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextArrayAction: 0x" << std::hex << this );
    1103             : 
    1104           0 :                 rendering::RenderState aLocalState( maState );
    1105           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1106             : 
    1107           0 :                 mpCanvas->getUNOCanvas()->drawTextLayout( mxTextLayout,
    1108           0 :                                                           mpCanvas->getViewState(),
    1109           0 :                                                           aLocalState );
    1110             : 
    1111           0 :                 return true;
    1112             :             }
    1113             : 
    1114           0 :             bool TextArrayAction::renderSubset( const ::basegfx::B2DHomMatrix&    rTransformation,
    1115             :                                                 const Subset&                     rSubset ) const
    1116             :             {
    1117             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextArrayAction::renderSubset()" );
    1118             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextArrayAction: 0x" << std::hex << this );
    1119             : 
    1120           0 :                 rendering::RenderState                      aLocalState( maState );
    1121           0 :                 uno::Reference< rendering::XTextLayout >    xTextLayout( mxTextLayout );
    1122             : 
    1123             :                 double nDummy0, nDummy1;
    1124             :                 createSubsetLayout( xTextLayout,
    1125             :                                     aLocalState,
    1126             :                                     nDummy0,
    1127             :                                     nDummy1,
    1128             :                                     rTransformation,
    1129           0 :                                     rSubset );
    1130             : 
    1131           0 :                 if( !xTextLayout.is() )
    1132           0 :                     return true; // empty layout, render nothing
    1133             : 
    1134           0 :                 mpCanvas->getUNOCanvas()->drawTextLayout( xTextLayout,
    1135           0 :                                                           mpCanvas->getViewState(),
    1136           0 :                                                           aLocalState );
    1137             : 
    1138           0 :                 return true;
    1139             :             }
    1140             : 
    1141           0 :             ::basegfx::B2DRange TextArrayAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const
    1142             :             {
    1143           0 :                 rendering::RenderState aLocalState( maState );
    1144           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1145             : 
    1146             :                 return tools::calcDevicePixelBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D(
    1147           0 :                                                          mxTextLayout->queryTextBounds() ),
    1148           0 :                                                      mpCanvas->getViewState(),
    1149           0 :                                                      aLocalState );
    1150             :             }
    1151             : 
    1152           0 :             ::basegfx::B2DRange TextArrayAction::getBounds( const ::basegfx::B2DHomMatrix&  rTransformation,
    1153             :                                                             const Subset&                   rSubset ) const
    1154             :             {
    1155             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextArrayAction::getBounds( subset )" );
    1156             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::TextArrayAction: 0x" << std::hex << this );
    1157             : 
    1158           0 :                 rendering::RenderState                      aLocalState( maState );
    1159           0 :                 uno::Reference< rendering::XTextLayout >    xTextLayout( mxTextLayout );
    1160             : 
    1161             :                 double nDummy0, nDummy1;
    1162             :                 createSubsetLayout( xTextLayout,
    1163             :                                     aLocalState,
    1164             :                                     nDummy0,
    1165             :                                     nDummy1,
    1166             :                                     rTransformation,
    1167           0 :                                     rSubset );
    1168             : 
    1169           0 :                 if( !xTextLayout.is() )
    1170           0 :                     return ::basegfx::B2DRange(); // empty layout, empty bounds
    1171             : 
    1172             :                 return tools::calcDevicePixelBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D(
    1173           0 :                                                          xTextLayout->queryTextBounds() ),
    1174           0 :                                                      mpCanvas->getViewState(),
    1175           0 :                                                      aLocalState );
    1176             :             }
    1177             : 
    1178           0 :             sal_Int32 TextArrayAction::getActionCount() const
    1179             :             {
    1180           0 :                 const rendering::StringContext& rOrigContext( mxTextLayout->getText() );
    1181             : 
    1182           0 :                 return rOrigContext.Length;
    1183             :             }
    1184             : 
    1185             : 
    1186             : 
    1187             : 
    1188           0 :             class EffectTextArrayAction :
    1189             :                 public Action,
    1190             :                 public TextRenderer,
    1191             :                 private ::boost::noncopyable
    1192             :             {
    1193             :             public:
    1194             :                 EffectTextArrayAction( const ::basegfx::B2DPoint&       rStartPoint,
    1195             :                                        const ::basegfx::B2DSize&        rReliefOffset,
    1196             :                                        const ::Color&                   rReliefColor,
    1197             :                                        const ::basegfx::B2DSize&        rShadowOffset,
    1198             :                                        const ::Color&                   rShadowColor,
    1199             :                                        const OUString&           rText,
    1200             :                                        sal_Int32                        nStartPos,
    1201             :                                        sal_Int32                        nLen,
    1202             :                                        const uno::Sequence< double >&   rOffsets,
    1203             :                                        VirtualDevice&                   rVDev,
    1204             :                                        const CanvasSharedPtr&           rCanvas,
    1205             :                                        const OutDevState&               rState  );
    1206             :                 EffectTextArrayAction( const ::basegfx::B2DPoint&       rStartPoint,
    1207             :                                        const ::basegfx::B2DSize&        rReliefOffset,
    1208             :                                        const ::Color&                   rReliefColor,
    1209             :                                        const ::basegfx::B2DSize&        rShadowOffset,
    1210             :                                        const ::Color&                   rShadowColor,
    1211             :                                        const OUString&           rText,
    1212             :                                        sal_Int32                        nStartPos,
    1213             :                                        sal_Int32                        nLen,
    1214             :                                        const uno::Sequence< double >&   rOffsets,
    1215             :                                        VirtualDevice&                   rVDev,
    1216             :                                        const CanvasSharedPtr&           rCanvas,
    1217             :                                        const OutDevState&               rState,
    1218             :                                        const ::basegfx::B2DHomMatrix&   rTextTransform );
    1219             : 
    1220             :                 virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
    1221             :                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
    1222             :                                            const Subset&                  rSubset ) const SAL_OVERRIDE;
    1223             : 
    1224             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
    1225             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
    1226             :                                                        const Subset&                    rSubset ) const SAL_OVERRIDE;
    1227             : 
    1228             :                 virtual sal_Int32 getActionCount() const SAL_OVERRIDE;
    1229             : 
    1230             :             private:
    1231             :                 // TextRenderer interface
    1232             :                 virtual bool operator()( const rendering::RenderState& rRenderState ) const SAL_OVERRIDE;
    1233             : 
    1234             :                 // TODO(P2): This is potentially a real mass object
    1235             :                 // (every character might be a separate TextAction),
    1236             :                 // thus, make it as lightweight as possible. For
    1237             :                 // example, share common RenderState among several
    1238             :                 // TextActions, maybe using maOffsets for the
    1239             :                 // translation.
    1240             : 
    1241             :                 uno::Reference< rendering::XTextLayout >        mxTextLayout;
    1242             :                 const CanvasSharedPtr                           mpCanvas;
    1243             :                 rendering::RenderState                          maState;
    1244             :                 const tools::TextLineInfo                       maTextLineInfo;
    1245             :                 ::basegfx::B2DSize                              maLinesOverallSize;
    1246             :                 uno::Reference< rendering::XPolyPolygon2D >     mxTextLines;
    1247             :                 const ::basegfx::B2DSize                        maReliefOffset;
    1248             :                 const ::Color                                   maReliefColor;
    1249             :                 const ::basegfx::B2DSize                        maShadowOffset;
    1250             :                 const ::Color                                   maShadowColor;
    1251             :             };
    1252             : 
    1253           0 :             EffectTextArrayAction::EffectTextArrayAction( const ::basegfx::B2DPoint&        rStartPoint,
    1254             :                                                           const ::basegfx::B2DSize&         rReliefOffset,
    1255             :                                                           const ::Color&                    rReliefColor,
    1256             :                                                           const ::basegfx::B2DSize&         rShadowOffset,
    1257             :                                                           const ::Color&                    rShadowColor,
    1258             :                                                           const OUString&            rText,
    1259             :                                                           sal_Int32                         nStartPos,
    1260             :                                                           sal_Int32                         nLen,
    1261             :                                                           const uno::Sequence< double >&    rOffsets,
    1262             :                                                           VirtualDevice&                    rVDev,
    1263             :                                                           const CanvasSharedPtr&            rCanvas,
    1264             :                                                           const OutDevState&                rState  ) :
    1265             :                 mxTextLayout(),
    1266             :                 mpCanvas( rCanvas ),
    1267             :                 maState(),
    1268             :                 maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ),
    1269             :                 maLinesOverallSize(),
    1270             :                 mxTextLines(),
    1271             :                 maReliefOffset( rReliefOffset ),
    1272             :                 maReliefColor( rReliefColor ),
    1273             :                 maShadowOffset( rShadowOffset ),
    1274           0 :                 maShadowColor( rShadowColor )
    1275             :             {
    1276             :                 initEffectLinePolyPolygon( maLinesOverallSize,
    1277             :                                            mxTextLines,
    1278             :                                            rCanvas,
    1279             :                                            rOffsets,
    1280           0 :                                            maTextLineInfo );
    1281             : 
    1282             :                 initArrayAction( maState,
    1283             :                                  mxTextLayout,
    1284             :                                  rStartPoint,
    1285             :                                  rText,
    1286             :                                  nStartPos,
    1287             :                                  nLen,
    1288             :                                  rOffsets,
    1289             :                                  rCanvas,
    1290           0 :                                  rState, NULL );
    1291           0 :             }
    1292             : 
    1293           0 :             EffectTextArrayAction::EffectTextArrayAction( const ::basegfx::B2DPoint&        rStartPoint,
    1294             :                                                           const ::basegfx::B2DSize&         rReliefOffset,
    1295             :                                                           const ::Color&                    rReliefColor,
    1296             :                                                           const ::basegfx::B2DSize&         rShadowOffset,
    1297             :                                                           const ::Color&                    rShadowColor,
    1298             :                                                           const OUString&            rText,
    1299             :                                                           sal_Int32                         nStartPos,
    1300             :                                                           sal_Int32                         nLen,
    1301             :                                                           const uno::Sequence< double >&    rOffsets,
    1302             :                                                           VirtualDevice&                    rVDev,
    1303             :                                                           const CanvasSharedPtr&            rCanvas,
    1304             :                                                           const OutDevState&                rState,
    1305             :                                                           const ::basegfx::B2DHomMatrix&    rTextTransform ) :
    1306             :                 mxTextLayout(),
    1307             :                 mpCanvas( rCanvas ),
    1308             :                 maState(),
    1309             :                 maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ),
    1310             :                 maLinesOverallSize(),
    1311             :                 mxTextLines(),
    1312             :                 maReliefOffset( rReliefOffset ),
    1313             :                 maReliefColor( rReliefColor ),
    1314             :                 maShadowOffset( rShadowOffset ),
    1315           0 :                 maShadowColor( rShadowColor )
    1316             :             {
    1317             :                 initEffectLinePolyPolygon( maLinesOverallSize,
    1318             :                                            mxTextLines,
    1319             :                                            rCanvas,
    1320             :                                            rOffsets,
    1321           0 :                                            maTextLineInfo );
    1322             : 
    1323             :                 initArrayAction( maState,
    1324             :                                  mxTextLayout,
    1325             :                                  rStartPoint,
    1326             :                                  rText,
    1327             :                                  nStartPos,
    1328             :                                  nLen,
    1329             :                                  rOffsets,
    1330             :                                  rCanvas,
    1331             :                                  rState,
    1332           0 :                                  &rTextTransform );
    1333           0 :             }
    1334             : 
    1335           0 :             bool EffectTextArrayAction::operator()( const rendering::RenderState& rRenderState ) const
    1336             :             {
    1337           0 :                 const rendering::ViewState& rViewState( mpCanvas->getViewState() );
    1338           0 :                 const uno::Reference< rendering::XCanvas >& rCanvas( mpCanvas->getUNOCanvas() );
    1339             : 
    1340           0 :                 rCanvas->fillPolyPolygon( mxTextLines,
    1341             :                                           rViewState,
    1342           0 :                                           rRenderState );
    1343             : 
    1344           0 :                 rCanvas->drawTextLayout( mxTextLayout,
    1345             :                                          rViewState,
    1346           0 :                                          rRenderState );
    1347             : 
    1348           0 :                 return true;
    1349             :             }
    1350             : 
    1351           0 :             bool EffectTextArrayAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const
    1352             :             {
    1353             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction::render()" );
    1354             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction: 0x" << std::hex << this );
    1355             : 
    1356           0 :                 rendering::RenderState aLocalState( maState );
    1357           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1358             : 
    1359             :                 return renderEffectText( *this,
    1360             :                                          aLocalState,
    1361           0 :                                          mpCanvas->getViewState(),
    1362           0 :                                          mpCanvas->getUNOCanvas(),
    1363             :                                          maShadowColor,
    1364             :                                          maShadowOffset,
    1365             :                                          maReliefColor,
    1366           0 :                                          maReliefOffset );
    1367             :             }
    1368             : 
    1369           0 :             class EffectTextArrayRenderHelper : public TextRenderer
    1370             :             {
    1371             :             public:
    1372           0 :                 EffectTextArrayRenderHelper( const uno::Reference< rendering::XCanvas >&        rCanvas,
    1373             :                                              const uno::Reference< rendering::XTextLayout >&    rTextLayout,
    1374             :                                              const uno::Reference< rendering::XPolyPolygon2D >& rLinePolygon,
    1375             :                                              const rendering::ViewState&                        rViewState ) :
    1376             :                     mrCanvas( rCanvas ),
    1377             :                     mrTextLayout( rTextLayout ),
    1378             :                     mrLinePolygon( rLinePolygon ),
    1379           0 :                     mrViewState( rViewState )
    1380             :                 {
    1381           0 :                 }
    1382             : 
    1383             :                 // TextRenderer interface
    1384           0 :                 virtual bool operator()( const rendering::RenderState& rRenderState ) const SAL_OVERRIDE
    1385             :                 {
    1386           0 :                     mrCanvas->fillPolyPolygon( mrLinePolygon,
    1387             :                                                mrViewState,
    1388           0 :                                                rRenderState );
    1389             : 
    1390           0 :                     mrCanvas->drawTextLayout( mrTextLayout,
    1391             :                                               mrViewState,
    1392           0 :                                               rRenderState );
    1393             : 
    1394           0 :                     return true;
    1395             :                 }
    1396             : 
    1397             :             private:
    1398             :                 const uno::Reference< rendering::XCanvas >&         mrCanvas;
    1399             :                 const uno::Reference< rendering::XTextLayout >&     mrTextLayout;
    1400             :                 const uno::Reference< rendering::XPolyPolygon2D >&  mrLinePolygon;
    1401             :                 const rendering::ViewState&                         mrViewState;
    1402             :             };
    1403             : 
    1404           0 :             bool EffectTextArrayAction::renderSubset( const ::basegfx::B2DHomMatrix&  rTransformation,
    1405             :                                                       const Subset&                   rSubset ) const
    1406             :             {
    1407             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction::renderSubset()" );
    1408             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction: 0x" << std::hex << this );
    1409             : 
    1410           0 :                 rendering::RenderState                   aLocalState( maState );
    1411           0 :                 uno::Reference< rendering::XTextLayout > xTextLayout( mxTextLayout );
    1412           0 :                 const geometry::RealRectangle2D          aTextBounds( mxTextLayout->queryTextBounds() );
    1413             : 
    1414           0 :                 double nMinPos(0.0);
    1415           0 :                 double nMaxPos(aTextBounds.X2 - aTextBounds.X1);
    1416             : 
    1417             :                 createSubsetLayout( xTextLayout,
    1418             :                                     aLocalState,
    1419             :                                     nMinPos,
    1420             :                                     nMaxPos,
    1421             :                                     rTransformation,
    1422           0 :                                     rSubset );
    1423             : 
    1424           0 :                 if( !xTextLayout.is() )
    1425           0 :                     return true; // empty layout, render nothing
    1426             : 
    1427             : 
    1428             :                 // create and setup local line polygon
    1429             :                 // ===================================
    1430             : 
    1431           0 :                 uno::Reference< rendering::XCanvas > xCanvas( mpCanvas->getUNOCanvas() );
    1432           0 :                 const rendering::ViewState&          rViewState( mpCanvas->getViewState() );
    1433             : 
    1434             :                 uno::Reference< rendering::XPolyPolygon2D > xTextLines(
    1435             :                     ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
    1436           0 :                         xCanvas->getDevice(),
    1437             :                         tools::createTextLinesPolyPolygon(
    1438           0 :                             0.0, nMaxPos - nMinPos,
    1439           0 :                             maTextLineInfo ) ) );
    1440             : 
    1441             : 
    1442             :                 // render everything
    1443             :                 // =================
    1444             : 
    1445             :                 return renderEffectText(
    1446             :                     EffectTextArrayRenderHelper( xCanvas,
    1447             :                                                  xTextLayout,
    1448             :                                                  xTextLines,
    1449             :                                                  rViewState ),
    1450             :                     aLocalState,
    1451             :                     rViewState,
    1452             :                     xCanvas,
    1453             :                     maShadowColor,
    1454             :                     maShadowOffset,
    1455             :                     maReliefColor,
    1456           0 :                     maReliefOffset );
    1457             :             }
    1458             : 
    1459           0 :             ::basegfx::B2DRange EffectTextArrayAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const
    1460             :             {
    1461           0 :                 rendering::RenderState aLocalState( maState );
    1462           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1463             : 
    1464             :                 return calcEffectTextBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D(
    1465           0 :                                                  mxTextLayout->queryTextBounds() ),
    1466             :                                              ::basegfx::B2DRange( 0,0,
    1467             :                                                                   maLinesOverallSize.getX(),
    1468             :                                                                   maLinesOverallSize.getY() ),
    1469             :                                              maReliefOffset,
    1470             :                                              maShadowOffset,
    1471             :                                              aLocalState,
    1472           0 :                                              mpCanvas->getViewState() );
    1473             :             }
    1474             : 
    1475           0 :             ::basegfx::B2DRange EffectTextArrayAction::getBounds( const ::basegfx::B2DHomMatrix&    rTransformation,
    1476             :                                                                   const Subset&                     rSubset ) const
    1477             :             {
    1478             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction::getBounds( subset )" );
    1479             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction: 0x" << std::hex << this );
    1480             : 
    1481           0 :                 rendering::RenderState                   aLocalState( maState );
    1482           0 :                 uno::Reference< rendering::XTextLayout > xTextLayout( mxTextLayout );
    1483           0 :                 const geometry::RealRectangle2D          aTextBounds( mxTextLayout->queryTextBounds() );
    1484             : 
    1485           0 :                 double nMinPos(0.0);
    1486           0 :                 double nMaxPos(aTextBounds.X2 - aTextBounds.X1);
    1487             : 
    1488             :                 createSubsetLayout( xTextLayout,
    1489             :                                     aLocalState,
    1490             :                                     nMinPos,
    1491             :                                     nMaxPos,
    1492             :                                     rTransformation,
    1493           0 :                                     rSubset );
    1494             : 
    1495           0 :                 if( !xTextLayout.is() )
    1496           0 :                     return ::basegfx::B2DRange(); // empty layout, empty bounds
    1497             : 
    1498             : 
    1499             :                 // create and setup local line polygon
    1500             :                 // ===================================
    1501             : 
    1502             :                 const ::basegfx::B2DPolyPolygon aPoly(
    1503             :                     tools::createTextLinesPolyPolygon(
    1504           0 :                         0.0, nMaxPos - nMinPos,
    1505           0 :                         maTextLineInfo ) );
    1506             : 
    1507             :                 return calcEffectTextBounds( ::basegfx::unotools::b2DRectangleFromRealRectangle2D(
    1508           0 :                                                  xTextLayout->queryTextBounds() ),
    1509             :                                              ::basegfx::tools::getRange( aPoly ),
    1510             :                                              maReliefOffset,
    1511             :                                              maShadowOffset,
    1512             :                                              aLocalState,
    1513           0 :                                              mpCanvas->getViewState() );
    1514             :             }
    1515             : 
    1516           0 :             sal_Int32 EffectTextArrayAction::getActionCount() const
    1517             :             {
    1518           0 :                 const rendering::StringContext& rOrigContext( mxTextLayout->getText() );
    1519             : 
    1520           0 :                 return rOrigContext.Length;
    1521             :             }
    1522             : 
    1523             : 
    1524             : 
    1525             : 
    1526           0 :             class OutlineAction :
    1527             :                 public Action,
    1528             :                 public TextRenderer,
    1529             :                 private ::boost::noncopyable
    1530             :             {
    1531             :             public:
    1532             :                 OutlineAction( const ::basegfx::B2DPoint&                           rStartPoint,
    1533             :                                const ::basegfx::B2DSize&                            rReliefOffset,
    1534             :                                const ::Color&                                       rReliefColor,
    1535             :                                const ::basegfx::B2DSize&                            rShadowOffset,
    1536             :                                const ::Color&                                       rShadowColor,
    1537             :                                const ::basegfx::B2DRectangle&                       rOutlineBounds,
    1538             :                                const uno::Reference< rendering::XPolyPolygon2D >&   rTextPoly,
    1539             :                                const ::std::vector< sal_Int32 >&                    rPolygonGlyphMap,
    1540             :                                const uno::Sequence< double >&                       rOffsets,
    1541             :                                VirtualDevice&                                       rVDev,
    1542             :                                const CanvasSharedPtr&                               rCanvas,
    1543             :                                const OutDevState&                                   rState  );
    1544             :                 OutlineAction( const ::basegfx::B2DPoint&                           rStartPoint,
    1545             :                                const ::basegfx::B2DSize&                            rReliefOffset,
    1546             :                                const ::Color&                                       rReliefColor,
    1547             :                                const ::basegfx::B2DSize&                            rShadowOffset,
    1548             :                                const ::Color&                                       rShadowColor,
    1549             :                                const ::basegfx::B2DRectangle&                       rOutlineBounds,
    1550             :                                const uno::Reference< rendering::XPolyPolygon2D >&   rTextPoly,
    1551             :                                const ::std::vector< sal_Int32 >&                    rPolygonGlyphMap,
    1552             :                                const uno::Sequence< double >&                       rOffsets,
    1553             :                                VirtualDevice&                                       rVDev,
    1554             :                                const CanvasSharedPtr&                               rCanvas,
    1555             :                                const OutDevState&                                   rState,
    1556             :                                const ::basegfx::B2DHomMatrix&                       rTextTransform );
    1557             : 
    1558             :                 virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
    1559             :                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
    1560             :                                            const Subset&                  rSubset ) const SAL_OVERRIDE;
    1561             : 
    1562             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const SAL_OVERRIDE;
    1563             :                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
    1564             :                                                        const Subset&                    rSubset ) const SAL_OVERRIDE;
    1565             : 
    1566             :                 virtual sal_Int32 getActionCount() const SAL_OVERRIDE;
    1567             : 
    1568             :             private:
    1569             :                 // TextRenderer interface
    1570             :                 virtual bool operator()( const rendering::RenderState& rRenderState ) const SAL_OVERRIDE;
    1571             : 
    1572             :                 // TODO(P2): This is potentially a real mass object
    1573             :                 // (every character might be a separate TextAction),
    1574             :                 // thus, make it as lightweight as possible. For
    1575             :                 // example, share common RenderState among several
    1576             :                 // TextActions, maybe using maOffsets for the
    1577             :                 // translation.
    1578             : 
    1579             :                 uno::Reference< rendering::XPolyPolygon2D >         mxTextPoly;
    1580             : 
    1581             :                 /** This vector denotes the index of the start polygon
    1582             :                     for the respective glyph sequence.
    1583             : 
    1584             :                     To get a polygon index range for a given character
    1585             :                     index i, take [ maPolygonGlyphMap[i],
    1586             :                     maPolygonGlyphMap[i+1] ). Note that this is wrong
    1587             :                     for BiDi
    1588             :                  */
    1589             :                 const ::std::vector< sal_Int32 >                    maPolygonGlyphMap;
    1590             :                 const uno::Sequence< double >                       maOffsets;
    1591             :                 const CanvasSharedPtr                               mpCanvas;
    1592             :                 rendering::RenderState                              maState;
    1593             :                 double                                              mnOutlineWidth;
    1594             :                 const uno::Sequence< double >                       maFillColor;
    1595             :                 const tools::TextLineInfo                           maTextLineInfo;
    1596             :                 ::basegfx::B2DSize                                  maLinesOverallSize;
    1597             :                 const ::basegfx::B2DRectangle                       maOutlineBounds;
    1598             :                 uno::Reference< rendering::XPolyPolygon2D >         mxTextLines;
    1599             :                 const ::basegfx::B2DSize                            maReliefOffset;
    1600             :                 const ::Color                                       maReliefColor;
    1601             :                 const ::basegfx::B2DSize                            maShadowOffset;
    1602             :                 const ::Color                                       maShadowColor;
    1603             :             };
    1604             : 
    1605           0 :             double calcOutlineWidth( const OutDevState& rState,
    1606             :                                      VirtualDevice&     rVDev )
    1607             :             {
    1608             :                 const ::basegfx::B2DSize aFontSize( 0,
    1609           0 :                                                     rVDev.GetFont().GetHeight() / 64.0 );
    1610             : 
    1611             :                 const double nOutlineWidth(
    1612           0 :                     (rState.mapModeTransform * aFontSize).getY() );
    1613             : 
    1614           0 :                 return nOutlineWidth < 1.0 ? 1.0 : nOutlineWidth;
    1615             :             }
    1616             : 
    1617           0 :             OutlineAction::OutlineAction( const ::basegfx::B2DPoint&                            rStartPoint,
    1618             :                                           const ::basegfx::B2DSize&                             rReliefOffset,
    1619             :                                           const ::Color&                                        rReliefColor,
    1620             :                                           const ::basegfx::B2DSize&                             rShadowOffset,
    1621             :                                           const ::Color&                                        rShadowColor,
    1622             :                                           const ::basegfx::B2DRectangle&                        rOutlineBounds,
    1623             :                                           const uno::Reference< rendering::XPolyPolygon2D >&    rTextPoly,
    1624             :                                           const ::std::vector< sal_Int32 >&                     rPolygonGlyphMap,
    1625             :                                           const uno::Sequence< double >&                        rOffsets,
    1626             :                                           VirtualDevice&                                        rVDev,
    1627             :                                           const CanvasSharedPtr&                                rCanvas,
    1628             :                                           const OutDevState&                                    rState  ) :
    1629             :                 mxTextPoly( rTextPoly ),
    1630             :                 maPolygonGlyphMap( rPolygonGlyphMap ),
    1631             :                 maOffsets( rOffsets ),
    1632             :                 mpCanvas( rCanvas ),
    1633             :                 maState(),
    1634           0 :                 mnOutlineWidth( calcOutlineWidth(rState,rVDev) ),
    1635             :                 maFillColor(
    1636             :                     vcl::unotools::colorToDoubleSequence(
    1637             :                         ::Color( COL_WHITE ),
    1638           0 :                         rCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() )),
    1639             :                 maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ),
    1640             :                 maLinesOverallSize(),
    1641             :                 maOutlineBounds( rOutlineBounds ),
    1642             :                 mxTextLines(),
    1643             :                 maReliefOffset( rReliefOffset ),
    1644             :                 maReliefColor( rReliefColor ),
    1645             :                 maShadowOffset( rShadowOffset ),
    1646           0 :                 maShadowColor( rShadowColor )
    1647             :             {
    1648             :                 initEffectLinePolyPolygon( maLinesOverallSize,
    1649             :                                            mxTextLines,
    1650             :                                            rCanvas,
    1651             :                                            rOffsets,
    1652           0 :                                            maTextLineInfo );
    1653             : 
    1654             :                 init( maState,
    1655             :                       rStartPoint,
    1656             :                       rState,
    1657           0 :                       rCanvas );
    1658           0 :             }
    1659             : 
    1660           0 :             OutlineAction::OutlineAction( const ::basegfx::B2DPoint&                            rStartPoint,
    1661             :                                           const ::basegfx::B2DSize&                             rReliefOffset,
    1662             :                                           const ::Color&                                        rReliefColor,
    1663             :                                           const ::basegfx::B2DSize&                             rShadowOffset,
    1664             :                                           const ::Color&                                        rShadowColor,
    1665             :                                           const ::basegfx::B2DRectangle&                        rOutlineBounds,
    1666             :                                           const uno::Reference< rendering::XPolyPolygon2D >&    rTextPoly,
    1667             :                                           const ::std::vector< sal_Int32 >&                     rPolygonGlyphMap,
    1668             :                                           const uno::Sequence< double >&                        rOffsets,
    1669             :                                           VirtualDevice&                                        rVDev,
    1670             :                                           const CanvasSharedPtr&                                rCanvas,
    1671             :                                           const OutDevState&                                    rState,
    1672             :                                           const ::basegfx::B2DHomMatrix&                        rTextTransform ) :
    1673             :                 mxTextPoly( rTextPoly ),
    1674             :                 maPolygonGlyphMap( rPolygonGlyphMap ),
    1675             :                 maOffsets( rOffsets ),
    1676             :                 mpCanvas( rCanvas ),
    1677             :                 maState(),
    1678           0 :                 mnOutlineWidth( calcOutlineWidth(rState,rVDev) ),
    1679             :                 maFillColor(
    1680             :                     vcl::unotools::colorToDoubleSequence(
    1681             :                         ::Color( COL_WHITE ),
    1682           0 :                         rCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() )),
    1683             :                 maTextLineInfo( tools::createTextLineInfo( rVDev, rState ) ),
    1684             :                 maLinesOverallSize(),
    1685             :                 maOutlineBounds( rOutlineBounds ),
    1686             :                 mxTextLines(),
    1687             :                 maReliefOffset( rReliefOffset ),
    1688             :                 maReliefColor( rReliefColor ),
    1689             :                 maShadowOffset( rShadowOffset ),
    1690           0 :                 maShadowColor( rShadowColor )
    1691             :             {
    1692             :                 initEffectLinePolyPolygon( maLinesOverallSize,
    1693             :                                            mxTextLines,
    1694             :                                            rCanvas,
    1695             :                                            rOffsets,
    1696           0 :                                            maTextLineInfo );
    1697             : 
    1698             :                 init( maState,
    1699             :                       rStartPoint,
    1700             :                       rState,
    1701             :                       rCanvas,
    1702           0 :                       rTextTransform );
    1703           0 :             }
    1704             : 
    1705           0 :             bool OutlineAction::operator()( const rendering::RenderState& rRenderState ) const
    1706             :             {
    1707           0 :                 const rendering::ViewState&                 rViewState( mpCanvas->getViewState() );
    1708           0 :                 const uno::Reference< rendering::XCanvas >& rCanvas( mpCanvas->getUNOCanvas() );
    1709             : 
    1710           0 :                 rendering::StrokeAttributes aStrokeAttributes;
    1711             : 
    1712           0 :                 aStrokeAttributes.StrokeWidth  = mnOutlineWidth;
    1713           0 :                 aStrokeAttributes.MiterLimit   = 1.0;
    1714           0 :                 aStrokeAttributes.StartCapType = rendering::PathCapType::BUTT;
    1715           0 :                 aStrokeAttributes.EndCapType   = rendering::PathCapType::BUTT;
    1716           0 :                 aStrokeAttributes.JoinType     = rendering::PathJoinType::MITER;
    1717             : 
    1718           0 :                 rendering::RenderState aLocalState( rRenderState );
    1719           0 :                 aLocalState.DeviceColor = maFillColor;
    1720             : 
    1721             :                 // TODO(P1): implement caching
    1722             : 
    1723             :                 // background of text
    1724           0 :                 rCanvas->fillPolyPolygon( mxTextPoly,
    1725             :                                           rViewState,
    1726           0 :                                           aLocalState );
    1727             : 
    1728             :                 // border line of text
    1729           0 :                 rCanvas->strokePolyPolygon( mxTextPoly,
    1730             :                                             rViewState,
    1731             :                                             rRenderState,
    1732           0 :                                             aStrokeAttributes );
    1733             : 
    1734             :                 // underlines/strikethrough - background
    1735           0 :                 rCanvas->fillPolyPolygon( mxTextLines,
    1736             :                                           rViewState,
    1737           0 :                                           aLocalState );
    1738             :                 // underlines/strikethrough - border
    1739           0 :                 rCanvas->strokePolyPolygon( mxTextLines,
    1740             :                                             rViewState,
    1741             :                                             rRenderState,
    1742           0 :                                             aStrokeAttributes );
    1743             : 
    1744           0 :                 return true;
    1745             :             }
    1746             : 
    1747           0 :             bool OutlineAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const
    1748             :             {
    1749             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction::render()" );
    1750             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::EffectTextArrayAction: 0x" << std::hex << this );
    1751             : 
    1752           0 :                 rendering::RenderState aLocalState( maState );
    1753           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1754             : 
    1755             :                 return renderEffectText( *this,
    1756             :                                          aLocalState,
    1757           0 :                                          mpCanvas->getViewState(),
    1758           0 :                                          mpCanvas->getUNOCanvas(),
    1759             :                                          maShadowColor,
    1760             :                                          maShadowOffset,
    1761             :                                          maReliefColor,
    1762           0 :                                          maReliefOffset );
    1763             :             }
    1764             : 
    1765             : #if 0 // see #if'ed out use in OutlineAction::renderSubset below:
    1766             :             class OutlineTextArrayRenderHelper : public TextRenderer
    1767             :             {
    1768             :             public:
    1769             :                 OutlineTextArrayRenderHelper( const uno::Reference< rendering::XCanvas >&        rCanvas,
    1770             :                                               const uno::Reference< rendering::XPolyPolygon2D >& rTextPolygon,
    1771             :                                               const uno::Reference< rendering::XPolyPolygon2D >& rLinePolygon,
    1772             :                                               const rendering::ViewState&                        rViewState,
    1773             :                                               double                                             nOutlineWidth ) :
    1774             :                     maFillColor(
    1775             :                         vcl::unotools::colorToDoubleSequence(
    1776             :                             ::Color( COL_WHITE ),
    1777             :                             rCanvas->getDevice()->getDeviceColorSpace() )),
    1778             :                     mnOutlineWidth( nOutlineWidth ),
    1779             :                     mrCanvas( rCanvas ),
    1780             :                     mrTextPolygon( rTextPolygon ),
    1781             :                     mrLinePolygon( rLinePolygon ),
    1782             :                     mrViewState( rViewState )
    1783             :                 {
    1784             :                 }
    1785             : 
    1786             :                 // TextRenderer interface
    1787             :                 virtual bool operator()( const rendering::RenderState& rRenderState ) const
    1788             :                 {
    1789             :                     rendering::StrokeAttributes aStrokeAttributes;
    1790             : 
    1791             :                     aStrokeAttributes.StrokeWidth  = mnOutlineWidth;
    1792             :                     aStrokeAttributes.MiterLimit   = 1.0;
    1793             :                     aStrokeAttributes.StartCapType = rendering::PathCapType::BUTT;
    1794             :                     aStrokeAttributes.EndCapType   = rendering::PathCapType::BUTT;
    1795             :                     aStrokeAttributes.JoinType     = rendering::PathJoinType::MITER;
    1796             : 
    1797             :                     rendering::RenderState aLocalState( rRenderState );
    1798             :                     aLocalState.DeviceColor = maFillColor;
    1799             : 
    1800             :                     // TODO(P1): implement caching
    1801             : 
    1802             :                     // background of text
    1803             :                     mrCanvas->fillPolyPolygon( mrTextPolygon,
    1804             :                                                mrViewState,
    1805             :                                                aLocalState );
    1806             : 
    1807             :                     // border line of text
    1808             :                     mrCanvas->strokePolyPolygon( mrTextPolygon,
    1809             :                                                  mrViewState,
    1810             :                                                  rRenderState,
    1811             :                                                  aStrokeAttributes );
    1812             : 
    1813             :                     // underlines/strikethrough - background
    1814             :                     mrCanvas->fillPolyPolygon( mrLinePolygon,
    1815             :                                                mrViewState,
    1816             :                                                aLocalState );
    1817             :                     // underlines/strikethrough - border
    1818             :                     mrCanvas->strokePolyPolygon( mrLinePolygon,
    1819             :                                                  mrViewState,
    1820             :                                                  rRenderState,
    1821             :                                                  aStrokeAttributes );
    1822             : 
    1823             :                     return true;
    1824             :                 }
    1825             : 
    1826             :             private:
    1827             :                 const uno::Sequence< double >                       maFillColor;
    1828             :                 double                                              mnOutlineWidth;
    1829             :                 const uno::Reference< rendering::XCanvas >&         mrCanvas;
    1830             :                 const uno::Reference< rendering::XPolyPolygon2D >&  mrTextPolygon;
    1831             :                 const uno::Reference< rendering::XPolyPolygon2D >&  mrLinePolygon;
    1832             :                 const rendering::ViewState&                         mrViewState;
    1833             :             };
    1834             : #endif
    1835             : 
    1836           0 :             bool OutlineAction::renderSubset( const ::basegfx::B2DHomMatrix&  rTransformation,
    1837             :                                               const Subset&                   rSubset ) const
    1838             :             {
    1839             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::OutlineAction::renderSubset()" );
    1840             :                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::OutlineAction: 0x" << std::hex << this );
    1841             : 
    1842           0 :                 if( rSubset.mnSubsetBegin == rSubset.mnSubsetEnd )
    1843           0 :                     return true; // empty range, render nothing
    1844             : 
    1845             : #if 1
    1846             :                 // TODO(F3): Subsetting NYI for outline text!
    1847           0 :                 return render( rTransformation );
    1848             : #else
    1849             :                 const rendering::StringContext rOrigContext( mxTextLayout->getText() );
    1850             : 
    1851             :                 if( rSubset.mnSubsetBegin == 0 &&
    1852             :                     rSubset.mnSubsetEnd == rOrigContext.Length )
    1853             :                 {
    1854             :                     // full range, no need for subsetting
    1855             :                     return render( rTransformation );
    1856             :                 }
    1857             : 
    1858             :                 rendering::RenderState aLocalState( maState );
    1859             :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1860             : 
    1861             : 
    1862             :                 // create and setup local Text polygon
    1863             :                 // ===================================
    1864             : 
    1865             :                 uno::Reference< rendering::XPolyPolygon2D > xTextPolygon();
    1866             : 
    1867             :                 // TODO(P3): Provide an API method for that!
    1868             : 
    1869             :                 if( !xTextLayout.is() )
    1870             :                     return false;
    1871             : 
    1872             :                 // render everything
    1873             :                 // =================
    1874             : 
    1875             :                 return renderEffectText(
    1876             :                     OutlineTextArrayRenderHelper(
    1877             :                         xCanvas,
    1878             :                         mnOutlineWidth,
    1879             :                         xTextLayout,
    1880             :                         xTextLines,
    1881             :                         rViewState ),
    1882             :                     aLocalState,
    1883             :                     rViewState,
    1884             :                     xCanvas,
    1885             :                     maShadowColor,
    1886             :                     maShadowOffset,
    1887             :                     maReliefColor,
    1888             :                     maReliefOffset );
    1889             : #endif
    1890             :             }
    1891             : 
    1892           0 :             ::basegfx::B2DRange OutlineAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const
    1893             :             {
    1894           0 :                 rendering::RenderState aLocalState( maState );
    1895           0 :                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
    1896             : 
    1897             :                 return calcEffectTextBounds( maOutlineBounds,
    1898             :                                              ::basegfx::B2DRange( 0,0,
    1899             :                                                                   maLinesOverallSize.getX(),
    1900             :                                                                   maLinesOverallSize.getY() ),
    1901             :                                              maReliefOffset,
    1902             :                                              maShadowOffset,
    1903             :                                              aLocalState,
    1904           0 :                                              mpCanvas->getViewState() );
    1905             :             }
    1906             : 
    1907           0 :             ::basegfx::B2DRange OutlineAction::getBounds( const ::basegfx::B2DHomMatrix&    rTransformation,
    1908             :                                                           const Subset&                     /*rSubset*/ ) const
    1909             :             {
    1910             :                 SAL_WARN( "cppcanvas.emf", "OutlineAction::getBounds(): Subset not yet supported by this object" );
    1911             : 
    1912           0 :                 return getBounds( rTransformation );
    1913             :             }
    1914             : 
    1915           0 :             sal_Int32 OutlineAction::getActionCount() const
    1916             :             {
    1917             :                 // TODO(F3): Subsetting NYI for outline text!
    1918           0 :                 return maOffsets.getLength();
    1919             :             }
    1920             : 
    1921             : 
    1922             : 
    1923             : 
    1924             :             // Action factory methods
    1925             : 
    1926             : 
    1927             : 
    1928             :             /** Create an outline action
    1929             : 
    1930             :                 This method extracts the polygonal outline from the
    1931             :                 text, and creates a properly setup OutlineAction from
    1932             :                 it.
    1933             :              */
    1934           0 :             ActionSharedPtr createOutline( const ::basegfx::B2DPoint&       rStartPoint,
    1935             :                                            const ::basegfx::B2DSize&        rReliefOffset,
    1936             :                                            const ::Color&                   rReliefColor,
    1937             :                                            const ::basegfx::B2DSize&        rShadowOffset,
    1938             :                                            const ::Color&                   rShadowColor,
    1939             :                                            const OUString&                  rText,
    1940             :                                            sal_Int32                        nStartPos,
    1941             :                                            sal_Int32                        nLen,
    1942             :                                            const long*                      pDXArray,
    1943             :                                            VirtualDevice&                   rVDev,
    1944             :                                            const CanvasSharedPtr&           rCanvas,
    1945             :                                            const OutDevState&               rState,
    1946             :                                            const Renderer::Parameters&      rParms  )
    1947             :             {
    1948             :                 // operate on raw DX array here (in logical coordinate
    1949             :                 // system), to have a higher resolution
    1950             :                 // PolyPolygon. That polygon is then converted to
    1951             :                 // device coordinate system.
    1952             : 
    1953             :                 // #i68512# Temporarily switch off font rotation
    1954             :                 // (which is already contained in the render state
    1955             :                 // transformation matrix - otherwise, glyph polygons
    1956             :                 // will be rotated twice)
    1957           0 :                 const vcl::Font aOrigFont( rVDev.GetFont() );
    1958           0 :                 vcl::Font       aUnrotatedFont( aOrigFont );
    1959           0 :                 aUnrotatedFont.SetOrientation(0);
    1960           0 :                 rVDev.SetFont( aUnrotatedFont );
    1961             : 
    1962             :                 // TODO(F3): Don't understand parameter semantics of
    1963             :                 // GetTextOutlines()
    1964           0 :                 ::basegfx::B2DPolyPolygon aResultingPolyPolygon;
    1965           0 :                 PolyPolyVector aVCLPolyPolyVector;
    1966             :                 const bool bHaveOutlines( rVDev.GetTextOutlines( aVCLPolyPolyVector, rText,
    1967             :                                                                  static_cast<sal_uInt16>(nStartPos),
    1968             :                                                                  static_cast<sal_uInt16>(nStartPos),
    1969             :                                                                  static_cast<sal_uInt16>(nLen),
    1970           0 :                                                                  true, 0, pDXArray ) );
    1971           0 :                 rVDev.SetFont(aOrigFont);
    1972             : 
    1973           0 :                 if( !bHaveOutlines )
    1974           0 :                     return ActionSharedPtr();
    1975             : 
    1976           0 :                 ::std::vector< sal_Int32 > aPolygonGlyphMap;
    1977             : 
    1978             :                 // first glyph starts at polygon index 0
    1979           0 :                 aPolygonGlyphMap.push_back( 0 );
    1980             : 
    1981             :                 // remove offsetting from mapmode transformation
    1982             :                 // (outline polygons must stay at origin, only need to
    1983             :                 // be scaled)
    1984             :                 ::basegfx::B2DHomMatrix aMapModeTransform(
    1985           0 :                     rState.mapModeTransform );
    1986           0 :                 aMapModeTransform.set(0,2, 0.0);
    1987           0 :                 aMapModeTransform.set(1,2, 0.0);
    1988             : 
    1989           0 :                 PolyPolyVector::const_iterator       aIter( aVCLPolyPolyVector.begin() );
    1990           0 :                 const PolyPolyVector::const_iterator aEnd( aVCLPolyPolyVector.end() );
    1991           0 :                 for( ; aIter!= aEnd; ++aIter )
    1992             :                 {
    1993           0 :                     ::basegfx::B2DPolyPolygon aPolyPolygon;
    1994             : 
    1995           0 :                     aPolyPolygon = aIter->getB2DPolyPolygon();
    1996           0 :                     aPolyPolygon.transform( aMapModeTransform );
    1997             : 
    1998             :                     // append result to collecting polypoly
    1999           0 :                     for( sal_uInt32 i=0; i<aPolyPolygon.count(); ++i )
    2000             :                     {
    2001             :                         // #i47795# Ensure closed polygons (since
    2002             :                         // FreeType returns the glyph outlines
    2003             :                         // open)
    2004           0 :                         const ::basegfx::B2DPolygon& rPoly( aPolyPolygon.getB2DPolygon( i ) );
    2005           0 :                         const sal_uInt32 nCount( rPoly.count() );
    2006           0 :                         if( nCount<3 ||
    2007           0 :                             rPoly.isClosed() )
    2008             :                         {
    2009             :                             // polygon either degenerate, or
    2010             :                             // already closed.
    2011           0 :                             aResultingPolyPolygon.append( rPoly );
    2012             :                         }
    2013             :                         else
    2014             :                         {
    2015           0 :                             ::basegfx::B2DPolygon aPoly(rPoly);
    2016           0 :                             aPoly.setClosed(true);
    2017             : 
    2018           0 :                             aResultingPolyPolygon.append( aPoly );
    2019             :                         }
    2020           0 :                     }
    2021             : 
    2022             :                     // TODO(F3): Depending on the semantics of
    2023             :                     // GetTextOutlines(), this here is wrong!
    2024             : 
    2025             :                     // calc next glyph index
    2026           0 :                     aPolygonGlyphMap.push_back( aResultingPolyPolygon.count() );
    2027           0 :                 }
    2028             : 
    2029             :                 const uno::Sequence< double > aCharWidthSeq(
    2030             :                     pDXArray ?
    2031             :                     setupDXArray( pDXArray, nLen, rState ) :
    2032             :                     setupDXArray( rText,
    2033             :                                   nStartPos,
    2034             :                                   nLen,
    2035             :                                   rVDev,
    2036           0 :                                   rState ));
    2037             :                 const uno::Reference< rendering::XPolyPolygon2D > xTextPoly(
    2038             :                     ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
    2039           0 :                         rCanvas->getUNOCanvas()->getDevice(),
    2040           0 :                         aResultingPolyPolygon ) );
    2041             : 
    2042           0 :                 if( rParms.maTextTransformation.is_initialized() )
    2043             :                 {
    2044             :                     return ActionSharedPtr(
    2045             :                         new OutlineAction(
    2046             :                             rStartPoint,
    2047             :                             rReliefOffset,
    2048             :                             rReliefColor,
    2049             :                             rShadowOffset,
    2050             :                             rShadowColor,
    2051             :                             ::basegfx::tools::getRange(aResultingPolyPolygon),
    2052             :                             xTextPoly,
    2053             :                             aPolygonGlyphMap,
    2054             :                             aCharWidthSeq,
    2055             :                             rVDev,
    2056             :                             rCanvas,
    2057             :                             rState,
    2058           0 :                             *rParms.maTextTransformation ) );
    2059             :                 }
    2060             :                 else
    2061             :                 {
    2062             :                     return ActionSharedPtr(
    2063             :                         new OutlineAction(
    2064             :                             rStartPoint,
    2065             :                             rReliefOffset,
    2066             :                             rReliefColor,
    2067             :                             rShadowOffset,
    2068             :                             rShadowColor,
    2069             :                             ::basegfx::tools::getRange(aResultingPolyPolygon),
    2070             :                             xTextPoly,
    2071             :                             aPolygonGlyphMap,
    2072             :                             aCharWidthSeq,
    2073             :                             rVDev,
    2074             :                             rCanvas,
    2075           0 :                             rState  ) );
    2076           0 :                 }
    2077             :             }
    2078             : 
    2079             :         } // namespace
    2080             : 
    2081             : 
    2082             : 
    2083             : 
    2084           0 :         ActionSharedPtr TextActionFactory::createTextAction( const ::Point&                 rStartPoint,
    2085             :                                                              const ::Size&                  rReliefOffset,
    2086             :                                                              const ::Color&                 rReliefColor,
    2087             :                                                              const ::Size&                  rShadowOffset,
    2088             :                                                              const ::Color&                 rShadowColor,
    2089             :                                                              const OUString&                rText,
    2090             :                                                              sal_Int32                      nStartPos,
    2091             :                                                              sal_Int32                      nLen,
    2092             :                                                              const long*                    pDXArray,
    2093             :                                                              VirtualDevice&                 rVDev,
    2094             :                                                              const CanvasSharedPtr&         rCanvas,
    2095             :                                                              const OutDevState&             rState,
    2096             :                                                              const Renderer::Parameters&    rParms,
    2097             :                                                              bool                           bSubsettable    )
    2098             :         {
    2099             :             const ::Size  aBaselineOffset( tools::getBaselineOffset( rState,
    2100           0 :                                                                      rVDev ) );
    2101             :             // #143885# maintain (nearly) full precision positioning,
    2102             :             // by circumventing integer-based OutDev-mapping
    2103             :             const ::basegfx::B2DPoint aStartPoint(
    2104             :                 rState.mapModeTransform *
    2105           0 :                 ::basegfx::B2DPoint(rStartPoint.X() + aBaselineOffset.Width(),
    2106           0 :                                     rStartPoint.Y() + aBaselineOffset.Height()) );
    2107             : 
    2108             :             const ::basegfx::B2DSize aReliefOffset(
    2109           0 :                 rState.mapModeTransform * vcl::unotools::b2DSizeFromSize( rReliefOffset ) );
    2110             :             const ::basegfx::B2DSize aShadowOffset(
    2111           0 :                 rState.mapModeTransform * vcl::unotools::b2DSizeFromSize( rShadowOffset ) );
    2112             : 
    2113           0 :             if( rState.isTextOutlineModeSet )
    2114             :             {
    2115             :                 return createOutline(
    2116             :                             aStartPoint,
    2117             :                             aReliefOffset,
    2118             :                             rReliefColor,
    2119             :                             aShadowOffset,
    2120             :                             rShadowColor,
    2121             :                             rText,
    2122             :                             nStartPos,
    2123             :                             nLen,
    2124             :                             pDXArray,
    2125             :                             rVDev,
    2126             :                             rCanvas,
    2127             :                             rState,
    2128           0 :                             rParms );
    2129             :             }
    2130             : 
    2131             :             // convert DX array to device coordinate system (and
    2132             :             // create it in the first place, if pDXArray is NULL)
    2133             :             const uno::Sequence< double > aCharWidths(
    2134             :                 pDXArray ?
    2135             :                 setupDXArray( pDXArray, nLen, rState ) :
    2136             :                 setupDXArray( rText,
    2137             :                               nStartPos,
    2138             :                               nLen,
    2139             :                               rVDev,
    2140           0 :                               rState ));
    2141             : 
    2142             :             // determine type of text action to create
    2143             :             // =======================================
    2144             : 
    2145           0 :             const ::Color aEmptyColor( COL_AUTO );
    2146             : 
    2147           0 :             ActionSharedPtr ret;
    2148             : 
    2149             :             // no DX array, and no need to subset - no need to store
    2150             :             // DX array, then.
    2151           0 :             if( !pDXArray && !bSubsettable )
    2152             :             {
    2153             :                 // effects, or not?
    2154           0 :                 if( !rState.textOverlineStyle &&
    2155           0 :                     !rState.textUnderlineStyle &&
    2156           0 :                     !rState.textStrikeoutStyle &&
    2157           0 :                     rReliefColor == aEmptyColor &&
    2158           0 :                     rShadowColor == aEmptyColor )
    2159             :                 {
    2160             :                     // nope
    2161           0 :                     if( rParms.maTextTransformation.is_initialized() )
    2162             :                     {
    2163           0 :                         ret = ActionSharedPtr( new TextAction(
    2164             :                                                     aStartPoint,
    2165             :                                                     rText,
    2166             :                                                     nStartPos,
    2167             :                                                     nLen,
    2168             :                                                     rCanvas,
    2169             :                                                     rState,
    2170           0 :                                                     *rParms.maTextTransformation ) );
    2171             :                     }
    2172             :                     else
    2173             :                     {
    2174           0 :                         ret = ActionSharedPtr( new TextAction(
    2175             :                                                     aStartPoint,
    2176             :                                                     rText,
    2177             :                                                     nStartPos,
    2178             :                                                     nLen,
    2179             :                                                     rCanvas,
    2180           0 :                                                     rState ) );
    2181             :                     }
    2182             :                 }
    2183             :                 else
    2184             :                 {
    2185             :                     // at least one of the effects requested
    2186           0 :                     if( rParms.maTextTransformation.is_initialized() )
    2187           0 :                         ret = ActionSharedPtr( new EffectTextAction(
    2188             :                                                     aStartPoint,
    2189             :                                                     aReliefOffset,
    2190             :                                                     rReliefColor,
    2191             :                                                     aShadowOffset,
    2192             :                                                     rShadowColor,
    2193             :                                                     rText,
    2194             :                                                     nStartPos,
    2195             :                                                     nLen,
    2196             :                                                     rVDev,
    2197             :                                                     rCanvas,
    2198             :                                                     rState,
    2199           0 :                                                     *rParms.maTextTransformation ) );
    2200             :                     else
    2201           0 :                         ret = ActionSharedPtr( new EffectTextAction(
    2202             :                                                     aStartPoint,
    2203             :                                                     aReliefOffset,
    2204             :                                                     rReliefColor,
    2205             :                                                     aShadowOffset,
    2206             :                                                     rShadowColor,
    2207             :                                                     rText,
    2208             :                                                     nStartPos,
    2209             :                                                     nLen,
    2210             :                                                     rVDev,
    2211             :                                                     rCanvas,
    2212           0 :                                                     rState ) );
    2213             :                 }
    2214             :             }
    2215             :             else
    2216             :             {
    2217             :                 // DX array necessary - any effects?
    2218           0 :                 if( !rState.textOverlineStyle &&
    2219           0 :                     !rState.textUnderlineStyle &&
    2220           0 :                     !rState.textStrikeoutStyle &&
    2221           0 :                     rReliefColor == aEmptyColor &&
    2222           0 :                     rShadowColor == aEmptyColor )
    2223             :                 {
    2224             :                     // nope
    2225           0 :                     if( rParms.maTextTransformation.is_initialized() )
    2226           0 :                         ret = ActionSharedPtr( new TextArrayAction(
    2227             :                                                     aStartPoint,
    2228             :                                                     rText,
    2229             :                                                     nStartPos,
    2230             :                                                     nLen,
    2231             :                                                     aCharWidths,
    2232             :                                                     rCanvas,
    2233             :                                                     rState,
    2234           0 :                                                     *rParms.maTextTransformation ) );
    2235             :                     else
    2236           0 :                         ret = ActionSharedPtr( new TextArrayAction(
    2237             :                                                     aStartPoint,
    2238             :                                                     rText,
    2239             :                                                     nStartPos,
    2240             :                                                     nLen,
    2241             :                                                     aCharWidths,
    2242             :                                                     rCanvas,
    2243           0 :                                                     rState ) );
    2244             :                 }
    2245             :                 else
    2246             :                 {
    2247             :                     // at least one of the effects requested
    2248           0 :                     if( rParms.maTextTransformation.is_initialized() )
    2249           0 :                         ret = ActionSharedPtr( new EffectTextArrayAction(
    2250             :                                                     aStartPoint,
    2251             :                                                     aReliefOffset,
    2252             :                                                     rReliefColor,
    2253             :                                                     aShadowOffset,
    2254             :                                                     rShadowColor,
    2255             :                                                     rText,
    2256             :                                                     nStartPos,
    2257             :                                                     nLen,
    2258             :                                                     aCharWidths,
    2259             :                                                     rVDev,
    2260             :                                                     rCanvas,
    2261             :                                                     rState,
    2262           0 :                                                     *rParms.maTextTransformation ) );
    2263             :                     else
    2264           0 :                         ret = ActionSharedPtr( new EffectTextArrayAction(
    2265             :                                                     aStartPoint,
    2266             :                                                     aReliefOffset,
    2267             :                                                     rReliefColor,
    2268             :                                                     aShadowOffset,
    2269             :                                                     rShadowColor,
    2270             :                                                     rText,
    2271             :                                                     nStartPos,
    2272             :                                                     nLen,
    2273             :                                                     aCharWidths,
    2274             :                                                     rVDev,
    2275             :                                                     rCanvas,
    2276           0 :                                                     rState ) );
    2277             :                 }
    2278             :             }
    2279           0 :             return ret;
    2280             :         }
    2281             :     }
    2282         753 : }
    2283             : 
    2284             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11