svx/source/svdraw/svdotextpathdecomposition.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: svdotextpathdecomposition.cxx,v $
  10  *
  11  * $Revision: 1.2 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_svx.hxx"
  34
  35 #include <svx/svdotext.hxx>
  36 #include <svx/svdoutl.hxx>
  37 #include <basegfx/vector/b2dvector.hxx>
  38 #include <svx/sdr/primitive2d/sdrtextprimitive2d.hxx>
  39 #include <basegfx/range/b2drange.hxx>
  40 #include <vcl/salbtype.hxx>
  41 #include <svtools/itemset.hxx>
  42 #include <basegfx/polygon/b2dpolygontools.hxx>
  43 #include <basegfx/polygon/b2dpolygon.hxx>
  44 #include <algorithm>
  45 #include <svx/xtextit.hxx>
  46 #include <svx/xftshtit.hxx>
  47 #include <vcl/virdev.hxx>
  48 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  49 #include <com/sun/star/i18n/ScriptType.hdl>
  50 #include <com/sun/star/i18n/XBreakIterator.hpp>
  51 #include <comphelper/processfactory.hxx>
  52 #include <com/sun/star/i18n/CharacterIteratorMode.hdl>
  53 #include <unolingu.hxx>
  54 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  55 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  56 #include <basegfx/color/bcolor.hxx>
  57
  58 //////////////////////////////////////////////////////////////////////////////
  59 // primitive decomposition helpers
  60
  61 #include <basegfx/polygon/b2dlinegeometry.hxx>
  62 #include <drawinglayer/attribute/strokeattribute.hxx>
  63 #include <svx/xlnclit.hxx>
  64 #include <svx/xlntrit.hxx>
  65 #include <svx/xlnwtit.hxx>
  66 #include <xlinjoit.hxx>
  67 #include <svx/xlndsit.hxx>
  68 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  69 #include <drawinglayer/primitive2d/unifiedalphaprimitive2d.hxx>
  70 #include <editstat.hxx>
  71 #include <unoapi.hxx>
  72 #include <drawinglayer/geometry/viewinformation2d.hxx>
  73 #include <svx/sdr/attribute/sdrformtextoutlineattribute.hxx>
  74
  75 //////////////////////////////////////////////////////////////////////////////
  76
  77 using namespace ::com::sun::star::uno;
  78 using namespace ::com::sun::star::lang;
  79 using namespace ::com::sun::star::i18n;
  80
  81 //////////////////////////////////////////////////////////////////////////////
  82 // PathTextPortion helper
  83
  84 namespace
  85 {
  86     class impPathTextPortion
  87     {
  88         basegfx::B2DVector                                                      maOffset;
  89         String                                                                          maText;
  90         xub_StrLen                                                                      mnTextStart;
  91         xub_StrLen                                                                      mnTextLength;
  92         sal_uInt16                                                                      mnParagraph;
  93         xub_StrLen                                                                      mnIndex;
  94         SvxFont                                                                         maFont;
  95         ::std::vector< double >                                         maDblDXArray;   // double DXArray, font size independent -> unit coordinate system
  96         ::com::sun::star::lang::Locale                          maLocale;
  97
  98         // bitfield
  99         unsigned                                                                        mbRTL : 1;
 100
 101     public:
 102         impPathTextPortion(DrawPortionInfo& rInfo)
 103         :       maOffset(rInfo.mrStartPos.X(), rInfo.mrStartPos.Y()),
 104             maText(rInfo.mrText),
 105             mnTextStart(rInfo.mnTextStart),
 106             mnTextLength(rInfo.mnTextLen),
 107             mnParagraph(rInfo.mnPara),
 108             mnIndex(rInfo.mnIndex),
 109             maFont(rInfo.mrFont),
 110             maDblDXArray(),
 111             maLocale(rInfo.mpLocale ? *rInfo.mpLocale : ::com::sun::star::lang::Locale()),
 112             mbRTL(rInfo.mrFont.IsVertical() ? false : rInfo.IsRTL())
 113         {
 114             if(mnTextLength)
 115             {
 116                 maDblDXArray.reserve(mnTextLength);
 117                 const sal_Int32 nFontWidth(0L == maFont.GetWidth() ? maFont.GetHeight() : maFont.GetWidth());
 118                 const double fScaleFactor(0L != nFontWidth ? 1.0 / (double)nFontWidth : 1.0);
 119
 120                 for(xub_StrLen a(0); a < mnTextLength; a++)
 121                 {
 122                     maDblDXArray.push_back((double)rInfo.mpDXArray[a] * fScaleFactor);
 123                 }
 124             }
 125         }
 126
 127         // for ::std::sort
 128         bool operator<(const impPathTextPortion& rComp) const
 129         {
 130             if(mnParagraph < rComp.mnParagraph)
 131             {
 132                 return true;
 133             }
 134
 135             if(maOffset.getX() < rComp.maOffset.getX())
 136             {
 137                 return true;
 138             }
 139
 140             return (maOffset.getY() < rComp.maOffset.getY());
 141         }
 142
 143         const basegfx::B2DVector& getOffset() const { return maOffset; }
 144         const String& getText() const { return maText; }
 145         xub_StrLen getTextStart() const { return mnTextStart; }
 146         xub_StrLen getTextLength() const { return mnTextLength; }
 147         sal_uInt16 getParagraph() const { return mnParagraph; }
 148         xub_StrLen getIndex() const { return mnIndex; }
 149         const SvxFont& getFont() const { return maFont; }
 150         bool isRTL() const { return mbRTL; }
 151         const ::std::vector< double >& getDoubleDXArray() const { return maDblDXArray; }
 152         const ::com::sun::star::lang::Locale& getLocale() const { return maLocale; }
 153
 154         xub_StrLen getPortionIndex(xub_StrLen nIndex, xub_StrLen nLength) const
 155         {
 156             if(mbRTL)
 157             {
 158                 return (mnTextStart + (mnTextLength - (nIndex + nLength)));
 159             }
 160             else
 161             {
 162                 return (mnTextStart + nIndex);
 163             }
 164         }
 165
 166         double getDisplayLength(xub_StrLen nIndex, xub_StrLen nLength) const
 167         {
 168             drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 169             double fRetval(0.0);
 170
 171             if(maFont.IsVertical())
 172             {
 173                 fRetval = aTextLayouter.getTextHeight() * (double)nLength;
 174             }
 175             else
 176             {
 177                 fRetval = aTextLayouter.getTextWidth(maText, getPortionIndex(nIndex, nLength), nLength);
 178             }
 179
 180             return fRetval;
 181         }
 182     };
 183 } // end of anonymous namespace
 184
 185 //////////////////////////////////////////////////////////////////////////////
 186 // TextBreakup helper
 187
 188 namespace
 189 {
 190     class impTextBreakupHandler
 191     {
 192         SdrOutliner&                                                            mrOutliner;
 193         ::std::vector< impPathTextPortion >                     maPathTextPortions;
 194
 195         DECL_LINK(decompositionPathTextPrimitive, DrawPortionInfo* );
 196
 197     public:
 198         impTextBreakupHandler(SdrOutliner& rOutliner)
 199         :       mrOutliner(rOutliner)
 200         {
 201         }
 202
 203         const ::std::vector< impPathTextPortion >& decompositionPathTextPrimitive()
 204         {
 205             // strip portions to maPathTextPortions
 206             mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decompositionPathTextPrimitive));
 207             mrOutliner.StripPortions();
 208
 209             if(maPathTextPortions.size())
 210             {
 211                 // sort portions by paragraph, x and y
 212                 ::std::sort(maPathTextPortions.begin(), maPathTextPortions.end());
 213             }
 214
 215             return maPathTextPortions;
 216         }
 217     };
 218
 219     IMPL_LINK(impTextBreakupHandler, decompositionPathTextPrimitive, DrawPortionInfo*, pInfo)
 220     {
 221         maPathTextPortions.push_back(impPathTextPortion(*pInfo));
 222         return 0;
 223     }
 224 } // end of anonymous namespace
 225
 226 //////////////////////////////////////////////////////////////////////////////
 227 // TextBreakup one poly and one paragraph helper
 228
 229 namespace
 230 {
 231     class impPolygonParagraphHandler
 232     {
 233         const drawinglayer::attribute::SdrFormTextAttribute&        mrSdrFormTextAttribute;     // FormText parameters
 234         std::vector< drawinglayer::primitive2d::BasePrimitive2D* >&     mrDecomposition;                // destination primitive list
 235         std::vector< drawinglayer::primitive2d::BasePrimitive2D* >&     mrShadowDecomposition;  // destination primitive list for shadow
 236         Reference < com::sun::star::i18n::XBreakIterator >                      mxBreak;                                // break iterator
 237
 238         double getParagraphTextLength(const ::std::vector< const impPathTextPortion* >& rTextPortions)
 239         {
 240             drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 241             double fRetval(0.0);
 242
 243             for(sal_uInt32 a(0L); a < rTextPortions.size(); a++)
 244             {
 245                 const impPathTextPortion* pCandidate = rTextPortions[a];
 246
 247                 if(pCandidate && pCandidate->getTextLength())
 248                 {
 249                     aTextLayouter.setFont(pCandidate->getFont());
 250                     fRetval += pCandidate->getDisplayLength(0L, pCandidate->getTextLength());
 251                 }
 252             }
 253
 254             return fRetval;
 255         }
 256
 257         xub_StrLen getNextGlyphLen(const impPathTextPortion* pCandidate, xub_StrLen nPosition, const ::com::sun::star::lang::Locale& rFontLocale)
 258         {
 259             xub_StrLen nNextGlyphLen(1);
 260
 261             if(mxBreak.is())
 262             {
 263                 sal_Int32 nDone(0L);
 264                 nNextGlyphLen = (xub_StrLen)mxBreak->nextCharacters(pCandidate->getText(), nPosition,
 265                     rFontLocale, CharacterIteratorMode::SKIPCELL, 1, nDone) - nPosition;
 266             }
 267
 268             return nNextGlyphLen;
 269         }
 270
 271     public:
 272         impPolygonParagraphHandler(
 273             const drawinglayer::attribute::SdrFormTextAttribute& rSdrFormTextAttribute,
 274             std::vector< drawinglayer::primitive2d::BasePrimitive2D* >& rDecomposition,
 275             std::vector< drawinglayer::primitive2d::BasePrimitive2D* >& rShadowDecomposition)
 276         :       mrSdrFormTextAttribute(rSdrFormTextAttribute),
 277             mrDecomposition(rDecomposition),
 278             mrShadowDecomposition(rShadowDecomposition)
 279         {
 280             // prepare BreakIterator
 281             Reference < XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
 282             Reference < XInterface > xInterface = xMSF->createInstance(::rtl::OUString::createFromAscii("com.sun.star.i18n.BreakIterator"));
 283
 284             if(xInterface.is())
 285             {
 286                 Any x = xInterface->queryInterface(::getCppuType((const Reference< XBreakIterator >*)0));
 287                 x >>= mxBreak;
 288             }
 289         }
 290
 291         void HandlePair(const basegfx::B2DPolygon rPolygonCandidate, const ::std::vector< const impPathTextPortion* >& rTextPortions)
 292         {
 293             // prepare polygon geometry, take into account as many parameters as possible
 294             basegfx::B2DPolygon aPolygonCandidate(rPolygonCandidate);
 295             const double fPolyLength(basegfx::tools::getLength(aPolygonCandidate));
 296             double fPolyEnd(fPolyLength);
 297             double fPolyStart(0.0);
 298             double fScaleFactor(1.0);
 299
 300             if(mrSdrFormTextAttribute.getFormTextMirror())
 301             {
 302                 aPolygonCandidate.flip();
 303             }
 304
 305             if(mrSdrFormTextAttribute.getFormTextStart()
 306                 && (XFT_LEFT == mrSdrFormTextAttribute.getFormTextAdjust()
 307                     || XFT_RIGHT == mrSdrFormTextAttribute.getFormTextAdjust()))
 308             {
 309                 if(XFT_LEFT == mrSdrFormTextAttribute.getFormTextAdjust())
 310                 {
 311                     fPolyStart += mrSdrFormTextAttribute.getFormTextStart();
 312
 313                     if(fPolyStart > fPolyEnd)
 314                     {
 315                         fPolyStart = fPolyEnd;
 316                     }
 317                 }
 318                 else
 319                 {
 320                     fPolyEnd -= mrSdrFormTextAttribute.getFormTextStart();
 321
 322                     if(fPolyEnd < fPolyStart)
 323                     {
 324                         fPolyEnd = fPolyStart;
 325                     }
 326                 }
 327             }
 328
 329             if(XFT_LEFT != mrSdrFormTextAttribute.getFormTextAdjust())
 330             {
 331                 // calculate total text length of this paragraph, some layout needs to be done
 332                 const double fParagraphTextLength(getParagraphTextLength(rTextPortions));
 333
 334                 // check if text is too long for paragraph. If yes, handle as if left aligned (default),
 335                 // but still take care of XFT_AUTOSIZE in that case
 336                 const bool bTextTooLong(fParagraphTextLength > (fPolyEnd - fPolyStart));
 337
 338                 if(XFT_RIGHT == mrSdrFormTextAttribute.getFormTextAdjust())
 339                 {
 340                     if(!bTextTooLong)
 341                     {
 342                         // if right aligned, add difference to polygon start
 343                         fPolyStart += ((fPolyEnd - fPolyStart) - fParagraphTextLength);
 344                     }
 345                 }
 346                 else if(XFT_CENTER == mrSdrFormTextAttribute.getFormTextAdjust())
 347                 {
 348                     if(!bTextTooLong)
 349                     {
 350                         // if centered, add half of difference to polygon start
 351                         fPolyStart += ((fPolyEnd - fPolyStart) - fParagraphTextLength) / 2.0;
 352                     }
 353                 }
 354                 else if(XFT_AUTOSIZE == mrSdrFormTextAttribute.getFormTextAdjust())
 355                 {
 356                     // if scale, prepare scale factor between curve length and text length
 357                     if(0.0 != fParagraphTextLength)
 358                     {
 359                         fScaleFactor = (fPolyEnd - fPolyStart) / fParagraphTextLength;
 360                     }
 361                 }
 362             }
 363
 364             // handle text portions for this paragraph
 365             for(sal_uInt32 a(0L); a < rTextPortions.size() && fPolyStart < fPolyEnd; a++)
 366             {
 367                 const impPathTextPortion* pCandidate = rTextPortions[a];
 368                 basegfx::B2DVector aSize;
 369                 const drawinglayer::primitive2d::FontAttributes aCandidateFontAttributes(drawinglayer::primitive2d::getFontAttributesFromVclFont(
 370                     aSize,
 371                     pCandidate->getFont(),
 372                     pCandidate->isRTL(),
 373                     false));
 374
 375                 if(pCandidate && pCandidate->getTextLength())
 376                 {
 377                     drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 378                     aTextLayouter.setFont(pCandidate->getFont());
 379                     xub_StrLen nUsedTextLength(0);
 380
 381                     while(nUsedTextLength < pCandidate->getTextLength() && fPolyStart < fPolyEnd)
 382                     {
 383                         xub_StrLen nNextGlyphLen(getNextGlyphLen(pCandidate, pCandidate->getTextStart() + nUsedTextLength, pCandidate->getLocale()));
 384
 385                         // prepare portion length. Takes RTL sections into account.
 386                         double fPortionLength(pCandidate->getDisplayLength(nUsedTextLength, nNextGlyphLen));
 387
 388                         if(XFT_AUTOSIZE == mrSdrFormTextAttribute.getFormTextAdjust())
 389                         {
 390                             // when scaling, expand portion length
 391                             fPortionLength *= fScaleFactor;
 392                         }
 393
 394                         // create transformation
 395                         basegfx::B2DHomMatrix aNewTransformA, aNewTransformB, aNewShadowTransform;
 396                         basegfx::B2DPoint aStartPos(basegfx::tools::getPositionAbsolute(aPolygonCandidate, fPolyStart, fPolyLength));
 397                         basegfx::B2DPoint aEndPos(aStartPos);
 398
 399                         // add font scaling
 400                         aNewTransformA.scale(aSize.getX(), aSize.getY());
 401
 402                         // prepare scaling of text primitive
 403                         if(XFT_AUTOSIZE == mrSdrFormTextAttribute.getFormTextAdjust())
 404                         {
 405                             // when scaling, expand text primitive scaling
 406                             aNewTransformA.scale(fScaleFactor, fScaleFactor);
 407                         }
 408
 409                         // eventually create shadow primitives from aDecomposition and add to rDecomposition
 410                         const bool bShadow(XFTSHADOW_NONE != mrSdrFormTextAttribute.getFormTextShadow());
 411
 412                         if(bShadow)
 413                         {
 414                             if(XFTSHADOW_NORMAL == mrSdrFormTextAttribute.getFormTextShadow())
 415                             {
 416                                 aNewShadowTransform.translate(
 417                                     mrSdrFormTextAttribute.getFormTextShdwXVal(),
 418                                     -mrSdrFormTextAttribute.getFormTextShdwYVal());
 419                             }
 420                             else // XFTSHADOW_SLANT
 421                             {
 422                                 double fScaleValue(mrSdrFormTextAttribute.getFormTextShdwYVal() / 100.0);
 423                                 double fShearValue(-mrSdrFormTextAttribute.getFormTextShdwXVal() * F_PI1800);
 424
 425                                 aNewShadowTransform.scale(1.0, fScaleValue);
 426                                 aNewShadowTransform.shearX(sin(fShearValue));
 427                                 aNewShadowTransform.scale(1.0, cos(fShearValue));
 428                             }
 429                         }
 430
 431                         switch(mrSdrFormTextAttribute.getFormTextStyle())
 432                         {
 433                             case XFT_ROTATE :
 434                             {
 435                                 aEndPos = basegfx::tools::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 436                                 const basegfx::B2DVector aDirection(aEndPos - aStartPos);
 437                                 aNewTransformB.rotate(atan2(aDirection.getY(), aDirection.getX()));
 438                                 aNewTransformB.translate(aStartPos.getX(), aStartPos.getY());
 439
 440                                 break;
 441                             }
 442                             case XFT_UPRIGHT :
 443                             {
 444                                 aNewTransformB.translate(aStartPos.getX() - (fPortionLength / 2.0), aStartPos.getY());
 445
 446                                 break;
 447                             }
 448                             case XFT_SLANTX :
 449                             {
 450                                 aEndPos = basegfx::tools::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 451                                 const basegfx::B2DVector aDirection(aEndPos - aStartPos);
 452                                 const double fShearValue(atan2(aDirection.getY(), aDirection.getX()));
 453                                 const double fSin(sin(fShearValue));
 454                                 const double fCos(cos(fShearValue));
 455
 456                                    aNewTransformB.shearX(-fSin);
 457
 458                                 // Scale may lead to objects without height since fCos == 0.0 is possible.
 459                                 // Renderers need to handle that, it's not a forbidden value and does not
 460                                 // need to be avoided
 461                                 aNewTransformB.scale(1.0, fCos);
 462                                 aNewTransformB.translate(aStartPos.getX() - (fPortionLength / 2.0), aStartPos.getY());
 463
 464                                 break;
 465                             }
 466                             case XFT_SLANTY :
 467                             {
 468                                 aEndPos = basegfx::tools::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 469                                 const basegfx::B2DVector aDirection(aEndPos - aStartPos);
 470                                 const double fShearValue(atan2(aDirection.getY(), aDirection.getX()));
 471                                 const double fCos(cos(fShearValue));
 472                                 const double fTan(tan(fShearValue));
 473
 474                                 // shear to 'stand' on the curve
 475                                 aNewTransformB.shearY(fTan);
 476
 477                                 // scale in X to make as tight as needed. As with XFT_SLANT_X, this may
 478                                 // lead to primitives without width which the renderers will handle
 479                                    aNewTransformA.scale(fCos, 1.0);
 480
 481                                 aNewTransformB.translate(aStartPos.getX(), aStartPos.getY());
 482
 483                                 break;
 484                             }
 485                             default : break; // XFT_NONE
 486                         }
 487
 488                         // distance from path?
 489                         if(mrSdrFormTextAttribute.getFormTextDistance())
 490                         {
 491                             if(aEndPos.equal(aStartPos))
 492                             {
 493                                 aEndPos = basegfx::tools::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 494                             }
 495
 496                             // use back vector (aStartPos - aEndPos) here to get mirrored perpendicular as in old stuff
 497                             const basegfx::B2DVector aPerpendicular(
 498                                 basegfx::getNormalizedPerpendicular(aStartPos - aEndPos) *
 499                                 mrSdrFormTextAttribute.getFormTextDistance());
 500                             aNewTransformB.translate(aPerpendicular.getX(), aPerpendicular.getY());
 501                         }
 502
 503                         // shadow primitive creation
 504                         if(bShadow)
 505                         {
 506                             if(pCandidate->getText().Len() && nNextGlyphLen)
 507                             {
 508                                 const Color aShadowColor(mrSdrFormTextAttribute.getFormTextShdwColor());
 509                                 const basegfx::BColor aRGBShadowColor(aShadowColor.getBColor());
 510                                 const xub_StrLen nPortionIndex(pCandidate->getPortionIndex(nUsedTextLength, nNextGlyphLen));
 511                                 const ::std::vector< double > aNewDXArray(
 512                                     pCandidate->getDoubleDXArray().begin() + nPortionIndex,
 513                                     pCandidate->getDoubleDXArray().begin() + nPortionIndex + nNextGlyphLen);
 514
 515                                 drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pNew = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 516                                     aNewTransformB * aNewShadowTransform * aNewTransformA,
 517                                     pCandidate->getText(),
 518                                     nPortionIndex,
 519                                     nNextGlyphLen,
 520                                     aNewDXArray,
 521                                     aCandidateFontAttributes,
 522                                     pCandidate->getLocale(),
 523                                     aRGBShadowColor);
 524
 525                                 mrShadowDecomposition.push_back(pNew);
 526                             }
 527                         }
 528
 529                         // primitive creation
 530                         if(pCandidate->getText().Len() && nNextGlyphLen)
 531                         {
 532                             const Color aColor(pCandidate->getFont().GetColor());
 533                             const basegfx::BColor aRGBColor(aColor.getBColor());
 534                             const xub_StrLen nPortionIndex(pCandidate->getPortionIndex(nUsedTextLength, nNextGlyphLen));
 535                             const ::std::vector< double > aNewDXArray(
 536                                 pCandidate->getDoubleDXArray().begin() + nPortionIndex,
 537                                 pCandidate->getDoubleDXArray().begin() + nPortionIndex + nNextGlyphLen);
 538
 539                             drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pNew = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 540                                 aNewTransformB * aNewTransformA,
 541                                 pCandidate->getText(),
 542                                 nPortionIndex,
 543                                 nNextGlyphLen,
 544                                 aNewDXArray,
 545                                 aCandidateFontAttributes,
 546                                 pCandidate->getLocale(),
 547                                 aRGBColor);
 548
 549                             mrDecomposition.push_back(pNew);
 550                         }
 551
 552                         // consume from portion // no += here, xub_StrLen is USHORT and the compiler will gererate a warning here
 553                         nUsedTextLength = nUsedTextLength + nNextGlyphLen;
 554
 555                         // consume from polygon
 556                         fPolyStart += fPortionLength;
 557                     }
 558                 }
 559             }
 560         }
 561     };
 562 } // end of anonymous namespace
 563
 564 //////////////////////////////////////////////////////////////////////////////
 565 // primitive decomposition helpers
 566
 567 namespace
 568 {
 569     void impAddPolygonStrokePrimitives(
 570         const basegfx::B2DPolyPolygonVector& rB2DPolyPolyVector,
 571         const basegfx::B2DHomMatrix& rTransform,
 572         const drawinglayer::attribute::LineAttribute& rLineAttribute,
 573         const drawinglayer::attribute::StrokeAttribute& rStrokeAttribute,
 574         std::vector< drawinglayer::primitive2d::BasePrimitive2D* >& rTarget)
 575     {
 576         for(basegfx::B2DPolyPolygonVector::const_iterator aPolygon(rB2DPolyPolyVector.begin()); aPolygon != rB2DPolyPolyVector.end(); aPolygon++)
 577         {
 578             // prepare PolyPolygons
 579             basegfx::B2DPolyPolygon aB2DPolyPolygon = *aPolygon;
 580             aB2DPolyPolygon.transform(rTransform);
 581
 582             for(sal_uInt32 a(0L); a < aB2DPolyPolygon.count(); a++)
 583             {
 584                 // create one primitive per polygon
 585                 drawinglayer::primitive2d::PolygonStrokePrimitive2D* pNew =
 586                     new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
 587                         aB2DPolyPolygon.getB2DPolygon(a), rLineAttribute, rStrokeAttribute);
 588                 rTarget.push_back(pNew);
 589             }
 590         }
 591     }
 592
 593     drawinglayer::primitive2d::Primitive2DSequence impAddPathTextOutlines(
 594         const std::vector< drawinglayer::primitive2d::BasePrimitive2D* >& rSource,
 595         const drawinglayer::attribute::SdrFormTextOutlineAttribute& rOutlineAttribute)
 596     {
 597         std::vector< drawinglayer::primitive2d::BasePrimitive2D* > aNewPrimitives;
 598
 599         for(sal_uInt32 a(0L); a < rSource.size(); a++)
 600         {
 601             const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pTextCandidate = dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(rSource[a]);
 602
 603             if(pTextCandidate)
 604             {
 605                 basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
 606                 basegfx::B2DHomMatrix aPolygonTransform;
 607
 608                 // get text outlines and their object transformation
 609                 pTextCandidate->getTextOutlinesAndTransformation(aB2DPolyPolyVector, aPolygonTransform);
 610
 611                 if(aB2DPolyPolyVector.size())
 612                 {
 613                     // create stroke primitives
 614                     std::vector< drawinglayer::primitive2d::BasePrimitive2D* > aStrokePrimitives;
 615                     impAddPolygonStrokePrimitives(
 616                         aB2DPolyPolyVector,
 617                         aPolygonTransform,
 618                         rOutlineAttribute.getLineAttribute(),
 619                         rOutlineAttribute.getStrokeAttribute(),
 620                         aStrokePrimitives);
 621                     const sal_uInt32 nStrokeCount(aStrokePrimitives.size());
 622
 623                     if(nStrokeCount)
 624                     {
 625                         if(rOutlineAttribute.getTransparence())
 626                         {
 627                             // create UnifiedAlphaPrimitive2D
 628                             drawinglayer::primitive2d::Primitive2DSequence aStrokePrimitiveSequence(nStrokeCount);
 629
 630                             for(sal_uInt32 b(0L); b < nStrokeCount; b++)
 631                             {
 632                                 aStrokePrimitiveSequence[b] = drawinglayer::primitive2d::Primitive2DReference(aStrokePrimitives[b]);
 633                             }
 634
 635                             drawinglayer::primitive2d::UnifiedAlphaPrimitive2D* pNew2 =
 636                                 new drawinglayer::primitive2d::UnifiedAlphaPrimitive2D(
 637                                     aStrokePrimitiveSequence,
 638                                     (double)rOutlineAttribute.getTransparence() / 100.0);
 639                             aNewPrimitives.push_back(pNew2);
 640                         }
 641                         else
 642                         {
 643                             // add polygons to rDecomposition as polygonStrokePrimitives
 644                             aNewPrimitives.insert(aNewPrimitives.end(), aStrokePrimitives.begin(), aStrokePrimitives.end());
 645                         }
 646                     }
 647                 }
 648             }
 649         }
 650
 651         const sal_uInt32 nNewCount(aNewPrimitives.size());
 652
 653         if(nNewCount)
 654         {
 655             drawinglayer::primitive2d::Primitive2DSequence aRetval(nNewCount);
 656
 657             for(sal_uInt32 a(0L); a < nNewCount; a++)
 658             {
 659                 aRetval[a] = drawinglayer::primitive2d::Primitive2DReference(aNewPrimitives[a]);
 660             }
 661
 662             return aRetval;
 663         }
 664         else
 665         {
 666             return drawinglayer::primitive2d::Primitive2DSequence();
 667         }
 668     }
 669 } // end of anonymous namespace
 670
 671 //////////////////////////////////////////////////////////////////////////////
 672 // primitive decomposition
 673
 674 bool SdrTextObj::impDecomposePathTextPrimitive(
 675     drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 676     const drawinglayer::primitive2d::SdrPathTextPrimitive2D& rSdrPathTextPrimitive,
 677     const drawinglayer::geometry::ViewInformation2D& aViewInformation) const
 678 {
 679     drawinglayer::primitive2d::Primitive2DSequence aRetvalA;
 680     drawinglayer::primitive2d::Primitive2DSequence aRetvalB;
 681
 682     // prepare outliner
 683     SdrOutliner& rOutliner = ImpGetDrawOutliner();
 684     rOutliner.SetUpdateMode(true);
 685     rOutliner.Clear();
 686     rOutliner.SetPaperSize(Size(LONG_MAX,LONG_MAX));
 687     rOutliner.SetText(rSdrPathTextPrimitive.getOutlinerParaObject());
 688
 689     // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition
 690     rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage()));
 691
 692     // now break up to text portions
 693     impTextBreakupHandler aConverter(rOutliner);
 694     const ::std::vector< impPathTextPortion > rPathTextPortions = aConverter.decompositionPathTextPrimitive();
 695
 696     if(rPathTextPortions.size())
 697     {
 698         // get FormText and polygon values
 699         const drawinglayer::attribute::SdrFormTextAttribute& rFormTextAttribute = rSdrPathTextPrimitive.getSdrFormTextAttribute();
 700         const basegfx::B2DPolyPolygon& rPathPolyPolygon(rSdrPathTextPrimitive.getPathPolyPolygon());
 701
 702         // get loop count
 703         sal_uInt32 nLoopCount(rPathPolyPolygon.count());
 704
 705         if(rOutliner.GetParagraphCount() < nLoopCount)
 706         {
 707             nLoopCount = rOutliner.GetParagraphCount();
 708         }
 709
 710         if(nLoopCount)
 711         {
 712             // prepare common decomposition stuff
 713             std::vector< drawinglayer::primitive2d::BasePrimitive2D* > aRegularDecomposition;
 714             std::vector< drawinglayer::primitive2d::BasePrimitive2D* > aShadowDecomposition;
 715             impPolygonParagraphHandler aPolygonParagraphHandler(
 716                 rFormTextAttribute, aRegularDecomposition, aShadowDecomposition);
 717             sal_uInt32 a;
 718
 719             for(a = 0L; a < nLoopCount; a++)
 720             {
 721                 // filter text portions for this paragraph
 722                 ::std::vector< const impPathTextPortion* > aParagraphTextPortions;
 723
 724                 for(sal_uInt32 b(0L); b < rPathTextPortions.size(); b++)
 725                 {
 726                     const impPathTextPortion& rCandidate = rPathTextPortions[b];
 727
 728                     if(rCandidate.getParagraph() == a)
 729                     {
 730                         aParagraphTextPortions.push_back(&rCandidate);
 731                     }
 732                 }
 733
 734                 // handle data pair polygon/ParagraphTextPortions
 735                 if(aParagraphTextPortions.size())
 736                 {
 737                     aPolygonParagraphHandler.HandlePair(rPathPolyPolygon.getB2DPolygon(a), aParagraphTextPortions);
 738                 }
 739             }
 740
 741             const sal_uInt32 nShadowCount(aShadowDecomposition.size());
 742             const sal_uInt32 nRegularCount(aRegularDecomposition.size());
 743
 744             if(nShadowCount)
 745             {
 746                 // add shadow primitives to decomposition
 747                 aRetvalA.realloc(nShadowCount);
 748
 749                 for(a = 0L; a < nShadowCount; a++)
 750                 {
 751                     aRetvalA[a] = drawinglayer::primitive2d::Primitive2DReference(aShadowDecomposition[a]);
 752                 }
 753
 754                 // evtl. add shadow outlines
 755                 if(rFormTextAttribute.getFormTextOutline() && rFormTextAttribute.getShadowOutline())
 756                 {
 757                     const drawinglayer::primitive2d::Primitive2DSequence aOutlines(
 758                         impAddPathTextOutlines(aShadowDecomposition, *rFormTextAttribute.getShadowOutline()));
 759                     drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(aRetvalA, aOutlines);
 760                 }
 761             }
 762
 763             if(nRegularCount)
 764             {
 765                 // add normal primitives to decomposition
 766                 aRetvalB.realloc(nRegularCount);
 767
 768                 for(a = 0L; a < nRegularCount; a++)
 769                 {
 770                     aRetvalB[a] = drawinglayer::primitive2d::Primitive2DReference(aRegularDecomposition[a]);
 771                 }
 772
 773                 // evtl. add outlines
 774                 if(rFormTextAttribute.getFormTextOutline() && rFormTextAttribute.getOutline())
 775                 {
 776                     const drawinglayer::primitive2d::Primitive2DSequence aOutlines(
 777                         impAddPathTextOutlines(aRegularDecomposition, *rFormTextAttribute.getOutline()));
 778                     drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(aRetvalB, aOutlines);
 779                 }
 780             }
 781         }
 782     }
 783
 784     // cleanup outliner
 785     rOutliner.SetDrawPortionHdl(Link());
 786     rOutliner.Clear();
 787     rOutliner.setVisualizedPage(0);
 788
 789     // concatenate all results
 790     drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aRetvalA);
 791     drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aRetvalB);
 792
 793     return false;
 794 }
 795
 796 //////////////////////////////////////////////////////////////////////////////
 797 // eof