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 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
  28 #include <utility>
  29 #include <o3tl/string_view.hxx>
  30 #include <osl/diagnose.h>
  31
  32 using namespace drawinglayer::primitive2d;
  33
  34 namespace svgio::svgreader
  35 {
  36         SvgTextPositions::SvgTextPositions()
  37         :  mbLengthAdjust(true)
  38         {
  39         }
  40
  41         void SvgTextPositions::parseTextPositionAttributes(SVGToken aSVGToken, std::u16string_view aContent)
  42         {
  43             // parse own
  44             switch(aSVGToken)
  45             {
  46                 case SVGToken::X:
  47                 {
  48                     if(!aContent.empty())
  49                     {
  50                         SvgNumberVector aVector;
  51
  52                         if(readSvgNumberVector(aContent, aVector))
  53                         {
  54                             setX(std::move(aVector));
  55                         }
  56                     }
  57                     break;
  58                 }
  59                 case SVGToken::Y:
  60                 {
  61                     if(!aContent.empty())
  62                     {
  63                         SvgNumberVector aVector;
  64
  65                         if(readSvgNumberVector(aContent, aVector))
  66                         {
  67                             setY(std::move(aVector));
  68                         }
  69                     }
  70                     break;
  71                 }
  72                 case SVGToken::Dx:
  73                 {
  74                     if(!aContent.empty())
  75                     {
  76                         SvgNumberVector aVector;
  77
  78                         if(readSvgNumberVector(aContent, aVector))
  79                         {
  80                             setDx(std::move(aVector));
  81                         }
  82                     }
  83                     break;
  84                 }
  85                 case SVGToken::Dy:
  86                 {
  87                     if(!aContent.empty())
  88                     {
  89                         SvgNumberVector aVector;
  90
  91                         if(readSvgNumberVector(aContent, aVector))
  92                         {
  93                             setDy(std::move(aVector));
  94                         }
  95                     }
  96                     break;
  97                 }
  98                 case SVGToken::Rotate:
  99                 {
 100                     if(!aContent.empty())
 101                     {
 102                         SvgNumberVector aVector;
 103
 104                         if(readSvgNumberVector(aContent, aVector))
 105                         {
 106                             setRotate(std::move(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.empty())
 127                     {
 128                         if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"spacing"))
 129                         {
 130                             setLengthAdjust(true);
 131                         }
 132                         else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"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 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 TextSimplePortionPrimitive2D& rSource,
 161                 SvgTextPosition& rSvgTextPosition)
 162             :   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             OUString aText)
 190         :   SvgNode(SVGToken::Character, rDocument, pParent),
 191             maText(std::move(aText))
 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<BasePrimitive2D> SvgCharacterNode::createSimpleTextPrimitive(
 213             SvgTextPosition& rSvgTextPosition,
 214             const SvgStyleAttributes& rSvgStyleAttributes) const
 215         {
 216             // prepare retval, index and length
 217             rtl::Reference<BasePrimitive2D> 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("Times New Roman");
 226                 if(!rFontFamilyVector.empty())
 227                     aFontFamily=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                 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(const auto &a : aExtendArray)
 288                         {
 289                             aTextArray.push_back(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(auto &a : aTextArray)
 313                         {
 314                             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                 basegfx::BColor aFill(0, 0, 0);
 413                 if(rSvgStyleAttributes.getFill())
 414                     aFill = *rSvgStyleAttributes.getFill();
 415
 416                 // get fill opacity
 417                 double fFillOpacity = 1.0;
 418                 if (rSvgStyleAttributes.getFillOpacity().isSet())
 419                 {
 420                     fFillOpacity = rSvgStyleAttributes.getFillOpacity().getNumber();
 421                 }
 422
 423                 // prepare TextTransformation
 424                 basegfx::B2DHomMatrix aTextTransform;
 425
 426                 aTextTransform.scale(fFontWidth, fFontHeight);
 427                 aTextTransform.translate(aPosition.getX(), aPosition.getY());
 428
 429                 // check TextDecoration and if TextDecoratedPortionPrimitive2D is needed
 430                 const TextDecoration aDeco(rSvgStyleAttributes.getTextDecoration());
 431
 432                 if(TextDecoration::underline == aDeco
 433                     || TextDecoration::overline == aDeco
 434                     || TextDecoration::line_through == aDeco)
 435                 {
 436                     // get the fill for decoration as described by SVG. We cannot
 437                     // have different stroke colors/definitions for those, though
 438                     const SvgStyleAttributes* pDecoDef = rSvgStyleAttributes.getTextDecorationDefiningSvgStyleAttributes();
 439
 440                     basegfx::BColor aDecoColor(aFill);
 441                     if(pDecoDef && pDecoDef->getFill())
 442                         aDecoColor = *pDecoDef->getFill();
 443
 444                     TextLine eFontOverline = TEXT_LINE_NONE;
 445                     if(TextDecoration::overline == aDeco)
 446                         eFontOverline = TEXT_LINE_SINGLE;
 447
 448                     TextLine eFontUnderline = TEXT_LINE_NONE;
 449                     if(TextDecoration::underline == aDeco)
 450                         eFontUnderline = TEXT_LINE_SINGLE;
 451
 452                     TextStrikeout eTextStrikeout = TEXT_STRIKEOUT_NONE;
 453                     if(TextDecoration::line_through == aDeco)
 454                         eTextStrikeout = TEXT_STRIKEOUT_SINGLE;
 455
 456                     // create decorated text primitive
 457                     pRetval = new TextDecoratedPortionPrimitive2D(
 458                         aTextTransform,
 459                         getText(),
 460                         nIndex,
 461                         nLength,
 462                         std::move(aTextArray),
 463                         {},
 464                         aFontAttribute,
 465                         aLocale,
 466                         aFill,
 467                         COL_TRANSPARENT,
 468
 469                         // extra props for decorated
 470                         aDecoColor,
 471                         aDecoColor,
 472                         eFontOverline,
 473                         eFontUnderline,
 474                         false,
 475                         eTextStrikeout,
 476                         false,
 477                         TEXT_FONT_EMPHASIS_MARK_NONE,
 478                         true,
 479                         false,
 480                         TEXT_RELIEF_NONE,
 481                         false);
 482                 }
 483                 else
 484                 {
 485                     // create text primitive
 486                     pRetval = new TextSimplePortionPrimitive2D(
 487                         aTextTransform,
 488                         getText(),
 489                         nIndex,
 490                         nLength,
 491                         std::move(aTextArray),
 492                         {},
 493                         aFontAttribute,
 494                         aLocale,
 495                         aFill);
 496                 }
 497
 498                 if (fFillOpacity != 1.0)
 499                 {
 500                     pRetval = new UnifiedTransparencePrimitive2D(
 501                         drawinglayer::primitive2d::Primitive2DContainer{ pRetval },
 502                         1.0 - fFillOpacity);
 503                 }
 504
 505                 // advance current TextPosition
 506                 rSvgTextPosition.setPosition(rSvgTextPosition.getPosition() + basegfx::B2DVector(fTextWidth, 0.0));
 507             }
 508
 509             return pRetval;
 510         }
 511
 512         void SvgCharacterNode::decomposeTextWithStyle(
 513             Primitive2DContainer& rTarget,
 514             SvgTextPosition& rSvgTextPosition,
 515             const SvgStyleAttributes& rSvgStyleAttributes) const
 516         {
 517             const Primitive2DReference xRef(
 518                 createSimpleTextPrimitive(
 519                     rSvgTextPosition,
 520                     rSvgStyleAttributes));
 521
 522             if(!(xRef.is() && (Visibility::visible == rSvgStyleAttributes.getVisibility())))
 523                 return;
 524
 525             if(!rSvgTextPosition.isRotated())
 526             {
 527                 rTarget.push_back(xRef);
 528             }
 529             else
 530             {
 531                 // need to apply rotations to each character as given
 532                 const TextSimplePortionPrimitive2D* pCandidate =
 533                     dynamic_cast< const TextSimplePortionPrimitive2D* >(xRef.get());
 534
 535                 if(pCandidate)
 536                 {
 537                     localTextBreakupHelper alocalTextBreakupHelper(*pCandidate, rSvgTextPosition);
 538                     Primitive2DContainer aResult = alocalTextBreakupHelper.extractResult();
 539
 540                     if(!aResult.empty())
 541                     {
 542                         rTarget.append(std::move(aResult));
 543                     }
 544
 545                     // also consume for the implied single space
 546                     rSvgTextPosition.consumeRotation();
 547                 }
 548                 else
 549                 {
 550                     OSL_ENSURE(false, "Used primitive is not a text primitive (!)");
 551                 }
 552             }
 553         }
 554
 555         void SvgCharacterNode::whiteSpaceHandling()
 556         {
 557             bool bIsDefault(XmlSpace::Default == getXmlSpace());
 558             // if xml:space="default" then remove all newline characters, otherwise convert them to space
 559             // convert tab to space too
 560             maText = maTextBeforeSpaceHandling = maText.replaceAll(u"\n", bIsDefault ? u"" : u" ").replaceAll(u"\t", u" ");
 561
 562             if(bIsDefault)
 563             {
 564                 // strip of all leading and trailing spaces
 565                 // and consolidate contiguous space
 566                 maText = consolidateContiguousSpace(maText.trim());
 567             }
 568         }
 569
 570         void SvgCharacterNode::addGap()
 571         {
 572             maText += " ";
 573         }
 574
 575         void SvgCharacterNode::concatenate(std::u16string_view rText)
 576         {
 577             maText += rText;
 578         }
 579
 580         void SvgCharacterNode::decomposeText(Primitive2DContainer& rTarget, SvgTextPosition& rSvgTextPosition) const
 581         {
 582             if(!getText().isEmpty())
 583             {
 584                 const SvgStyleAttributes* pSvgStyleAttributes = getSvgStyleAttributes();
 585
 586                 if(pSvgStyleAttributes)
 587                 {
 588                     decomposeTextWithStyle(rTarget, rSvgTextPosition, *pSvgStyleAttributes);
 589                 }
 590             }
 591         }
 592
 593
 594         SvgTextPosition::SvgTextPosition(
 595             SvgTextPosition* pParent,
 596             const InfoProvider& rInfoProvider,
 597             const SvgTextPositions& rSvgTextPositions)
 598         :   mpParent(pParent),
 599             maRotate(solveSvgNumberVector(rSvgTextPositions.getRotate(), rInfoProvider)),
 600             mfTextLength(0.0),
 601             mnRotationIndex(0),
 602             mbLengthAdjust(rSvgTextPositions.getLengthAdjust()),
 603             mbAbsoluteX(false)
 604         {
 605             // get TextLength if provided
 606             if(rSvgTextPositions.getTextLength().isSet())
 607             {
 608                 mfTextLength = rSvgTextPositions.getTextLength().solve(rInfoProvider);
 609             }
 610
 611             // SVG does not really define in which units a \91rotate\92 for Text/TSpan is given,
 612             // but it seems to be degrees. Convert here to radians
 613             if(!maRotate.empty())
 614             {
 615                 for (double& f : maRotate)
 616                 {
 617                     f = basegfx::deg2rad(f);
 618                 }
 619             }
 620
 621             // get text positions X
 622             const sal_uInt32 nSizeX(rSvgTextPositions.getX().size());
 623
 624             if(nSizeX)
 625             {
 626                 // we have absolute positions, get first one as current text position X
 627                 maPosition.setX(rSvgTextPositions.getX()[0].solve(rInfoProvider, NumberType::xcoordinate));
 628                 mbAbsoluteX = true;
 629
 630                 if(nSizeX > 1)
 631                 {
 632                     // fill deltas to maX
 633                     maX.reserve(nSizeX);
 634
 635                     for(sal_uInt32 a(1); a < nSizeX; a++)
 636                     {
 637                         maX.push_back(rSvgTextPositions.getX()[a].solve(rInfoProvider, NumberType::xcoordinate) - maPosition.getX());
 638                     }
 639                 }
 640             }
 641             else
 642             {
 643                 // no absolute position, get from parent
 644                 if(pParent)
 645                 {
 646                     maPosition.setX(pParent->getPosition().getX());
 647                 }
 648
 649                 const sal_uInt32 nSizeDx(rSvgTextPositions.getDx().size());
 650
 651                 if(nSizeDx)
 652                 {
 653                     // relative positions given, translate position derived from parent
 654                     maPosition.setX(maPosition.getX() + rSvgTextPositions.getDx()[0].solve(rInfoProvider, NumberType::xcoordinate));
 655
 656                     if(nSizeDx > 1)
 657                     {
 658                         // fill deltas to maX
 659                         maX.reserve(nSizeDx);
 660
 661                         for(sal_uInt32 a(1); a < nSizeDx; a++)
 662                         {
 663                             maX.push_back(rSvgTextPositions.getDx()[a].solve(rInfoProvider, NumberType::xcoordinate));
 664                         }
 665                     }
 666                 }
 667             }
 668
 669             // get text positions Y
 670             const sal_uInt32 nSizeY(rSvgTextPositions.getY().size());
 671
 672             if(nSizeY)
 673             {
 674                 // we have absolute positions, get first one as current text position Y
 675                 maPosition.setY(rSvgTextPositions.getY()[0].solve(rInfoProvider, NumberType::ycoordinate));
 676                 mbAbsoluteX = true;
 677
 678                 if(nSizeY > 1)
 679                 {
 680                     // fill deltas to maY
 681                     maY.reserve(nSizeY);
 682
 683                     for(sal_uInt32 a(1); a < nSizeY; a++)
 684                     {
 685                         maY.push_back(rSvgTextPositions.getY()[a].solve(rInfoProvider, NumberType::ycoordinate) - maPosition.getY());
 686                     }
 687                 }
 688             }
 689             else
 690             {
 691                 // no absolute position, get from parent
 692                 if(pParent)
 693                 {
 694                     maPosition.setY(pParent->getPosition().getY());
 695                 }
 696
 697                 const sal_uInt32 nSizeDy(rSvgTextPositions.getDy().size());
 698
 699                 if(nSizeDy)
 700                 {
 701                     // relative positions given, translate position derived from parent
 702                     maPosition.setY(maPosition.getY() + rSvgTextPositions.getDy()[0].solve(rInfoProvider, NumberType::ycoordinate));
 703
 704                     if(nSizeDy > 1)
 705                     {
 706                         // fill deltas to maY
 707                         maY.reserve(nSizeDy);
 708
 709                         for(sal_uInt32 a(1); a < nSizeDy; a++)
 710                         {
 711                             maY.push_back(rSvgTextPositions.getDy()[a].solve(rInfoProvider, NumberType::ycoordinate));
 712                         }
 713                     }
 714                 }
 715             }
 716         }
 717
 718         bool SvgTextPosition::isRotated() const
 719         {
 720             if(maRotate.empty())
 721             {
 722                 if(getParent())
 723                 {
 724                     return getParent()->isRotated();
 725                 }
 726                 else
 727                 {
 728                     return false;
 729                 }
 730             }
 731             else
 732             {
 733                 return true;
 734             }
 735         }
 736
 737         double SvgTextPosition::consumeRotation()
 738         {
 739             double fRetval(0.0);
 740
 741             if(maRotate.empty())
 742             {
 743                 if(getParent())
 744                 {
 745                     fRetval = mpParent->consumeRotation();
 746                 }
 747                 else
 748                 {
 749                     fRetval = 0.0;
 750                 }
 751             }
 752             else
 753             {
 754                 const sal_uInt32 nSize(maRotate.size());
 755
 756                 if(mnRotationIndex < nSize)
 757                 {
 758                     fRetval = maRotate[mnRotationIndex++];
 759                 }
 760                 else
 761                 {
 762                     fRetval = maRotate[nSize - 1];
 763                 }
 764             }
 765
 766             return fRetval;
 767         }
 768
 769 } // end of namespace svgio
 770
 771 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */