svgio/source/svgreader/svgcharacternode.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 <svgcharacternode.hxx>
  21 #include <svgstyleattributes.hxx>
  22 #include <drawinglayer/attribute/fontattribute.hxx>
  23 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  24 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  25 #include <drawinglayer/primitive2d/textbreakuphelper.hxx>
  26 #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
  27
  28 namespace svgio::svgreader
  29 {
  30         SvgTextPositions::SvgTextPositions()
  31         :   maX(),
  32             maY(),
  33             maDx(),
  34             maDy(),
  35             maRotate(),
  36             maTextLength(),
  37             mbLengthAdjust(true)
  38         {
  39         }
  40
  41         void SvgTextPositions::parseTextPositionAttributes(SVGToken aSVGToken, const OUString& aContent)
  42         {
  43             // parse own
  44             switch(aSVGToken)
  45             {
  46                 case SVGToken::X:
  47                 {
  48                     if(!aContent.isEmpty())
  49                     {
  50                         SvgNumberVector aVector;
  51
  52                         if(readSvgNumberVector(aContent, aVector))
  53                         {
  54                             setX(aVector);
  55                         }
  56                     }
  57                     break;
  58                 }
  59                 case SVGToken::Y:
  60                 {
  61                     if(!aContent.isEmpty())
  62                     {
  63                         SvgNumberVector aVector;
  64
  65                         if(readSvgNumberVector(aContent, aVector))
  66                         {
  67                             setY(aVector);
  68                         }
  69                     }
  70                     break;
  71                 }
  72                 case SVGToken::Dx:
  73                 {
  74                     if(!aContent.isEmpty())
  75                     {
  76                         SvgNumberVector aVector;
  77
  78                         if(readSvgNumberVector(aContent, aVector))
  79                         {
  80                             setDx(aVector);
  81                         }
  82                     }
  83                     break;
  84                 }
  85                 case SVGToken::Dy:
  86                 {
  87                     if(!aContent.isEmpty())
  88                     {
  89                         SvgNumberVector aVector;
  90
  91                         if(readSvgNumberVector(aContent, aVector))
  92                         {
  93                             setDy(aVector);
  94                         }
  95                     }
  96                     break;
  97                 }
  98                 case SVGToken::Rotate:
  99                 {
 100                     if(!aContent.isEmpty())
 101                     {
 102                         SvgNumberVector aVector;
 103
 104                         if(readSvgNumberVector(aContent, aVector))
 105                         {
 106                             setRotate(aVector);
 107                         }
 108                     }
 109                     break;
 110                 }
 111                 case SVGToken::TextLength:
 112                 {
 113                     SvgNumber aNum;
 114
 115                     if(readSingleNumber(aContent, aNum))
 116                     {
 117                         if(aNum.isPositive())
 118                         {
 119                             setTextLength(aNum);
 120                         }
 121                     }
 122                     break;
 123                 }
 124                 case SVGToken::LengthAdjust:
 125                 {
 126                     if(!aContent.isEmpty())
 127                     {
 128                         if(aContent.startsWith("spacing"))
 129                         {
 130                             setLengthAdjust(true);
 131                         }
 132                         else if(aContent.startsWith("spacingAndGlyphs"))
 133                         {
 134                             setLengthAdjust(false);
 135                         }
 136                     }
 137                     break;
 138                 }
 139                 default:
 140                 {
 141                     break;
 142                 }
 143             }
 144         }
 145
 146         namespace {
 147
 148         class localTextBreakupHelper : public drawinglayer::primitive2d::TextBreakupHelper
 149         {
 150         private:
 151             SvgTextPosition&                    mrSvgTextPosition;
 152
 153         protected:
 154             /// allow user callback to allow changes to the new TextTransformation. Default
 155             /// does nothing.
 156             virtual bool allowChange(sal_uInt32 nCount, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength) override;
 157
 158         public:
 159             localTextBreakupHelper(
 160                 const drawinglayer::primitive2d::TextSimplePortionPrimitive2D& rSource,
 161                 SvgTextPosition& rSvgTextPosition)
 162             :   drawinglayer::primitive2d::TextBreakupHelper(rSource),
 163                 mrSvgTextPosition(rSvgTextPosition)
 164             {
 165             }
 166         };
 167
 168         }
 169
 170         bool localTextBreakupHelper::allowChange(sal_uInt32 /*nCount*/, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 /*nIndex*/, sal_uInt32 /*nLength*/)
 171         {
 172             const double fRotation(mrSvgTextPosition.consumeRotation());
 173
 174             if(0.0 != fRotation)
 175             {
 176                 const basegfx::B2DPoint aBasePoint(rNewTransform * basegfx::B2DPoint(0.0, 0.0));
 177
 178                 rNewTransform.translate(-aBasePoint.getX(), -aBasePoint.getY());
 179                 rNewTransform.rotate(fRotation);
 180                 rNewTransform.translate(aBasePoint.getX(), aBasePoint.getY());
 181             }
 182
 183             return true;
 184         }
 185
 186         SvgCharacterNode::SvgCharacterNode(
 187             SvgDocument& rDocument,
 188             SvgNode* pParent,
 189             const OUString& rText)
 190         :   SvgNode(SVGToken::Character, rDocument, pParent),
 191             maText(rText)
 192         {
 193         }
 194
 195         SvgCharacterNode::~SvgCharacterNode()
 196         {
 197         }
 198
 199         const SvgStyleAttributes* SvgCharacterNode::getSvgStyleAttributes() const
 200         {
 201             // no own style, use parent's
 202             if(getParent())
 203             {
 204                 return getParent()->getSvgStyleAttributes();
 205             }
 206             else
 207             {
 208                 return nullptr;
 209             }
 210         }
 211
 212         rtl::Reference<drawinglayer::primitive2d::TextSimplePortionPrimitive2D> SvgCharacterNode::createSimpleTextPrimitive(
 213             SvgTextPosition& rSvgTextPosition,
 214             const SvgStyleAttributes& rSvgStyleAttributes) const
 215         {
 216             // prepare retval, index and length
 217             rtl::Reference<drawinglayer::primitive2d::TextSimplePortionPrimitive2D> pRetval;
 218             sal_uInt32 nLength(getText().getLength());
 219
 220             if(nLength)
 221             {
 222                 sal_uInt32 nIndex(0);
 223                 // prepare FontAttribute
 224                 const SvgStringVector& rFontFamilyVector = rSvgStyleAttributes.getFontFamily();
 225                 OUString aFontFamily = rFontFamilyVector.empty() ?
 226                     OUString("Times New Roman") :
 227                     rFontFamilyVector[0];
 228
 229                 // #i122324# if the FontFamily name ends on ' embedded' it is probably a re-import
 230                 // of a SVG export with font embedding. Remove this to make font matching work. This
 231                 // is pretty safe since there should be no font family names ending on ' embedded'.
 232                 // Remove again when FontEmbedding is implemented in SVG import
 233                 if(aFontFamily.endsWith(" embedded"))
 234                 {
 235                     aFontFamily = aFontFamily.copy(0, aFontFamily.getLength() - 9);
 236                 }
 237
 238                 const ::FontWeight nFontWeight(getVclFontWeight(rSvgStyleAttributes.getFontWeight()));
 239                 bool bItalic(FontStyle::italic == rSvgStyleAttributes.getFontStyle() || FontStyle::oblique == rSvgStyleAttributes.getFontStyle());
 240
 241                 const drawinglayer::attribute::FontAttribute aFontAttribute(
 242                     aFontFamily,
 243                     OUString(),
 244                     nFontWeight,
 245                     false/*bSymbol*/,
 246                     false/*bVertical*/,
 247                     bItalic,
 248                     false/*bMonospaced*/,
 249                     false/*bOutline*/,
 250                     false/*bRTL*/,
 251                     false/*bBiDiStrong*/);
 252
 253                 // prepare FontSizeNumber
 254                 double fFontWidth(rSvgStyleAttributes.getFontSizeNumber().solve(*this));
 255                 double fFontHeight(fFontWidth);
 256
 257                 // prepare locale
 258                 css::lang::Locale aLocale;
 259
 260                 // prepare TextLayouterDevice
 261                 drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
 262                 aTextLayouterDevice.setFontAttribute(aFontAttribute, fFontWidth, fFontHeight, aLocale);
 263
 264                 // prepare TextArray
 265                 ::std::vector< double > aTextArray(rSvgTextPosition.getX());
 266
 267                 if(!aTextArray.empty() && aTextArray.size() < nLength)
 268                 {
 269                     const sal_uInt32 nArray(aTextArray.size());
 270
 271                     if(nArray < nLength)
 272                     {
 273                         double fStartX(0.0);
 274
 275                         if(rSvgTextPosition.getParent() && rSvgTextPosition.getParent()->getAbsoluteX())
 276                         {
 277                             fStartX = rSvgTextPosition.getParent()->getPosition().getX();
 278                         }
 279                         else
 280                         {
 281                             fStartX = aTextArray[nArray - 1];
 282                         }
 283
 284                         ::std::vector< double > aExtendArray(aTextLayouterDevice.getTextArray(getText(), nArray, nLength - nArray));
 285                         aTextArray.reserve(nLength);
 286
 287                         for(size_t a(0); a < aExtendArray.size(); a++)
 288                         {
 289                             aTextArray.push_back(aExtendArray[a] + fStartX);
 290                         }
 291                     }
 292                 }
 293
 294                 // get current TextPosition and TextWidth in units
 295                 basegfx::B2DPoint aPosition(rSvgTextPosition.getPosition());
 296                 double fTextWidth(aTextLayouterDevice.getTextWidth(getText(), nIndex, nLength));
 297
 298                 // check for user-given TextLength
 299                 if(0.0 != rSvgTextPosition.getTextLength()
 300                     && !basegfx::fTools::equal(fTextWidth, rSvgTextPosition.getTextLength()))
 301                 {
 302                     const double fFactor(rSvgTextPosition.getTextLength() / fTextWidth);
 303
 304                     if(rSvgTextPosition.getLengthAdjust())
 305                     {
 306                         // spacing, need to create and expand TextArray
 307                         if(aTextArray.empty())
 308                         {
 309                             aTextArray = aTextLayouterDevice.getTextArray(getText(), nIndex, nLength);
 310                         }
 311
 312                         for(size_t a(0); a < aTextArray.size(); a++)
 313                         {
 314                             aTextArray[a] *= fFactor;
 315                         }
 316                     }
 317                     else
 318                     {
 319                         // spacing and glyphs, just apply to FontWidth
 320                         fFontWidth *= fFactor;
 321                     }
 322
 323                     fTextWidth = rSvgTextPosition.getTextLength();
 324                 }
 325
 326                 // get TextAlign
 327                 TextAlign aTextAlign(rSvgStyleAttributes.getTextAlign());
 328
 329                 // map TextAnchor to TextAlign, there seems not to be a difference
 330                 if(TextAnchor::notset != rSvgStyleAttributes.getTextAnchor())
 331                 {
 332                     switch(rSvgStyleAttributes.getTextAnchor())
 333                     {
 334                         case TextAnchor::start:
 335                         {
 336                             aTextAlign = TextAlign::left;
 337                             break;
 338                         }
 339                         case TextAnchor::middle:
 340                         {
 341                             aTextAlign = TextAlign::center;
 342                             break;
 343                         }
 344                         case TextAnchor::end:
 345                         {
 346                             aTextAlign = TextAlign::right;
 347                             break;
 348                         }
 349                         default:
 350                         {
 351                             break;
 352                         }
 353                     }
 354                 }
 355
 356                 // apply TextAlign
 357                 switch(aTextAlign)
 358                 {
 359                     case TextAlign::right:
 360                     {
 361                         aPosition.setX(aPosition.getX() - fTextWidth);
 362                         break;
 363                     }
 364                     case TextAlign::center:
 365                     {
 366                         aPosition.setX(aPosition.getX() - (fTextWidth * 0.5));
 367                         break;
 368                     }
 369                     case TextAlign::notset:
 370                     case TextAlign::left:
 371                     case TextAlign::justify:
 372                     {
 373                         // TextAlign::notset, TextAlign::left: nothing to do
 374                         // TextAlign::justify is not clear currently; handle as TextAlign::left
 375                         break;
 376                     }
 377                 }
 378
 379                 // get BaselineShift
 380                 const BaselineShift aBaselineShift(rSvgStyleAttributes.getBaselineShift());
 381
 382                 // apply BaselineShift
 383                 switch(aBaselineShift)
 384                 {
 385                     case BaselineShift::Sub:
 386                     {
 387                         aPosition.setY(aPosition.getY() + aTextLayouterDevice.getUnderlineOffset());
 388                         break;
 389                     }
 390                     case BaselineShift::Super:
 391                     {
 392                         aPosition.setY(aPosition.getY() + aTextLayouterDevice.getOverlineOffset());
 393                         break;
 394                     }
 395                     case BaselineShift::Percentage:
 396                     case BaselineShift::Length:
 397                     {
 398                         const SvgNumber aNumber(rSvgStyleAttributes.getBaselineShiftNumber());
 399                         const double mfBaselineShift(aNumber.solve(*this));
 400
 401                         aPosition.setY(aPosition.getY() + mfBaselineShift);
 402                         break;
 403                     }
 404                     default: // BaselineShift::Baseline
 405                     {
 406                         // nothing to do
 407                         break;
 408                     }
 409                 }
 410
 411                 // get fill color
 412                 const basegfx::BColor aFill(rSvgStyleAttributes.getFill()
 413                     ? *rSvgStyleAttributes.getFill()
 414                     : basegfx::BColor(0.0, 0.0, 0.0));
 415
 416                 // prepare TextTransformation
 417                 basegfx::B2DHomMatrix aTextTransform;
 418
 419                 aTextTransform.scale(fFontWidth, fFontHeight);
 420                 aTextTransform.translate(aPosition.getX(), aPosition.getY());
 421
 422                 // check TextDecoration and if TextDecoratedPortionPrimitive2D is needed
 423                 const TextDecoration aDeco(rSvgStyleAttributes.getTextDecoration());
 424
 425                 if(TextDecoration::underline == aDeco
 426                     || TextDecoration::overline == aDeco
 427                     || TextDecoration::line_through == aDeco)
 428                 {
 429                     // get the fill for decoration as described by SVG. We cannot
 430                     // have different stroke colors/definitions for those, though
 431                     const SvgStyleAttributes* pDecoDef = rSvgStyleAttributes.getTextDecorationDefiningSvgStyleAttributes();
 432                     const basegfx::BColor aDecoColor(pDecoDef && pDecoDef->getFill() ? *pDecoDef->getFill() : aFill);
 433
 434                     // create decorated text primitive
 435                     pRetval = new drawinglayer::primitive2d::TextDecoratedPortionPrimitive2D(
 436                         aTextTransform,
 437                         getText(),
 438                         nIndex,
 439                         nLength,
 440                         aTextArray,
 441                         aFontAttribute,
 442                         aLocale,
 443                         aFill,
 444                         COL_TRANSPARENT,
 445
 446                         // extra props for decorated
 447                         aDecoColor,
 448                         aDecoColor,
 449                         TextDecoration::overline == aDeco ? drawinglayer::primitive2d::TEXT_LINE_SINGLE : drawinglayer::primitive2d::TEXT_LINE_NONE,
 450                         TextDecoration::underline == aDeco ? drawinglayer::primitive2d::TEXT_LINE_SINGLE : drawinglayer::primitive2d::TEXT_LINE_NONE,
 451                         false,
 452                         TextDecoration::line_through == aDeco ? drawinglayer::primitive2d::TEXT_STRIKEOUT_SINGLE : drawinglayer::primitive2d::TEXT_STRIKEOUT_NONE,
 453                         false,
 454                         drawinglayer::primitive2d::TEXT_FONT_EMPHASIS_MARK_NONE,
 455                         true,
 456                         false,
 457                         drawinglayer::primitive2d::TEXT_RELIEF_NONE,
 458                         false);
 459                 }
 460                 else
 461                 {
 462                     // create text primitive
 463                     pRetval = new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 464                         aTextTransform,
 465                         getText(),
 466                         nIndex,
 467                         nLength,
 468                         aTextArray,
 469                         aFontAttribute,
 470                         aLocale,
 471                         aFill);
 472                 }
 473
 474                 // advance current TextPosition
 475                 rSvgTextPosition.setPosition(rSvgTextPosition.getPosition() + basegfx::B2DVector(fTextWidth, 0.0));
 476             }
 477
 478             return pRetval;
 479         }
 480
 481         void SvgCharacterNode::decomposeTextWithStyle(
 482             drawinglayer::primitive2d::Primitive2DContainer& rTarget,
 483             SvgTextPosition& rSvgTextPosition,
 484             const SvgStyleAttributes& rSvgStyleAttributes) const
 485         {
 486             const drawinglayer::primitive2d::Primitive2DReference xRef(
 487                 createSimpleTextPrimitive(
 488                     rSvgTextPosition,
 489                     rSvgStyleAttributes));
 490
 491             if(!(xRef.is() && (Visibility::visible == rSvgStyleAttributes.getVisibility())))
 492                 return;
 493
 494             if(!rSvgTextPosition.isRotated())
 495             {
 496                 rTarget.push_back(xRef);
 497             }
 498             else
 499             {
 500                 // need to apply rotations to each character as given
 501                 const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pCandidate =
 502                     dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(xRef.get());
 503
 504                 if(pCandidate)
 505                 {
 506                     const localTextBreakupHelper alocalTextBreakupHelper(*pCandidate, rSvgTextPosition);
 507                     const drawinglayer::primitive2d::Primitive2DContainer& aResult(
 508                         alocalTextBreakupHelper.getResult());
 509
 510                     if(!aResult.empty())
 511                     {
 512                         rTarget.append(aResult);
 513                     }
 514
 515                     // also consume for the implied single space
 516                     rSvgTextPosition.consumeRotation();
 517                 }
 518                 else
 519                 {
 520                     OSL_ENSURE(false, "Used primitive is not a text primitive (!)");
 521                 }
 522             }
 523         }
 524
 525         void SvgCharacterNode::whiteSpaceHandling()
 526         {
 527             if (XmlSpace::Default == getXmlSpace())
 528             {
 529                 maText = whiteSpaceHandlingDefault(maText);
 530             }
 531             else
 532             {
 533                 maText = whiteSpaceHandlingPreserve(maText);
 534             }
 535         }
 536
 537         void SvgCharacterNode::addGap()
 538         {
 539             maText += " ";
 540         }
 541
 542         void SvgCharacterNode::concatenate(std::u16string_view rText)
 543         {
 544             maText += rText;
 545         }
 546
 547         void SvgCharacterNode::decomposeText(drawinglayer::primitive2d::Primitive2DContainer& rTarget, SvgTextPosition& rSvgTextPosition) const
 548         {
 549             if(!getText().isEmpty())
 550             {
 551                 const SvgStyleAttributes* pSvgStyleAttributes = getSvgStyleAttributes();
 552
 553                 if(pSvgStyleAttributes)
 554                 {
 555                     decomposeTextWithStyle(rTarget, rSvgTextPosition, *pSvgStyleAttributes);
 556                 }
 557             }
 558         }
 559
 560
 561         SvgTextPosition::SvgTextPosition(
 562             SvgTextPosition* pParent,
 563             const InfoProvider& rInfoProvider,
 564             const SvgTextPositions& rSvgTextPositions)
 565         :   mpParent(pParent),
 566             maX(), // computed below
 567             maY(), // computed below
 568             maRotate(solveSvgNumberVector(rSvgTextPositions.getRotate(), rInfoProvider)),
 569             mfTextLength(0.0),
 570             maPosition(), // computed below
 571             mnRotationIndex(0),
 572             mbLengthAdjust(rSvgTextPositions.getLengthAdjust()),
 573             mbAbsoluteX(false)
 574         {
 575             // get TextLength if provided
 576             if(rSvgTextPositions.getTextLength().isSet())
 577             {
 578                 mfTextLength = rSvgTextPositions.getTextLength().solve(rInfoProvider);
 579             }
 580
 581             // SVG does not really define in which units a \91rotate\92 for Text/TSpan is given,
 582             // but it seems to be degrees. Convert here to radians
 583             if(!maRotate.empty())
 584             {
 585                 for (double& f : maRotate)
 586                 {
 587                     f = basegfx::deg2rad(f);
 588                 }
 589             }
 590
 591             // get text positions X
 592             const sal_uInt32 nSizeX(rSvgTextPositions.getX().size());
 593
 594             if(nSizeX)
 595             {
 596                 // we have absolute positions, get first one as current text position X
 597                 maPosition.setX(rSvgTextPositions.getX()[0].solve(rInfoProvider, NumberType::xcoordinate));
 598                 mbAbsoluteX = true;
 599
 600                 if(nSizeX > 1)
 601                 {
 602                     // fill deltas to maX
 603                     maX.reserve(nSizeX);
 604
 605                     for(sal_uInt32 a(1); a < nSizeX; a++)
 606                     {
 607                         maX.push_back(rSvgTextPositions.getX()[a].solve(rInfoProvider, NumberType::xcoordinate) - maPosition.getX());
 608                     }
 609                 }
 610             }
 611             else
 612             {
 613                 // no absolute position, get from parent
 614                 if(pParent)
 615                 {
 616                     maPosition.setX(pParent->getPosition().getX());
 617                 }
 618
 619                 const sal_uInt32 nSizeDx(rSvgTextPositions.getDx().size());
 620
 621                 if(nSizeDx)
 622                 {
 623                     // relative positions given, translate position derived from parent
 624                     maPosition.setX(maPosition.getX() + rSvgTextPositions.getDx()[0].solve(rInfoProvider, NumberType::xcoordinate));
 625
 626                     if(nSizeDx > 1)
 627                     {
 628                         // fill deltas to maX
 629                         maX.reserve(nSizeDx);
 630
 631                         for(sal_uInt32 a(1); a < nSizeDx; a++)
 632                         {
 633                             maX.push_back(rSvgTextPositions.getDx()[a].solve(rInfoProvider, NumberType::xcoordinate));
 634                         }
 635                     }
 636                 }
 637             }
 638
 639             // get text positions Y
 640             const sal_uInt32 nSizeY(rSvgTextPositions.getY().size());
 641
 642             if(nSizeY)
 643             {
 644                 // we have absolute positions, get first one as current text position Y
 645                 maPosition.setY(rSvgTextPositions.getY()[0].solve(rInfoProvider, NumberType::ycoordinate));
 646                 mbAbsoluteX = true;
 647
 648                 if(nSizeY > 1)
 649                 {
 650                     // fill deltas to maY
 651                     maY.reserve(nSizeY);
 652
 653                     for(sal_uInt32 a(1); a < nSizeY; a++)
 654                     {
 655                         maY.push_back(rSvgTextPositions.getY()[a].solve(rInfoProvider, NumberType::ycoordinate) - maPosition.getY());
 656                     }
 657                 }
 658             }
 659             else
 660             {
 661                 // no absolute position, get from parent
 662                 if(pParent)
 663                 {
 664                     maPosition.setY(pParent->getPosition().getY());
 665                 }
 666
 667                 const sal_uInt32 nSizeDy(rSvgTextPositions.getDy().size());
 668
 669                 if(nSizeDy)
 670                 {
 671                     // relative positions given, translate position derived from parent
 672                     maPosition.setY(maPosition.getY() + rSvgTextPositions.getDy()[0].solve(rInfoProvider, NumberType::ycoordinate));
 673
 674                     if(nSizeDy > 1)
 675                     {
 676                         // fill deltas to maY
 677                         maY.reserve(nSizeDy);
 678
 679                         for(sal_uInt32 a(1); a < nSizeDy; a++)
 680                         {
 681                             maY.push_back(rSvgTextPositions.getDy()[a].solve(rInfoProvider, NumberType::ycoordinate));
 682                         }
 683                     }
 684                 }
 685             }
 686         }
 687
 688         bool SvgTextPosition::isRotated() const
 689         {
 690             if(maRotate.empty())
 691             {
 692                 if(getParent())
 693                 {
 694                     return getParent()->isRotated();
 695                 }
 696                 else
 697                 {
 698                     return false;
 699                 }
 700             }
 701             else
 702             {
 703                 return true;
 704             }
 705         }
 706
 707         double SvgTextPosition::consumeRotation()
 708         {
 709             double fRetval(0.0);
 710
 711             if(maRotate.empty())
 712             {
 713                 if(getParent())
 714                 {
 715                     fRetval = mpParent->consumeRotation();
 716                 }
 717                 else
 718                 {
 719                     fRetval = 0.0;
 720                 }
 721             }
 722             else
 723             {
 724                 const sal_uInt32 nSize(maRotate.size());
 725
 726                 if(mnRotationIndex < nSize)
 727                 {
 728                     fRetval = maRotate[mnRotationIndex++];
 729                 }
 730                 else
 731                 {
 732                     fRetval = maRotate[nSize - 1];
 733                 }
 734             }
 735
 736             return fRetval;
 737         }
 738
 739 } // end of namespace svgio
 740
 741 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */