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 //////////////////////////////////////////////////////////////////////////////
  37
  38 namespace svgio
  39 {
  40     namespace svgreader
  41     {
  42         SvgImageNode::SvgImageNode(
  43             SvgDocument& rDocument,
  44             SvgNode* pParent)
  45         :   SvgNode(SVGTokenRect, rDocument, pParent),
  46             maSvgStyleAttributes(*this),
  47             maSvgAspectRatio(),
  48             mpaTransform(0),
  49             maX(0),
  50             maY(0),
  51             maWidth(0),
  52             maHeight(0),
  53             maXLink(),
  54             maUrl(),
  55             maMimeType(),
  56             maData()
  57         {
  58         }
  59
  60         SvgImageNode::~SvgImageNode()
  61         {
  62             if(mpaTransform) delete mpaTransform;
  63         }
  64
  65         const SvgStyleAttributes* SvgImageNode::getSvgStyleAttributes() const
  66         {
  67             static rtl::OUString aClassStr(rtl::OUString::createFromAscii("image"));
  68             return checkForCssStyle(aClassStr, maSvgStyleAttributes);
  69         }
  70
  71         void SvgImageNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
  72         {
  73             // call parent
  74             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
  75
  76             // read style attributes
  77             maSvgStyleAttributes.parseStyleAttribute(rTokenName, aSVGToken, aContent);
  78
  79             // parse own
  80             switch(aSVGToken)
  81             {
  82                 case SVGTokenStyle:
  83                 {
  84                     maSvgStyleAttributes.readStyle(aContent);
  85                     break;
  86                 }
  87                 case SVGTokenPreserveAspectRatio:
  88                 {
  89                     setSvgAspectRatio(readSvgAspectRatio(aContent));
  90                     break;
  91                 }
  92                 case SVGTokenTransform:
  93                 {
  94                     const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
  95
  96                     if(!aMatrix.isIdentity())
  97                     {
  98                         setTransform(&aMatrix);
  99                     }
 100                     break;
 101                 }
 102                 case SVGTokenX:
 103                 {
 104                     SvgNumber aNum;
 105
 106                     if(readSingleNumber(aContent, aNum))
 107                     {
 108                         setX(aNum);
 109                     }
 110                     break;
 111                 }
 112                 case SVGTokenY:
 113                 {
 114                     SvgNumber aNum;
 115
 116                     if(readSingleNumber(aContent, aNum))
 117                     {
 118                         setY(aNum);
 119                     }
 120                     break;
 121                 }
 122                 case SVGTokenWidth:
 123                 {
 124                     SvgNumber aNum;
 125
 126                     if(readSingleNumber(aContent, aNum))
 127                     {
 128                         if(aNum.isPositive())
 129                         {
 130                             setWidth(aNum);
 131                         }
 132                     }
 133                     break;
 134                 }
 135                 case SVGTokenHeight:
 136                 {
 137                     SvgNumber aNum;
 138
 139                     if(readSingleNumber(aContent, aNum))
 140                     {
 141                         if(aNum.isPositive())
 142                         {
 143                             setHeight(aNum);
 144                         }
 145                     }
 146                     break;
 147                 }
 148                 case SVGTokenXlinkHref:
 149                 {
 150                     const sal_Int32 nLen(aContent.getLength());
 151
 152                     if(nLen)
 153                     {
 154                         readImageLink(aContent, maXLink, maUrl, maMimeType, maData);
 155                     }
 156                     break;
 157                 }
 158                 default:
 159                 {
 160                     break;
 161                 }
 162             }
 163         }
 164
 165         void extractFromGraphic(
 166             const Graphic& rGraphic,
 167             drawinglayer::primitive2d::Primitive2DSequence& rEmbedded,
 168             basegfx::B2DRange& rViewBox,
 169             BitmapEx& rBitmapEx)
 170         {
 171             if(GRAPHIC_BITMAP == rGraphic.GetType())
 172             {
 173                 if(rGraphic.getSvgData().get())
 174                 {
 175                     // embedded Svg
 176                     rEmbedded = rGraphic.getSvgData()->getPrimitive2DSequence();
 177
 178                     // fill aViewBox
 179                     rViewBox = rGraphic.getSvgData()->getRange();
 180                 }
 181                 else
 182                 {
 183                     // get bitmap
 184                     rBitmapEx = rGraphic.GetBitmapEx();
 185                 }
 186             }
 187             else
 188             {
 189                 // evtl. convert to bitmap
 190                 rBitmapEx = rGraphic.GetBitmapEx();
 191             }
 192         }
 193
 194         void SvgImageNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DSequence& rTarget, bool /*bReferenced*/) const
 195         {
 196             // get size range and create path
 197             const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
 198
 199             if(pStyle && getWidth().isSet() && getHeight().isSet())
 200             {
 201                 const double fWidth(getWidth().solve(*this, xcoordinate));
 202                 const double fHeight(getHeight().solve(*this, ycoordinate));
 203
 204                 if(fWidth > 0.0 && fHeight > 0.0)
 205                 {
 206                     BitmapEx aBitmapEx;
 207                     drawinglayer::primitive2d::Primitive2DSequence aNewTarget;
 208
 209                     // prepare Target and ViewBox for evtl. AspectRatio mappings
 210                     const double fX(getX().isSet() ? getX().solve(*this, xcoordinate) : 0.0);
 211                     const double fY(getY().isSet() ? getY().solve(*this, ycoordinate) : 0.0);
 212                     const basegfx::B2DRange aTarget(fX, fY, fX + fWidth, fY + fHeight);
 213                     basegfx::B2DRange aViewBox(aTarget);
 214
 215                     if(maMimeType.getLength() && maData.getLength())
 216                     {
 217                         // use embedded base64 encoded data
 218                         ::com::sun::star::uno::Sequence< sal_Int8 > aPass;
 219                         ::sax::Converter::decodeBase64(aPass, maData);
 220
 221                         if(aPass.hasElements())
 222                         {
 223                             SvMemoryStream aStream(aPass.getArray(), aPass.getLength(), STREAM_READ);
 224                             Graphic aGraphic;
 225
 226                             if(GRFILTER_OK == GraphicFilter::GetGraphicFilter().ImportGraphic(
 227                                 aGraphic,
 228                                 String(),
 229                                 aStream))
 230                             {
 231                                 extractFromGraphic(aGraphic, aNewTarget, aViewBox, aBitmapEx);
 232                             }
 233                         }
 234                     }
 235                     else if(maUrl.getLength())
 236                     {
 237                         const OUString& rPath = getDocument().getAbsolutePath();
 238                         const OUString aAbsUrl(rtl::Uri::convertRelToAbs(rPath, maUrl));
 239
 240                         if(aAbsUrl.getLength())
 241                         {
 242                             SvFileStream aStream(aAbsUrl, STREAM_STD_READ);
 243                             Graphic aGraphic;
 244
 245                             if(GRFILTER_OK == GraphicFilter::GetGraphicFilter().ImportGraphic(
 246                                 aGraphic,
 247                                 aAbsUrl,
 248                                 aStream))
 249                             {
 250                                 extractFromGraphic(aGraphic, aNewTarget, aViewBox, aBitmapEx);
 251                             }
 252                         }
 253                     }
 254                     else if(maXLink.getLength())
 255                     {
 256                         const SvgNode* mpXLink = getDocument().findSvgNodeById(maXLink);
 257
 258                         if(mpXLink)
 259                         {
 260                             mpXLink->decomposeSvgNode(aNewTarget, true);
 261
 262                             if(aNewTarget.hasElements())
 263                             {
 264                                 aViewBox = drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(
 265                                     aNewTarget,
 266                                     drawinglayer::geometry::ViewInformation2D());
 267                             }
 268                         }
 269                     }
 270
 271                     if(!aBitmapEx.IsEmpty())
 272                     {
 273                         // create content from created bitmap
 274                         aNewTarget.realloc(1);
 275                         aNewTarget[0] = new drawinglayer::primitive2d::BitmapPrimitive2D(
 276                             aBitmapEx,
 277                             basegfx::B2DHomMatrix());
 278
 279                         // fill aViewBox. No size set yet, use unit size
 280                         aViewBox = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
 281                     }
 282
 283                     if(aNewTarget.hasElements())
 284                     {
 285                         if(aTarget.equal(aViewBox))
 286                         {
 287                             // just add to rTarget
 288                             drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aNewTarget);
 289                         }
 290                         else
 291                         {
 292                             // create mapping
 293                             const SvgAspectRatio& rRatio = getSvgAspectRatio();
 294
 295                             if(rRatio.isSet())
 296                             {
 297                                 // let mapping be created from SvgAspectRatio
 298                                 const basegfx::B2DHomMatrix aEmbeddingTransform(rRatio.createMapping(aTarget, aViewBox));
 299
 300                                 if(!aEmbeddingTransform.isIdentity())
 301                                 {
 302                                     const drawinglayer::primitive2d::Primitive2DReference xRef(
 303                                         new drawinglayer::primitive2d::TransformPrimitive2D(
 304                                             aEmbeddingTransform,
 305                                             aNewTarget));
 306
 307                                     aNewTarget = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
 308                                 }
 309
 310                                 if(!rRatio.isMeetOrSlice())
 311                                 {
 312                                     // need to embed in MaskPrimitive2D to ensure clipping
 313                                     const drawinglayer::primitive2d::Primitive2DReference xMask(
 314                                         new drawinglayer::primitive2d::MaskPrimitive2D(
 315                                             basegfx::B2DPolyPolygon(
 316                                                 basegfx::tools::createPolygonFromRect(aTarget)),
 317                                             aNewTarget));
 318
 319                                     aNewTarget = drawinglayer::primitive2d::Primitive2DSequence(&xMask, 1);
 320                                 }
 321                             }
 322                             else
 323                             {
 324                                 // choose default mapping
 325                                 const basegfx::B2DHomMatrix aEmbeddingTransform(rRatio.createLinearMapping(aTarget, aViewBox));
 326
 327                                 if(!aEmbeddingTransform.isIdentity())
 328                                 {
 329                                     const drawinglayer::primitive2d::Primitive2DReference xRef(
 330                                         new drawinglayer::primitive2d::TransformPrimitive2D(
 331                                             aEmbeddingTransform,
 332                                             aNewTarget));
 333
 334                                     aNewTarget = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
 335                                 }
 336                             }
 337
 338                             // embed and add to rTarget, take local extra-transform into account
 339                             pStyle->add_postProcess(rTarget, aNewTarget, getTransform());
 340                         }
 341                     }
 342                 }
 343             }
 344         }
 345
 346     } // end of namespace svgreader
 347 } // end of namespace svgio
 348
 349 //////////////////////////////////////////////////////////////////////////////
 350 // eof
 351
 352 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */