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