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