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