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