svgio/source/svgreader/svgpatternnode.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 <svgpatternnode.hxx>
  21 #include <svgdocument.hxx>
  22
  23 namespace svgio::svgreader
  24 {
  25         void SvgPatternNode::tryToFindLink()
  26         {
  27             if(!mpXLink && !maXLink.isEmpty())
  28             {
  29                 mpXLink = dynamic_cast< const SvgPatternNode* >(getDocument().findSvgNodeById(maXLink));
  30             }
  31         }
  32
  33         SvgPatternNode::SvgPatternNode(
  34             SvgDocument& rDocument,
  35             SvgNode* pParent)
  36         :   SvgNode(SVGToken::Pattern, rDocument, pParent),
  37             aPrimitives(),
  38             maSvgStyleAttributes(*this),
  39             maSvgAspectRatio(),
  40             maX(),
  41             maY(),
  42             maWidth(),
  43             maHeight(),
  44             mbResolvingLink(false),
  45             maXLink(),
  46             mpXLink(nullptr)
  47         {
  48         }
  49
  50         SvgPatternNode::~SvgPatternNode()
  51         {
  52         }
  53
  54         const SvgStyleAttributes* SvgPatternNode::getSvgStyleAttributes() const
  55         {
  56             return checkForCssStyle("pattern", maSvgStyleAttributes);
  57         }
  58
  59         void SvgPatternNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
  60         {
  61             // call parent
  62             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
  63
  64             // read style attributes
  65             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
  66
  67             // parse own
  68             switch(aSVGToken)
  69             {
  70                 case SVGToken::Style:
  71                 {
  72                     readLocalCssStyle(aContent);
  73                     break;
  74                 }
  75                 case SVGToken::ViewBox:
  76                 {
  77                     const basegfx::B2DRange aRange(readViewBox(aContent, *this));
  78
  79                     if(!aRange.isEmpty())
  80                     {
  81                         setViewBox(&aRange);
  82                     }
  83                     break;
  84                 }
  85                 case SVGToken::PreserveAspectRatio:
  86                 {
  87                     maSvgAspectRatio = readSvgAspectRatio(aContent);
  88                     break;
  89                 }
  90                 case SVGToken::X:
  91                 {
  92                     SvgNumber aNum;
  93
  94                     if(readSingleNumber(aContent, aNum))
  95                     {
  96                         maX = aNum;
  97                     }
  98                     break;
  99                 }
 100                 case SVGToken::Y:
 101                 {
 102                     SvgNumber aNum;
 103
 104                     if(readSingleNumber(aContent, aNum))
 105                     {
 106                         maY = aNum;
 107                     }
 108                     break;
 109                 }
 110                 case SVGToken::Width:
 111                 {
 112                     SvgNumber aNum;
 113
 114                     if(readSingleNumber(aContent, aNum))
 115                     {
 116                         if(aNum.isPositive())
 117                         {
 118                             maWidth = aNum;
 119                         }
 120                     }
 121                     break;
 122                 }
 123                 case SVGToken::Height:
 124                 {
 125                     SvgNumber aNum;
 126
 127                     if(readSingleNumber(aContent, aNum))
 128                     {
 129                         if(aNum.isPositive())
 130                         {
 131                             maHeight = aNum;
 132                         }
 133                     }
 134                     break;
 135                 }
 136                 case SVGToken::PatternUnits:
 137                 {
 138                     if(!aContent.isEmpty())
 139                     {
 140                         if(aContent.match(commonStrings::aStrUserSpaceOnUse))
 141                         {
 142                             setPatternUnits(SvgUnits::userSpaceOnUse);
 143                         }
 144                         else if(aContent.match(commonStrings::aStrObjectBoundingBox))
 145                         {
 146                             setPatternUnits(SvgUnits::objectBoundingBox);
 147                         }
 148                     }
 149                     break;
 150                 }
 151                 case SVGToken::PatternContentUnits:
 152                 {
 153                     if(!aContent.isEmpty())
 154                     {
 155                         if(aContent.match(commonStrings::aStrUserSpaceOnUse))
 156                         {
 157                             setPatternContentUnits(SvgUnits::userSpaceOnUse);
 158                         }
 159                         else if(aContent.match(commonStrings::aStrObjectBoundingBox))
 160                         {
 161                             setPatternContentUnits(SvgUnits::objectBoundingBox);
 162                         }
 163                     }
 164                     break;
 165                 }
 166                 case SVGToken::PatternTransform:
 167                 {
 168                     const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
 169
 170                     if(!aMatrix.isIdentity())
 171                     {
 172                         setPatternTransform(&aMatrix);
 173                     }
 174                     break;
 175                 }
 176                 case SVGToken::XlinkHref:
 177                 {
 178                     const sal_Int32 nLen(aContent.getLength());
 179
 180                     if(nLen && '#' == aContent[0])
 181                     {
 182                         maXLink = aContent.copy(1);
 183                         tryToFindLink();
 184                     }
 185                     break;
 186                 }
 187                 default:
 188                 {
 189                     break;
 190                 }
 191             }
 192         }
 193
 194         void SvgPatternNode::getValuesRelative(double& rfX, double& rfY, double& rfW, double& rfH, const basegfx::B2DRange& rGeoRange, SvgNode const & rUser) const
 195         {
 196             double fTargetWidth(rGeoRange.getWidth());
 197             double fTargetHeight(rGeoRange.getHeight());
 198
 199             if(fTargetWidth <= 0.0 || fTargetHeight <= 0.0)
 200                 return;
 201
 202             const SvgUnits aPatternUnits(getPatternUnits() ? *getPatternUnits() : SvgUnits::objectBoundingBox);
 203
 204             if (SvgUnits::objectBoundingBox == aPatternUnits)
 205             {
 206                 rfW = (getWidth().isSet()) ? getWidth().getNumber() : 0.0;
 207                 rfH = (getHeight().isSet()) ? getHeight().getNumber() : 0.0;
 208
 209                 if(SvgUnit::percent == getWidth().getUnit())
 210                 {
 211                     rfW *= 0.01;
 212                 }
 213
 214                 if(SvgUnit::percent == getHeight().getUnit())
 215                 {
 216                     rfH *= 0.01;
 217                 }
 218             }
 219             else
 220             {
 221                 rfW = (getWidth().isSet()) ? getWidth().solve(rUser, NumberType::xcoordinate) : 0.0;
 222                 rfH = (getHeight().isSet()) ? getHeight().solve(rUser, NumberType::ycoordinate) : 0.0;
 223
 224                 // make relative to rGeoRange
 225                 rfW /= fTargetWidth;
 226                 rfH /= fTargetHeight;
 227             }
 228
 229             if(rfW <= 0.0 || rfH <= 0.0)
 230                 return;
 231
 232             if (SvgUnits::objectBoundingBox == aPatternUnits)
 233             {
 234                 rfX = (getX().isSet()) ? getX().getNumber() : 0.0;
 235                 rfY = (getY().isSet()) ? getY().getNumber() : 0.0;
 236
 237                 if(SvgUnit::percent == getX().getUnit())
 238                 {
 239                     rfX *= 0.01;
 240                 }
 241
 242                 if(SvgUnit::percent == getY().getUnit())
 243                 {
 244                     rfY *= 0.01;
 245                 }
 246             }
 247             else
 248             {
 249                 rfX = (getX().isSet()) ? getX().solve(rUser, NumberType::xcoordinate) : 0.0;
 250                 rfY = (getY().isSet()) ? getY().solve(rUser, NumberType::ycoordinate) : 0.0;
 251
 252                 // make relative to rGeoRange
 253                 rfX = (rfX - rGeoRange.getMinX()) / fTargetWidth;
 254                 rfY = (rfY - rGeoRange.getMinY()) / fTargetHeight;
 255             }
 256         }
 257
 258         const drawinglayer::primitive2d::Primitive2DContainer& SvgPatternNode::getPatternPrimitives() const
 259         {
 260             if(aPrimitives.empty() && Display::None != getDisplay())
 261             {
 262                 decomposeSvgNode(const_cast< SvgPatternNode* >(this)->aPrimitives, true);
 263             }
 264
 265             if(aPrimitives.empty() && !maXLink.isEmpty())
 266             {
 267                 const_cast< SvgPatternNode* >(this)->tryToFindLink();
 268
 269                 if (mpXLink && !mbResolvingLink)
 270                 {
 271                     mbResolvingLink = true;
 272                     const drawinglayer::primitive2d::Primitive2DContainer& ret = mpXLink->getPatternPrimitives();
 273                     mbResolvingLink = false;
 274                     return ret;
 275                 }
 276             }
 277
 278             return aPrimitives;
 279         }
 280
 281         basegfx::B2DRange SvgPatternNode::getCurrentViewPort() const
 282         {
 283             if(getViewBox())
 284             {
 285                 return *(getViewBox());
 286             }
 287             else
 288             {
 289                 return SvgNode::getCurrentViewPort();
 290             }
 291         }
 292
 293         const basegfx::B2DRange* SvgPatternNode::getViewBox() const
 294         {
 295             if(mpViewBox)
 296             {
 297                 return mpViewBox.get();
 298             }
 299
 300             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 301
 302             if (mpXLink && !mbResolvingLink)
 303             {
 304                 mbResolvingLink = true;
 305                 auto ret = mpXLink->getViewBox();
 306                 mbResolvingLink = false;
 307                 return ret;
 308             }
 309
 310             return nullptr;
 311         }
 312
 313         const SvgAspectRatio& SvgPatternNode::getSvgAspectRatio() const
 314         {
 315             if(maSvgAspectRatio.isSet())
 316             {
 317                 return maSvgAspectRatio;
 318             }
 319
 320             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 321
 322             if (mpXLink && !mbResolvingLink)
 323             {
 324                 mbResolvingLink = true;
 325                 const SvgAspectRatio& ret = mpXLink->getSvgAspectRatio();
 326                 mbResolvingLink = false;
 327                 return ret;
 328             }
 329
 330             return maSvgAspectRatio;
 331         }
 332
 333         const SvgNumber& SvgPatternNode::getX() const
 334         {
 335             if(maX.isSet())
 336             {
 337                 return maX;
 338             }
 339
 340             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 341
 342             if (mpXLink && !mbResolvingLink)
 343             {
 344                 mbResolvingLink = true;
 345                 const SvgNumber& ret = mpXLink->getX();
 346                 mbResolvingLink = false;
 347                 return ret;
 348             }
 349
 350             return maX;
 351         }
 352
 353         const SvgNumber& SvgPatternNode::getY() const
 354         {
 355             if(maY.isSet())
 356             {
 357                 return maY;
 358             }
 359
 360             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 361
 362             if (mpXLink && !mbResolvingLink)
 363             {
 364                 mbResolvingLink = true;
 365                 const SvgNumber& ret = mpXLink->getY();
 366                 mbResolvingLink = false;
 367                 return ret;
 368             }
 369
 370             return maY;
 371         }
 372
 373         const SvgNumber& SvgPatternNode::getWidth() const
 374         {
 375             if(maWidth.isSet())
 376             {
 377                 return maWidth;
 378             }
 379
 380             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 381
 382             if (mpXLink && !mbResolvingLink)
 383             {
 384                 mbResolvingLink = true;
 385                 const SvgNumber& ret = mpXLink->getWidth();
 386                 mbResolvingLink = false;
 387                 return ret;
 388             }
 389
 390             return maWidth;
 391         }
 392
 393         const SvgNumber& SvgPatternNode::getHeight() const
 394         {
 395             if(maHeight.isSet())
 396             {
 397                 return maHeight;
 398             }
 399
 400             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 401
 402             if (mpXLink && !mbResolvingLink)
 403             {
 404                 mbResolvingLink = true;
 405                 const SvgNumber& ret = mpXLink->getHeight();
 406                 mbResolvingLink = false;
 407                 return ret;
 408             }
 409
 410             return maHeight;
 411         }
 412
 413         const SvgUnits* SvgPatternNode::getPatternUnits() const
 414         {
 415             if(mpPatternUnits)
 416             {
 417                 return mpPatternUnits.get();
 418             }
 419
 420             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 421
 422             if (mpXLink && !mbResolvingLink)
 423             {
 424                 mbResolvingLink = true;
 425                 auto ret = mpXLink->getPatternUnits();
 426                 mbResolvingLink = false;
 427                 return ret;
 428             }
 429
 430             return nullptr;
 431         }
 432
 433         const SvgUnits* SvgPatternNode::getPatternContentUnits() const
 434         {
 435             if(mpPatternContentUnits)
 436             {
 437                 return mpPatternContentUnits.get();
 438             }
 439
 440             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 441
 442             if (mpXLink && !mbResolvingLink)
 443             {
 444                 mbResolvingLink = true;
 445                 auto ret = mpXLink->getPatternContentUnits();
 446                 mbResolvingLink = false;
 447                 return ret;
 448             }
 449
 450             return nullptr;
 451         }
 452
 453         const basegfx::B2DHomMatrix* SvgPatternNode::getPatternTransform() const
 454         {
 455             if(mpaPatternTransform)
 456             {
 457                 return mpaPatternTransform.get();
 458             }
 459
 460             const_cast< SvgPatternNode* >(this)->tryToFindLink();
 461
 462             if (mpXLink && !mbResolvingLink)
 463             {
 464                 mbResolvingLink = true;
 465                 auto ret = mpXLink->getPatternTransform();
 466                 mbResolvingLink = false;
 467                 return ret;
 468             }
 469
 470             return nullptr;
 471         }
 472
 473 } // end of namespace svgio::svgreader
 474
 475 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */