svgio/source/svgreader/svgclippathnode.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 <svgclippathnode.hxx>
  21 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  22 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
  23 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  24 #include <drawinglayer/geometry/viewinformation2d.hxx>
  25 #include <drawinglayer/processor2d/contourextractor2d.hxx>
  26 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  27 #include <basegfx/polygon/b2dpolygontools.hxx>
  28
  29 namespace svgio::svgreader
  30 {
  31         SvgClipPathNode::SvgClipPathNode(
  32             SvgDocument& rDocument,
  33             SvgNode* pParent)
  34         :   SvgNode(SVGTokenClipPathNode, rDocument, pParent),
  35             maSvgStyleAttributes(*this),
  36             maClipPathUnits(userSpaceOnUse)
  37         {
  38         }
  39
  40         SvgClipPathNode::~SvgClipPathNode()
  41         {
  42         }
  43
  44         const SvgStyleAttributes* SvgClipPathNode::getSvgStyleAttributes() const
  45         {
  46             return &maSvgStyleAttributes;
  47         }
  48
  49         void SvgClipPathNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
  50         {
  51             // call parent
  52             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
  53
  54             // read style attributes
  55             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
  56
  57             // parse own
  58             switch(aSVGToken)
  59             {
  60                 case SVGTokenStyle:
  61                 {
  62                     readLocalCssStyle(aContent);
  63                     break;
  64                 }
  65                 case SVGTokenTransform:
  66                 {
  67                     const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
  68
  69                     if(!aMatrix.isIdentity())
  70                     {
  71                         setTransform(&aMatrix);
  72                     }
  73                     break;
  74                 }
  75                 case SVGTokenClipPathUnits:
  76                 {
  77                     if(!aContent.isEmpty())
  78                     {
  79                         if(aContent.match(commonStrings::aStrUserSpaceOnUse))
  80                         {
  81                             setClipPathUnits(userSpaceOnUse);
  82                         }
  83                         else if(aContent.match(commonStrings::aStrObjectBoundingBox))
  84                         {
  85                             setClipPathUnits(objectBoundingBox);
  86                         }
  87                     }
  88                     break;
  89                 }
  90                 default:
  91                 {
  92                     break;
  93                 }
  94             }
  95         }
  96
  97         void SvgClipPathNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
  98         {
  99             drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
 100
 101             // decompose children
 102             SvgNode::decomposeSvgNode(aNewTarget, bReferenced);
 103
 104             if(aNewTarget.empty())
 105                 return;
 106
 107             if(getTransform())
 108             {
 109                 // create embedding group element with transformation
 110                 const drawinglayer::primitive2d::Primitive2DReference xRef(
 111                     new drawinglayer::primitive2d::TransformPrimitive2D(
 112                         *getTransform(),
 113                         aNewTarget));
 114
 115                 rTarget.push_back(xRef);
 116             }
 117             else
 118             {
 119                 // append to current target
 120                 rTarget.append(aNewTarget);
 121             }
 122         }
 123
 124         void SvgClipPathNode::apply(
 125             drawinglayer::primitive2d::Primitive2DContainer& rContent,
 126             const basegfx::B2DHomMatrix* pTransform) const
 127         {
 128             if(rContent.empty() || Display_none == getDisplay())
 129                 return;
 130
 131             const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 132             drawinglayer::primitive2d::Primitive2DContainer aClipTarget;
 133             basegfx::B2DPolyPolygon aClipPolyPolygon;
 134
 135             // get clipPath definition as primitives
 136             decomposeSvgNode(aClipTarget, true);
 137
 138             if(!aClipTarget.empty())
 139             {
 140                 // extract filled polygons as base for a mask PolyPolygon
 141                 drawinglayer::processor2d::ContourExtractor2D aExtractor(aViewInformation2D, true);
 142
 143                 aExtractor.process(aClipTarget);
 144
 145                 const basegfx::B2DPolyPolygonVector& rResult(aExtractor.getExtractedContour());
 146                 const sal_uInt32 nSize(rResult.size());
 147
 148                 if(nSize > 1)
 149                 {
 150                     // merge to single clipPolyPolygon
 151                     aClipPolyPolygon = basegfx::utils::mergeToSinglePolyPolygon(rResult);
 152                 }
 153                 else
 154                 {
 155                     aClipPolyPolygon = rResult[0];
 156                 }
 157             }
 158
 159             if(aClipPolyPolygon.count())
 160             {
 161                 if(objectBoundingBox == getClipPathUnits())
 162                 {
 163                     // clip is object-relative, transform using content transformation
 164                     const basegfx::B2DRange aContentRange(rContent.getB2DRange(aViewInformation2D));
 165
 166                     aClipPolyPolygon.transform(
 167                         basegfx::utils::createScaleTranslateB2DHomMatrix(
 168                             aContentRange.getRange(),
 169                             aContentRange.getMinimum()));
 170                 }
 171                 else // userSpaceOnUse
 172                 {
 173                     // #i124852#
 174                     if(pTransform)
 175                     {
 176                         aClipPolyPolygon.transform(*pTransform);
 177                     }
 178                 }
 179
 180                 // #i124313# try to avoid creating an embedding to a MaskPrimitive2D if
 181                 // possible; MaskPrimitive2D processing is potentially expensive
 182                 bool bCreateEmbedding(true);
 183                 bool bAddContent(true);
 184
 185                 if(basegfx::utils::isRectangle(aClipPolyPolygon))
 186                 {
 187                     // ClipRegion is a rectangle, thus it is not expensive to tell
 188                     // if the content is completely inside or outside of it; get ranges
 189                     const basegfx::B2DRange aClipRange(aClipPolyPolygon.getB2DRange());
 190                     const basegfx::B2DRange aContentRange(
 191                         rContent.getB2DRange(
 192                             aViewInformation2D));
 193
 194                     if(aClipRange.isInside(aContentRange))
 195                     {
 196                         // completely contained, no need to clip at all, so no need for embedding
 197                         bCreateEmbedding = false;
 198                     }
 199                     else if(aClipRange.overlaps(aContentRange))
 200                     {
 201                         // overlap; embedding needed. ClipRegion can be minimized by using
 202                         // the intersection of the ClipRange and the ContentRange. Minimizing
 203                         // the ClipRegion potentially enhances further processing since
 204                         // usually clip operations are expensive.
 205                         basegfx::B2DRange aCommonRange(aContentRange);
 206
 207                         aCommonRange.intersect(aClipRange);
 208                         aClipPolyPolygon = basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aCommonRange));
 209                     }
 210                     else
 211                     {
 212                         // not inside and no overlap -> completely outside
 213                         // no need for embedding, no need for content at all
 214                         bCreateEmbedding = false;
 215                         bAddContent = false;
 216                     }
 217                 }
 218                 else
 219                 {
 220                     // ClipRegion is not a simple rectangle, it would be possible but expensive to
 221                     // tell if the content needs clipping or not. It is also dependent of
 222                     // the content's decomposition. To do this, a processor would be needed that
 223                     // is capable if processing the given sequence of primitives and decide
 224                     // if all is inside or all is outside. Such a ClipProcessor could be written,
 225                     // but for now just create the embedding
 226                 }
 227
 228                 if(bCreateEmbedding)
 229                 {
 230                     // redefine target. Use MaskPrimitive2D with created clip
 231                     // geometry. Using the automatically set mbIsClipPathContent at
 232                     // SvgStyleAttributes the clip definition is without fill, stroke,
 233                     // and strokeWidth and forced to black
 234                     const drawinglayer::primitive2d::Primitive2DReference xEmbedTransparence(
 235                         new drawinglayer::primitive2d::MaskPrimitive2D(
 236                             aClipPolyPolygon,
 237                             rContent));
 238
 239                     rContent = drawinglayer::primitive2d::Primitive2DContainer { xEmbedTransparence };
 240                 }
 241                 else
 242                 {
 243                     if(!bAddContent)
 244                     {
 245                         rContent.clear();
 246                     }
 247                 }
 248             }
 249             else
 250             {
 251                 // An empty clipping path will completely clip away the element that had
 252                 // the clip-path property applied. (Svg spec)
 253                 rContent.clear();
 254             }
 255         }
 256
 257 } // end of namespace svgio::svgreader
 258
 259 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */