svx/source/svdraw/svdotextpathdecomposition.cxx

   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 #include <sal/config.h>
  21
  22 #include <o3tl/safeint.hxx>
  23 #include <svx/svdotext.hxx>
  24 #include <svx/svdoutl.hxx>
  25 #include <basegfx/vector/b2dvector.hxx>
  26 #include <sdr/primitive2d/sdrtextprimitive2d.hxx>
  27 #include <basegfx/polygon/b2dpolygontools.hxx>
  28 #include <basegfx/polygon/b2dpolygon.hxx>
  29 #include <algorithm>
  30 #include <com/sun/star/i18n/BreakIterator.hpp>
  31 #include <comphelper/processfactory.hxx>
  32 #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
  33 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  34 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  35 #include <basegfx/color/bcolor.hxx>
  36
  37 // primitive decomposition helpers
  38 #include <drawinglayer/attribute/strokeattribute.hxx>
  39 #include <drawinglayer/primitive2d/PolygonStrokePrimitive2D.hxx>
  40 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
  41 #include <svx/unoapi.hxx>
  42 #include <drawinglayer/geometry/viewinformation2d.hxx>
  43 #include <sdr/attribute/sdrformtextoutlineattribute.hxx>
  44 #include <utility>
  45
  46 using namespace com::sun::star;
  47
  48 // PathTextPortion helper
  49
  50 namespace
  51 {
  52     class impPathTextPortion
  53     {
  54         basegfx::B2DVector                          maOffset;
  55         OUString                                    maText;
  56         sal_Int32                                   mnTextStart;
  57         sal_Int32                                   mnTextLength;
  58         sal_Int32                                   mnParagraph;
  59         SvxFont                                     maFont;
  60         ::std::vector< double >                     maDblDXArray;   // double DXArray, font size independent -> unit coordinate system
  61         ::std::vector< sal_Bool >                   maKashidaArray;
  62         lang::Locale                           maLocale;
  63
  64         bool                                        mbRTL : 1;
  65
  66     public:
  67         explicit impPathTextPortion(const DrawPortionInfo& rInfo)
  68         :   maOffset(rInfo.mrStartPos.X(), rInfo.mrStartPos.Y()),
  69             maText(rInfo.maText),
  70             mnTextStart(rInfo.mnTextStart),
  71             mnTextLength(rInfo.mnTextLen),
  72             mnParagraph(rInfo.mnPara),
  73             maFont(rInfo.mrFont),
  74             maKashidaArray(rInfo.mpKashidaArray.begin(), rInfo.mpKashidaArray.end()),
  75             maLocale(rInfo.mpLocale ? *rInfo.mpLocale : lang::Locale()),
  76             mbRTL(!rInfo.mrFont.IsVertical() && rInfo.IsRTL())
  77         {
  78             if(mnTextLength && !rInfo.mpDXArray.empty())
  79             {
  80                 maDblDXArray.reserve(mnTextLength);
  81
  82                 for(sal_Int32 a=0; a < mnTextLength; a++)
  83                 {
  84                     maDblDXArray.push_back(rInfo.mpDXArray[a]);
  85                 }
  86             }
  87         }
  88
  89         // for ::std::sort
  90         bool operator<(const impPathTextPortion& rComp) const
  91         {
  92             if(mnParagraph < rComp.mnParagraph)
  93             {
  94                 return true;
  95             }
  96
  97             if(maOffset.getX() < rComp.maOffset.getX())
  98             {
  99                 return true;
 100             }
 101
 102             return (maOffset.getY() < rComp.maOffset.getY());
 103         }
 104
 105         const OUString& getText() const { return maText; }
 106         sal_Int32 getTextStart() const { return mnTextStart; }
 107         sal_Int32 getTextLength() const { return mnTextLength; }
 108         sal_Int32 getParagraph() const { return mnParagraph; }
 109         const SvxFont& getFont() const { return maFont; }
 110         bool isRTL() const { return mbRTL; }
 111         const ::std::vector< double >& getDoubleDXArray() const { return maDblDXArray; }
 112         const ::std::vector< sal_Bool >& getKashidaArray() const { return maKashidaArray; }
 113         const lang::Locale& getLocale() const { return maLocale; }
 114
 115         sal_Int32 getPortionIndex(sal_Int32 nIndex, sal_Int32 nLength) const
 116         {
 117             if(mbRTL)
 118             {
 119                 return (mnTextStart + (mnTextLength - (nIndex + nLength)));
 120             }
 121             else
 122             {
 123                 return (mnTextStart + nIndex);
 124             }
 125         }
 126
 127         double getDisplayLength(sal_Int32 nIndex, sal_Int32 nLength) const
 128         {
 129             drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 130             double fRetval(0.0);
 131
 132             if(maFont.IsVertical())
 133             {
 134                 fRetval = aTextLayouter.getTextHeight() * static_cast<double>(nLength);
 135             }
 136             else
 137             {
 138                 fRetval = aTextLayouter.getTextWidth(maText, getPortionIndex(nIndex, nLength), nLength);
 139             }
 140
 141             return fRetval;
 142         }
 143     };
 144 } // end of anonymous namespace
 145
 146
 147 // TextBreakup helper
 148
 149 namespace
 150 {
 151     class impTextBreakupHandler
 152     {
 153         SdrOutliner&                                mrOutliner;
 154         ::std::vector< impPathTextPortion >         maPathTextPortions;
 155
 156         DECL_LINK(decompositionPathTextPrimitive, DrawPortionInfo*, void );
 157
 158     public:
 159         explicit impTextBreakupHandler(SdrOutliner& rOutliner)
 160         :   mrOutliner(rOutliner)
 161         {
 162         }
 163
 164         const ::std::vector< impPathTextPortion >& decompositionPathTextPrimitive()
 165         {
 166             // strip portions to maPathTextPortions
 167             mrOutliner.SetDrawPortionHdl(LINK(this, impTextBreakupHandler, decompositionPathTextPrimitive));
 168             mrOutliner.StripPortions();
 169
 170             if(!maPathTextPortions.empty())
 171             {
 172                 // sort portions by paragraph, x and y
 173                 ::std::sort(maPathTextPortions.begin(), maPathTextPortions.end());
 174             }
 175
 176             return maPathTextPortions;
 177         }
 178     };
 179
 180     IMPL_LINK(impTextBreakupHandler, decompositionPathTextPrimitive, DrawPortionInfo*, pInfo, void)
 181     {
 182         maPathTextPortions.emplace_back(*pInfo);
 183     }
 184 } // end of anonymous namespace
 185
 186
 187 // TextBreakup one poly and one paragraph helper
 188
 189 namespace
 190 {
 191     class impPolygonParagraphHandler
 192     {
 193         const drawinglayer::attribute::SdrFormTextAttribute         maSdrFormTextAttribute; // FormText parameters
 194         drawinglayer::primitive2d::Primitive2DContainer&            mrDecomposition;        // destination primitive list
 195         drawinglayer::primitive2d::Primitive2DContainer&            mrShadowDecomposition;  // destination primitive list for shadow
 196         uno::Reference<i18n::XBreakIterator>                     mxBreak;                // break iterator
 197
 198         static double getParagraphTextLength(const ::std::vector< const impPathTextPortion* >& rTextPortions)
 199         {
 200             drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 201             double fRetval(0.0);
 202
 203             for(const impPathTextPortion* pCandidate : rTextPortions)
 204             {
 205                 if(pCandidate && pCandidate->getTextLength())
 206                 {
 207                     aTextLayouter.setFont(pCandidate->getFont());
 208                     fRetval += pCandidate->getDisplayLength(0, pCandidate->getTextLength());
 209                 }
 210             }
 211
 212             return fRetval;
 213         }
 214
 215         sal_Int32 getNextGlyphLen(const impPathTextPortion* pCandidate, sal_Int32 nPosition, const lang::Locale& rFontLocale)
 216         {
 217             sal_Int32 nNextGlyphLen(1);
 218
 219             if(mxBreak.is())
 220             {
 221                 sal_Int32 nDone(0);
 222                 nNextGlyphLen = mxBreak->nextCharacters(pCandidate->getText(), nPosition,
 223                     rFontLocale, i18n::CharacterIteratorMode::SKIPCELL, 1, nDone) - nPosition;
 224             }
 225
 226             return nNextGlyphLen;
 227         }
 228
 229     public:
 230         impPolygonParagraphHandler(
 231             drawinglayer::attribute::SdrFormTextAttribute aSdrFormTextAttribute,
 232             drawinglayer::primitive2d::Primitive2DContainer& rDecomposition,
 233             drawinglayer::primitive2d::Primitive2DContainer& rShadowDecomposition)
 234         :   maSdrFormTextAttribute(std::move(aSdrFormTextAttribute)),
 235             mrDecomposition(rDecomposition),
 236             mrShadowDecomposition(rShadowDecomposition)
 237         {
 238             // prepare BreakIterator
 239             const uno::Reference<uno::XComponentContext>& xContext = ::comphelper::getProcessComponentContext();
 240             mxBreak = i18n::BreakIterator::create(xContext);
 241         }
 242
 243         void HandlePair(const basegfx::B2DPolygon& rPolygonCandidate, const ::std::vector< const impPathTextPortion* >& rTextPortions)
 244         {
 245             // prepare polygon geometry, take into account as many parameters as possible
 246             basegfx::B2DPolygon aPolygonCandidate(rPolygonCandidate);
 247             const double fPolyLength(basegfx::utils::getLength(aPolygonCandidate));
 248             double fPolyEnd(fPolyLength);
 249             double fPolyStart(0.0);
 250             double fAutosizeScaleFactor(1.0);
 251             bool bAutosizeScale(false);
 252
 253             if(maSdrFormTextAttribute.getFormTextMirror())
 254             {
 255                 aPolygonCandidate.flip();
 256             }
 257
 258             if(maSdrFormTextAttribute.getFormTextStart()
 259                 && (XFormTextAdjust::Left == maSdrFormTextAttribute.getFormTextAdjust()
 260                     || XFormTextAdjust::Right == maSdrFormTextAttribute.getFormTextAdjust()))
 261             {
 262                 if(XFormTextAdjust::Left == maSdrFormTextAttribute.getFormTextAdjust())
 263                 {
 264                     fPolyStart += maSdrFormTextAttribute.getFormTextStart();
 265
 266                     if(fPolyStart > fPolyEnd)
 267                     {
 268                         fPolyStart = fPolyEnd;
 269                     }
 270                 }
 271                 else
 272                 {
 273                     fPolyEnd -= maSdrFormTextAttribute.getFormTextStart();
 274
 275                     if(fPolyEnd < fPolyStart)
 276                     {
 277                         fPolyEnd = fPolyStart;
 278                     }
 279                 }
 280             }
 281
 282             if(XFormTextAdjust::Left != maSdrFormTextAttribute.getFormTextAdjust())
 283             {
 284                 // calculate total text length of this paragraph, some layout needs to be done
 285                 const double fParagraphTextLength(getParagraphTextLength(rTextPortions));
 286
 287                 // check if text is too long for paragraph. If yes, handle as if left aligned (default),
 288                 // but still take care of XFormTextAdjust::AutoSize in that case
 289                 const bool bTextTooLong(fParagraphTextLength > (fPolyEnd - fPolyStart));
 290
 291                 if(XFormTextAdjust::Right == maSdrFormTextAttribute.getFormTextAdjust())
 292                 {
 293                     if(!bTextTooLong)
 294                     {
 295                         // if right aligned, add difference to polygon start
 296                         fPolyStart += ((fPolyEnd - fPolyStart) - fParagraphTextLength);
 297                     }
 298                 }
 299                 else if(XFormTextAdjust::Center == maSdrFormTextAttribute.getFormTextAdjust())
 300                 {
 301                     if(!bTextTooLong)
 302                     {
 303                         // if centered, add half of difference to polygon start
 304                         fPolyStart += ((fPolyEnd - fPolyStart) - fParagraphTextLength) / 2.0;
 305                     }
 306                 }
 307                 else if(XFormTextAdjust::AutoSize == maSdrFormTextAttribute.getFormTextAdjust())
 308                 {
 309                     // if scale, prepare scale factor between curve length and text length
 310                     if(0.0 != fParagraphTextLength)
 311                     {
 312                         fAutosizeScaleFactor = (fPolyEnd - fPolyStart) / fParagraphTextLength;
 313                         bAutosizeScale = true;
 314                     }
 315                 }
 316             }
 317
 318             // handle text portions for this paragraph
 319             for(auto a = rTextPortions.begin(); a != rTextPortions.end() && fPolyStart < fPolyEnd; ++a)
 320             {
 321                 const impPathTextPortion* pCandidate = *a;
 322                 basegfx::B2DVector aFontScaling;
 323
 324                 if(pCandidate && pCandidate->getTextLength())
 325                 {
 326                     const drawinglayer::attribute::FontAttribute aCandidateFontAttribute(
 327                         drawinglayer::primitive2d::getFontAttributeFromVclFont(
 328                             aFontScaling,
 329                             pCandidate->getFont(),
 330                             pCandidate->isRTL(),
 331                             false));
 332
 333                     drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 334                     aTextLayouter.setFont(pCandidate->getFont());
 335                     sal_Int32 nUsedTextLength(0);
 336
 337                     while(nUsedTextLength < pCandidate->getTextLength() && fPolyStart < fPolyEnd)
 338                     {
 339                         sal_Int32 nNextGlyphLen(getNextGlyphLen(pCandidate, pCandidate->getTextStart() + nUsedTextLength, pCandidate->getLocale()));
 340
 341                         // prepare portion length. Takes RTL sections into account.
 342                         double fPortionLength(pCandidate->getDisplayLength(nUsedTextLength, nNextGlyphLen));
 343
 344                         if(bAutosizeScale)
 345                         {
 346                             // when autosize scaling, expand portion length
 347                             fPortionLength *= fAutosizeScaleFactor;
 348                         }
 349
 350                         // create transformation
 351                         basegfx::B2DHomMatrix aNewTransformA, aNewTransformB, aNewShadowTransform;
 352                         basegfx::B2DPoint aStartPos(basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart, fPolyLength));
 353                         basegfx::B2DPoint aEndPos(aStartPos);
 354
 355                         // add font scaling
 356                         aNewTransformA.scale(aFontScaling.getX(), aFontScaling.getY());
 357
 358                         // prepare scaling of text primitive
 359                         if(bAutosizeScale)
 360                         {
 361                             // when autosize scaling, expand text primitive scaling to it
 362                             aNewTransformA.scale(fAutosizeScaleFactor, fAutosizeScaleFactor);
 363                         }
 364
 365                         // eventually create shadow primitives from aDecomposition and add to rDecomposition
 366                         const bool bShadow(XFormTextShadow::NONE != maSdrFormTextAttribute.getFormTextShadow());
 367
 368                         if(bShadow)
 369                         {
 370                             if(XFormTextShadow::Normal == maSdrFormTextAttribute.getFormTextShadow())
 371                             {
 372                                 aNewShadowTransform.translate(
 373                                     maSdrFormTextAttribute.getFormTextShdwXVal(),
 374                                     -maSdrFormTextAttribute.getFormTextShdwYVal());
 375                             }
 376                             else // XFormTextShadow::Slant
 377                             {
 378                                 double fScaleValue(maSdrFormTextAttribute.getFormTextShdwYVal() / 100.0);
 379                                 double fShearValue(-basegfx::deg2rad<10>(maSdrFormTextAttribute.getFormTextShdwXVal()));
 380
 381                                 aNewShadowTransform.scale(1.0, fScaleValue);
 382                                 aNewShadowTransform.shearX(sin(fShearValue));
 383                                 aNewShadowTransform.scale(1.0, cos(fShearValue));
 384                             }
 385                         }
 386
 387                         switch(maSdrFormTextAttribute.getFormTextStyle())
 388                         {
 389                             case XFormTextStyle::Rotate :
 390                             {
 391                                 aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 392                                 const basegfx::B2DVector aDirection(aEndPos - aStartPos);
 393                                 aNewTransformB.rotate(atan2(aDirection.getY(), aDirection.getX()));
 394                                 aNewTransformB.translate(aStartPos.getX(), aStartPos.getY());
 395
 396                                 break;
 397                             }
 398                             case XFormTextStyle::Upright :
 399                             {
 400                                 aNewTransformB.translate(aStartPos.getX() - (fPortionLength / 2.0), aStartPos.getY());
 401
 402                                 break;
 403                             }
 404                             case XFormTextStyle::SlantX :
 405                             {
 406                                 aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 407                                 const basegfx::B2DVector aDirection(aEndPos - aStartPos);
 408                                 const double fShearValue(atan2(aDirection.getY(), aDirection.getX()));
 409                                 const double fSin(sin(fShearValue));
 410                                 const double fCos(cos(fShearValue));
 411
 412                                 aNewTransformB.shearX(-fSin);
 413
 414                                 // Scale may lead to objects without height since fCos == 0.0 is possible.
 415                                 // Renderers need to handle that, it's not a forbidden value and does not
 416                                 // need to be avoided
 417                                 aNewTransformB.scale(1.0, fCos);
 418                                 aNewTransformB.translate(aStartPos.getX() - (fPortionLength / 2.0), aStartPos.getY());
 419
 420                                 break;
 421                             }
 422                             case XFormTextStyle::SlantY :
 423                             {
 424                                 aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 425                                 const basegfx::B2DVector aDirection(aEndPos - aStartPos);
 426                                 const double fShearValue(atan2(aDirection.getY(), aDirection.getX()));
 427                                 const double fCos(cos(fShearValue));
 428                                 const double fTan(tan(fShearValue));
 429
 430                                 // shear to 'stand' on the curve
 431                                 aNewTransformB.shearY(fTan);
 432
 433                                 // scale in X to make as tight as needed. As with XFT_SLANT_X, this may
 434                                 // lead to primitives without width which the renderers will handle
 435                                 aNewTransformA.scale(fCos, 1.0);
 436
 437                                 aNewTransformB.translate(aStartPos.getX(), aStartPos.getY());
 438
 439                                 break;
 440                             }
 441                             default : break; // XFormTextStyle::NONE
 442                         }
 443
 444                         // distance from path?
 445                         if(maSdrFormTextAttribute.getFormTextDistance())
 446                         {
 447                             if(aEndPos.equal(aStartPos))
 448                             {
 449                                 aEndPos = basegfx::utils::getPositionAbsolute(aPolygonCandidate, fPolyStart + fPortionLength, fPolyLength);
 450                             }
 451
 452                             // use back vector (aStartPos - aEndPos) here to get mirrored perpendicular as in old stuff
 453                             const basegfx::B2DVector aPerpendicular(
 454                                 basegfx::getNormalizedPerpendicular(aStartPos - aEndPos) *
 455                                 maSdrFormTextAttribute.getFormTextDistance());
 456                             aNewTransformB.translate(aPerpendicular.getX(), aPerpendicular.getY());
 457                         }
 458
 459                         if(!pCandidate->getText().isEmpty() && nNextGlyphLen)
 460                         {
 461                             const sal_Int32 nPortionIndex(pCandidate->getPortionIndex(nUsedTextLength, nNextGlyphLen));
 462                             ::std::vector< double > aNewDXArray;
 463
 464                             if(nNextGlyphLen > 1 && !pCandidate->getDoubleDXArray().empty())
 465                             {
 466                                 // copy DXArray for portion
 467                                 aNewDXArray.insert(
 468                                     aNewDXArray.begin(),
 469                                     pCandidate->getDoubleDXArray().begin() + nPortionIndex,
 470                                     pCandidate->getDoubleDXArray().begin() + (nPortionIndex + nNextGlyphLen));
 471
 472                                 if(nPortionIndex > 0)
 473                                 {
 474                                     // adapt to portion start
 475                                     double fDXOffset= *(pCandidate->getDoubleDXArray().begin() + (nPortionIndex - 1));
 476                                     ::std::transform(
 477                                         aNewDXArray.begin(), aNewDXArray.end(),
 478                                         aNewDXArray.begin(), [fDXOffset](double x) { return x - fDXOffset; });
 479                                 }
 480
 481                                 if(bAutosizeScale)
 482                                 {
 483                                     // when autosize scaling, adapt to DXArray, too
 484                                     ::std::transform(
 485                                         aNewDXArray.begin(), aNewDXArray.end(),
 486                                         aNewDXArray.begin(), [fAutosizeScaleFactor](double x) { return x * fAutosizeScaleFactor; });
 487                                 }
 488                             }
 489
 490                             if(bShadow)
 491                             {
 492                                 // shadow primitive creation
 493                                 const Color aShadowColor(maSdrFormTextAttribute.getFormTextShdwColor());
 494                                 const basegfx::BColor aRGBShadowColor(aShadowColor.getBColor());
 495
 496                                 mrShadowDecomposition.push_back(
 497                                     new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 498                                         aNewTransformB * aNewShadowTransform * aNewTransformA,
 499                                         pCandidate->getText(),
 500                                         nPortionIndex,
 501                                         nNextGlyphLen,
 502                                         std::vector(aNewDXArray),
 503                                         std::vector(pCandidate->getKashidaArray()),
 504                                         aCandidateFontAttribute,
 505                                         pCandidate->getLocale(),
 506                                         aRGBShadowColor) );
 507                             }
 508
 509                             {
 510                                 // primitive creation
 511                                 const Color aColor(pCandidate->getFont().GetColor());
 512                                 const basegfx::BColor aRGBColor(aColor.getBColor());
 513
 514                                 mrDecomposition.push_back(
 515                                     new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 516                                         aNewTransformB * aNewTransformA,
 517                                         pCandidate->getText(),
 518                                         nPortionIndex,
 519                                         nNextGlyphLen,
 520                                         std::move(aNewDXArray),
 521                                         std::vector(pCandidate->getKashidaArray()),
 522                                         aCandidateFontAttribute,
 523                                         pCandidate->getLocale(),
 524                                         aRGBColor) );
 525                             }
 526                         }
 527
 528                         // consume from portion
 529                         nUsedTextLength += nNextGlyphLen;
 530
 531                         // consume from polygon
 532                         fPolyStart += fPortionLength;
 533                     }
 534                 }
 535             }
 536         }
 537     };
 538 } // end of anonymous namespace
 539
 540
 541 // primitive decomposition helpers
 542
 543 namespace
 544 {
 545     void impAddPolygonStrokePrimitives(
 546         const basegfx::B2DPolyPolygonVector& rB2DPolyPolyVector,
 547         const basegfx::B2DHomMatrix& rTransform,
 548         const drawinglayer::attribute::LineAttribute& rLineAttribute,
 549         const drawinglayer::attribute::StrokeAttribute& rStrokeAttribute,
 550         drawinglayer::primitive2d::Primitive2DContainer& rTarget)
 551     {
 552         for(const auto& rB2DPolyPolygon : rB2DPolyPolyVector)
 553         {
 554             // prepare PolyPolygons
 555             basegfx::B2DPolyPolygon aB2DPolyPolygon = rB2DPolyPolygon;
 556             aB2DPolyPolygon.transform(rTransform);
 557
 558             for(auto const& rPolygon : std::as_const(aB2DPolyPolygon))
 559             {
 560                 // create one primitive per polygon
 561                 rTarget.push_back(
 562                     new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
 563                         rPolygon, rLineAttribute, rStrokeAttribute) );
 564             }
 565         }
 566     }
 567
 568     drawinglayer::primitive2d::Primitive2DContainer impAddPathTextOutlines(
 569         const drawinglayer::primitive2d::Primitive2DContainer& rSource,
 570         const drawinglayer::attribute::SdrFormTextOutlineAttribute& rOutlineAttribute)
 571     {
 572         drawinglayer::primitive2d::Primitive2DContainer aNewPrimitives;
 573
 574         for(const drawinglayer::primitive2d::Primitive2DReference& a : rSource)
 575         {
 576             const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pTextCandidate = dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(a.get());
 577
 578             if(pTextCandidate)
 579             {
 580                 basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
 581                 basegfx::B2DHomMatrix aPolygonTransform;
 582
 583                 // get text outlines and their object transformation
 584                 pTextCandidate->getTextOutlinesAndTransformation(aB2DPolyPolyVector, aPolygonTransform);
 585
 586                 if(!aB2DPolyPolyVector.empty())
 587                 {
 588                     // create stroke primitives
 589                     drawinglayer::primitive2d::Primitive2DContainer aStrokePrimitives;
 590                     impAddPolygonStrokePrimitives(
 591                         aB2DPolyPolyVector,
 592                         aPolygonTransform,
 593                         rOutlineAttribute.getLineAttribute(),
 594                         rOutlineAttribute.getStrokeAttribute(),
 595                         aStrokePrimitives);
 596
 597                     if(!aStrokePrimitives.empty())
 598                     {
 599                         if(rOutlineAttribute.getTransparence())
 600                         {
 601                             // create UnifiedTransparencePrimitive2D
 602                             aNewPrimitives.push_back(
 603                                 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
 604                                     std::move(aStrokePrimitives),
 605                                     static_cast<double>(rOutlineAttribute.getTransparence()) / 100.0) );
 606                         }
 607                         else
 608                         {
 609                             // add polygons to rDecomposition as polygonStrokePrimitives
 610                             aNewPrimitives.append( std::move(aStrokePrimitives) );
 611                         }
 612                     }
 613                 }
 614             }
 615         }
 616
 617         return aNewPrimitives;
 618     }
 619 } // end of anonymous namespace
 620
 621
 622 // primitive decomposition
 623
 624 void SdrTextObj::impDecomposePathTextPrimitive(
 625     drawinglayer::primitive2d::Primitive2DContainer& rTarget,
 626     const drawinglayer::primitive2d::SdrPathTextPrimitive2D& rSdrPathTextPrimitive,
 627     const drawinglayer::geometry::ViewInformation2D& aViewInformation) const
 628 {
 629     drawinglayer::primitive2d::Primitive2DContainer aRetvalA;
 630     drawinglayer::primitive2d::Primitive2DContainer aRetvalB;
 631
 632     // prepare outliner
 633     SdrOutliner& rOutliner = ImpGetDrawOutliner();
 634     rOutliner.SetUpdateLayout(true);
 635     rOutliner.Clear();
 636     rOutliner.SetPaperSize(Size(LONG_MAX,LONG_MAX));
 637     rOutliner.SetText(rSdrPathTextPrimitive.getOutlinerParaObject());
 638
 639     // set visualizing page at Outliner; needed e.g. for PageNumberField decomposition
 640     rOutliner.setVisualizedPage(GetSdrPageFromXDrawPage(aViewInformation.getVisualizedPage()));
 641
 642     // now break up to text portions
 643     impTextBreakupHandler aConverter(rOutliner);
 644     const ::std::vector< impPathTextPortion > rPathTextPortions = aConverter.decompositionPathTextPrimitive();
 645
 646     if(!rPathTextPortions.empty())
 647     {
 648         // get FormText and polygon values
 649         const drawinglayer::attribute::SdrFormTextAttribute& rFormTextAttribute = rSdrPathTextPrimitive.getSdrFormTextAttribute();
 650         const basegfx::B2DPolyPolygon& rPathPolyPolygon(rSdrPathTextPrimitive.getPathPolyPolygon());
 651
 652         // get loop count
 653         sal_uInt32 nLoopCount(rPathPolyPolygon.count());
 654
 655         if(o3tl::make_unsigned(rOutliner.GetParagraphCount()) < nLoopCount)
 656         {
 657             nLoopCount = rOutliner.GetParagraphCount();
 658         }
 659
 660         if(nLoopCount)
 661         {
 662             // prepare common decomposition stuff
 663             drawinglayer::primitive2d::Primitive2DContainer aRegularDecomposition;
 664             drawinglayer::primitive2d::Primitive2DContainer aShadowDecomposition;
 665             impPolygonParagraphHandler aPolygonParagraphHandler(
 666                 rFormTextAttribute,
 667                 aRegularDecomposition,
 668                 aShadowDecomposition);
 669             sal_uInt32 a;
 670
 671             for(a = 0; a < nLoopCount; a++)
 672             {
 673                 // filter text portions for this paragraph
 674                 ::std::vector< const impPathTextPortion* > aParagraphTextPortions;
 675
 676                 for(const auto & rCandidate : rPathTextPortions)
 677                 {
 678                     if(static_cast<sal_uInt32>(rCandidate.getParagraph()) == a)
 679                     {
 680                         aParagraphTextPortions.push_back(&rCandidate);
 681                     }
 682                 }
 683
 684                 // handle data pair polygon/ParagraphTextPortions
 685                 if(!aParagraphTextPortions.empty())
 686                 {
 687                     aPolygonParagraphHandler.HandlePair(rPathPolyPolygon.getB2DPolygon(a), aParagraphTextPortions);
 688                 }
 689             }
 690
 691             const sal_uInt32 nShadowCount(aShadowDecomposition.size());
 692             const sal_uInt32 nRegularCount(aRegularDecomposition.size());
 693
 694             if(nShadowCount)
 695             {
 696                 // add shadow primitives to decomposition
 697
 698                 // if necessary, add shadow outlines
 699                 if(rFormTextAttribute.getFormTextOutline()
 700                     && !rFormTextAttribute.getShadowOutline().isDefault())
 701                 {
 702                     aRetvalA = aShadowDecomposition;
 703                     const drawinglayer::primitive2d::Primitive2DContainer aOutlines(
 704                         impAddPathTextOutlines(
 705                             aShadowDecomposition,
 706                             rFormTextAttribute.getShadowOutline()));
 707
 708                     aRetvalA.append(aOutlines);
 709                 }
 710                 else
 711                     aRetvalA = std::move(aShadowDecomposition);
 712             }
 713
 714             if(nRegularCount)
 715             {
 716                 // add normal primitives to decomposition
 717
 718                 // if necessary, add outlines
 719                 if(rFormTextAttribute.getFormTextOutline()
 720                     && !rFormTextAttribute.getOutline().isDefault())
 721                 {
 722                     aRetvalB = aRegularDecomposition;
 723                     const drawinglayer::primitive2d::Primitive2DContainer aOutlines(
 724                         impAddPathTextOutlines(
 725                             aRegularDecomposition,
 726                             rFormTextAttribute.getOutline()));
 727
 728                     aRetvalB.append(aOutlines);
 729                 }
 730                 else
 731                     aRetvalB = std::move(aRegularDecomposition);
 732             }
 733         }
 734     }
 735
 736     // clean up outliner
 737     rOutliner.SetDrawPortionHdl(Link<DrawPortionInfo*,void>());
 738     rOutliner.Clear();
 739     rOutliner.setVisualizedPage(nullptr);
 740
 741     // concatenate all results
 742     rTarget.append(std::move(aRetvalA));
 743     rTarget.append(std::move(aRetvalB));
 744 }
 745
 746
 747 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */