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 <svgio/svgreader/svgimagenode.hxx>
  21 #include <svgio/svgreader/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
  36 namespace svgio
  37 {
  38     namespace svgreader
  39     {
  40         SvgImageNode::SvgImageNode(
  41             SvgDocument& rDocument,
  42             SvgNode* pParent)
  43         :   SvgNode(SVGTokenRect, rDocument, pParent),
  44             maSvgStyleAttributes(*this),
  45             maSvgAspectRatio(),
  46             mpaTransform(0),
  47             maX(0),
  48             maY(0),
  49             maWidth(0),
  50             maHeight(0),
  51             maXLink(),
  52             maUrl(),
  53             maMimeType(),
  54             maData()
  55         {
  56         }
  57
  58         SvgImageNode::~SvgImageNode()
  59         {
  60             if(mpaTransform) delete mpaTransform;
  61         }
  62
  63         const SvgStyleAttributes* SvgImageNode::getSvgStyleAttributes() const
  64         {
  65             return checkForCssStyle(OUString("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(rTokenName, 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                     setSvgAspectRatio(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                         setX(aNum);
 106                     }
 107                     break;
 108                 }
 109                 case SVGTokenY:
 110                 {
 111                     SvgNumber aNum;
 112
 113                     if(readSingleNumber(aContent, aNum))
 114                     {
 115                         setY(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                             setWidth(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                             setHeight(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::Primitive2DSequence& rEmbedded,
 165             basegfx::B2DRange& rViewBox,
 166             BitmapEx& rBitmapEx)
 167         {
 168             if(GRAPHIC_BITMAP == rGraphic.GetType())
 169             {
 170                 if(rGraphic.getSvgData().get())
 171                 {
 172                     // embedded Svg
 173                     rEmbedded = rGraphic.getSvgData()->getPrimitive2DSequence();
 174
 175                     // fill aViewBox
 176                     rViewBox = rGraphic.getSvgData()->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::Primitive2DSequence& 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::Primitive2DSequence 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                         ::com::sun::star::uno::Sequence< sal_Int8 > aPass;
 216                         ::sax::Converter::decodeBase64(aPass, maData);
 217
 218                         if(aPass.hasElements())
 219                         {
 220                             SvMemoryStream aStream(aPass.getArray(), aPass.getLength(), StreamMode::READ);
 221                             Graphic aGraphic;
 222
 223                             if(GRFILTER_OK == 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())
 246                         {
 247                             SvFileStream aStream(aAbsUrl, STREAM_STD_READ);
 248                             Graphic aGraphic;
 249
 250                             if(GRFILTER_OK == 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* mpXLink = getDocument().findSvgNodeById(maXLink);
 262
 263                         if(mpXLink && Display_none != mpXLink->getDisplay())
 264                         {
 265                             mpXLink->decomposeSvgNode(aNewTarget, true);
 266
 267                             if(aNewTarget.hasElements())
 268                             {
 269                                 aViewBox = drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(
 270                                     aNewTarget,
 271                                     drawinglayer::geometry::ViewInformation2D());
 272                             }
 273                         }
 274                     }
 275
 276                     if(!aBitmapEx.IsEmpty())
 277                     {
 278                         // create content from created bitmap
 279                         aNewTarget.realloc(1);
 280                         aNewTarget[0] = new drawinglayer::primitive2d::BitmapPrimitive2D(
 281                             aBitmapEx,
 282                             basegfx::B2DHomMatrix());
 283
 284                         // fill aViewBox. No size set yet, use unit size
 285                         aViewBox = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
 286                     }
 287
 288                     if(aNewTarget.hasElements())
 289                     {
 290                         if(aTarget.equal(aViewBox))
 291                         {
 292                             // just add to rTarget
 293                             drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aNewTarget);
 294                         }
 295                         else
 296                         {
 297                             // create mapping
 298                             const SvgAspectRatio& rRatio = getSvgAspectRatio();
 299
 300                             if(rRatio.isSet())
 301                             {
 302                                 // let mapping be created from SvgAspectRatio
 303                                 const basegfx::B2DHomMatrix aEmbeddingTransform(rRatio.createMapping(aTarget, aViewBox));
 304
 305                                 if(!aEmbeddingTransform.isIdentity())
 306                                 {
 307                                     const drawinglayer::primitive2d::Primitive2DReference xRef(
 308                                         new drawinglayer::primitive2d::TransformPrimitive2D(
 309                                             aEmbeddingTransform,
 310                                             aNewTarget));
 311
 312                                     aNewTarget = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
 313                                 }
 314
 315                                 if(!rRatio.isMeetOrSlice())
 316                                 {
 317                                     // need to embed in MaskPrimitive2D to ensure clipping
 318                                     const drawinglayer::primitive2d::Primitive2DReference xMask(
 319                                         new drawinglayer::primitive2d::MaskPrimitive2D(
 320                                             basegfx::B2DPolyPolygon(
 321                                                 basegfx::tools::createPolygonFromRect(aTarget)),
 322                                             aNewTarget));
 323
 324                                     aNewTarget = drawinglayer::primitive2d::Primitive2DSequence(&xMask, 1);
 325                                 }
 326                             }
 327                             else
 328                             {
 329                                 // choose default mapping
 330                                 const basegfx::B2DHomMatrix aEmbeddingTransform(SvgAspectRatio::createLinearMapping(aTarget, aViewBox));
 331
 332                                 if(!aEmbeddingTransform.isIdentity())
 333                                 {
 334                                     const drawinglayer::primitive2d::Primitive2DReference xRef(
 335                                         new drawinglayer::primitive2d::TransformPrimitive2D(
 336                                             aEmbeddingTransform,
 337                                             aNewTarget));
 338
 339                                     aNewTarget = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
 340                                 }
 341                             }
 342
 343                             // embed and add to rTarget, take local extra-transform into account
 344                             pStyle->add_postProcess(rTarget, aNewTarget, getTransform());
 345                         }
 346                     }
 347                 }
 348             }
 349         }
 350
 351     } // end of namespace svgreader
 352 } // end of namespace svgio
 353
 354 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */