svgio/source/svgreader/svgsvgnode.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 <svgsvgnode.hxx>
  21 #include <drawinglayer/geometry/viewinformation2d.hxx>
  22 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  23 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
  24 #include <basegfx/polygon/b2dpolygontools.hxx>
  25 #include <basegfx/polygon/b2dpolygon.hxx>
  26 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  27 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  28 #include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
  29 #include <svgdocument.hxx>
  30
  31 namespace svgio::svgreader
  32 {
  33         SvgSvgNode::SvgSvgNode(
  34             SvgDocument& rDocument,
  35             SvgNode* pParent)
  36         :   SvgNode(SVGToken::Svg, rDocument, pParent),
  37             maSvgStyleAttributes(*this),
  38             maSvgAspectRatio(),
  39             maX(),
  40             maY(),
  41             maWidth(),
  42             maHeight(),
  43             maVersion(),
  44             mbStyleAttributesInitialized(false) // #i125258#
  45         {
  46         }
  47
  48         // #i125258#
  49         void SvgSvgNode::initializeStyleAttributes()
  50         {
  51             if(mbStyleAttributesInitialized)
  52                 return;
  53
  54             // #i125258# determine if initial values need to be initialized with hard values
  55             // for the case that this is the outmost SVG statement and it has no parent
  56             // stale (CssStyle for svg may be defined)
  57             bool bSetInitialValues(true);
  58
  59             if(getParent())
  60             {
  61                 // #i125258# no initial values when it's a SVG element embedded in SVG
  62                 bSetInitialValues = false;
  63             }
  64
  65             if(bSetInitialValues)
  66             {
  67                 const SvgStyleAttributes* pStyles = getSvgStyleAttributes();
  68
  69                 if(pStyles && pStyles->getParentStyle())
  70                 {
  71                     // SVG has a parent style (probably CssStyle), check if fill is set there anywhere
  72                     // already. If yes, do not set the default fill (black)
  73                     bool bFillSet(false);
  74                     const SvgStyleAttributes* pParentStyle = pStyles->getParentStyle();
  75
  76                     while(pParentStyle && !bFillSet)
  77                     {
  78                         bFillSet = pParentStyle->isFillSet();
  79                         pParentStyle = pParentStyle->getParentStyle();
  80                     }
  81
  82                     if(bFillSet)
  83                     {
  84                         // #125258# no initial values when SVG has a parent style at which a fill
  85                         // is already set
  86                         bSetInitialValues = false;
  87                     }
  88                 }
  89             }
  90
  91             if(bSetInitialValues)
  92             {
  93                 // #i125258# only set if not yet initialized (SvgSvgNode::parseAttribute is already done,
  94                 // just setting may revert an already set valid value)
  95                 if(!maSvgStyleAttributes.isFillSet())
  96                 {
  97                     // #i125258# initial fill is black (see SVG1.1 spec)
  98                     maSvgStyleAttributes.setFill(SvgPaint(basegfx::BColor(0.0, 0.0, 0.0), true, true));
  99                 }
 100             }
 101
 102             mbStyleAttributesInitialized = true;
 103         }
 104
 105         SvgSvgNode::~SvgSvgNode()
 106         {
 107         }
 108
 109         const SvgStyleAttributes* SvgSvgNode::getSvgStyleAttributes() const
 110         {
 111             // #i125258# svg node can have CssStyles, too, so check for it here
 112             return checkForCssStyle("svg", maSvgStyleAttributes);
 113         }
 114
 115         void SvgSvgNode::parseAttribute(const OUString& rTokenName, SVGToken aSVGToken, const OUString& aContent)
 116         {
 117             // call parent
 118             SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
 119
 120             // read style attributes
 121             maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent, false);
 122
 123             // parse own
 124             switch(aSVGToken)
 125             {
 126                 case SVGToken::Style:
 127                 {
 128                     readLocalCssStyle(aContent);
 129                     break;
 130                 }
 131                 case SVGToken::ViewBox:
 132                 {
 133                     const basegfx::B2DRange aRange(readViewBox(aContent, *this));
 134
 135                     if(!aRange.isEmpty())
 136                     {
 137                         setViewBox(&aRange);
 138                     }
 139                     break;
 140                 }
 141                 case SVGToken::PreserveAspectRatio:
 142                 {
 143                     maSvgAspectRatio = readSvgAspectRatio(aContent);
 144                     break;
 145                 }
 146                 case SVGToken::X:
 147                 {
 148                     SvgNumber aNum;
 149
 150                     if(readSingleNumber(aContent, aNum))
 151                     {
 152                         maX = aNum;
 153                     }
 154                     break;
 155                 }
 156                 case SVGToken::Y:
 157                 {
 158                     SvgNumber aNum;
 159
 160                     if(readSingleNumber(aContent, aNum))
 161                     {
 162                         maY = aNum;
 163                     }
 164                     break;
 165                 }
 166                 case SVGToken::Width:
 167                 {
 168                     SvgNumber aNum;
 169
 170                     if(readSingleNumber(aContent, aNum))
 171                     {
 172                         if(aNum.isPositive())
 173                         {
 174                             maWidth = aNum;
 175                         }
 176                     }
 177                     break;
 178                 }
 179                 case SVGToken::Height:
 180                 {
 181                     SvgNumber aNum;
 182
 183                     if(readSingleNumber(aContent, aNum))
 184                     {
 185                         if(aNum.isPositive())
 186                         {
 187                             maHeight = aNum;
 188                         }
 189                     }
 190                     break;
 191                 }
 192                 case SVGToken::Version:
 193                 {
 194                     SvgNumber aNum;
 195
 196                     if(readSingleNumber(aContent, aNum))
 197                     {
 198                         maVersion = aNum;
 199                     }
 200                     break;
 201                 }
 202                 default:
 203                 {
 204                     break;
 205                 }
 206             }
 207         }
 208
 209         void SvgSvgNode::seekReferenceWidth(double& fWidth, bool& bHasFound) const
 210         {
 211             if (!getParent() || bHasFound)
 212             {
 213                 return;
 214             }
 215             const SvgSvgNode* pParentSvgSvgNode = nullptr;
 216             // enclosing svg might have relative width, need to cumulate them till they are
 217             // resolved somewhere up in the node tree
 218             double fPercentage(1.0);
 219             for(const SvgNode* pParent = getParent(); pParent && !bHasFound; pParent = pParent->getParent())
 220             {
 221                 // dynamic_cast results Null-pointer for not SvgSvgNode and so skips them in if condition
 222                 pParentSvgSvgNode = dynamic_cast< const SvgSvgNode* >(pParent);
 223                 if (pParentSvgSvgNode)
 224                 {
 225                     if (pParentSvgSvgNode->getViewBox())
 226                     {
 227                         // viewbox values are already in 'user unit'.
 228                         fWidth = pParentSvgSvgNode->getViewBox()->getWidth() * fPercentage;
 229                         bHasFound = true;
 230                     }
 231                     else
 232                     {
 233                         // take absolute value or cumulate percentage
 234                         if (pParentSvgSvgNode->getWidth().isSet())
 235                         {
 236                             if (SvgUnit::percent == pParentSvgSvgNode->getWidth().getUnit())
 237                             {
 238                                 fPercentage *= pParentSvgSvgNode->getWidth().getNumber() * 0.01;
 239                             }
 240                             else
 241                             {
 242                                 fWidth = pParentSvgSvgNode->getWidth().solveNonPercentage(*pParentSvgSvgNode) * fPercentage;
 243                                 bHasFound = true;
 244                             }
 245                         } // not set => width=100% => factor 1, no need for else
 246                     }
 247                 }
 248             }
 249         }
 250
 251         void SvgSvgNode::seekReferenceHeight(double& fHeight, bool& bHasFound) const
 252         {
 253             if (!getParent() || bHasFound)
 254             {
 255                 return;
 256             }
 257             const SvgSvgNode* pParentSvgSvgNode = nullptr;
 258             // enclosing svg might have relative width and height, need to cumulate them till they are
 259             // resolved somewhere up in the node tree
 260             double fPercentage(1.0);
 261             for(const SvgNode* pParent = getParent(); pParent && !bHasFound; pParent = pParent->getParent())
 262             {
 263                 // dynamic_cast results Null-pointer for not SvgSvgNode and so skips them in if condition
 264                 pParentSvgSvgNode = dynamic_cast< const SvgSvgNode* >(pParent);
 265                 if (pParentSvgSvgNode)
 266                 {
 267                     if (pParentSvgSvgNode->getViewBox())
 268                     {
 269                         // viewbox values are already in 'user unit'.
 270                         fHeight = pParentSvgSvgNode->getViewBox()->getHeight() * fPercentage;
 271                         bHasFound = true;
 272                     }
 273                     else
 274                     {
 275                         // take absolute value or cumulate percentage
 276                         if (pParentSvgSvgNode->getHeight().isSet())
 277                         {
 278                             if (SvgUnit::percent == pParentSvgSvgNode->getHeight().getUnit())
 279                             {
 280                                 fPercentage *= pParentSvgSvgNode->getHeight().getNumber() * 0.01;
 281                             }
 282                             else
 283                             {
 284                                 fHeight = pParentSvgSvgNode->getHeight().solveNonPercentage(*pParentSvgSvgNode) * fPercentage;
 285                                 bHasFound = true;
 286                             }
 287                         } // not set => height=100% => factor 1, no need for else
 288                     }
 289                 }
 290             }
 291         }
 292
 293 // ToDo: Consider attribute overflow in method decomposeSvgNode
 294         void SvgSvgNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
 295         {
 296             drawinglayer::primitive2d::Primitive2DContainer aSequence;
 297
 298             // #i125258# check now if we need to init some style settings locally. Do not do this
 299             // in the constructor, there is not yet information e.g. about existing CssStyles.
 300             // Here all nodes are read and interpreted
 301             const_cast< SvgSvgNode* >(this)->initializeStyleAttributes();
 302
 303             // decompose children
 304             SvgNode::decomposeSvgNode(aSequence, bReferenced);
 305
 306             if(!aSequence.empty())
 307             {
 308                 if(getParent())
 309                 {
 310                     // #i122594# if width/height is not given, it's 100% (see 5.1.2 The 'svg' element in SVG1.1 spec).
 311                     // If it is relative, the question is to what. The previous implementation assumed relative to the
 312                     // local ViewBox which is implied by (4.2 Basic data types):
 313
 314                     // "Note that the non-property <length> definition also allows a percentage unit identifier.
 315                     // The meaning of a percentage length value depends on the attribute for which the percentage
 316                     // length value has been specified. Two common cases are: (a) when a percentage length value
 317                     // represents a percentage of the viewport width or height (refer to the section that discusses
 318                     // units in general), and (b) when a percentage length value represents a percentage of the
 319                     // bounding box width or height on a given object (refer to the section that describes object
 320                     // bounding box units)."
 321
 322                     // Comparisons with common browsers show that it's mostly interpreted relative to the viewport
 323                     // of the parent, and so does the new implementation.
 324
 325                     // Extract known viewport data
 326                     // bXXXIsAbsolute tracks whether relative values could be resolved to absolute values
 327
 328                     // If width or height is not provided, the default 100% is used, see SVG 1.1 section 5.1.2
 329                     // value 0.0 here is only to initialize variable
 330                     bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
 331                     double fW( bWidthIsAbsolute ? getWidth().solveNonPercentage(*this) : 0.0);
 332
 333                     bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
 334                     double fH( bHeightIsAbsolute ? getHeight().solveNonPercentage(*this) : 0.0);
 335
 336                     // If x or y not provided, then default 0.0 is used, see SVG 1.1 Section 5.1.2
 337                     bool bXIsAbsolute((getX().isSet() && SvgUnit::percent != getX().getUnit()) || !getX().isSet());
 338                     double fX( bXIsAbsolute && getX().isSet() ? getX().solveNonPercentage(*this) : 0.0);
 339
 340                     bool bYIsAbsolute((getY().isSet() && SvgUnit::percent != getY().getUnit()) || !getY().isSet());
 341                     double fY( bYIsAbsolute && getY().isSet() ? getY().solveNonPercentage(*this) : 0.0);
 342
 343                     if ( !bXIsAbsolute || !bWidthIsAbsolute)
 344                     {
 345                         // get width of enclosing svg and resolve percentage in x and width;
 346                         double fWReference(0.0);
 347                         bool bHasFoundWidth(false);
 348                         seekReferenceWidth(fWReference, bHasFoundWidth);
 349                         if (!bHasFoundWidth)
 350                         {
 351                             if (getViewBox())
 352                             {
 353                                 fWReference = getViewBox()->getWidth();
 354                             }
 355                             else
 356                             {
 357                                 // Even outermost svg has not all information to resolve relative values,
 358                                 // I use content itself as fallback to set missing values for viewport
 359                                 // Any better idea for such ill structured svg documents?
 360                                 const basegfx::B2DRange aChildRange(
 361                                             aSequence.getB2DRange(
 362                                                 drawinglayer::geometry::ViewInformation2D()));
 363                                 fWReference = aChildRange.getWidth();
 364                             }
 365                         }
 366                         // referenced values are already in 'user unit'
 367                         if (!bXIsAbsolute)
 368                         {
 369                             fX = getX().getNumber() * 0.01 * fWReference;
 370                         }
 371                         if (!bWidthIsAbsolute)
 372                         {
 373                             fW = (getWidth().isSet() ? getWidth().getNumber() *0.01 : 1.0) * fWReference;
 374                         }
 375                     }
 376
 377                     if ( !bYIsAbsolute || !bHeightIsAbsolute)
 378                     {
 379                         // get height of enclosing svg and resolve percentage in y and height
 380                         double fHReference(0.0);
 381                         bool bHasFoundHeight(false);
 382                         seekReferenceHeight(fHReference, bHasFoundHeight);
 383                         if (!bHasFoundHeight)
 384                         {
 385                             if (getViewBox())
 386                             {
 387                                 fHReference = getViewBox()->getHeight();
 388                             }
 389                             else
 390                             {
 391                             // Even outermost svg has not all information to resolve relative values,
 392                                 // I use content itself as fallback to set missing values for viewport
 393                                 // Any better idea for such ill structured svg documents?
 394                                 const basegfx::B2DRange aChildRange(
 395                                         aSequence.getB2DRange(
 396                                             drawinglayer::geometry::ViewInformation2D()));
 397                                 fHReference = aChildRange.getHeight();
 398                             }
 399                         }
 400
 401                         // referenced values are already in 'user unit'
 402                         if (!bYIsAbsolute)
 403                         {
 404                             fY = getY().getNumber() * 0.01 * fHReference;
 405                         }
 406                         if (!bHeightIsAbsolute)
 407                         {
 408                             fH = (getHeight().isSet() ? getHeight().getNumber() *0.01 : 1.0) * fHReference;
 409                         }
 410                     }
 411
 412                     if(getViewBox())
 413                     {
 414                         // SVG 1.1 defines in section 7.7 that a negative value for width or height
 415                         // in viewBox is an error and that 0.0 disables rendering
 416                         if(basegfx::fTools::more(getViewBox()->getWidth(),0.0) && basegfx::fTools::more(getViewBox()->getHeight(),0.0))
 417                         {
 418                             // create target range homing x,y, width and height as calculated above
 419                             const basegfx::B2DRange aTarget(fX, fY, fX + fW, fY + fH);
 420
 421                             if(aTarget.equal(*getViewBox()))
 422                             {
 423                                 // no mapping needed, append
 424                                 rTarget.append(aSequence);
 425                             }
 426                             else
 427                             {
 428                                 // create mapping
 429                                 // #i122610 SVG 1.1 defines in section 5.1.2 that if the attribute preserveAspectRatio is not specified,
 430                                 // then the effect is as if a value of 'xMidYMid meet' were specified.
 431                                 SvgAspectRatio aRatioDefault(SvgAlign::xMidYMid,true);
 432                                 const SvgAspectRatio& rRatio = getSvgAspectRatio().isSet()? getSvgAspectRatio() : aRatioDefault;
 433
 434                                 // let mapping be created from SvgAspectRatio
 435                                 const basegfx::B2DHomMatrix aEmbeddingTransform(
 436                                     rRatio.createMapping(aTarget, *getViewBox()));
 437
 438                                 // prepare embedding in transformation
 439                                 const drawinglayer::primitive2d::Primitive2DReference xRef(
 440                                     new drawinglayer::primitive2d::TransformPrimitive2D(
 441                                         aEmbeddingTransform,
 442                                         aSequence));
 443
 444                                 if(rRatio.isMeetOrSlice())
 445                                 {
 446                                     // embed in transformation
 447                                     rTarget.push_back(xRef);
 448                                 }
 449                                 else
 450                                 {
 451                                     // need to embed in MaskPrimitive2D, too
 452                                     const drawinglayer::primitive2d::Primitive2DReference xMask(
 453                                         new drawinglayer::primitive2d::MaskPrimitive2D(
 454                                             basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aTarget)),
 455                                             drawinglayer::primitive2d::Primitive2DContainer { xRef }));
 456
 457                                     rTarget.push_back(xMask);
 458                                 }
 459                             }
 460                         }
 461                     }
 462                     else // no viewBox attribute
 463                     {
 464                         // Svg defines that a negative value is an error and that 0.0 disables rendering
 465                         if(basegfx::fTools::more(fW, 0.0) && basegfx::fTools::more(fH, 0.0))
 466                         {
 467                             if(!basegfx::fTools::equalZero(fX) || !basegfx::fTools::equalZero(fY))
 468                             {
 469                                 // embed in transform
 470                                 const drawinglayer::primitive2d::Primitive2DReference xRef(
 471                                     new drawinglayer::primitive2d::TransformPrimitive2D(
 472                                         basegfx::utils::createTranslateB2DHomMatrix(fX, fY),
 473                                         aSequence));
 474
 475                                 aSequence = drawinglayer::primitive2d::Primitive2DContainer { xRef, };
 476                             }
 477
 478                             // embed in MaskPrimitive2D to clip
 479                             const drawinglayer::primitive2d::Primitive2DReference xMask(
 480                                 new drawinglayer::primitive2d::MaskPrimitive2D(
 481                                     basegfx::B2DPolyPolygon(
 482                                         basegfx::utils::createPolygonFromRect(
 483                                             basegfx::B2DRange(fX, fY, fX + fW, fY + fH))),
 484                                     aSequence));
 485
 486                             // append
 487                             rTarget.push_back(xMask);
 488                         }
 489                     }
 490                 }
 491                 else // Outermost SVG element
 492                 {
 493                     // Svg defines that a negative value is an error and that 0.0 disables rendering
 494                     // isPositive() not usable because it allows 0.0 in contrast to mathematical definition of 'positive'
 495                     const bool bWidthInvalid(getWidth().isSet() && basegfx::fTools::lessOrEqual(getWidth().getNumber(), 0.0));
 496                     const bool bHeightInvalid(getHeight().isSet() && basegfx::fTools::lessOrEqual(getHeight().getNumber(), 0.0));
 497                     if(!bWidthInvalid && !bHeightInvalid)
 498                     {
 499                         basegfx::B2DRange aSvgCanvasRange; // viewport
 500                         double fW = 0.0; // dummy values
 501                         double fH = 0.0;
 502                         if (const basegfx::B2DRange* pBox = getViewBox())
 503                         {
 504                             // SVG 1.1 defines in section 7.7 that a negative value for width or height
 505                             // in viewBox is an error and that 0.0 disables rendering
 506                             const double fViewBoxWidth = pBox->getWidth();
 507                             const double fViewBoxHeight = pBox->getHeight();
 508                             if(basegfx::fTools::more(fViewBoxWidth,0.0) && basegfx::fTools::more(fViewBoxHeight,0.0))
 509                             {
 510                                 // The intrinsic aspect ratio of the svg element is given by absolute values of svg width and svg height
 511                                 // or by the width and height of the viewBox, if svg width or svg height is relative.
 512                                 // see SVG 1.1 section 7.12
 513                                 bool bNeedsMapping(true);
 514                                 const bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
 515                                 const bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
 516                                 const double fViewBoxRatio(fViewBoxWidth/fViewBoxHeight);
 517                                 if(bWidthIsAbsolute && bHeightIsAbsolute)
 518                                 {
 519                                     fW = getWidth().solveNonPercentage(*this);
 520                                     fH = getHeight().solveNonPercentage(*this);
 521                                     aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
 522                                 }
 523                                 else if (bWidthIsAbsolute)
 524                                 {
 525                                     fW = getWidth().solveNonPercentage(*this);
 526                                     fH = fW / fViewBoxRatio ;
 527                                     aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
 528                                 }
 529                                 else if (bHeightIsAbsolute)
 530                                 {
 531                                     fH = getHeight().solveNonPercentage(*this);
 532                                     fW = fH * fViewBoxRatio ;
 533                                     aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
 534                                 }
 535                                 else
 536                                 {
 537                                     // There exists no parent to resolve relative width or height.
 538                                     // Use child size as fallback and expand to aspect ratio given
 539                                     // by the viewBox. No mapping.
 540                                     // We get viewport >= content, therefore no clipping.
 541                                     bNeedsMapping = false;
 542
 543                                     const double fChildWidth(pBox->getWidth());
 544                                     const double fChildHeight(pBox->getHeight());
 545                                     const double fLeft(pBox->getMinX());
 546                                     const double fTop(pBox->getMinY());
 547                                     if ( fChildWidth / fViewBoxWidth > fChildHeight / fViewBoxHeight )
 548                                     {  // expand y
 549                                         fW = fChildWidth;
 550                                         fH = fChildWidth / fViewBoxRatio;
 551                                     }
 552                                     else
 553                                     {  // expand x
 554                                         fH = fChildHeight;
 555                                         fW = fChildHeight * fViewBoxRatio;
 556                                     }
 557                                     aSvgCanvasRange = basegfx::B2DRange(fLeft, fTop, fLeft + fW, fTop + fH);
 558                                 }
 559
 560                                 if (bNeedsMapping)
 561                                 {
 562                                     // create mapping
 563                                     // SVG 1.1 defines in section 5.1.2 that if the attribute preserveAspectRatio is not specified,
 564                                     // then the effect is as if a value of 'xMidYMid meet' were specified.
 565                                     SvgAspectRatio aRatioDefault(SvgAlign::xMidYMid, true);
 566                                     const SvgAspectRatio& rRatio = getSvgAspectRatio().isSet()? getSvgAspectRatio() : aRatioDefault;
 567
 568                                     basegfx::B2DHomMatrix aViewBoxMapping = rRatio.createMapping(aSvgCanvasRange, *pBox);
 569                                     // no need to check ratio here for slice, the outermost Svg will
 570                                     // be clipped anyways (see below)
 571
 572                                     // scale content to viewBox definitions
 573                                     const drawinglayer::primitive2d::Primitive2DReference xTransform(
 574                                         new drawinglayer::primitive2d::TransformPrimitive2D(
 575                                             aViewBoxMapping,
 576                                             aSequence));
 577
 578                                     aSequence = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
 579                                 }
 580                             }
 581                         }
 582                         else // no viewbox => no mapping
 583                         {
 584                             const bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
 585                             const bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
 586                             if (bWidthIsAbsolute && bHeightIsAbsolute)
 587                             {
 588                                 fW =getWidth().solveNonPercentage(*this);
 589                                 fH =getHeight().solveNonPercentage(*this);
 590                                 aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
 591                             }
 592                             else
 593                             {
 594                                 // There exists no parent to resolve relative width or height.
 595                                 // Use child size as fallback. We get viewport >= content, therefore no clipping.
 596                                 const basegfx::B2DRange aChildRange(
 597                                      aSequence.getB2DRange(
 598                                          drawinglayer::geometry::ViewInformation2D()));
 599                                 const double fChildWidth(aChildRange.getWidth());
 600                                 const double fChildHeight(aChildRange.getHeight());
 601                                 const double fChildLeft(aChildRange.getMinX());
 602                                 const double fChildTop(aChildRange.getMinY());
 603                                 fW = bWidthIsAbsolute ? getWidth().solveNonPercentage(*this) : fChildWidth;
 604                                 fH = bHeightIsAbsolute ? getHeight().solveNonPercentage(*this) : fChildHeight;
 605                                 const double fLeft(bWidthIsAbsolute ? 0.0 : fChildLeft);
 606                                 const double fTop(bHeightIsAbsolute ? 0.0 : fChildTop);
 607                                 aSvgCanvasRange = basegfx::B2DRange(fLeft, fTop, fLeft+fW, fTop+fH);
 608                             }
 609
 610                         }
 611
 612                         // to be completely correct in Svg sense it is necessary to clip
 613                         // the whole content to the given canvas. I choose here to do this
 614                         // initially despite I found various examples of Svg files out there
 615                         // which have no correct values for this clipping. It's correct
 616                         // due to the Svg spec.
 617
 618                         // different from Svg we have the possibility with primitives to get
 619                         // a correct bounding box for the geometry. Get it for evtl. taking action
 620                         const basegfx::B2DRange aContentRange(
 621                             aSequence.getB2DRange(
 622                                 drawinglayer::geometry::ViewInformation2D()));
 623
 624                         if(aSvgCanvasRange.isInside(aContentRange))
 625                         {
 626                             // no clip needed, but an invisible HiddenGeometryPrimitive2D
 627                             // to allow getting the full Svg range using the primitive mechanisms.
 628                             // This is needed since e.g. an SdrObject using this as graphic will
 629                             // create a mapping transformation to exactly map the content to its
 630                             // real life size
 631                             const drawinglayer::primitive2d::Primitive2DReference xLine(
 632                                 new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
 633                                     basegfx::utils::createPolygonFromRect(
 634                                         aSvgCanvasRange),
 635                                     basegfx::BColor(0.0, 0.0, 0.0)));
 636                             const drawinglayer::primitive2d::Primitive2DReference xHidden(
 637                                 new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(
 638                                     drawinglayer::primitive2d::Primitive2DContainer { xLine }));
 639
 640                             aSequence.push_back(xHidden);
 641                         }
 642                         else if(aSvgCanvasRange.overlaps(aContentRange))
 643                         {
 644                             // Clip is necessary. This will make Svg images evtl. smaller
 645                             // than wanted from Svg (the free space which may be around it is
 646                             // conform to the Svg spec), but avoids an expensive and unnecessary
 647                             // clip. Keep the full Svg range here to get the correct mappings
 648                             // to objects using this. Optimizations can be done in the processors
 649                             const drawinglayer::primitive2d::Primitive2DReference xMask(
 650                                 new drawinglayer::primitive2d::MaskPrimitive2D(
 651                                     basegfx::B2DPolyPolygon(
 652                                         basegfx::utils::createPolygonFromRect(
 653                                             aSvgCanvasRange)),
 654                                     aSequence));
 655
 656                             aSequence = drawinglayer::primitive2d::Primitive2DContainer { xMask };
 657                         }
 658                         else
 659                         {
 660                             // not inside, no overlap. Empty Svg
 661                             aSequence.clear();
 662                         }
 663
 664                         if(!aSequence.empty())
 665                         {
 666                             // Another correction:
 667                             // If no Width/Height is set (usually done in
 668                             // <svg ... width="215.9mm" height="279.4mm" >) which
 669                             // is the case for own-Impress-exports, assume that
 670                             // the Units are already 100ThMM.
 671                             // Maybe only for own-Impress-exports, thus may need to be
 672                             // &&ed with getDocument().findSvgNodeById("ooo:meta_slides"),
 673                             // but does not need to be.
 674                             bool bEmbedInFinalTransformPxTo100ThMM(true);
 675
 676                             if(getDocument().findSvgNodeById("ooo:meta_slides")
 677                                 && !getWidth().isSet()
 678                                 && !getHeight().isSet())
 679                             {
 680                                 bEmbedInFinalTransformPxTo100ThMM = false;
 681                             }
 682
 683                             if(bEmbedInFinalTransformPxTo100ThMM)
 684                             {
 685                                 // embed in transform primitive to scale to 1/100th mm
 686                                 // where 1 inch == 25.4 mm to get from Svg coordinates (px) to
 687                                 // drawinglayer coordinates
 688                                 const double fScaleTo100thmm(25.4 * 100.0 / F_SVG_PIXEL_PER_INCH);
 689                                 const basegfx::B2DHomMatrix aTransform(
 690                                     basegfx::utils::createScaleB2DHomMatrix(
 691                                         fScaleTo100thmm,
 692                                         fScaleTo100thmm));
 693
 694                                 const drawinglayer::primitive2d::Primitive2DReference xTransform(
 695                                     new drawinglayer::primitive2d::TransformPrimitive2D(
 696                                         aTransform,
 697                                         aSequence));
 698
 699                                 aSequence = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
 700                             }
 701
 702                             // append to result
 703                             rTarget.append(aSequence);
 704                         }
 705                     }
 706                 }
 707             }
 708
 709             if(!(aSequence.empty() && !getParent() && getViewBox()))
 710                 return;
 711
 712             // tdf#118232 No geometry, Outermost SVG element and we have a ViewBox.
 713             // Create a HiddenGeometry Primitive containing an expanded
 714             // hairline geometry to have the size contained
 715             const drawinglayer::primitive2d::Primitive2DReference xLine(
 716                 new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
 717                     basegfx::utils::createPolygonFromRect(
 718                         *getViewBox()),
 719                     basegfx::BColor(0.0, 0.0, 0.0)));
 720             const drawinglayer::primitive2d::Primitive2DReference xHidden(
 721                 new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(
 722                     drawinglayer::primitive2d::Primitive2DContainer { xLine }));
 723
 724             rTarget.push_back(xHidden);
 725         }
 726
 727         basegfx::B2DRange SvgSvgNode::getCurrentViewPort() const
 728         {
 729             if(getViewBox())
 730             {
 731                 return *(getViewBox());
 732             }
 733             else // viewport should be given by x, y, width, and height
 734             {
 735                 // Extract known viewport data
 736                 // bXXXIsAbsolute tracks whether relative values could be resolved to absolute values
 737                 if (getParent())
 738                     {
 739                     // If width or height is not provided, the default 100% is used, see SVG 1.1 section 5.1.2
 740                     // value 0.0 here is only to initialize variable
 741                     bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
 742                     double fW( bWidthIsAbsolute ? getWidth().solveNonPercentage(*this) : 0.0);
 743                     bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
 744                     double fH( bHeightIsAbsolute ? getHeight().solveNonPercentage(*this) : 0.0);
 745
 746                     // If x or y not provided, then default 0.0 is used, see SVG 1.1 Section 5.1.2
 747                     bool bXIsAbsolute((getX().isSet() && SvgUnit::percent != getX().getUnit()) || !getX().isSet());
 748                     double fX( bXIsAbsolute && getX().isSet() ? getX().solveNonPercentage(*this) : 0.0);
 749
 750                     bool bYIsAbsolute((getY().isSet() && SvgUnit::percent != getY().getUnit()) || !getY().isSet());
 751                     double fY( bYIsAbsolute && getY().isSet() ? getY().solveNonPercentage(*this) : 0.0);
 752
 753                     if (bXIsAbsolute && bYIsAbsolute && bWidthIsAbsolute && bHeightIsAbsolute)
 754                     {
 755                         return basegfx::B2DRange(fX, fY, fX+fW, fY+fH);
 756                     }
 757                     else // try to resolve relative values
 758                     {
 759                         if (!bXIsAbsolute || !bWidthIsAbsolute)
 760                         {
 761                             // get width of enclosing svg and resolve percentage in x and width
 762                             double fWReference(0.0);
 763                             bool bHasFoundWidth(false);
 764                             seekReferenceWidth(fWReference, bHasFoundWidth);
 765                             // referenced values are already in 'user unit'
 766                             if (!bXIsAbsolute && bHasFoundWidth)
 767                             {
 768                                 fX = getX().getNumber() * 0.01 * fWReference;
 769                                 bXIsAbsolute = true;
 770                             }
 771                             if (!bWidthIsAbsolute && bHasFoundWidth)
 772                             {
 773                                 fW = (getWidth().isSet() ? getWidth().getNumber() *0.01 : 1.0) * fWReference;
 774                                 bWidthIsAbsolute = true;
 775                             }
 776                         }
 777                         if (!bYIsAbsolute || !bHeightIsAbsolute)
 778                         {
 779                             // get height of enclosing svg and resolve percentage in y and height
 780                             double fHReference(0.0);
 781                             bool bHasFoundHeight(false);
 782                             seekReferenceHeight(fHReference, bHasFoundHeight);
 783                             // referenced values are already in 'user unit'
 784                             if (!bYIsAbsolute && bHasFoundHeight)
 785                             {
 786                                 fY = getY().getNumber() * 0.01 * fHReference;
 787                                 bYIsAbsolute = true;
 788                             }
 789                             if (!bHeightIsAbsolute && bHasFoundHeight)
 790                             {
 791                                 fH = (getHeight().isSet() ? getHeight().getNumber() *0.01 : 1.0) * fHReference;
 792                                 bHeightIsAbsolute = true;
 793                             }
 794                         }
 795
 796                         if (bXIsAbsolute && bYIsAbsolute && bWidthIsAbsolute && bHeightIsAbsolute)
 797                         {
 798                             return basegfx::B2DRange(fX, fY, fX+fW, fY+fH);
 799                         }
 800                         else // relative values could not be resolved, there exists no fallback
 801                         {
 802                             return SvgNode::getCurrentViewPort();
 803                         }
 804                     }
 805                 }
 806                 else //outermost svg
 807                 {
 808                     // If width or height is not provided, the default would be 100%, see SVG 1.1 section 5.1.2
 809                     // But here it cannot be resolved and no fallback exists.
 810                     // SVG 1.1 defines in section 5.1.2 that x,y has no meaning for the outermost SVG element.
 811                     bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
 812                     bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
 813                     if (bWidthIsAbsolute && bHeightIsAbsolute)
 814                     {
 815                         double fW( getWidth().solveNonPercentage(*this) );
 816                         double fH( getHeight().solveNonPercentage(*this) );
 817                         return basegfx::B2DRange(0.0, 0.0, fW, fH);
 818                     }
 819                     else // no fallback exists
 820                     {
 821                             return SvgNode::getCurrentViewPort();
 822                     }
 823                 }
 824 // TODO: Is it possible to decompose and use the bounding box of the children, if even the
 825 //       outermost svg has no information to resolve percentage? Is it worth, how expensive is it?
 826
 827             }
 828         }
 829
 830 } // end of namespace svgio
 831
 832 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */