svgio/source/svgreader/svggradientnode.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 <svggradientnode.hxx>
  21 #include <svgdocument.hxx>
  22 #include <svggradientstopnode.hxx>
  23
  24 namespace svgio::svgreader
  25 {
  26         void SvgGradientNode::tryToFindLink()
  27         {
  28             if(!mpXLink && !maXLink.isEmpty())
  29             {
  30                 mpXLink = dynamic_cast< const SvgGradientNode* >(getDocument().findSvgNodeById(maXLink));
  31             }
  32         }
  33
  34         SvgGradientNode::SvgGradientNode(
  35             SVGToken aType,
  36             SvgDocument& rDocument,
  37             SvgNode* pParent)
  38         :   SvgNode(aType, rDocument, pParent),
  39             maSvgStyleAttributes(*this),
  40             maX1(),
  41             maY1(),
  42             maX2(),
  43             maY2(),
  44             maCx(),
  45             maCy(),
  46             maR(),
  47             maFx(),
  48             maFy(),
  49             maGradientUnits(SvgUnits::objectBoundingBox),
  50             maSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Pad),
  51             mbResolvingLink(false),
  52             maXLink(),
  53             mpXLink(nullptr)
  54         {
  55             OSL_ENSURE(aType == SVGToken::LinearGradient || aType == SVGToken::RadialGradient, "SvgGradientNode should only be used for Linear and Radial gradient (!)");
  56         }
  57
  58         SvgGradientNode::~SvgGradientNode()
  59         {
  60             // do NOT delete mpXLink, it's only referenced, not owned
  61         }
  62
  63         const SvgStyleAttributes* SvgGradientNode::getSvgStyleAttributes() const
  64         {
  65             return checkForCssStyle(
  66                 SVGToken::LinearGradient == getType() ? OUString("linearGradient") : OUString("radialGradient"),
  67                 maSvgStyleAttributes);
  68         }
  69
  70         void SvgGradientNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
  71         {
  72             // call parent
  73             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
  74
  75             // read style attributes
  76             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
  77
  78             // parse own
  79             switch(aSVGToken)
  80             {
  81                 case SVGToken::Style:
  82                 {
  83                     readLocalCssStyle(aContent);
  84                     break;
  85                 }
  86                 case SVGToken::X1:
  87                 {
  88                     SvgNumber aNum;
  89
  90                     if(readSingleNumber(aContent, aNum))
  91                     {
  92                         maX1 = aNum;
  93                     }
  94                     break;
  95                 }
  96                 case SVGToken::Y1:
  97                 {
  98                     SvgNumber aNum;
  99
 100                     if(readSingleNumber(aContent, aNum))
 101                     {
 102                         maY1 = aNum;
 103                     }
 104                     break;
 105                 }
 106                 case SVGToken::X2:
 107                 {
 108                     SvgNumber aNum;
 109
 110                     if(readSingleNumber(aContent, aNum))
 111                     {
 112                         maX2 = aNum;
 113                     }
 114                     break;
 115                 }
 116                 case SVGToken::Y2:
 117                 {
 118                     SvgNumber aNum;
 119
 120                     if(readSingleNumber(aContent, aNum))
 121                     {
 122                         maY2 = aNum;
 123                     }
 124                     break;
 125                 }
 126                 case SVGToken::Cx:
 127                 {
 128                     SvgNumber aNum;
 129
 130                     if(readSingleNumber(aContent, aNum))
 131                     {
 132                         maCx = aNum;
 133                     }
 134                     break;
 135                 }
 136                 case SVGToken::Cy:
 137                 {
 138                     SvgNumber aNum;
 139
 140                     if(readSingleNumber(aContent, aNum))
 141                     {
 142                         maCy = aNum;
 143                     }
 144                     break;
 145                 }
 146                 case SVGToken::Fx:
 147                 {
 148                     SvgNumber aNum;
 149
 150                     if(readSingleNumber(aContent, aNum))
 151                     {
 152                         maFx = aNum;
 153                     }
 154                     break;
 155                 }
 156                 case SVGToken::Fy:
 157                 {
 158                     SvgNumber aNum;
 159
 160                     if(readSingleNumber(aContent, aNum))
 161                     {
 162                         maFy = aNum;
 163                     }
 164                     break;
 165                 }
 166                 case SVGToken::R:
 167                 {
 168                     SvgNumber aNum;
 169
 170                     if(readSingleNumber(aContent, aNum))
 171                     {
 172                         if(aNum.isPositive())
 173                         {
 174                             maR = aNum;
 175                         }
 176                     }
 177                     break;
 178                 }
 179                 case SVGToken::GradientUnits:
 180                 {
 181                     if(!aContent.isEmpty())
 182                     {
 183                         if(aContent.match(commonStrings::aStrUserSpaceOnUse))
 184                         {
 185                             setGradientUnits(SvgUnits::userSpaceOnUse);
 186                         }
 187                         else if(aContent.match(commonStrings::aStrObjectBoundingBox))
 188                         {
 189                             setGradientUnits(SvgUnits::objectBoundingBox);
 190                         }
 191                     }
 192                     break;
 193                 }
 194                 case SVGToken::SpreadMethod:
 195                 {
 196                     if(!aContent.isEmpty())
 197                     {
 198                         if(aContent.startsWith("pad"))
 199                         {
 200                             setSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Pad);
 201                         }
 202                         else if(aContent.startsWith("reflect"))
 203                         {
 204                             setSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Reflect);
 205                         }
 206                         else if(aContent.startsWith("repeat"))
 207                         {
 208                             setSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Repeat);
 209                         }
 210                     }
 211                     break;
 212                 }
 213                 case SVGToken::GradientTransform:
 214                 {
 215                     const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
 216
 217                     if(!aMatrix.isIdentity())
 218                     {
 219                         setGradientTransform(&aMatrix);
 220                     }
 221                     break;
 222                 }
 223                 case SVGToken::XlinkHref:
 224                 {
 225                     const sal_Int32 nLen(aContent.getLength());
 226
 227                     if(nLen && '#' == aContent[0])
 228                     {
 229                         maXLink = aContent.copy(1);
 230                         tryToFindLink();
 231                     }
 232                     break;
 233                 }
 234                 default:
 235                 {
 236                     break;
 237                 }
 238             }
 239         }
 240
 241         void SvgGradientNode::collectGradientEntries(drawinglayer::primitive2d::SvgGradientEntryVector& aVector) const
 242         {
 243             if(getChildren().empty())
 244             {
 245                 const_cast< SvgGradientNode* >(this)->tryToFindLink();
 246
 247                 if (mpXLink && !mbResolvingLink)
 248                 {
 249                     mbResolvingLink = true;
 250                     mpXLink->collectGradientEntries(aVector);
 251                     mbResolvingLink = false;
 252                 }
 253             }
 254             else
 255             {
 256                 const sal_uInt32 nCount(getChildren().size());
 257
 258                 for(sal_uInt32 a(0); a < nCount; a++)
 259                 {
 260                     const SvgGradientStopNode* pCandidate = dynamic_cast< const SvgGradientStopNode* >(getChildren()[a].get());
 261
 262                     if(pCandidate)
 263                     {
 264                         const SvgStyleAttributes* pStyle = pCandidate->getSvgStyleAttributes();
 265
 266                         if(pStyle)
 267                         {
 268                             const SvgNumber aOffset(pCandidate->getOffset());
 269                             double fOffset(0.0);
 270
 271                             if(SvgUnit::percent == aOffset.getUnit())
 272                             {
 273                                 // percent is not relative to distances in ColorStop context, solve locally
 274                                 fOffset = aOffset.getNumber() * 0.01;
 275                             }
 276                             else
 277                             {
 278                                 fOffset = aOffset.solve(*this);
 279                             }
 280
 281                             if(fOffset < 0.0)
 282                             {
 283                                 OSL_ENSURE(false, "OOps, SvgGradientStopNode with offset out of range (!)");
 284                                 fOffset = 0.0;
 285                             }
 286                             else if(fOffset > 1.0)
 287                             {
 288                                 OSL_ENSURE(false, "OOps, SvgGradientStopNode with offset out of range (!)");
 289                                 fOffset = 1.0;
 290                             }
 291
 292                             aVector.emplace_back(
 293                                     fOffset,
 294                                     pStyle->getStopColor(),
 295                                     pStyle->getStopOpacity().solve(*this));
 296                         }
 297                         else
 298                         {
 299                             OSL_ENSURE(false, "OOps, SvgGradientStopNode without Style (!)");
 300                         }
 301                     }
 302                 }
 303             }
 304         }
 305
 306         SvgNumber SvgGradientNode::getX1() const
 307         {
 308             if(maX1.isSet())
 309             {
 310                 return maX1;
 311             }
 312
 313             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 314
 315             if (mpXLink && !mbResolvingLink)
 316             {
 317                 mbResolvingLink = true;
 318                 auto ret = mpXLink->getX1();
 319                 mbResolvingLink = false;
 320                 return ret;
 321             }
 322
 323             // default is 0%
 324             return SvgNumber(0.0, SvgUnit::percent);
 325         }
 326
 327         SvgNumber SvgGradientNode::getY1() const
 328         {
 329             if(maY1.isSet())
 330             {
 331                 return maY1;
 332             }
 333
 334             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 335
 336             if (mpXLink && !mbResolvingLink)
 337             {
 338                 mbResolvingLink = true;
 339                 auto ret = mpXLink->getY1();
 340                 mbResolvingLink = false;
 341                 return ret;
 342             }
 343
 344             // default is 0%
 345             return SvgNumber(0.0, SvgUnit::percent);
 346         }
 347
 348         SvgNumber SvgGradientNode::getX2() const
 349         {
 350             if(maX2.isSet())
 351             {
 352                 return maX2;
 353             }
 354
 355             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 356
 357             if (mpXLink && !mbResolvingLink)
 358             {
 359                 mbResolvingLink = true;
 360                 auto ret = mpXLink->getX2();
 361                 mbResolvingLink = false;
 362                 return ret;
 363             }
 364
 365             // default is 100%
 366             return SvgNumber(100.0, SvgUnit::percent);
 367         }
 368
 369         SvgNumber SvgGradientNode::getY2() const
 370         {
 371             if(maY2.isSet())
 372             {
 373                 return maY2;
 374             }
 375
 376             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 377
 378             if (mpXLink && !mbResolvingLink)
 379             {
 380                 mbResolvingLink = true;
 381                 auto ret = mpXLink->getY2();
 382                 mbResolvingLink = false;
 383                 return ret;
 384             }
 385
 386             // default is 0%
 387             return SvgNumber(0.0, SvgUnit::percent);
 388         }
 389
 390         SvgNumber SvgGradientNode::getCx() const
 391         {
 392             if(maCx.isSet())
 393             {
 394                 return maCx;
 395             }
 396
 397             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 398
 399             if (mpXLink && !mbResolvingLink)
 400             {
 401                 mbResolvingLink = true;
 402                 auto ret = mpXLink->getCx();
 403                 mbResolvingLink = false;
 404                 return ret;
 405             }
 406
 407             // default is 50%
 408             return SvgNumber(50.0, SvgUnit::percent);
 409         }
 410
 411         SvgNumber SvgGradientNode::getCy() const
 412         {
 413             if(maCy.isSet())
 414             {
 415                 return maCy;
 416             }
 417
 418             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 419
 420             if (mpXLink && !mbResolvingLink)
 421             {
 422                 mbResolvingLink = true;
 423                 auto ret = mpXLink->getCy();
 424                 mbResolvingLink = false;
 425                 return ret;
 426             }
 427
 428             // default is 50%
 429             return SvgNumber(50.0, SvgUnit::percent);
 430         }
 431
 432         SvgNumber SvgGradientNode::getR() const
 433         {
 434             if(maR.isSet())
 435             {
 436                 return maR;
 437             }
 438
 439             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 440
 441             if (mpXLink && !mbResolvingLink)
 442             {
 443                 mbResolvingLink = true;
 444                 auto ret = mpXLink->getR();
 445                 mbResolvingLink = false;
 446                 return ret;
 447             }
 448
 449             // default is 50%
 450             return SvgNumber(50.0, SvgUnit::percent);
 451         }
 452
 453         const SvgNumber* SvgGradientNode::getFx() const
 454         {
 455             if(maFx.isSet())
 456             {
 457                 return &maFx;
 458             }
 459
 460             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 461
 462             if (mpXLink && !mbResolvingLink)
 463             {
 464                 mbResolvingLink = true;
 465                 auto ret = mpXLink->getFx();
 466                 mbResolvingLink = false;
 467                 return ret;
 468             }
 469
 470             return nullptr;
 471         }
 472
 473         const SvgNumber* SvgGradientNode::getFy() const
 474         {
 475             if(maFy.isSet())
 476             {
 477                 return &maFy;
 478             }
 479
 480             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 481
 482             if (mpXLink && !mbResolvingLink)
 483             {
 484                 mbResolvingLink = true;
 485                 auto ret = mpXLink->getFy();
 486                 mbResolvingLink = false;
 487                 return ret;
 488             }
 489
 490             return nullptr;
 491         }
 492
 493         const basegfx::B2DHomMatrix* SvgGradientNode::getGradientTransform() const
 494         {
 495             if(mpaGradientTransform)
 496             {
 497                 return mpaGradientTransform.get();
 498             }
 499
 500             const_cast< SvgGradientNode* >(this)->tryToFindLink();
 501
 502             if (mpXLink && !mbResolvingLink)
 503             {
 504                 mbResolvingLink = true;
 505                 auto ret = mpXLink->getGradientTransform();
 506                 mbResolvingLink = false;
 507                 return ret;
 508             }
 509
 510             return nullptr;
 511         }
 512
 513         void SvgGradientNode::setGradientTransform(const basegfx::B2DHomMatrix* pMatrix)
 514         {
 515             mpaGradientTransform.reset();
 516
 517             if(pMatrix)
 518             {
 519                 mpaGradientTransform.reset(new basegfx::B2DHomMatrix(*pMatrix) );
 520             }
 521         }
 522
 523 } // end of namespace svgio::svgreader
 524
 525 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */