svgio/source/svgreader/svgdocumenthandler.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 <svgdocumenthandler.hxx>
  21 #include <svgtoken.hxx>
  22 #include <svgsvgnode.hxx>
  23 #include <svggnode.hxx>
  24 #include <svganode.hxx>
  25 #include <svgnode.hxx>
  26 #include <svgpathnode.hxx>
  27 #include <svgrectnode.hxx>
  28 #include <svggradientnode.hxx>
  29 #include <svggradientstopnode.hxx>
  30 #include <svgsymbolnode.hxx>
  31 #include <svgusenode.hxx>
  32 #include <svgcirclenode.hxx>
  33 #include <svgellipsenode.hxx>
  34 #include <svglinenode.hxx>
  35 #include <svgpolynode.hxx>
  36 #include <svgtextnode.hxx>
  37 #include <svgcharacternode.hxx>
  38 #include <svgtspannode.hxx>
  39 #include <svgtrefnode.hxx>
  40 #include <svgtextpathnode.hxx>
  41 #include <svgstylenode.hxx>
  42 #include <svgimagenode.hxx>
  43 #include <svgclippathnode.hxx>
  44 #include <svgmasknode.hxx>
  45 #include <svgmarkernode.hxx>
  46 #include <svgpatternnode.hxx>
  47 #include <svgtitledescnode.hxx>
  48 #include <sal/log.hxx>
  49
  50 using namespace com::sun::star;
  51
  52 namespace
  53 {
  54     svgio::svgreader::SvgCharacterNode* whiteSpaceHandling(svgio::svgreader::SvgNode const * pNode, svgio::svgreader::SvgCharacterNode* pLast)
  55     {
  56         if(pNode)
  57         {
  58             const auto& rChilds = pNode->getChildren();
  59             const sal_uInt32 nCount(rChilds.size());
  60
  61             for(sal_uInt32 a(0); a < nCount; a++)
  62             {
  63                 svgio::svgreader::SvgNode* pCandidate = rChilds[a].get();
  64
  65                 if(pCandidate)
  66                 {
  67                     switch(pCandidate->getType())
  68                     {
  69                         case svgio::svgreader::SVGTokenCharacter:
  70                         {
  71                             // clean whitespace in text span
  72                             svgio::svgreader::SvgCharacterNode* pCharNode = static_cast< svgio::svgreader::SvgCharacterNode* >(pCandidate);
  73                             pCharNode->whiteSpaceHandling();
  74
  75                             // pCharNode may have lost all text. If that's the case, ignore
  76                             // as invalid character node
  77                             if(!pCharNode->getText().isEmpty())
  78                             {
  79                                 if(pLast)
  80                                 {
  81                                     bool bAddGap(true);
  82                                     static bool bNoGapsForBaselineShift(true); // loplugin:constvars:ignore
  83
  84                                     if(bNoGapsForBaselineShift)
  85                                     {
  86                                         // With this option a baseline shift between two char parts ('words')
  87                                         // will not add a space 'gap' to the end of the (non-last) word. This
  88                                         // seems to be the standard behaviour, see last bugdoc attached #122524#
  89                                         const svgio::svgreader::SvgStyleAttributes* pStyleLast = pLast->getSvgStyleAttributes();
  90                                         const svgio::svgreader::SvgStyleAttributes* pStyleCurrent = pCandidate->getSvgStyleAttributes();
  91
  92                                         if(pStyleLast && pStyleCurrent && pStyleLast->getBaselineShift() != pStyleCurrent->getBaselineShift())
  93                                         {
  94                                             bAddGap = false;
  95                                         }
  96                                     }
  97
  98                                     // add in-between whitespace (single space) to last
  99                                     // known character node
 100                                     if(bAddGap)
 101                                     {
 102                                         pLast->addGap();
 103                                     }
 104                                 }
 105
 106                                 // remember new last corrected character node
 107                                 pLast = pCharNode;
 108                             }
 109                             break;
 110                         }
 111                         case svgio::svgreader::SVGTokenTspan:
 112                         case svgio::svgreader::SVGTokenTextPath:
 113                         case svgio::svgreader::SVGTokenTref:
 114                         {
 115                             // recursively clean whitespaces in subhierarchy
 116                             pLast = whiteSpaceHandling(pCandidate, pLast);
 117                             break;
 118                         }
 119                         default:
 120                         {
 121                             OSL_ENSURE(false, "Unexpected token inside SVGTokenText (!)");
 122                             break;
 123                         }
 124                     }
 125                 }
 126             }
 127         }
 128
 129         return pLast;
 130     }
 131 }
 132
 133
 134 namespace svgio
 135 {
 136     namespace svgreader
 137     {
 138         SvgDocHdl::SvgDocHdl(const OUString& aAbsolutePath)
 139         :   maDocument(aAbsolutePath),
 140             mpTarget(nullptr),
 141             maCssContents(),
 142             bSkip(false)
 143         {
 144         }
 145
 146         SvgDocHdl::~SvgDocHdl()
 147         {
 148             if (mpTarget)
 149             {
 150                 OSL_ENSURE(false, "SvgDocHdl destructed with active target (!)");
 151
 152                 while (mpTarget->getParent())
 153                     mpTarget = const_cast< SvgNode* >(mpTarget->getParent());
 154
 155                 const SvgNodeVector& rOwnedTopLevels = maDocument.getSvgNodeVector();
 156                 if (std::none_of(rOwnedTopLevels.begin(), rOwnedTopLevels.end(),
 157                                 [&](std::unique_ptr<SvgNode> const & p) { return p.get() == mpTarget; }))
 158                     delete mpTarget;
 159             }
 160             OSL_ENSURE(maCssContents.empty(), "SvgDocHdl destructed with active css style stack entry (!)");
 161         }
 162
 163         void SvgDocHdl::startDocument(  )
 164         {
 165             OSL_ENSURE(!mpTarget, "Already a target at document start (!)");
 166             OSL_ENSURE(maCssContents.empty(), "SvgDocHdl startDocument with active css style stack entry (!)");
 167         }
 168
 169         void SvgDocHdl::endDocument(  )
 170         {
 171             OSL_ENSURE(!mpTarget, "Still a target at document end (!)");
 172             OSL_ENSURE(maCssContents.empty(), "SvgDocHdl endDocument with active css style stack entry (!)");
 173         }
 174
 175         void SvgDocHdl::startElement( const OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs )
 176         {
 177             if (bSkip)
 178                 return;
 179             if(aName.isEmpty())
 180                 return;
 181
 182             const SVGToken aSVGToken(StrToSVGToken(aName, false));
 183
 184             switch(aSVGToken)
 185             {
 186                 /// structural elements
 187                 case SVGTokenSymbol:
 188                 {
 189                     /// new basic node for Symbol. Content gets scanned, but
 190                     /// will not be decomposed (see SvgNode::decomposeSvgNode and bReferenced)
 191                     mpTarget = new SvgSymbolNode(maDocument, mpTarget);
 192                     mpTarget->parseAttributes(xAttribs);
 193                     break;
 194                 }
 195                 case SVGTokenDefs:
 196                 case SVGTokenG:
 197                 {
 198                     /// new node for Defs/G
 199                     mpTarget = new SvgGNode(aSVGToken, maDocument, mpTarget);
 200                     mpTarget->parseAttributes(xAttribs);
 201                     break;
 202                 }
 203                 case SVGTokenSvg:
 204                 {
 205                     /// new node for Svg
 206                     mpTarget = new SvgSvgNode(maDocument, mpTarget);
 207                     mpTarget->parseAttributes(xAttribs);
 208                     break;
 209                 }
 210                 case SVGTokenUse:
 211                 {
 212                     /// new node for Use
 213                     mpTarget = new SvgUseNode(maDocument, mpTarget);
 214                     mpTarget->parseAttributes(xAttribs);
 215                     break;
 216                 }
 217                 case SVGTokenA:
 218                 {
 219                     /// new node for A
 220                     mpTarget = new SvgANode(maDocument, mpTarget);
 221                     mpTarget->parseAttributes(xAttribs);
 222                     break;
 223                 }
 224
 225                 /// shape elements
 226                 case SVGTokenCircle:
 227                 {
 228                     /// new node for Circle
 229                     mpTarget = new SvgCircleNode(maDocument, mpTarget);
 230                     mpTarget->parseAttributes(xAttribs);
 231                     break;
 232                 }
 233                 case SVGTokenEllipse:
 234                 {
 235                     /// new node for Ellipse
 236                     mpTarget = new SvgEllipseNode(maDocument, mpTarget);
 237                     mpTarget->parseAttributes(xAttribs);
 238                     break;
 239                 }
 240                 case SVGTokenLine:
 241                 {
 242                     /// new node for Line
 243                     mpTarget = new SvgLineNode(maDocument, mpTarget);
 244                     mpTarget->parseAttributes(xAttribs);
 245                     break;
 246                 }
 247                 case SVGTokenPath:
 248                 {
 249                     /// new node for Path
 250                     mpTarget = new SvgPathNode(maDocument, mpTarget);
 251                     mpTarget->parseAttributes(xAttribs);
 252                     break;
 253                 }
 254                 case SVGTokenPolygon:
 255                 {
 256                     /// new node for Polygon
 257                     mpTarget = new SvgPolyNode(maDocument, mpTarget, false);
 258                     mpTarget->parseAttributes(xAttribs);
 259                     break;
 260                 }
 261                 case SVGTokenPolyline:
 262                 {
 263                     /// new node for Polyline
 264                     mpTarget = new SvgPolyNode(maDocument, mpTarget, true);
 265                     mpTarget->parseAttributes(xAttribs);
 266                     break;
 267                 }
 268                 case SVGTokenRect:
 269                 {
 270                     /// new node for Rect
 271                     mpTarget = new SvgRectNode(maDocument, mpTarget);
 272                     mpTarget->parseAttributes(xAttribs);
 273                     break;
 274                 }
 275                 case SVGTokenImage:
 276                 {
 277                     /// new node for Image
 278                     mpTarget = new SvgImageNode(maDocument, mpTarget);
 279                     mpTarget->parseAttributes(xAttribs);
 280                     break;
 281                 }
 282
 283                 /// title and description
 284                 case SVGTokenTitle:
 285                 case SVGTokenDesc:
 286                 {
 287                     /// new node for Title and/or Desc
 288                     mpTarget = new SvgTitleDescNode(aSVGToken, maDocument, mpTarget);
 289                     break;
 290                 }
 291
 292                 /// gradients
 293                 case SVGTokenLinearGradient:
 294                 case SVGTokenRadialGradient:
 295                 {
 296                     mpTarget = new SvgGradientNode(aSVGToken, maDocument, mpTarget);
 297                     mpTarget->parseAttributes(xAttribs);
 298                     break;
 299                 }
 300
 301                 /// gradient stops
 302                 case SVGTokenStop:
 303                 {
 304                     mpTarget = new SvgGradientStopNode(maDocument, mpTarget);
 305                     mpTarget->parseAttributes(xAttribs);
 306                     break;
 307                 }
 308
 309                 /// text
 310                 case SVGTokenText:
 311                 {
 312                     mpTarget = new SvgTextNode(maDocument, mpTarget);
 313                     mpTarget->parseAttributes(xAttribs);
 314                     break;
 315                 }
 316                 case SVGTokenTspan:
 317                 {
 318                     mpTarget = new SvgTspanNode(maDocument, mpTarget);
 319                     mpTarget->parseAttributes(xAttribs);
 320                     break;
 321                 }
 322                 case SVGTokenTref:
 323                 {
 324                     mpTarget = new SvgTrefNode(maDocument, mpTarget);
 325                     mpTarget->parseAttributes(xAttribs);
 326                     break;
 327                 }
 328                 case SVGTokenTextPath:
 329                 {
 330                     mpTarget = new SvgTextPathNode(maDocument, mpTarget);
 331                     mpTarget->parseAttributes(xAttribs);
 332                     break;
 333                 }
 334
 335                 /// styles (as stylesheets)
 336                 case SVGTokenStyle:
 337                 {
 338                     SvgStyleNode* pNew = new SvgStyleNode(maDocument, mpTarget);
 339                     mpTarget = pNew;
 340                     const sal_uInt32 nAttributes(xAttribs->getLength());
 341
 342                     if(0 == nAttributes)
 343                     {
 344                         // #i125326# no attributes, thus also no type="text/css". This is allowed to be missing,
 345                         // thus do mark this style as CssStyle. This is required to read the contained
 346                         // text (which defines the css style)
 347                         pNew->setTextCss(true);
 348                     }
 349                     else
 350                     {
 351                         // #i125326# there are attributes, read them. This will set isTextCss to true if
 352                         // a type="text/css" is contained as exact match, else not
 353                         mpTarget->parseAttributes(xAttribs);
 354                     }
 355
 356                     if(pNew->isTextCss())
 357                     {
 358                         // if it is a Css style, allow reading text between the start and end tag (see
 359                         // SvgDocHdl::characters for details)
 360                         maCssContents.emplace_back();
 361                     }
 362                     break;
 363                 }
 364
 365                 /// structural elements clip-path and mask. Content gets scanned, but
 366                 /// will not be decomposed (see SvgNode::decomposeSvgNode and bReferenced)
 367                 case SVGTokenClipPathNode:
 368                 {
 369                     /// new node for ClipPath
 370                     mpTarget = new SvgClipPathNode(maDocument, mpTarget);
 371                     mpTarget->parseAttributes(xAttribs);
 372                     break;
 373                 }
 374                 case SVGTokenMask:
 375                 {
 376                     /// new node for Mask
 377                     mpTarget = new SvgMaskNode(maDocument, mpTarget);
 378                     mpTarget->parseAttributes(xAttribs);
 379                     break;
 380                 }
 381
 382                 /// structural element marker
 383                 case SVGTokenMarker:
 384                 {
 385                     /// new node for marker
 386                     mpTarget = new SvgMarkerNode(maDocument, mpTarget);
 387                     mpTarget->parseAttributes(xAttribs);
 388                     break;
 389                 }
 390
 391                 /// structural element pattern
 392                 case SVGTokenPattern:
 393                 {
 394                     /// new node for pattern
 395                     mpTarget = new SvgPatternNode(maDocument, mpTarget);
 396                     mpTarget->parseAttributes(xAttribs);
 397                     break;
 398                 }
 399
 400                 // ignore FlowRoot and child nodes
 401                 case SVGTokenFlowRoot:
 402                 {
 403                     bSkip = true;
 404                     break;
 405                 }
 406
 407                 default:
 408                 {
 409                     /// invalid token, ignore
 410                     SAL_WARN( "svgio", "Unknown Base SvgToken <" + aName + "> (!)" );
 411                     break;
 412                 }
 413             }
 414         }
 415
 416         void SvgDocHdl::endElement( const OUString& aName )
 417         {
 418             if(aName.isEmpty())
 419                 return;
 420
 421             const SVGToken aSVGToken(StrToSVGToken(aName, false));
 422             SvgNode* pWhitespaceCheck(SVGTokenText == aSVGToken ? mpTarget : nullptr);
 423             SvgStyleNode* pCssStyle(SVGTokenStyle == aSVGToken ? static_cast< SvgStyleNode* >(mpTarget) : nullptr);
 424             SvgTitleDescNode* pSvgTitleDescNode(SVGTokenTitle == aSVGToken || SVGTokenDesc == aSVGToken ? static_cast< SvgTitleDescNode* >(mpTarget) : nullptr);
 425
 426             // if we are in skipping mode and we reach the flowRoot end tag: stop skipping mode
 427             if(bSkip && aSVGToken == SVGTokenFlowRoot)
 428                 bSkip = false;
 429             // we are in skipping mode: do nothing until we found the flowRoot end tag
 430             else if(bSkip)
 431                 return;
 432
 433             switch(aSVGToken)
 434             {
 435                 /// valid tokens for which a new one was created
 436
 437                 /// structural elements
 438                 case SVGTokenDefs:
 439                 case SVGTokenG:
 440                 case SVGTokenSvg:
 441                 case SVGTokenSymbol:
 442                 case SVGTokenUse:
 443                 case SVGTokenA:
 444
 445                 /// shape elements
 446                 case SVGTokenCircle:
 447                 case SVGTokenEllipse:
 448                 case SVGTokenLine:
 449                 case SVGTokenPath:
 450                 case SVGTokenPolygon:
 451                 case SVGTokenPolyline:
 452                 case SVGTokenRect:
 453                 case SVGTokenImage:
 454
 455                 /// title and description
 456                 case SVGTokenTitle:
 457                 case SVGTokenDesc:
 458
 459                 /// gradients
 460                 case SVGTokenLinearGradient:
 461                 case SVGTokenRadialGradient:
 462
 463                 /// gradient stops
 464                 case SVGTokenStop:
 465
 466                 /// text
 467                 case SVGTokenText:
 468                 case SVGTokenTspan:
 469                 case SVGTokenTextPath:
 470                 case SVGTokenTref:
 471
 472                 /// styles (as stylesheets)
 473                 case SVGTokenStyle:
 474
 475                 /// structural elements clip-path and mask
 476                 case SVGTokenClipPathNode:
 477                 case SVGTokenMask:
 478
 479                 /// structural element marker
 480                 case SVGTokenMarker:
 481
 482                 /// structural element pattern
 483                 case SVGTokenPattern:
 484
 485                 /// content handling after parsing
 486                 {
 487                     if(mpTarget)
 488                     {
 489                         if(!mpTarget->getParent())
 490                         {
 491                             // last element closing, save this tree
 492                             maDocument.appendNode(std::unique_ptr<SvgNode>(mpTarget));
 493                         }
 494
 495                         mpTarget = const_cast< SvgNode* >(mpTarget->getParent());
 496                     }
 497                     else
 498                     {
 499                         OSL_ENSURE(false, "Closing token, but no context (!)");
 500                     }
 501                     break;
 502                 }
 503                 default:
 504                 {
 505                     /// invalid token, ignore
 506                 }
 507             }
 508
 509             if(pSvgTitleDescNode && mpTarget)
 510             {
 511                 const OUString& aText(pSvgTitleDescNode->getText());
 512
 513                 if(!aText.isEmpty())
 514                 {
 515                     if(SVGTokenTitle == aSVGToken)
 516                     {
 517                         mpTarget->parseAttribute(getStrTitle(), aSVGToken, aText);
 518                     }
 519                     else // if(SVGTokenDesc == aSVGToken)
 520                     {
 521                         mpTarget->parseAttribute(getStrDesc(), aSVGToken, aText);
 522                     }
 523                 }
 524             }
 525
 526             if(pCssStyle && pCssStyle->isTextCss())
 527             {
 528                 // css style parsing
 529                 if(!maCssContents.empty())
 530                 {
 531                     // need to interpret css styles and remember them as StyleSheets
 532                     // #125325# Caution! the Css content may contain block comments
 533                     // (see http://www.w3.org/wiki/CSS_basics#CSS_comments). These need
 534                     // to be removed first
 535                     const OUString aCommentFreeSource(removeBlockComments(*(maCssContents.end() - 1)));
 536
 537                     if(aCommentFreeSource.getLength())
 538                     {
 539                         pCssStyle->addCssStyleSheet(aCommentFreeSource);
 540                     }
 541
 542                     maCssContents.pop_back();
 543                 }
 544                 else
 545                 {
 546                     OSL_ENSURE(false, "Closing CssStyle, but no collector string on stack (!)");
 547                 }
 548             }
 549
 550             if(pWhitespaceCheck)
 551             {
 552                 // cleanup read strings
 553                 whiteSpaceHandling(pWhitespaceCheck, nullptr);
 554             }
 555         }
 556
 557         void SvgDocHdl::characters( const OUString& aChars )
 558         {
 559             const sal_uInt32 nLength(aChars.getLength());
 560
 561             if(!(mpTarget && nLength))
 562                 return;
 563
 564             switch(mpTarget->getType())
 565             {
 566                 case SVGTokenText:
 567                 case SVGTokenTspan:
 568                 case SVGTokenTextPath:
 569                 {
 570                     const auto& rChilds = mpTarget->getChildren();
 571                     SvgCharacterNode* pTarget = nullptr;
 572
 573                     if(!rChilds.empty())
 574                     {
 575                         pTarget = dynamic_cast< SvgCharacterNode* >(rChilds[rChilds.size() - 1].get());
 576                     }
 577
 578                     if(pTarget)
 579                     {
 580                         // concatenate to current character span
 581                         pTarget->concatenate(aChars);
 582                     }
 583                     else
 584                     {
 585                         // add character span as simplified tspan (no arguments)
 586                         // as direct child of SvgTextNode/SvgTspanNode/SvgTextPathNode
 587                         new SvgCharacterNode(maDocument, mpTarget, aChars);
 588                     }
 589                     break;
 590                 }
 591                 case SVGTokenStyle:
 592                 {
 593                     SvgStyleNode& rSvgStyleNode = static_cast< SvgStyleNode& >(*mpTarget);
 594
 595                     if(rSvgStyleNode.isTextCss())
 596                     {
 597                         // collect characters for css style
 598                         if(!maCssContents.empty())
 599                         {
 600                             const OUString aTrimmedChars(aChars.trim());
 601
 602                             if(!aTrimmedChars.isEmpty())
 603                             {
 604                                 std::vector< OUString >::iterator aString(maCssContents.end() - 1);
 605                                 (*aString) += aTrimmedChars;
 606                             }
 607                         }
 608                         else
 609                         {
 610                             OSL_ENSURE(false, "Closing CssStyle, but no collector string on stack (!)");
 611                         }
 612                     }
 613                     break;
 614                 }
 615                 case SVGTokenTitle:
 616                 case SVGTokenDesc:
 617                 {
 618                     SvgTitleDescNode& rSvgTitleDescNode = static_cast< SvgTitleDescNode& >(*mpTarget);
 619
 620                     // add text directly to SvgTitleDescNode
 621                     rSvgTitleDescNode.concatenate(aChars);
 622                     break;
 623                 }
 624                 default:
 625                 {
 626                     // characters not used by a known node
 627                     break;
 628                 }
 629             }
 630         }
 631
 632         void SvgDocHdl::ignorableWhitespace(const OUString& /*aWhitespaces*/)
 633         {
 634         }
 635
 636         void SvgDocHdl::processingInstruction(const OUString& /*aTarget*/, const OUString& /*aData*/)
 637         {
 638         }
 639
 640         void SvgDocHdl::setDocumentLocator(const uno::Reference< xml::sax::XLocator >& /*xLocator*/)
 641         {
 642         }
 643     } // end of namespace svgreader
 644 } // end of namespace svgio
 645
 646 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */