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