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