svgio/source/svgreader/svgtextpathnode.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 <svgtextpathnode.hxx>
  21 #include <svgstyleattributes.hxx>
  22 #include <svgpathnode.hxx>
  23 #include <svgdocument.hxx>
  24 #include <basegfx/polygon/b2dpolygon.hxx>
  25 #include <basegfx/polygon/b2dpolygontools.hxx>
  26 #include <drawinglayer/primitive2d/textbreakuphelper.hxx>
  27 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  28 #include <basegfx/curve/b2dcubicbezier.hxx>
  29 #include <basegfx/curve/b2dbeziertools.hxx>
  30
  31 namespace svgio::svgreader
  32 {
  33         namespace {
  34
  35         class pathTextBreakupHelper : public drawinglayer::primitive2d::TextBreakupHelper
  36         {
  37         private:
  38             const basegfx::B2DPolygon&      mrPolygon;
  39             const double                    mfBasegfxPathLength;
  40             double                          mfPosition;
  41             const basegfx::B2DPoint&        mrTextStart;
  42
  43             const sal_uInt32                mnMaxIndex;
  44             sal_uInt32                      mnIndex;
  45             basegfx::B2DCubicBezier         maCurrentSegment;
  46             std::unique_ptr<basegfx::B2DCubicBezierHelper> mpB2DCubicBezierHelper;
  47             double                          mfCurrentSegmentLength;
  48             double                          mfSegmentStartPosition;
  49
  50         protected:
  51             /// allow user callback to allow changes to the new TextTransformation. Default
  52             /// does nothing.
  53             virtual bool allowChange(sal_uInt32 nCount, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength) override;
  54
  55             void freeB2DCubicBezierHelper();
  56             basegfx::B2DCubicBezierHelper* getB2DCubicBezierHelper();
  57             void advanceToPosition(double fNewPosition);
  58
  59         public:
  60             pathTextBreakupHelper(
  61                 const drawinglayer::primitive2d::TextSimplePortionPrimitive2D& rSource,
  62                 const basegfx::B2DPolygon& rPolygon,
  63                 const double fBasegfxPathLength,
  64                 double fPosition,
  65                 const basegfx::B2DPoint& rTextStart);
  66             virtual ~pathTextBreakupHelper() override;
  67
  68             // read access to evtl. advanced position
  69             double getPosition() const { return mfPosition; }
  70         };
  71
  72         }
  73
  74         void pathTextBreakupHelper::freeB2DCubicBezierHelper()
  75         {
  76             mpB2DCubicBezierHelper.reset();
  77         }
  78
  79         basegfx::B2DCubicBezierHelper* pathTextBreakupHelper::getB2DCubicBezierHelper()
  80         {
  81             if(!mpB2DCubicBezierHelper && maCurrentSegment.isBezier())
  82             {
  83                 mpB2DCubicBezierHelper.reset(new basegfx::B2DCubicBezierHelper(maCurrentSegment));
  84             }
  85
  86             return mpB2DCubicBezierHelper.get();
  87         }
  88
  89         void pathTextBreakupHelper::advanceToPosition(double fNewPosition)
  90         {
  91             while(mfSegmentStartPosition + mfCurrentSegmentLength < fNewPosition && mnIndex < mnMaxIndex)
  92             {
  93                 mfSegmentStartPosition += mfCurrentSegmentLength;
  94                 mnIndex++;
  95
  96                 if(mnIndex < mnMaxIndex)
  97                 {
  98                     freeB2DCubicBezierHelper();
  99                     mrPolygon.getBezierSegment(mnIndex % mrPolygon.count(), maCurrentSegment);
 100                     maCurrentSegment.testAndSolveTrivialBezier();
 101                     mfCurrentSegmentLength = getB2DCubicBezierHelper()
 102                         ? getB2DCubicBezierHelper()->getLength()
 103                         : maCurrentSegment.getLength();
 104                 }
 105             }
 106
 107             mfPosition = fNewPosition;
 108         }
 109
 110         pathTextBreakupHelper::pathTextBreakupHelper(
 111             const drawinglayer::primitive2d::TextSimplePortionPrimitive2D& rSource,
 112             const basegfx::B2DPolygon& rPolygon,
 113             const double fBasegfxPathLength,
 114             double fPosition,
 115             const basegfx::B2DPoint& rTextStart)
 116         :   drawinglayer::primitive2d::TextBreakupHelper(rSource),
 117             mrPolygon(rPolygon),
 118             mfBasegfxPathLength(fBasegfxPathLength),
 119             mfPosition(0.0),
 120             mrTextStart(rTextStart),
 121             mnMaxIndex(rPolygon.isClosed() ? rPolygon.count() : rPolygon.count() - 1),
 122             mnIndex(0),
 123             maCurrentSegment(),
 124             mfCurrentSegmentLength(0.0),
 125             mfSegmentStartPosition(0.0)
 126         {
 127             mrPolygon.getBezierSegment(mnIndex % mrPolygon.count(), maCurrentSegment);
 128             mfCurrentSegmentLength = maCurrentSegment.getLength();
 129
 130             advanceToPosition(fPosition);
 131         }
 132
 133         pathTextBreakupHelper::~pathTextBreakupHelper()
 134         {
 135             freeB2DCubicBezierHelper();
 136         }
 137
 138         bool pathTextBreakupHelper::allowChange(sal_uInt32 /*nCount*/, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength)
 139         {
 140             bool bRetval(false);
 141
 142             if(mfPosition < mfBasegfxPathLength && nLength && mnIndex < mnMaxIndex)
 143             {
 144                 const double fSnippetWidth(
 145                     getTextLayouter().getTextWidth(
 146                         getSource().getText(),
 147                         nIndex,
 148                         nLength));
 149
 150                 if(basegfx::fTools::more(fSnippetWidth, 0.0))
 151                 {
 152                     const OUString aText(getSource().getText());
 153                     const OUString aTrimmedChars(aText.copy(nIndex, nLength).trim());
 154                     const double fEndPos(mfPosition + fSnippetWidth);
 155
 156                     if(!aTrimmedChars.isEmpty() && (mfPosition < mfBasegfxPathLength || fEndPos > 0.0))
 157                     {
 158                         const double fHalfSnippetWidth(fSnippetWidth * 0.5);
 159
 160                         advanceToPosition(mfPosition + fHalfSnippetWidth);
 161
 162                         // create representation for this snippet
 163                         bRetval = true;
 164
 165                         // get target position and tangent in that point
 166                         basegfx::B2DPoint aPosition(0.0, 0.0);
 167                         basegfx::B2DVector aTangent(0.0, 1.0);
 168
 169                         if(mfPosition < 0.0)
 170                         {
 171                             // snippet center is left of first segment, but right edge is on it (SVG allows that)
 172                             aTangent = maCurrentSegment.getTangent(0.0);
 173                             aTangent.normalize();
 174                             aPosition = maCurrentSegment.getStartPoint() + (aTangent * (mfPosition - mfSegmentStartPosition));
 175                         }
 176                         else if(mfPosition > mfBasegfxPathLength)
 177                         {
 178                             // snippet center is right of last segment, but left edge is on it (SVG allows that)
 179                             aTangent = maCurrentSegment.getTangent(1.0);
 180                             aTangent.normalize();
 181                             aPosition = maCurrentSegment.getEndPoint() + (aTangent * (mfPosition - mfSegmentStartPosition));
 182                         }
 183                         else
 184                         {
 185                             // snippet center inside segment, interpolate
 186                             double fBezierDistance(mfPosition - mfSegmentStartPosition);
 187
 188                             if(getB2DCubicBezierHelper())
 189                             {
 190                                 // use B2DCubicBezierHelper to bridge the non-linear gap between
 191                                 // length and bezier distances (if it's a bezier segment)
 192                                 fBezierDistance = getB2DCubicBezierHelper()->distanceToRelative(fBezierDistance);
 193                             }
 194                             else
 195                             {
 196                                 // linear relationship, make relative to segment length
 197                                 fBezierDistance = fBezierDistance / mfCurrentSegmentLength;
 198                             }
 199
 200                             aPosition = maCurrentSegment.interpolatePoint(fBezierDistance);
 201                             aTangent = maCurrentSegment.getTangent(fBezierDistance);
 202                             aTangent.normalize();
 203                         }
 204
 205                         // detect evtl. hor/ver translations (depends on text direction)
 206                         const basegfx::B2DPoint aBasePoint(rNewTransform * basegfx::B2DPoint(0.0, 0.0));
 207                         const basegfx::B2DVector aOffset(aBasePoint - mrTextStart);
 208
 209                         if(!basegfx::fTools::equalZero(aOffset.getY()))
 210                         {
 211                             // ...and apply
 212                             aPosition.setY(aPosition.getY() + aOffset.getY());
 213                         }
 214
 215                         // move target position from snippet center to left text start
 216                         aPosition -= fHalfSnippetWidth * aTangent;
 217
 218                         // remove current translation
 219                         rNewTransform.translate(-aBasePoint.getX(), -aBasePoint.getY());
 220
 221                         // rotate due to tangent
 222                         rNewTransform.rotate(atan2(aTangent.getY(), aTangent.getX()));
 223
 224                         // add new translation
 225                         rNewTransform.translate(aPosition.getX(), aPosition.getY());
 226                     }
 227
 228                     // advance to end
 229                     advanceToPosition(fEndPos);
 230                 }
 231             }
 232
 233             return bRetval;
 234         }
 235
 236 } // end of namespace svgio::svgreader
 237
 238
 239 namespace svgio::svgreader
 240 {
 241         SvgTextPathNode::SvgTextPathNode(
 242             SvgDocument& rDocument,
 243             SvgNode* pParent)
 244         :   SvgNode(SVGToken::TextPath, rDocument, pParent),
 245             maSvgStyleAttributes(*this),
 246             maXLink(),
 247             maStartOffset()
 248         {
 249         }
 250
 251         SvgTextPathNode::~SvgTextPathNode()
 252         {
 253         }
 254
 255         const SvgStyleAttributes* SvgTextPathNode::getSvgStyleAttributes() const
 256         {
 257             return &maSvgStyleAttributes;
 258         }
 259
 260         void SvgTextPathNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
 261         {
 262             // call parent
 263             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
 264
 265             // read style attributes
 266             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
 267
 268             // parse own
 269             switch(aSVGToken)
 270             {
 271                 case SVGToken::Style:
 272                 {
 273                     readLocalCssStyle(aContent);
 274                     break;
 275                 }
 276                 case SVGToken::StartOffset:
 277                 {
 278                     SvgNumber aNum;
 279
 280                     if(readSingleNumber(aContent, aNum))
 281                     {
 282                         if(aNum.isPositive())
 283                         {
 284                             maStartOffset = aNum;
 285                         }
 286                     }
 287                     break;
 288                 }
 289                 case SVGToken::Method:
 290                 {
 291                     break;
 292                 }
 293                 case SVGToken::Spacing:
 294                 {
 295                     break;
 296                 }
 297                 case SVGToken::XlinkHref:
 298                 {
 299                     const sal_Int32 nLen(aContent.getLength());
 300
 301                     if(nLen && '#' == aContent[0])
 302                     {
 303                         maXLink = aContent.copy(1);
 304                     }
 305                     break;
 306                 }
 307                 default:
 308                 {
 309                     break;
 310                 }
 311             }
 312         }
 313
 314         bool SvgTextPathNode::isValid() const
 315         {
 316             const SvgPathNode* pSvgPathNode = dynamic_cast< const SvgPathNode* >(getDocument().findSvgNodeById(maXLink));
 317
 318             if(!pSvgPathNode)
 319             {
 320                 return false;
 321             }
 322
 323             const basegfx::B2DPolyPolygon* pPolyPolyPath = pSvgPathNode->getPath();
 324
 325             if(!pPolyPolyPath || !pPolyPolyPath->count())
 326             {
 327                 return false;
 328             }
 329
 330             const basegfx::B2DPolygon aPolygon(pPolyPolyPath->getB2DPolygon(0));
 331
 332             if(!aPolygon.count())
 333             {
 334                 return false;
 335             }
 336
 337             const double fBasegfxPathLength(basegfx::utils::getLength(aPolygon));
 338
 339             return !basegfx::fTools::equalZero(fBasegfxPathLength);
 340         }
 341
 342         void SvgTextPathNode::decomposePathNode(
 343             const drawinglayer::primitive2d::Primitive2DContainer& rPathContent,
 344             drawinglayer::primitive2d::Primitive2DContainer& rTarget,
 345             const basegfx::B2DPoint& rTextStart) const
 346         {
 347             if(rPathContent.empty())
 348                 return;
 349
 350             const SvgPathNode* pSvgPathNode = dynamic_cast< const SvgPathNode* >(getDocument().findSvgNodeById(maXLink));
 351
 352             if(!pSvgPathNode)
 353                 return;
 354
 355             const basegfx::B2DPolyPolygon* pPolyPolyPath = pSvgPathNode->getPath();
 356
 357             if(!(pPolyPolyPath && pPolyPolyPath->count()))
 358                 return;
 359
 360             basegfx::B2DPolygon aPolygon(pPolyPolyPath->getB2DPolygon(0));
 361
 362             if(pSvgPathNode->getTransform())
 363             {
 364                 aPolygon.transform(*pSvgPathNode->getTransform());
 365             }
 366
 367             const double fBasegfxPathLength(basegfx::utils::getLength(aPolygon));
 368
 369             if(basegfx::fTools::equalZero(fBasegfxPathLength))
 370                 return;
 371
 372             double fUserToBasegfx(1.0); // multiply: user->basegfx, divide: basegfx->user
 373
 374             if(pSvgPathNode->getPathLength().isSet())
 375             {
 376                 const double fUserLength(pSvgPathNode->getPathLength().solve(*this));
 377
 378                 if(fUserLength > 0.0 && !basegfx::fTools::equal(fUserLength, fBasegfxPathLength))
 379                 {
 380                     fUserToBasegfx = fUserLength / fBasegfxPathLength;
 381                 }
 382             }
 383
 384             double fPosition(0.0);
 385
 386             if(getStartOffset().isSet())
 387             {
 388                 if (SvgUnit::percent == getStartOffset().getUnit())
 389                 {
 390                     // percent are relative to path length
 391                     fPosition = getStartOffset().getNumber() * 0.01 * fBasegfxPathLength;
 392                 }
 393                 else
 394                 {
 395                     fPosition = getStartOffset().solve(*this) * fUserToBasegfx;
 396                 }
 397             }
 398
 399             if(fPosition < 0.0)
 400                 return;
 401
 402             const sal_Int32 nLength(rPathContent.size());
 403             sal_Int32 nCurrent(0);
 404
 405             while(fPosition < fBasegfxPathLength && nCurrent < nLength)
 406             {
 407                 const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pCandidate = nullptr;
 408                 const drawinglayer::primitive2d::Primitive2DReference xReference(rPathContent[nCurrent]);
 409
 410                 if(xReference.is())
 411                 {
 412                     pCandidate = dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(xReference.get());
 413                 }
 414
 415                 if(pCandidate)
 416                 {
 417                     const pathTextBreakupHelper aPathTextBreakupHelper(
 418                         *pCandidate,
 419                         aPolygon,
 420                         fBasegfxPathLength,
 421                         fPosition,
 422                         rTextStart);
 423
 424                     const drawinglayer::primitive2d::Primitive2DContainer& aResult(
 425                         aPathTextBreakupHelper.getResult());
 426
 427                     if(!aResult.empty())
 428                     {
 429                         rTarget.append(aResult);
 430                     }
 431
 432                     // advance position to consumed
 433                     fPosition = aPathTextBreakupHelper.getPosition();
 434                 }
 435
 436                 nCurrent++;
 437             }
 438         }
 439
 440 } // end of namespace svgio
 441
 442 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */