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