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