svgio/source/svgreader/svgnode.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 <basegfx/polygon/b2dpolypolygontools.hxx>
  21 #include <svgio/svgreader/svgdocument.hxx>
  22 #include <svgio/svgreader/svgnode.hxx>
  23 #include <svgio/svgreader/svgstyleattributes.hxx>
  24 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
  25 #include <tools/urlobj.hxx>
  26
  27 //////////////////////////////////////////////////////////////////////////////
  28
  29 namespace svgio
  30 {
  31     namespace svgreader
  32     {
  33         const SvgStyleAttributes* SvgNode::getSvgStyleAttributes() const
  34         {
  35             return 0;
  36         }
  37
  38         const SvgStyleAttributes* SvgNode::checkForCssStyle(const rtl::OUString& rClassStr, const SvgStyleAttributes& rOriginal) const
  39         {
  40             if(maCssStyleVector.empty()) // #120435# Evaluate for CSS styles only once, this cannot change
  41             {
  42                 const SvgDocument& rDocument = getDocument();
  43
  44                 if(rDocument.hasSvgStyleAttributesById())
  45                 {
  46                     if(getClass())
  47                     {
  48                         // find all referenced CSS styles, a list of entries is allowed
  49                         const rtl::OUString* pClassList = getClass();
  50                         const sal_Int32 nLen(pClassList->getLength());
  51                         sal_Int32 nPos(0);
  52                         const SvgStyleAttributes* pNew = 0;
  53
  54                         skip_char(*pClassList, sal_Unicode(' '), nPos, nLen);
  55
  56                         while(nPos < nLen)
  57                         {
  58                             rtl::OUStringBuffer aTokenValue;
  59
  60                             copyToLimiter(*pClassList, sal_Unicode(' '), nPos, aTokenValue, nLen);
  61                             skip_char(*pClassList, sal_Unicode(' '), nPos, nLen);
  62
  63                             rtl::OUString aId(rtl::OUString::createFromAscii("."));
  64                             const rtl::OUString aOUTokenValue(aTokenValue.makeStringAndClear());
  65
  66                             // look for CSS style common to token
  67                             aId = aId + aOUTokenValue;
  68                             pNew = rDocument.findSvgStyleAttributesById(aId);
  69
  70                             if(!pNew && rClassStr.getLength())
  71                             {
  72                                 // look for CSS style common to class.token
  73                                 aId = rClassStr + aId;
  74
  75                                 pNew = rDocument.findSvgStyleAttributesById(aId);
  76                             }
  77
  78                             if(pNew)
  79                             {
  80                                 const_cast< SvgNode* >(this)->maCssStyleVector.push_back(pNew);
  81                             }
  82                         }
  83                     }
  84
  85                     if(maCssStyleVector.empty() && getId())
  86                     {
  87                         // if none found, search for CSS style equal to Id
  88                         const SvgStyleAttributes* pNew = rDocument.findSvgStyleAttributesById(*getId());
  89
  90                         if(pNew)
  91                         {
  92                             const_cast< SvgNode* >(this)->maCssStyleVector.push_back(pNew);
  93                         }
  94                     }
  95
  96                     if(maCssStyleVector.empty() && rClassStr.getLength())
  97                     {
  98                         // if none found, search for CSS style equal to class type
  99                         const SvgStyleAttributes* pNew = rDocument.findSvgStyleAttributesById(rClassStr);
 100
 101                         if(pNew)
 102                         {
 103                             const_cast< SvgNode* >(this)->maCssStyleVector.push_back(pNew);
 104                         }
 105                     }
 106                 }
 107             }
 108
 109             if(!maCssStyleVector.empty())
 110             {
 111                 // #i123510# if CSS styles were found, create a linked list with rOriginal as parent
 112                 // and all CSS styles as linked children, so that the style attribute has
 113                 // priority over the CSS style. If there is no style attribute this means that
 114                 // no values are set at rOriginal, thus it is still correct to have that order.
 115                 // Repeated style requests should only be issued from sub-Text nodes and I'm not
 116                 // sure if in-between text nodes may build other chains (should not happen). But
 117                 // it's only a re-chaining with pointers (cheap), so allow to do it every time.
 118                 SvgStyleAttributes* pCurrent = const_cast< SvgStyleAttributes* >(&rOriginal);
 119                 pCurrent->setCssStyleParent(0);
 120
 121                 for(sal_uInt32 a(0); a < maCssStyleVector.size(); a++)
 122                 {
 123                     SvgStyleAttributes* pNext = const_cast< SvgStyleAttributes* >(maCssStyleVector[a]);
 124
 125                     pCurrent->setCssStyleParent(pNext);
 126                     pCurrent = pNext;
 127                     pCurrent->setCssStyleParent(0);
 128                 }
 129             }
 130
 131             return &rOriginal;
 132         }
 133
 134         SvgNode::SvgNode(
 135             SVGToken aType,
 136             SvgDocument& rDocument,
 137             SvgNode* pParent)
 138         :   maType(aType),
 139             mrDocument(rDocument),
 140             mpParent(pParent),
 141             mpAlternativeParent(0),
 142             maChildren(),
 143             mpId(0),
 144             mpClass(0),
 145             maXmlSpace(XmlSpace_notset),
 146             maCssStyleVector()
 147         {
 148             OSL_ENSURE(SVGTokenUnknown != maType, "SvgNode with unknown type created (!)");
 149
 150             if(pParent)
 151             {
 152                 pParent->maChildren.push_back(this);
 153             }
 154             else
 155             {
 156 #ifdef DBG_UTIL
 157                 if(SVGTokenSvg != getType())
 158                 {
 159                     OSL_ENSURE(false, "No parent for this node (!)");
 160                 }
 161 #endif
 162             }
 163         }
 164
 165         SvgNode::~SvgNode()
 166         {
 167             while(maChildren.size())
 168             {
 169                 delete maChildren[maChildren.size() - 1];
 170                 maChildren.pop_back();
 171             }
 172
 173             if(mpId) delete mpId;
 174             if(mpClass) delete mpClass;
 175         }
 176
 177         void SvgNode::parseAttributes(const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >& xAttribs)
 178         {
 179             const sal_uInt32 nAttributes(xAttribs->getLength());
 180
 181             for(sal_uInt32 a(0); a < nAttributes; a++)
 182             {
 183                 const OUString aTokenName(xAttribs->getNameByIndex(a));
 184
 185                 parseAttribute(aTokenName, StrToSVGToken(aTokenName), xAttribs->getValueByIndex(a));
 186             }
 187         }
 188
 189         void SvgNode::parseAttribute(const OUString& /*rTokenName*/, SVGToken aSVGToken, const OUString& aContent)
 190         {
 191             switch(aSVGToken)
 192             {
 193                 case SVGTokenId:
 194                 {
 195                     if(aContent.getLength())
 196                     {
 197                         setId(&aContent);
 198                     }
 199                     break;
 200                 }
 201                 case SVGTokenClass:
 202                 {
 203                     if(aContent.getLength())
 204                     {
 205                         setClass(&aContent);
 206                     }
 207                     break;
 208                 }
 209                 case SVGTokenXmlSpace:
 210                 {
 211                     if(aContent.getLength())
 212                     {
 213                         static OUString aStrDefault(OUString::createFromAscii("default"));
 214                         static OUString aStrPreserve(OUString::createFromAscii("preserve"));
 215
 216                         if(aContent.match(aStrDefault))
 217                         {
 218                             setXmlSpace(XmlSpace_default);
 219                         }
 220                         else if(aContent.match(aStrPreserve))
 221                         {
 222                             setXmlSpace(XmlSpace_preserve);
 223                         }
 224                     }
 225                     break;
 226                 }
 227                 default:
 228                 {
 229                     break;
 230                 }
 231             }
 232         }
 233
 234         void SvgNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DSequence& rTarget, bool bReferenced) const
 235         {
 236             if(!bReferenced)
 237             {
 238                 if(SVGTokenDefs == getType() ||
 239                     SVGTokenSymbol == getType() ||
 240                     SVGTokenClipPathNode == getType() ||
 241                     SVGTokenMask == getType() ||
 242                     SVGTokenMarker == getType() ||
 243                     SVGTokenPattern == getType())
 244                 {
 245                     // do not decompose defs or symbol nodes (these hold only style-like
 246                     // objects which may be used by referencing them) except when doing
 247                     // so controlled referenced
 248
 249                     // also do not decompose ClipPaths and Masks. These should be embedded
 250                     // in a defs node (which gets not decomposed by itself), but you never
 251                     // know
 252
 253                     // also not directly used are Markers and Patterns, only indirecty used
 254                     // by reference
 255                     return;
 256                 }
 257             }
 258
 259             const SvgNodeVector& rChildren = getChildren();
 260
 261             if(!rChildren.empty())
 262             {
 263                 const sal_uInt32 nCount(rChildren.size());
 264
 265                 for(sal_uInt32 a(0); a < nCount; a++)
 266                 {
 267                     SvgNode* pCandidate = rChildren[a];
 268
 269                     if(pCandidate)
 270                     {
 271                         drawinglayer::primitive2d::Primitive2DSequence aNewTarget;
 272
 273                         pCandidate->decomposeSvgNode(aNewTarget, bReferenced);
 274
 275                         if(aNewTarget.hasElements())
 276                         {
 277                             drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aNewTarget);
 278                         }
 279                     }
 280                     else
 281                     {
 282                         OSL_ENSURE(false, "Null-Pointer in child node list (!)");
 283                     }
 284                 }
 285
 286                 if(rTarget.hasElements())
 287                 {
 288                     const SvgStyleAttributes* pStyles = getSvgStyleAttributes();
 289
 290                     if(pStyles)
 291                     {
 292                         // check if we have Title or Desc
 293                         const OUString& rTitle = pStyles->getTitle();
 294                         const OUString& rDesc = pStyles->getDesc();
 295
 296                         if(rTitle.getLength() || rDesc.getLength())
 297                         {
 298                             // default object name is empty
 299                             OUString aObjectName;
 300
 301                             // use path as object name when outmost element
 302                             if(SVGTokenSvg == getType())
 303                             {
 304                                 aObjectName = getDocument().getAbsolutePath();
 305
 306                                 if(aObjectName.getLength())
 307                                 {
 308                                     INetURLObject aURL(aObjectName);
 309
 310                                     aObjectName = aURL.getName(
 311                                         INetURLObject::LAST_SEGMENT,
 312                                         true,
 313                                         INetURLObject::DECODE_WITH_CHARSET);
 314                                 }
 315                             }
 316
 317                             // pack in ObjectInfoPrimitive2D group
 318                             const drawinglayer::primitive2d::Primitive2DReference xRef(
 319                                 new drawinglayer::primitive2d::ObjectInfoPrimitive2D(
 320                                     rTarget,
 321                                     aObjectName,
 322                                     rTitle,
 323                                     rDesc));
 324
 325                             rTarget = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
 326                         }
 327                     }
 328                 }
 329             }
 330         }
 331
 332         const basegfx::B2DRange* SvgNode::getCurrentViewPort() const
 333         {
 334             if(getParent())
 335             {
 336                 return getParent()->getCurrentViewPort();
 337             }
 338             else
 339             {
 340                 return 0;
 341             }
 342         }
 343
 344         double SvgNode::getCurrentFontSizeInherited() const
 345         {
 346             if(getParent())
 347             {
 348                 return getParent()->getCurrentFontSize();
 349             }
 350             else
 351             {
 352                 return 0.0;
 353             }
 354         }
 355
 356         double SvgNode::getCurrentFontSize() const
 357         {
 358             if(getSvgStyleAttributes())
 359                 return getSvgStyleAttributes()->getFontSize().solve(*this, xcoordinate);
 360
 361             return getCurrentFontSizeInherited();
 362         }
 363
 364         double SvgNode::getCurrentXHeightInherited() const
 365         {
 366             if(getParent())
 367             {
 368                 return getParent()->getCurrentXHeight();
 369             }
 370             else
 371             {
 372                 return 0.0;
 373             }
 374         }
 375
 376         double SvgNode::getCurrentXHeight() const
 377         {
 378             if(getSvgStyleAttributes())
 379                 // for XHeight, use FontSize currently
 380                 return getSvgStyleAttributes()->getFontSize().solve(*this, ycoordinate);
 381
 382             return getCurrentXHeightInherited();
 383         }
 384
 385         void SvgNode::setId(const OUString* pfId)
 386         {
 387             if(mpId)
 388             {
 389                 mrDocument.removeSvgNodeFromMapper(*mpId);
 390                 delete mpId;
 391                 mpId = 0;
 392             }
 393
 394             if(pfId)
 395             {
 396                 mpId = new OUString(*pfId);
 397                 mrDocument.addSvgNodeToMapper(*mpId, *this);
 398             }
 399         }
 400
 401         void SvgNode::setClass(const OUString* pfClass)
 402         {
 403             if(mpClass)
 404             {
 405                 mrDocument.removeSvgNodeFromMapper(*mpClass);
 406                 delete mpClass;
 407                 mpClass = 0;
 408             }
 409
 410             if(pfClass)
 411             {
 412                 mpClass = new OUString(*pfClass);
 413                 mrDocument.addSvgNodeToMapper(*mpClass, *this);
 414             }
 415         }
 416
 417         XmlSpace SvgNode::getXmlSpace() const
 418         {
 419             if(maXmlSpace != XmlSpace_notset)
 420             {
 421                 return maXmlSpace;
 422             }
 423
 424             if(getParent())
 425             {
 426                 return getParent()->getXmlSpace();
 427             }
 428
 429             // default is XmlSpace_default
 430             return XmlSpace_default;
 431         }
 432
 433     } // end of namespace svgreader
 434 } // end of namespace svgio
 435
 436 //////////////////////////////////////////////////////////////////////////////
 437 // eof
 438
 439 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */