svgio/source/svgreader/svgnode.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 <svgdocument.hxx>
  21 #include <svgnode.hxx>
  22 #include <svgstyleattributes.hxx>
  23 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
  24 #include <tools/urlobj.hxx>
  25
  26
  27 namespace svgio::svgreader
  28 {
  29         /// #i125258#
  30         bool SvgNode::supportsParentStyle() const
  31         {
  32             return true;
  33         }
  34
  35         const SvgStyleAttributes* SvgNode::getSvgStyleAttributes() const
  36         {
  37             return nullptr;
  38         }
  39
  40         void SvgNode::fillCssStyleVectorUsingHierarchyAndSelectors(
  41             const OUString& rClassStr,
  42             const SvgNode& rCurrent,
  43             const OUString& aConcatenated)
  44         {
  45             const SvgDocument& rDocument = getDocument();
  46
  47             if(!rDocument.hasGlobalCssStyleAttributes())
  48                 return;
  49
  50             const SvgNode* pParent = rCurrent.getParent();
  51
  52             // check for ID (highest priority)
  53             if(rCurrent.getId())
  54             {
  55                 const OUString& rId = *rCurrent.getId();
  56
  57                 if(rId.getLength())
  58                 {
  59                     const OUString aNewConcatenated(
  60                         "#" + rId + aConcatenated);
  61
  62                     if(pParent)
  63                     {
  64                         // check for combined selectors at parent firstso that higher specificity will be in front
  65                         fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *pParent, aNewConcatenated);
  66                     }
  67
  68                     const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aNewConcatenated);
  69
  70                     if(pNew)
  71                     {
  72                         // add CssStyle if found
  73                         maCssStyleVector.push_back(pNew);
  74                     }
  75                 }
  76             }
  77
  78             // check for 'class' references (a list of entries is allowed)
  79             if(rCurrent.getClass())
  80             {
  81                 const OUString& rClassList = *rCurrent.getClass();
  82                 const sal_Int32 nLen(rClassList.getLength());
  83
  84                 if(nLen)
  85                 {
  86                     std::vector< OUString > aParts;
  87                     sal_Int32 nPos(0);
  88                     OUStringBuffer aToken;
  89
  90                     while(nPos < nLen)
  91                     {
  92                         const sal_Int32 nInitPos(nPos);
  93                         copyToLimiter(rClassList, u' ', nPos, aToken, nLen);
  94                         skip_char(rClassList, u' ', nPos, nLen);
  95                         const OUString aPart(aToken.makeStringAndClear().trim());
  96
  97                         if(aPart.getLength())
  98                         {
  99                             aParts.push_back(aPart);
 100                         }
 101
 102                         if(nInitPos == nPos)
 103                         {
 104                             OSL_ENSURE(false, "Could not interpret on current position (!)");
 105                             nPos++;
 106                         }
 107                     }
 108
 109                     for(size_t a(0); a < aParts.size(); a++)
 110                     {
 111                         const OUString aNewConcatenated(
 112                             "." + aParts[a] + aConcatenated);
 113
 114                         if(pParent)
 115                         {
 116                             // check for combined selectors at parent firstso that higher specificity will be in front
 117                             fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *pParent, aNewConcatenated);
 118                         }
 119
 120                         const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aNewConcatenated);
 121
 122                         if(pNew)
 123                         {
 124                             // add CssStyle if found
 125                             maCssStyleVector.push_back(pNew);
 126                         }
 127                     }
 128                 }
 129             }
 130
 131             // check for class-dependent references to CssStyles
 132             if(rClassStr.isEmpty())
 133                 return;
 134
 135             OUString aNewConcatenated(aConcatenated);
 136
 137             if(!rCurrent.getId() && !rCurrent.getClass() && 0 == aConcatenated.indexOf(rClassStr))
 138             {
 139                 // no new CssStyle Selector and already starts with rClassStr, do not concatenate;
 140                 // we pass an 'empty' node (in the sense of CssStyle Selector)
 141             }
 142             else
 143             {
 144                 aNewConcatenated = rClassStr + aConcatenated;
 145             }
 146
 147             if(pParent)
 148             {
 149                 // check for combined selectors at parent firstso that higher specificity will be in front
 150                 fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *pParent, aNewConcatenated);
 151             }
 152
 153             const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aNewConcatenated);
 154
 155             if(pNew)
 156             {
 157                 // add CssStyle if found
 158                 maCssStyleVector.push_back(pNew);
 159             }
 160         }
 161
 162         void SvgNode::fillCssStyleVector(const OUString& rClassStr, const SvgStyleAttributes& rOriginal)
 163         {
 164             OSL_ENSURE(!mbCssStyleVectorBuilt, "OOps, fillCssStyleVector called double ?!?");
 165             mbCssStyleVectorBuilt = true;
 166
 167             // #i125293# If we have CssStyles we need to build a linked list of SvgStyleAttributes
 168             // which represent this for the current object. There are various methods to
 169             // specify CssStyles which need to be taken into account in a given order:
 170             // - local CssStyle (independent from global CssStyles at SvgDocument)
 171             // - 'id' CssStyle
 172             // - 'class' CssStyle(s)
 173             // - type-dependent elements (e..g. 'rect' for all rect elements)
 174             // - Css selector '*'
 175             // - local attributes (rOriginal)
 176             // - inherited attributes (up the hierarchy)
 177             // The first four will be collected in maCssStyleVector for the current element
 178             // (once, this will not change) and be linked in the needed order using the
 179             // get/setCssStyleParent at the SvgStyleAttributes which will be used preferred in
 180             // member evaluation over the existing parent hierarchy
 181
 182             // check for local CssStyle with highest priority
 183             if(mpLocalCssStyle)
 184             {
 185                 // if we have one, use as first entry
 186                 maCssStyleVector.push_back(mpLocalCssStyle.get());
 187             }
 188
 189             // check the hierarchy for concatenated patterns of Selectors
 190             fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *this, OUString());
 191
 192             // tdf#99115, Add css selector '*' style only if the element is on top of the hierarchy
 193             // meaning its parent is <svg>
 194             const SvgNode* pParent = this->getParent();
 195
 196             if(pParent && pParent->getType() == SVGToken::Svg)
 197             {
 198                 // #i125329# find Css selector '*', add as last element if found
 199                 const SvgStyleAttributes* pNew = getDocument().findGlobalCssStyleAttributes("*");
 200
 201                 if(pNew)
 202                 {
 203                     // add CssStyle for selector '*' if found
 204                     maCssStyleVector.push_back(pNew);
 205                 }
 206             }
 207
 208             //local attributes
 209             maCssStyleVector.push_back(&rOriginal);
 210         }
 211
 212         const SvgStyleAttributes* SvgNode::checkForCssStyle(const OUString& rClassStr, const SvgStyleAttributes& rOriginal) const
 213         {
 214             if(!mbCssStyleVectorBuilt)
 215             {
 216                 // build needed CssStyleVector for local node
 217                 const_cast< SvgNode* >(this)->fillCssStyleVector(rClassStr, rOriginal);
 218             }
 219
 220             if(maCssStyleVector.empty())
 221             {
 222                 // return given original if no CssStyles found
 223                 return &rOriginal;
 224             }
 225             else
 226             {
 227                 // #i125293# rOriginal will be the last element in the linked list; use no CssStyleParent
 228                 // there (reset it) to ensure that the parent hierarchy will be used when it's base
 229                 // is referenced. This new chaining inserts the CssStyles before the original style,
 230                 // this makes the whole process much safer since the original style when used will
 231                 // be not different to the situation without CssStyles; thus loops which may be caused
 232                 // by trying to use the parent hierarchy of the owner of the style will be avoided
 233                 // already in this mechanism. It's still good to keep the supportsParentStyle
 234                 // from #i125258# in place, though.
 235                 // This chain building using pointers will be done every time when checkForCssStyle
 236                 // is used (not the search, only the chaining). This is needed since the CssStyles
 237                 // themselves will be potentially used multiple times. It is not expensive since it's
 238                 // only changing some pointers.
 239                 // The alternative would be to create the style hierarchy for every element (or even
 240                 // for the element containing the hierarchy) in a vector of pointers and to use that.
 241                 // Resetting the CssStyleParent on rOriginal is probably not needed
 242                 // but simply safer to do.
 243
 244                 // loop over the existing CssStyles and link them. There is a first one, take
 245                 // as current
 246                 SvgStyleAttributes* pCurrent = const_cast< SvgStyleAttributes* >(maCssStyleVector[0]);
 247
 248                 for(size_t a(1); a < maCssStyleVector.size(); a++)
 249                 {
 250                     SvgStyleAttributes* pNext = const_cast< SvgStyleAttributes* >(maCssStyleVector[a]);
 251
 252                     pCurrent->setCssStyleParent(pNext);
 253                     pCurrent = pNext;
 254                 }
 255
 256                 // return 1st CssStyle as style chain start element (only for the
 257                 // local element, still no hierarchy used here)
 258                 return maCssStyleVector[0];
 259             }
 260         }
 261
 262         SvgNode::SvgNode(
 263             SVGToken aType,
 264             SvgDocument& rDocument,
 265             SvgNode* pParent)
 266         :   maType(aType),
 267             mrDocument(rDocument),
 268             mpParent(pParent),
 269             mpAlternativeParent(nullptr),
 270             maChildren(),
 271             maXmlSpace(XmlSpace::NotSet),
 272             maDisplay(Display::Inline),
 273             maCssStyleVector(),
 274             mbDecomposing(false),
 275             mbCssStyleVectorBuilt(false)
 276         {
 277             OSL_ENSURE(SVGToken::Unknown != maType, "SvgNode with unknown type created (!)");
 278
 279             if(pParent)
 280             {
 281                 pParent->maChildren.emplace_back(this);
 282             }
 283             else
 284             {
 285 #ifdef DBG_UTIL
 286                 if(SVGToken::Svg != getType())
 287                 {
 288                     OSL_ENSURE(false, "No parent for this node (!)");
 289                 }
 290 #endif
 291             }
 292         }
 293
 294         SvgNode::~SvgNode()
 295         {
 296         }
 297
 298         void SvgNode::readLocalCssStyle(const OUString& aContent)
 299         {
 300             if(!mpLocalCssStyle)
 301             {
 302                 // create LocalCssStyle if needed but not yet added
 303                 mpLocalCssStyle.reset(new SvgStyleAttributes(*this));
 304             }
 305             else
 306             {
 307                 // 2nd fill would be an error
 308                 OSL_ENSURE(false, "Svg node has two local CssStyles, this may lead to problems (!)");
 309             }
 310
 311             if(mpLocalCssStyle)
 312             {
 313                 // parse and set values to it
 314                 mpLocalCssStyle->readCssStyle(aContent);
 315             }
 316             else
 317             {
 318                 OSL_ENSURE(false, "Could not get/create a local CssStyle for a node (!)");
 319             }
 320         }
 321
 322         void SvgNode::parseAttributes(const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs)
 323         {
 324             // no longer need to pre-sort moving 'style' entries to the back so that
 325             // values get overwritten - that was the previous, not complete solution for
 326             // handling the priorities between svg and Css properties
 327             const sal_uInt32 nAttributes(xAttribs->getLength());
 328
 329             for(sal_uInt32 a(0); a < nAttributes; a++)
 330             {
 331                 const OUString aTokenName(xAttribs->getNameByIndex(a));
 332                 const SVGToken aSVGToken(StrToSVGToken(aTokenName, false));
 333
 334                 parseAttribute(aTokenName, aSVGToken, xAttribs->getValueByIndex(a));
 335             }
 336         }
 337
 338         Display getDisplayFromContent(const OUString& aContent)
 339         {
 340             if(!aContent.isEmpty())
 341             {
 342                 if(aContent.startsWith("inline"))
 343                 {
 344                     return Display::Inline;
 345                 }
 346                 else if(aContent.startsWith("none"))
 347                 {
 348                     return Display::None;
 349                 }
 350                 else if(aContent.startsWith("inherit"))
 351                 {
 352                     return Display::Inherit;
 353                 }
 354                 else if(aContent.startsWith("block"))
 355                 {
 356                     return Display::Block;
 357                 }
 358                 else if(aContent.startsWith("list-item"))
 359                 {
 360                     return Display::ListItem;
 361                 }
 362                 else if(aContent.startsWith("run-in"))
 363                 {
 364                     return Display::RunIn;
 365                 }
 366                 else if(aContent.startsWith("compact"))
 367                 {
 368                     return Display::Compact;
 369                 }
 370                 else if(aContent.startsWith("marker"))
 371                 {
 372                     return Display::Marker;
 373                 }
 374                 else if(aContent.startsWith("table"))
 375                 {
 376                     return Display::Table;
 377                 }
 378                 else if(aContent.startsWith("inline-table"))
 379                 {
 380                     return Display::InlineTable;
 381                 }
 382                 else if(aContent.startsWith("table-row-group"))
 383                 {
 384                     return Display::TableRowGroup;
 385                 }
 386                 else if(aContent.startsWith("table-header-group"))
 387                 {
 388                     return Display::TableHeaderGroup;
 389                 }
 390                 else if(aContent.startsWith("table-footer-group"))
 391                 {
 392                     return Display::TableFooterGroup;
 393                 }
 394                 else if(aContent.startsWith("table-row"))
 395                 {
 396                     return Display::TableRow;
 397                 }
 398                 else if(aContent.startsWith("table-column-group"))
 399                 {
 400                     return Display::TableColumnGroup;
 401                 }
 402                 else if(aContent.startsWith("table-column"))
 403                 {
 404                     return Display::TableColumn;
 405                 }
 406                 else if(aContent.startsWith("table-cell"))
 407                 {
 408                     return Display::TableCell;
 409                 }
 410                 else if(aContent.startsWith("table-caption"))
 411                 {
 412                     return Display::TableCaption;
 413                 }
 414             }
 415
 416             // return the default
 417             return Display::Inline;
 418         }
 419
 420         void SvgNode::parseAttribute(const OUString& /*rTokenName*/, SVGToken aSVGToken, const OUString& aContent)
 421         {
 422             switch(aSVGToken)
 423             {
 424                 case SVGToken::Id:
 425                 {
 426                     if(!aContent.isEmpty())
 427                     {
 428                         setId(aContent);
 429                     }
 430                     break;
 431                 }
 432                 case SVGToken::Class:
 433                 {
 434                     if(!aContent.isEmpty())
 435                     {
 436                         setClass(aContent);
 437                     }
 438                     break;
 439                 }
 440                 case SVGToken::XmlSpace:
 441                 {
 442                     if(!aContent.isEmpty())
 443                     {
 444                         if(aContent.startsWith("default"))
 445                         {
 446                             setXmlSpace(XmlSpace::Default);
 447                         }
 448                         else if(aContent.startsWith("preserve"))
 449                         {
 450                             setXmlSpace(XmlSpace::Preserve);
 451                         }
 452                     }
 453                     break;
 454                 }
 455                 case SVGToken::Display:
 456                 {
 457                     if(!aContent.isEmpty())
 458                     {
 459                         setDisplay(getDisplayFromContent(aContent));
 460                     }
 461                     break;
 462                 }
 463                 default:
 464                 {
 465                     break;
 466                 }
 467             }
 468         }
 469
 470         void SvgNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
 471         {
 472             if (mbDecomposing) //guard against infinite recurse
 473                 return;
 474
 475             if(Display::None == getDisplay())
 476             {
 477                 return;
 478             }
 479
 480             if(!bReferenced)
 481             {
 482                 if(SVGToken::Defs == getType() ||
 483                     SVGToken::Symbol == getType() ||
 484                     SVGToken::ClipPathNode == getType() ||
 485                     SVGToken::Mask == getType() ||
 486                     SVGToken::Marker == getType() ||
 487                     SVGToken::Pattern == getType())
 488                 {
 489                     // do not decompose defs or symbol nodes (these hold only style-like
 490                     // objects which may be used by referencing them) except when doing
 491                     // so controlled referenced
 492
 493                     // also do not decompose ClipPaths and Masks. These should be embedded
 494                     // in a defs node (which gets not decomposed by itself), but you never
 495                     // know
 496
 497                     // also not directly used are Markers and Patterns, only indirectly used
 498                     // by reference
 499
 500                     // #i121656# also do not decompose nodes which have display="none" set
 501                     // as property
 502                     return;
 503                 }
 504             }
 505
 506             const auto& rChildren = getChildren();
 507
 508             if(rChildren.empty())
 509                 return;
 510
 511             mbDecomposing = true;
 512
 513             const sal_uInt32 nCount(rChildren.size());
 514
 515             for(sal_uInt32 a(0); a < nCount; a++)
 516             {
 517                 SvgNode* pCandidate = rChildren[a].get();
 518
 519                 if(pCandidate && Display::None != pCandidate->getDisplay())
 520                 {
 521                     const auto& rGrandChildren = pCandidate->getChildren();
 522                     const SvgStyleAttributes* pChildStyles = pCandidate->getSvgStyleAttributes();
 523                     // decompose:
 524                     // - visible terminal nodes
 525                     // - all non-terminal nodes (might contain visible nodes down the hierarchy)
 526                     if( !rGrandChildren.empty() || ( pChildStyles && (Visibility::visible == pChildStyles->getVisibility())) )
 527                     {
 528                         drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
 529                         pCandidate->decomposeSvgNode(aNewTarget, bReferenced);
 530
 531                         if(!aNewTarget.empty())
 532                         {
 533                             rTarget.append(aNewTarget);
 534                         }
 535                     }
 536                 }
 537                 else if(!pCandidate)
 538                 {
 539                     OSL_ENSURE(false, "Null-Pointer in child node list (!)");
 540                 }
 541             }
 542
 543             if(!rTarget.empty())
 544             {
 545                 const SvgStyleAttributes* pStyles = getSvgStyleAttributes();
 546                 if(pStyles)
 547                 {
 548                     // check if we have Title or Desc
 549                     const OUString& rTitle = pStyles->getTitle();
 550                     const OUString& rDesc = pStyles->getDesc();
 551
 552                     if(!rTitle.isEmpty() || !rDesc.isEmpty())
 553                     {
 554                         // default object name is empty
 555                         OUString aObjectName;
 556
 557                         // use path as object name when outmost element
 558                         if (SVGToken::Svg == getType())
 559                         {
 560                             aObjectName = getDocument().getAbsolutePath();
 561
 562                             if(!aObjectName.isEmpty())
 563                             {
 564                                 INetURLObject aURL(aObjectName);
 565
 566                                 aObjectName = aURL.getName(
 567                                     INetURLObject::LAST_SEGMENT,
 568                                     true,
 569                                     INetURLObject::DecodeMechanism::WithCharset);
 570                             }
 571                         }
 572
 573                         // pack in ObjectInfoPrimitive2D group
 574                         const drawinglayer::primitive2d::Primitive2DReference xRef(
 575                             new drawinglayer::primitive2d::ObjectInfoPrimitive2D(
 576                                 rTarget,
 577                                 aObjectName,
 578                                 rTitle,
 579                                 rDesc));
 580
 581                         rTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
 582                     }
 583                 }
 584             }
 585             mbDecomposing = false;
 586         }
 587
 588         basegfx::B2DRange SvgNode::getCurrentViewPort() const
 589         {
 590             if(getParent())
 591             {
 592                 return getParent()->getCurrentViewPort();
 593             }
 594             else
 595             {
 596                 return basegfx::B2DRange(); // return empty B2DRange
 597             }
 598         }
 599
 600         double SvgNode::getCurrentFontSizeInherited() const
 601         {
 602             if(getParent())
 603             {
 604                 return getParent()->getCurrentFontSize();
 605             }
 606             else
 607             {
 608                 return 0.0;
 609             }
 610         }
 611
 612         double SvgNode::getCurrentFontSize() const
 613         {
 614             if(getSvgStyleAttributes())
 615                 return getSvgStyleAttributes()->getFontSizeNumber().solve(*this, NumberType::xcoordinate);
 616
 617             return getCurrentFontSizeInherited();
 618         }
 619
 620         double SvgNode::getCurrentXHeightInherited() const
 621         {
 622             if(getParent())
 623             {
 624                 return getParent()->getCurrentXHeight();
 625             }
 626             else
 627             {
 628                 return 0.0;
 629             }
 630         }
 631
 632         double SvgNode::getCurrentXHeight() const
 633         {
 634             if(getSvgStyleAttributes())
 635                 // for XHeight, use FontSize currently
 636                 return getSvgStyleAttributes()->getFontSizeNumber().solve(*this, NumberType::ycoordinate);
 637
 638             return getCurrentXHeightInherited();
 639         }
 640
 641         void SvgNode::setId(OUString const & rId)
 642         {
 643             if(mpId)
 644             {
 645                 mrDocument.removeSvgNodeFromMapper(*mpId);
 646                 mpId.reset();
 647             }
 648
 649             mpId = rId;
 650             mrDocument.addSvgNodeToMapper(*mpId, *this);
 651         }
 652
 653         void SvgNode::setClass(OUString const & rClass)
 654         {
 655             if(mpClass)
 656             {
 657                 mrDocument.removeSvgNodeFromMapper(*mpClass);
 658                 mpClass.reset();
 659             }
 660
 661             mpClass = rClass;
 662             mrDocument.addSvgNodeToMapper(*mpClass, *this);
 663         }
 664
 665         XmlSpace SvgNode::getXmlSpace() const
 666         {
 667             if(maXmlSpace != XmlSpace::NotSet)
 668             {
 669                 return maXmlSpace;
 670             }
 671
 672             if(getParent())
 673             {
 674                 return getParent()->getXmlSpace();
 675             }
 676
 677             // default is XmlSpace::Default
 678             return XmlSpace::Default;
 679         }
 680
 681         void SvgNode::accept(Visitor & rVisitor)
 682         {
 683             rVisitor.visit(*this);
 684         }
 685 } // end of namespace svgio
 686
 687
 688 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */