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