svgio/source/svgreader/svgimagenode.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 <svgimagenode.hxx>
  21 #include <svgdocument.hxx>
  22 #include <sax/tools/converter.hxx>
  23 #include <tools/stream.hxx>
  24 #include <vcl/bitmapex.hxx>
  25 #include <vcl/graphicfilter.hxx>
  26 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  27 #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
  28 #include <drawinglayer/primitive2d/groupprimitive2d.hxx>
  29 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  30 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
  31 #include <basegfx/polygon/b2dpolygontools.hxx>
  32 #include <basegfx/polygon/b2dpolygon.hxx>
  33 #include <rtl/uri.hxx>
  34 #include <drawinglayer/geometry/viewinformation2d.hxx>
  35 #include <comphelper/base64.hxx>
  36
  37 namespace svgio
  38 {
  39     namespace svgreader
  40     {
  41         SvgImageNode::SvgImageNode(
  42             SvgDocument& rDocument,
  43             SvgNode* pParent)
  44         :   SvgNode(SVGTokenRect, rDocument, pParent),
  45             maSvgStyleAttributes(*this),
  46             maSvgAspectRatio(),
  47             mpaTransform(nullptr),
  48             maX(0),
  49             maY(0),
  50             maWidth(0),
  51             maHeight(0),
  52             maXLink(),
  53             maUrl(),
  54             maMimeType(),
  55             maData()
  56         {
  57         }
  58
  59         SvgImageNode::~SvgImageNode()
  60         {
  61         }
  62
  63         const SvgStyleAttributes* SvgImageNode::getSvgStyleAttributes() const
  64         {
  65             return checkForCssStyle("image", maSvgStyleAttributes);
  66         }
  67
  68         void SvgImageNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
  69         {
  70             // call parent
  71             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
  72
  73             // read style attributes
  74             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
  75
  76             // parse own
  77             switch(aSVGToken)
  78             {
  79                 case SVGTokenStyle:
  80                 {
  81                     readLocalCssStyle(aContent);
  82                     break;
  83                 }
  84                 case SVGTokenPreserveAspectRatio:
  85                 {
  86                     maSvgAspectRatio = readSvgAspectRatio(aContent);
  87                     break;
  88                 }
  89                 case SVGTokenTransform:
  90                 {
  91                     const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
  92
  93                     if(!aMatrix.isIdentity())
  94                     {
  95                         setTransform(&aMatrix);
  96                     }
  97                     break;
  98                 }
  99                 case SVGTokenX:
 100                 {
 101                     SvgNumber aNum;
 102
 103                     if(readSingleNumber(aContent, aNum))
 104                     {
 105                         maX = aNum;
 106                     }
 107                     break;
 108                 }
 109                 case SVGTokenY:
 110                 {
 111                     SvgNumber aNum;
 112
 113                     if(readSingleNumber(aContent, aNum))
 114                     {
 115                         maY = aNum;
 116                     }
 117                     break;
 118                 }
 119                 case SVGTokenWidth:
 120                 {
 121                     SvgNumber aNum;
 122
 123                     if(readSingleNumber(aContent, aNum))
 124                     {
 125                         if(aNum.isPositive())
 126                         {
 127                             maWidth = aNum;
 128                         }
 129                     }
 130                     break;
 131                 }
 132                 case SVGTokenHeight:
 133                 {
 134                     SvgNumber aNum;
 135
 136                     if(readSingleNumber(aContent, aNum))
 137                     {
 138                         if(aNum.isPositive())
 139                         {
 140                             maHeight = aNum;
 141                         }
 142                     }
 143                     break;
 144                 }
 145                 case SVGTokenXlinkHref:
 146                 {
 147                     const sal_Int32 nLen(aContent.getLength());
 148
 149                     if(nLen)
 150                     {
 151                         readImageLink(aContent, maXLink, maUrl, maMimeType, maData);
 152                     }
 153                     break;
 154                 }
 155                 default:
 156                 {
 157                     break;
 158                 }
 159             }
 160         }
 161
 162         void extractFromGraphic(
 163             const Graphic& rGraphic,
 164             drawinglayer::primitive2d::Primitive2DContainer& rEmbedded,
 165             basegfx::B2DRange& rViewBox,
 166             BitmapEx& rBitmapEx)
 167         {
 168             if(GraphicType::Bitmap == rGraphic.GetType())
 169             {
 170                 if(rGraphic.getVectorGraphicData().get())
 171                 {
 172                     // embedded Svg
 173                     rEmbedded = rGraphic.getVectorGraphicData()->getPrimitive2DSequence();
 174
 175                     // fill aViewBox
 176                     rViewBox = rGraphic.getVectorGraphicData()->getRange();
 177                 }
 178                 else
 179                 {
 180                     // get bitmap
 181                     rBitmapEx = rGraphic.GetBitmapEx();
 182                 }
 183             }
 184             else
 185             {
 186                 // evtl. convert to bitmap
 187                 rBitmapEx = rGraphic.GetBitmapEx();
 188             }
 189         }
 190
 191         void SvgImageNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
 192         {
 193             // get size range and create path
 194             const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
 195
 196             if(pStyle && getWidth().isSet() && getHeight().isSet())
 197             {
 198                 const double fWidth(getWidth().solve(*this, xcoordinate));
 199                 const double fHeight(getHeight().solve(*this, ycoordinate));
 200
 201                 if(fWidth > 0.0 && fHeight > 0.0)
 202                 {
 203                     BitmapEx aBitmapEx;
 204                     drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
 205
 206                     // prepare Target and ViewBox for evtl. AspectRatio mappings
 207                     const double fX(getX().isSet() ? getX().solve(*this, xcoordinate) : 0.0);
 208                     const double fY(getY().isSet() ? getY().solve(*this, ycoordinate) : 0.0);
 209                     const basegfx::B2DRange aTarget(fX, fY, fX + fWidth, fY + fHeight);
 210                     basegfx::B2DRange aViewBox(aTarget);
 211
 212                     if(!maMimeType.isEmpty() && !maData.isEmpty())
 213                     {
 214                         // use embedded base64 encoded data
 215                         css::uno::Sequence< sal_Int8 > aPass;
 216                         ::comphelper::Base64::decode(aPass, maData);
 217
 218                         if(aPass.hasElements())
 219                         {
 220                             SvMemoryStream aStream(aPass.getArray(), aPass.getLength(), StreamMode::READ);
 221                             Graphic aGraphic;
 222
 223                             if(ERRCODE_NONE == GraphicFilter::GetGraphicFilter().ImportGraphic(
 224                                 aGraphic,
 225                                 OUString(),
 226                                 aStream))
 227                             {
 228                                 extractFromGraphic(aGraphic, aNewTarget, aViewBox, aBitmapEx);
 229                             }
 230                         }
 231                     }
 232                     else if(!maUrl.isEmpty())
 233                     {
 234                         const OUString& rPath = getDocument().getAbsolutePath();
 235                         OUString aAbsUrl;
 236                         try {
 237                             aAbsUrl = rtl::Uri::convertRelToAbs(rPath, maUrl);
 238                         } catch (rtl::MalformedUriException & e) {
 239                             SAL_WARN(
 240                                 "svg",
 241                                 "caught rtl::MalformedUriException \""
 242                                     << e.getMessage() << "\"");
 243                         }
 244
 245                         if (!aAbsUrl.isEmpty() && rPath != aAbsUrl)
 246                         {
 247                             SvFileStream aStream(aAbsUrl, StreamMode::STD_READ);
 248                             Graphic aGraphic;
 249
 250                             if(ERRCODE_NONE == GraphicFilter::GetGraphicFilter().ImportGraphic(
 251                                    aGraphic,
 252                                    aAbsUrl,
 253                                    aStream))
 254                             {
 255                                 extractFromGraphic(aGraphic, aNewTarget, aViewBox, aBitmapEx);
 256                             }
 257                         }
 258                     }
 259                     else if(!maXLink.isEmpty())
 260                     {
 261                         const SvgNode* pXLink = getDocument().findSvgNodeById(maXLink);
 262
 263                         if(pXLink && Display_none != pXLink->getDisplay())
 264                         {
 265                             pXLink->decomposeSvgNode(aNewTarget, true);
 266
 267                             if(!aNewTarget.empty())
 268                             {
 269                                 aViewBox = aNewTarget.getB2DRange(drawinglayer::geometry::ViewInformation2D());
 270                             }
 271                         }
 272                     }
 273
 274                     if(!aBitmapEx.IsEmpty() && 0 != aBitmapEx.GetSizePixel().Width()  && 0 != aBitmapEx.GetSizePixel().Height())
 275                     {
 276                         // calculate centered unit size
 277                         const double fAspectRatio = static_cast<double>(aBitmapEx.GetSizePixel().Width()) / static_cast<double>(aBitmapEx.GetSizePixel().Height());
 278
 279                         if(basegfx::fTools::equal(fAspectRatio, 0.0))
 280                         {
 281                             // use unit range
 282                             aViewBox = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
 283                         }
 284                         else if(basegfx::fTools::more(fAspectRatio, 0.0))
 285                         {
 286                             // width bigger height
 287                             const double fHalfHeight((1.0 / fAspectRatio) * 0.5);
 288                             aViewBox = basegfx::B2DRange(
 289                                 0.0,
 290                                 0.5 - fHalfHeight,
 291                                 1.0,
 292                                 0.5 + fHalfHeight);
 293                         }
 294                         else
 295                         {
 296                             // height bigger width
 297                             const double fHalfWidth(fAspectRatio * 0.5);
 298                             aViewBox = basegfx::B2DRange(
 299                                 0.5 - fHalfWidth,
 300                                 0.0,
 301                                 0.5 + fHalfWidth,
 302                                 1.0);
 303                         }
 304
 305                         // create content from created bitmap, use calculated unit range size
 306                         // as transformation to map the picture data correctly
 307                         aNewTarget.resize(1);
 308                         aNewTarget[0] = new drawinglayer::primitive2d::BitmapPrimitive2D(
 309                             aBitmapEx,
 310                             basegfx::utils::createScaleTranslateB2DHomMatrix(
 311                                 aViewBox.getRange(),
 312                                 aViewBox.getMinimum()));
 313                     }
 314
 315                     if(!aNewTarget.empty())
 316                     {
 317                         if(aTarget.equal(aViewBox))
 318                         {
 319                             // just add to rTarget
 320                             rTarget.append(aNewTarget);
 321                         }
 322                         else
 323                         {
 324                             // create mapping
 325                             const SvgAspectRatio& rRatio = maSvgAspectRatio;
 326
 327                             // even when ratio is not set, use the defaults
 328                             // let mapping be created from SvgAspectRatio
 329                             const basegfx::B2DHomMatrix aEmbeddingTransform(rRatio.createMapping(aTarget, aViewBox));
 330
 331                             if(!aEmbeddingTransform.isIdentity())
 332                             {
 333                                 const drawinglayer::primitive2d::Primitive2DReference xRef(
 334                                     new drawinglayer::primitive2d::TransformPrimitive2D(
 335                                         aEmbeddingTransform,
 336                                         aNewTarget));
 337
 338                                 aNewTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
 339                             }
 340
 341                             if(!rRatio.isMeetOrSlice())
 342                             {
 343                                 // need to embed in MaskPrimitive2D to ensure clipping
 344                                 const drawinglayer::primitive2d::Primitive2DReference xMask(
 345                                     new drawinglayer::primitive2d::MaskPrimitive2D(
 346                                         basegfx::B2DPolyPolygon(
 347                                             basegfx::utils::createPolygonFromRect(aTarget)),
 348                                         aNewTarget));
 349
 350                                 aNewTarget = drawinglayer::primitive2d::Primitive2DContainer { xMask };
 351                             }
 352
 353                             // embed and add to rTarget, take local extra-transform into account
 354                             pStyle->add_postProcess(rTarget, aNewTarget, getTransform());
 355                         }
 356                     }
 357                 }
 358             }
 359         }
 360
 361     } // end of namespace svgreader
 362 } // end of namespace svgio
 363
 364 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */