svgio/source/svgreader/svgmasknode.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 <svgmasknode.hxx>
  21 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  22 #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>
  23 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  24 #include <drawinglayer/geometry/viewinformation2d.hxx>
  25 #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
  26 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
  27 #include <basegfx/polygon/b2dpolygontools.hxx>
  28 #include <basegfx/polygon/b2dpolygon.hxx>
  29
  30 namespace svgio::svgreader
  31 {
  32         SvgMaskNode::SvgMaskNode(
  33             SvgDocument& rDocument,
  34             SvgNode* pParent)
  35         :   SvgNode(SVGToken::Mask, rDocument, pParent),
  36             maSvgStyleAttributes(*this),
  37             maX(SvgNumber(-10.0, SvgUnit::percent, true)),
  38             maY(SvgNumber(-10.0, SvgUnit::percent, true)),
  39             maWidth(SvgNumber(120.0, SvgUnit::percent, true)),
  40             maHeight(SvgNumber(120.0, SvgUnit::percent, true)),
  41             maMaskUnits(SvgUnits::objectBoundingBox),
  42             maMaskContentUnits(SvgUnits::userSpaceOnUse)
  43         {
  44         }
  45
  46         SvgMaskNode::~SvgMaskNode()
  47         {
  48         }
  49
  50         const SvgStyleAttributes* SvgMaskNode::getSvgStyleAttributes() const
  51         {
  52             return &maSvgStyleAttributes;
  53         }
  54
  55         void SvgMaskNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
  56         {
  57             // call parent
  58             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
  59
  60             // read style attributes
  61             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
  62
  63             // parse own
  64             switch(aSVGToken)
  65             {
  66                 case SVGToken::Style:
  67                 {
  68                     readLocalCssStyle(aContent);
  69                     break;
  70                 }
  71                 case SVGToken::X:
  72                 {
  73                     SvgNumber aNum;
  74
  75                     if(readSingleNumber(aContent, aNum))
  76                     {
  77                         maX = aNum;
  78                     }
  79                     break;
  80                 }
  81                 case SVGToken::Y:
  82                 {
  83                     SvgNumber aNum;
  84
  85                     if(readSingleNumber(aContent, aNum))
  86                     {
  87                         maY = aNum;
  88                     }
  89                     break;
  90                 }
  91                 case SVGToken::Width:
  92                 {
  93                     SvgNumber aNum;
  94
  95                     if(readSingleNumber(aContent, aNum))
  96                     {
  97                         if(aNum.isPositive())
  98                         {
  99                             maWidth = aNum;
 100                         }
 101                     }
 102                     break;
 103                 }
 104                 case SVGToken::Height:
 105                 {
 106                     SvgNumber aNum;
 107
 108                     if(readSingleNumber(aContent, aNum))
 109                     {
 110                         if(aNum.isPositive())
 111                         {
 112                             maHeight = aNum;
 113                         }
 114                     }
 115                     break;
 116                 }
 117                 case SVGToken::Transform:
 118                 {
 119                     const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
 120
 121                     if(!aMatrix.isIdentity())
 122                     {
 123                         setTransform(&aMatrix);
 124                     }
 125                     break;
 126                 }
 127                 case SVGToken::MaskUnits:
 128                 {
 129                     if(!aContent.isEmpty())
 130                     {
 131                         if(aContent.match(commonStrings::aStrUserSpaceOnUse))
 132                         {
 133                             setMaskUnits(SvgUnits::userSpaceOnUse);
 134                         }
 135                         else if(aContent.match(commonStrings::aStrObjectBoundingBox))
 136                         {
 137                             setMaskUnits(SvgUnits::objectBoundingBox);
 138                         }
 139                     }
 140                     break;
 141                 }
 142                 case SVGToken::MaskContentUnits:
 143                 {
 144                     if(!aContent.isEmpty())
 145                     {
 146                         if(aContent.match(commonStrings::aStrUserSpaceOnUse))
 147                         {
 148                             setMaskContentUnits(SvgUnits::userSpaceOnUse);
 149                         }
 150                         else if(aContent.match(commonStrings::aStrObjectBoundingBox))
 151                         {
 152                             setMaskContentUnits(SvgUnits::objectBoundingBox);
 153                         }
 154                     }
 155                     break;
 156                 }
 157                 default:
 158                 {
 159                     break;
 160                 }
 161             }
 162         }
 163
 164         void SvgMaskNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
 165         {
 166             drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
 167
 168             // decompose children
 169             SvgNode::decomposeSvgNode(aNewTarget, bReferenced);
 170
 171             if(aNewTarget.empty())
 172                 return;
 173
 174             if(getTransform())
 175             {
 176                 // create embedding group element with transformation
 177                 const drawinglayer::primitive2d::Primitive2DReference xRef(
 178                     new drawinglayer::primitive2d::TransformPrimitive2D(
 179                         *getTransform(),
 180                         aNewTarget));
 181
 182                 aNewTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
 183             }
 184
 185             // append to current target
 186             rTarget.append(aNewTarget);
 187         }
 188
 189         void SvgMaskNode::apply(
 190             drawinglayer::primitive2d::Primitive2DContainer& rTarget,
 191             const basegfx::B2DHomMatrix* pTransform) const
 192         {
 193             if(rTarget.empty() || Display::None == getDisplay())
 194                 return;
 195
 196             drawinglayer::primitive2d::Primitive2DContainer aMaskTarget;
 197
 198             // get mask definition as primitives
 199             decomposeSvgNode(aMaskTarget, true);
 200
 201             if(!aMaskTarget.empty())
 202             {
 203                 // get range of content to be masked
 204                 const basegfx::B2DRange aContentRange(
 205                         rTarget.getB2DRange(
 206                             drawinglayer::geometry::ViewInformation2D()));
 207                 const double fContentWidth(aContentRange.getWidth());
 208                 const double fContentHeight(aContentRange.getHeight());
 209
 210                 if(fContentWidth > 0.0 && fContentHeight > 0.0)
 211                 {
 212                     // create OffscreenBufferRange
 213                     basegfx::B2DRange aOffscreenBufferRange;
 214
 215                     if (SvgUnits::objectBoundingBox == maMaskUnits)
 216                     {
 217                         // fractions or percentages of the bounding box of the element to which the mask is applied
 218                         const double fX(SvgUnit::percent == getX().getUnit() ? getX().getNumber() * 0.01 : getX().getNumber());
 219                         const double fY(SvgUnit::percent == getY().getUnit() ? getY().getNumber() * 0.01 : getY().getNumber());
 220                         const double fW(SvgUnit::percent == getWidth().getUnit() ? getWidth().getNumber() * 0.01 : getWidth().getNumber());
 221                         const double fH(SvgUnit::percent == getHeight().getUnit() ? getHeight().getNumber() * 0.01 : getHeight().getNumber());
 222
 223                         aOffscreenBufferRange = basegfx::B2DRange(
 224                             aContentRange.getMinX() + (fX * fContentWidth),
 225                             aContentRange.getMinY() + (fY * fContentHeight),
 226                             aContentRange.getMinX() + ((fX + fW) * fContentWidth),
 227                             aContentRange.getMinY() + ((fY + fH) * fContentHeight));
 228                     }
 229                     else
 230                     {
 231                         const double fX(getX().isSet() ? getX().solve(*this, NumberType::xcoordinate) : 0.0);
 232                         const double fY(getY().isSet() ? getY().solve(*this, NumberType::ycoordinate) : 0.0);
 233
 234                         aOffscreenBufferRange = basegfx::B2DRange(
 235                             fX,
 236                             fY,
 237                             fX + (getWidth().isSet() ? getWidth().solve(*this, NumberType::xcoordinate) : 0.0),
 238                             fY + (getHeight().isSet() ? getHeight().solve(*this, NumberType::ycoordinate) : 0.0));
 239                     }
 240
 241                     if (SvgUnits::objectBoundingBox == maMaskContentUnits)
 242                     {
 243                         // mask is object-relative, embed in content transformation
 244                         const drawinglayer::primitive2d::Primitive2DReference xTransform(
 245                             new drawinglayer::primitive2d::TransformPrimitive2D(
 246                                 basegfx::utils::createScaleTranslateB2DHomMatrix(
 247                                     aContentRange.getRange(),
 248                                     aContentRange.getMinimum()),
 249                                 aMaskTarget));
 250
 251                         aMaskTarget = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
 252                     }
 253                     else // userSpaceOnUse
 254                     {
 255                         // #i124852#
 256                         if(pTransform)
 257                         {
 258                             const drawinglayer::primitive2d::Primitive2DReference xTransform(
 259                                 new drawinglayer::primitive2d::TransformPrimitive2D(
 260                                     *pTransform,
 261                                     aMaskTarget));
 262
 263                             aMaskTarget = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
 264                         }
 265                     }
 266
 267                     // embed content to a ModifiedColorPrimitive2D since the definitions
 268                     // how content is used as alpha is special for Svg
 269                     {
 270                         const drawinglayer::primitive2d::Primitive2DReference xInverseMask(
 271                             new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
 272                                 aMaskTarget,
 273                                 std::make_shared<basegfx::BColorModifier_luminance_to_alpha>()));
 274
 275                         aMaskTarget = drawinglayer::primitive2d::Primitive2DContainer { xInverseMask };
 276                     }
 277
 278                     // prepare new content
 279                     drawinglayer::primitive2d::Primitive2DReference xNewContent(
 280                         new drawinglayer::primitive2d::TransparencePrimitive2D(
 281                             rTarget,
 282                             aMaskTarget));
 283
 284                     // output up to now is defined by aContentRange and mask is oriented
 285                     // relative to it. It is possible that aOffscreenBufferRange defines
 286                     // a smaller area. In that case, embed to a mask primitive
 287                     if(!aOffscreenBufferRange.isInside(aContentRange))
 288                     {
 289                         xNewContent = new drawinglayer::primitive2d::MaskPrimitive2D(
 290                             basegfx::B2DPolyPolygon(
 291                                 basegfx::utils::createPolygonFromRect(
 292                                     aOffscreenBufferRange)),
 293                             drawinglayer::primitive2d::Primitive2DContainer { xNewContent });
 294                     }
 295
 296                     // redefine target. Use TransparencePrimitive2D with created mask
 297                     // geometry
 298                     rTarget = drawinglayer::primitive2d::Primitive2DContainer { xNewContent };
 299                 }
 300                 else
 301                 {
 302                     // content is geometrically empty
 303                     rTarget.clear();
 304                 }
 305             }
 306             else
 307             {
 308                 // An empty clipping path will completely clip away the element that had
 309                 // the clip-path property applied. (Svg spec)
 310                 rTarget.clear();
 311             }
 312         }
 313
 314 } // end of namespace svgio::svgreader
 315
 316 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */