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