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 <svgdocument.hxx>
  21 #include <svgnode.hxx>
  22 #include <svgstyleattributes.hxx>
  23 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
  24 #include <o3tl/string_view.hxx>
  25 #include <osl/diagnose.h>
  26 #include <tools/urlobj.hxx>
  27
  28
  29 namespace svgio::svgreader
  30 {
  31         /// #i125258#
  32         bool SvgNode::supportsParentStyle() const
  33         {
  34             return true;
  35         }
  36
  37         const SvgStyleAttributes* SvgNode::getSvgStyleAttributes() const
  38         {
  39             return nullptr;
  40         }
  41
  42         void SvgNode::fillCssStyleVectorUsingHierarchyAndSelectors(
  43             const OUString& rClassStr,
  44             const SvgNode& rCurrent,
  45             const OUString& aConcatenated)
  46         {
  47             const SvgDocument& rDocument = getDocument();
  48
  49             if(!rDocument.hasGlobalCssStyleAttributes())
  50                 return;
  51
  52             const SvgNode* pParent = rCurrent.getParent();
  53
  54             // check for ID (highest priority)
  55             if(rCurrent.getId())
  56             {
  57                 const OUString& rId = *rCurrent.getId();
  58
  59                 if(rId.getLength())
  60                 {
  61                     const OUString aNewConcatenated(
  62                         "#" + rId + aConcatenated);
  63
  64                     if(pParent)
  65                     {
  66                         // check for combined selectors at parent firstso that higher specificity will be in front
  67                         fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *pParent, aNewConcatenated);
  68                     }
  69
  70                     const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aNewConcatenated);
  71
  72                     if(pNew)
  73                     {
  74                         // add CssStyle if found
  75                         maCssStyleVector.push_back(pNew);
  76                     }
  77                 }
  78             }
  79
  80             // check for 'class' references (a list of entries is allowed)
  81             if(rCurrent.getClass())
  82             {
  83                 const OUString& rClassList = *rCurrent.getClass();
  84                 const sal_Int32 nLen(rClassList.getLength());
  85
  86                 if(nLen)
  87                 {
  88                     std::vector< OUString > aParts;
  89                     sal_Int32 nPos(0);
  90                     OUStringBuffer aToken;
  91
  92                     while(nPos < nLen)
  93                     {
  94                         const sal_Int32 nInitPos(nPos);
  95                         copyToLimiter(rClassList, u' ', nPos, aToken, nLen);
  96                         skip_char(rClassList, u' ', nPos, nLen);
  97                         const OUString aPart(o3tl::trim(aToken));
  98                         aToken.setLength(0);
  99
 100                         if(aPart.getLength())
 101                         {
 102                             aParts.push_back(aPart);
 103                         }
 104
 105                         if(nInitPos == nPos)
 106                         {
 107                             OSL_ENSURE(false, "Could not interpret on current position (!)");
 108                             nPos++;
 109                         }
 110                     }
 111
 112                     for(const auto &a : aParts)
 113                     {
 114                         const OUString aNewConcatenated(
 115                             "." + a + aConcatenated);
 116
 117                         if(pParent)
 118                         {
 119                             // check for combined selectors at parent firstso that higher specificity will be in front
 120                             fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *pParent, aNewConcatenated);
 121                         }
 122
 123                         const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aNewConcatenated);
 124
 125                         if(pNew)
 126                         {
 127                             // add CssStyle if found
 128                             maCssStyleVector.push_back(pNew);
 129                         }
 130                     }
 131                 }
 132             }
 133
 134             // check for class-dependent references to CssStyles
 135             if(rClassStr.isEmpty())
 136                 return;
 137
 138             OUString aNewConcatenated(aConcatenated);
 139
 140             if(!rCurrent.getId() && !rCurrent.getClass() && 0 == aConcatenated.indexOf(rClassStr))
 141             {
 142                 // no new CssStyle Selector and already starts with rClassStr, do not concatenate;
 143                 // we pass an 'empty' node (in the sense of CssStyle Selector)
 144             }
 145             else
 146             {
 147                 aNewConcatenated = rClassStr + aConcatenated;
 148             }
 149
 150             if(pParent)
 151             {
 152                 // check for combined selectors at parent firstso that higher specificity will be in front
 153                 fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *pParent, aNewConcatenated);
 154             }
 155
 156             const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aNewConcatenated);
 157
 158             if(pNew)
 159             {
 160                 // add CssStyle if found
 161                 maCssStyleVector.push_back(pNew);
 162             }
 163         }
 164
 165         void SvgNode::fillCssStyleVector(const OUString& rClassStr, const SvgStyleAttributes& rOriginal)
 166         {
 167             OSL_ENSURE(!mbCssStyleVectorBuilt, "OOps, fillCssStyleVector called double ?!?");
 168             mbCssStyleVectorBuilt = true;
 169
 170             // #i125293# If we have CssStyles we need to build a linked list of SvgStyleAttributes
 171             // which represent this for the current object. There are various methods to
 172             // specify CssStyles which need to be taken into account in a given order:
 173             // - local CssStyle (independent from global CssStyles at SvgDocument)
 174             // - 'id' CssStyle
 175             // - 'class' CssStyle(s)
 176             // - type-dependent elements (e..g. 'rect' for all rect elements)
 177             // - Css selector '*'
 178             // - local attributes (rOriginal)
 179             // - inherited attributes (up the hierarchy)
 180             // The first four will be collected in maCssStyleVector for the current element
 181             // (once, this will not change) and be linked in the needed order using the
 182             // get/setCssStyleParent at the SvgStyleAttributes which will be used preferred in
 183             // member evaluation over the existing parent hierarchy
 184
 185             // check for local CssStyle with highest priority
 186             if(mpLocalCssStyle)
 187             {
 188                 // if we have one, use as first entry
 189                 maCssStyleVector.push_back(mpLocalCssStyle.get());
 190             }
 191
 192             // check the hierarchy for concatenated patterns of Selectors
 193             fillCssStyleVectorUsingHierarchyAndSelectors(rClassStr, *this, OUString());
 194
 195             // tdf#99115, Add css selector '*' style only if the element is on top of the hierarchy
 196             // meaning its parent is <svg>
 197             const SvgNode* pParent = this->getParent();
 198
 199             if(pParent && pParent->getType() == SVGToken::Svg)
 200             {
 201                 // #i125329# find Css selector '*', add as last element if found
 202                 const SvgStyleAttributes* pNew = getDocument().findGlobalCssStyleAttributes("*");
 203
 204                 if(pNew)
 205                 {
 206                     // add CssStyle for selector '*' if found
 207                     maCssStyleVector.push_back(pNew);
 208                 }
 209             }
 210
 211             //local attributes
 212             maCssStyleVector.push_back(&rOriginal);
 213         }
 214
 215         const SvgStyleAttributes* SvgNode::checkForCssStyle(const OUString& rClassStr, const SvgStyleAttributes& rOriginal) const
 216         {
 217             if(!mbCssStyleVectorBuilt)
 218             {
 219                 // build needed CssStyleVector for local node
 220                 const_cast< SvgNode* >(this)->fillCssStyleVector(rClassStr, rOriginal);
 221             }
 222
 223             if(maCssStyleVector.empty())
 224             {
 225                 // return given original if no CssStyles found
 226                 return &rOriginal;
 227             }
 228             else
 229             {
 230                 // #i125293# rOriginal will be the last element in the linked list; use no CssStyleParent
 231                 // there (reset it) to ensure that the parent hierarchy will be used when it's base
 232                 // is referenced. This new chaining inserts the CssStyles before the original style,
 233                 // this makes the whole process much safer since the original style when used will
 234                 // be not different to the situation without CssStyles; thus loops which may be caused
 235                 // by trying to use the parent hierarchy of the owner of the style will be avoided
 236                 // already in this mechanism. It's still good to keep the supportsParentStyle
 237                 // from #i125258# in place, though.
 238                 // This chain building using pointers will be done every time when checkForCssStyle
 239                 // is used (not the search, only the chaining). This is needed since the CssStyles
 240                 // themselves will be potentially used multiple times. It is not expensive since it's
 241                 // only changing some pointers.
 242                 // The alternative would be to create the style hierarchy for every element (or even
 243                 // for the element containing the hierarchy) in a vector of pointers and to use that.
 244                 // Resetting the CssStyleParent on rOriginal is probably not needed
 245                 // but simply safer to do.
 246
 247                 // loop over the existing CssStyles and link them. There is a first one, take
 248                 // as current
 249                 SvgStyleAttributes* pCurrent = const_cast< SvgStyleAttributes* >(maCssStyleVector[0]);
 250
 251                 for(size_t a(1); a < maCssStyleVector.size(); a++)
 252                 {
 253                     SvgStyleAttributes* pNext = const_cast< SvgStyleAttributes* >(maCssStyleVector[a]);
 254
 255                     pCurrent->setCssStyleParent(pNext);
 256                     pCurrent = pNext;
 257                 }
 258
 259                 // return 1st CssStyle as style chain start element (only for the
 260                 // local element, still no hierarchy used here)
 261                 return maCssStyleVector[0];
 262             }
 263         }
 264
 265         SvgNode::SvgNode(
 266             SVGToken aType,
 267             SvgDocument& rDocument,
 268             SvgNode* pParent)
 269         :   maType(aType),
 270             mrDocument(rDocument),
 271             mpParent(pParent),
 272             mpAlternativeParent(nullptr),
 273             maXmlSpace(XmlSpace::NotSet),
 274             maDisplay(Display::Inline),
 275             mbDecomposing(false),
 276             mbCssStyleVectorBuilt(false)
 277         {
 278             OSL_ENSURE(SVGToken::Unknown != maType, "SvgNode with unknown type created (!)");
 279
 280             if(pParent)
 281             {
 282                 pParent->maChildren.emplace_back(this);
 283             }
 284             else
 285             {
 286 #ifdef DBG_UTIL
 287                 if(SVGToken::Svg != getType())
 288                 {
 289                     OSL_ENSURE(false, "No parent for this node (!)");
 290                 }
 291 #endif
 292             }
 293         }
 294
 295         SvgNode::~SvgNode()
 296         {
 297         }
 298
 299         void SvgNode::readLocalCssStyle(std::u16string_view aContent)
 300         {
 301             if(!mpLocalCssStyle)
 302             {
 303                 // create LocalCssStyle if needed but not yet added
 304                 mpLocalCssStyle.reset(new SvgStyleAttributes(*this));
 305             }
 306             else
 307             {
 308                 // 2nd fill would be an error
 309                 OSL_ENSURE(false, "Svg node has two local CssStyles, this may lead to problems (!)");
 310             }
 311
 312             if(mpLocalCssStyle)
 313             {
 314                 // parse and set values to it
 315                 mpLocalCssStyle->readCssStyle(aContent);
 316             }
 317             else
 318             {
 319                 OSL_ENSURE(false, "Could not get/create a local CssStyle for a node (!)");
 320             }
 321         }
 322
 323         void SvgNode::parseAttributes(const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs)
 324         {
 325             // no longer need to pre-sort moving 'style' entries to the back so that
 326             // values get overwritten - that was the previous, not complete solution for
 327             // handling the priorities between svg and Css properties
 328             const sal_uInt32 nAttributes(xAttribs->getLength());
 329
 330             for(sal_uInt32 a(0); a < nAttributes; a++)
 331             {
 332                 const OUString aTokenName(xAttribs->getNameByIndex(a));
 333                 const SVGToken aSVGToken(StrToSVGToken(aTokenName, false));
 334
 335                 parseAttribute(aTokenName, aSVGToken, xAttribs->getValueByIndex(a));
 336             }
 337         }
 338
 339         Display getDisplayFromContent(std::u16string_view aContent)
 340         {
 341             if(!aContent.empty())
 342             {
 343                 if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inline"))
 344                 {
 345                     return Display::Inline;
 346                 }
 347                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"none"))
 348                 {
 349                     return Display::None;
 350                 }
 351                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inherit"))
 352                 {
 353                     return Display::Inherit;
 354                 }
 355                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"block"))
 356                 {
 357                     return Display::Block;
 358                 }
 359                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"list-item"))
 360                 {
 361                     return Display::ListItem;
 362                 }
 363                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"run-in"))
 364                 {
 365                     return Display::RunIn;
 366                 }
 367                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"compact"))
 368                 {
 369                     return Display::Compact;
 370                 }
 371                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"marker"))
 372                 {
 373                     return Display::Marker;
 374                 }
 375                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table"))
 376                 {
 377                     return Display::Table;
 378                 }
 379                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inline-table"))
 380                 {
 381                     return Display::InlineTable;
 382                 }
 383                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-row-group"))
 384                 {
 385                     return Display::TableRowGroup;
 386                 }
 387                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-header-group"))
 388                 {
 389                     return Display::TableHeaderGroup;
 390                 }
 391                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-footer-group"))
 392                 {
 393                     return Display::TableFooterGroup;
 394                 }
 395                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-row"))
 396                 {
 397                     return Display::TableRow;
 398                 }
 399                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-column-group"))
 400                 {
 401                     return Display::TableColumnGroup;
 402                 }
 403                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-column"))
 404                 {
 405                     return Display::TableColumn;
 406                 }
 407                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-cell"))
 408                 {
 409                     return Display::TableCell;
 410                 }
 411                 else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-caption"))
 412                 {
 413                     return Display::TableCaption;
 414                 }
 415             }
 416
 417             // return the default
 418             return Display::Inline;
 419         }
 420
 421         void SvgNode::parseAttribute(const OUString& /*rTokenName*/, SVGToken aSVGToken, const OUString& aContent)
 422         {
 423             switch(aSVGToken)
 424             {
 425                 case SVGToken::Id:
 426                 {
 427                     if(!aContent.isEmpty())
 428                     {
 429                         setId(aContent);
 430                     }
 431                     break;
 432                 }
 433                 case SVGToken::Class:
 434                 {
 435                     if(!aContent.isEmpty())
 436                     {
 437                         setClass(aContent);
 438                     }
 439                     break;
 440                 }
 441                 case SVGToken::XmlSpace:
 442                 {
 443                     if(!aContent.isEmpty())
 444                     {
 445                         if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"default"))
 446                         {
 447                             setXmlSpace(XmlSpace::Default);
 448                         }
 449                         else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"preserve"))
 450                         {
 451                             setXmlSpace(XmlSpace::Preserve);
 452                         }
 453                     }
 454                     break;
 455                 }
 456                 case SVGToken::Display:
 457                 {
 458                     if(!aContent.isEmpty())
 459                     {
 460                         setDisplay(getDisplayFromContent(aContent));
 461                     }
 462                     break;
 463                 }
 464                 default:
 465                 {
 466                     break;
 467                 }
 468             }
 469         }
 470
 471         void SvgNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
 472         {
 473             if (mbDecomposing) //guard against infinite recurse
 474                 return;
 475
 476             if(Display::None == getDisplay())
 477             {
 478                 return;
 479             }
 480
 481             if(!bReferenced)
 482             {
 483                 if(SVGToken::Defs == getType() ||
 484                     SVGToken::Symbol == getType() ||
 485                     SVGToken::ClipPathNode == getType() ||
 486                     SVGToken::Mask == getType() ||
 487                     SVGToken::Marker == getType() ||
 488                     SVGToken::Pattern == getType())
 489                 {
 490                     // do not decompose defs or symbol nodes (these hold only style-like
 491                     // objects which may be used by referencing them) except when doing
 492                     // so controlled referenced
 493
 494                     // also do not decompose ClipPaths and Masks. These should be embedded
 495                     // in a defs node (which gets not decomposed by itself), but you never
 496                     // know
 497
 498                     // also not directly used are Markers and Patterns, only indirectly used
 499                     // by reference
 500
 501                     // #i121656# also do not decompose nodes which have display="none" set
 502                     // as property
 503                     return;
 504                 }
 505             }
 506
 507             const auto& rChildren = getChildren();
 508
 509             if(rChildren.empty())
 510                 return;
 511
 512             mbDecomposing = true;
 513
 514             const sal_uInt32 nCount(rChildren.size());
 515
 516             for(sal_uInt32 a(0); a < nCount; a++)
 517             {
 518                 SvgNode* pCandidate = rChildren[a].get();
 519
 520                 if(pCandidate && Display::None != pCandidate->getDisplay())
 521                 {
 522                     const auto& rGrandChildren = pCandidate->getChildren();
 523                     const SvgStyleAttributes* pChildStyles = pCandidate->getSvgStyleAttributes();
 524                     // decompose:
 525                     // - visible terminal nodes
 526                     // - all non-terminal nodes (might contain visible nodes down the hierarchy)
 527                     if( !rGrandChildren.empty() || ( pChildStyles && (Visibility::visible == pChildStyles->getVisibility())) )
 528                     {
 529                         drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
 530                         pCandidate->decomposeSvgNode(aNewTarget, bReferenced);
 531
 532                         if(!aNewTarget.empty())
 533                         {
 534                             rTarget.append(aNewTarget);
 535                         }
 536                     }
 537                 }
 538                 else if(!pCandidate)
 539                 {
 540                     OSL_ENSURE(false, "Null-Pointer in child node list (!)");
 541                 }
 542             }
 543
 544             if(!rTarget.empty())
 545             {
 546                 const SvgStyleAttributes* pStyles = getSvgStyleAttributes();
 547                 if(pStyles)
 548                 {
 549                     // check if we have Title or Desc
 550                     const OUString& rTitle = pStyles->getTitle();
 551                     const OUString& rDesc = pStyles->getDesc();
 552
 553                     if(!rTitle.isEmpty() || !rDesc.isEmpty())
 554                     {
 555                         // default object name is empty
 556                         OUString aObjectName;
 557
 558                         // use path as object name when outmost element
 559                         if (SVGToken::Svg == getType())
 560                         {
 561                             aObjectName = getDocument().getAbsolutePath();
 562
 563                             if(!aObjectName.isEmpty())
 564                             {
 565                                 INetURLObject aURL(aObjectName);
 566
 567                                 aObjectName = aURL.getName(
 568                                     INetURLObject::LAST_SEGMENT,
 569                                     true,
 570                                     INetURLObject::DecodeMechanism::WithCharset);
 571                             }
 572                         }
 573
 574                         // pack in ObjectInfoPrimitive2D group
 575                         drawinglayer::primitive2d::Primitive2DReference xRef(
 576                             new drawinglayer::primitive2d::ObjectInfoPrimitive2D(
 577                                 std::move(rTarget),
 578                                 aObjectName,
 579                                 rTitle,
 580                                 rDesc));
 581
 582                         rTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
 583                     }
 584                 }
 585             }
 586             mbDecomposing = false;
 587         }
 588
 589         basegfx::B2DRange SvgNode::getCurrentViewPort() const
 590         {
 591             if(getParent())
 592             {
 593                 return getParent()->getCurrentViewPort();
 594             }
 595             else
 596             {
 597                 return basegfx::B2DRange(); // return empty B2DRange
 598             }
 599         }
 600
 601         double SvgNode::getCurrentFontSizeInherited() const
 602         {
 603             if(getParent())
 604             {
 605                 return getParent()->getCurrentFontSize();
 606             }
 607             else
 608             {
 609                 return 0.0;
 610             }
 611         }
 612
 613         double SvgNode::getCurrentFontSize() const
 614         {
 615             if(getSvgStyleAttributes())
 616                 return getSvgStyleAttributes()->getFontSizeNumber().solve(*this, NumberType::xcoordinate);
 617
 618             return getCurrentFontSizeInherited();
 619         }
 620
 621         double SvgNode::getCurrentXHeightInherited() const
 622         {
 623             if(getParent())
 624             {
 625                 return getParent()->getCurrentXHeight();
 626             }
 627             else
 628             {
 629                 return 0.0;
 630             }
 631         }
 632
 633         double SvgNode::getCurrentXHeight() const
 634         {
 635             if(getSvgStyleAttributes())
 636                 // for XHeight, use FontSize currently
 637                 return getSvgStyleAttributes()->getFontSizeNumber().solve(*this, NumberType::ycoordinate);
 638
 639             return getCurrentXHeightInherited();
 640         }
 641
 642         void SvgNode::setId(OUString const & rId)
 643         {
 644             if(mpId)
 645             {
 646                 mrDocument.removeSvgNodeFromMapper(*mpId);
 647                 mpId.reset();
 648             }
 649
 650             mpId = rId;
 651             mrDocument.addSvgNodeToMapper(*mpId, *this);
 652         }
 653
 654         void SvgNode::setClass(OUString const & rClass)
 655         {
 656             if(mpClass)
 657             {
 658                 mrDocument.removeSvgNodeFromMapper(*mpClass);
 659                 mpClass.reset();
 660             }
 661
 662             mpClass = rClass;
 663             mrDocument.addSvgNodeToMapper(*mpClass, *this);
 664         }
 665
 666         XmlSpace SvgNode::getXmlSpace() const
 667         {
 668             if(maXmlSpace != XmlSpace::NotSet)
 669             {
 670                 return maXmlSpace;
 671             }
 672
 673             if(getParent())
 674             {
 675                 return getParent()->getXmlSpace();
 676             }
 677
 678             // default is XmlSpace::Default
 679             return XmlSpace::Default;
 680         }
 681
 682         void SvgNode::accept(Visitor & rVisitor)
 683         {
 684             rVisitor.visit(*this);
 685         }
 686 } // end of namespace svgio
 687
 688
 689 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */