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