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