oox/source/drawingml/diagram/diagramlayoutatoms.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 "diagramlayoutatoms.hxx"
  21
  22 #include <functional>
  23
  24 #include <basegfx/numeric/ftools.hxx>
  25
  26 #include "oox/helper/attributelist.hxx"
  27 #include "drawingml/fillproperties.hxx"
  28 #include "drawingml/lineproperties.hxx"
  29 #include "drawingml/textbody.hxx"
  30 #include "drawingml/textparagraph.hxx"
  31 #include "drawingml/textrun.hxx"
  32 #include "drawingml/customshapeproperties.hxx"
  33 #include "layoutnodecontext.hxx"
  34
  35 using namespace ::com::sun::star;
  36 using namespace ::com::sun::star::uno;
  37 using namespace ::com::sun::star::xml::sax;
  38 using namespace ::oox::core;
  39
  40 namespace oox { namespace drawingml {
  41
  42 IteratorAttr::IteratorAttr( )
  43     : mnAxis( 0 )
  44     , mnCnt( -1 )
  45     , mbHideLastTrans( false )
  46     , mnPtType( 0 )
  47     , mnSt( 0 )
  48     , mnStep( 1 )
  49 {
  50 }
  51
  52 void IteratorAttr::loadFromXAttr( const Reference< XFastAttributeList >& xAttr )
  53 {
  54     AttributeList attr( xAttr );
  55     mnAxis = xAttr->getOptionalValueToken( XML_axis, 0 );
  56     mnCnt = attr.getInteger( XML_cnt, -1 );
  57     mbHideLastTrans = attr.getBool( XML_hideLastTrans, false );
  58     mnPtType = xAttr->getOptionalValueToken( XML_ptType, 0 );
  59     mnSt = attr.getInteger( XML_st, 0 );
  60     mnStep = attr.getInteger( XML_step, 1 );
  61 }
  62
  63 ConditionAttr::ConditionAttr()
  64     : mnFunc( 0 )
  65     , mnArg( 0 )
  66     , mnOp( 0 )
  67 {
  68
  69 }
  70
  71 void ConditionAttr::loadFromXAttr( const Reference< XFastAttributeList >& xAttr )
  72 {
  73     mnFunc = xAttr->getOptionalValueToken( XML_func, 0 );
  74     // mnArg will be -1 for "none" or any other unknown value
  75     mnArg = LayoutNodeContext::tagToVarIdx( xAttr->getOptionalValueToken( XML_arg, XML_none ) );
  76     mnOp = xAttr->getOptionalValueToken( XML_op, 0 );
  77     msVal = xAttr->getOptionalValue( XML_val );
  78 }
  79
  80 void LayoutAtom::dump(int level)
  81 {
  82     SAL_INFO("oox.drawingml",  "level = " << level << " - " << msName << " of type " << typeid(*this).name() );
  83     const std::vector<LayoutAtomPtr>& rChildren=getChildren();
  84     std::for_each( rChildren.begin(), rChildren.end(),
  85         [level] (LayoutAtomPtr const& pAtom) { pAtom->dump(level + 1); } );
  86 }
  87
  88 ForEachAtom::ForEachAtom(const Reference< XFastAttributeList >& xAttributes)
  89 {
  90     maIter.loadFromXAttr(xAttributes);
  91 }
  92
  93 void ForEachAtom::accept( LayoutAtomVisitor& rVisitor )
  94 {
  95     rVisitor.visit(*this);
  96 }
  97
  98 void ChooseAtom::accept( LayoutAtomVisitor& rVisitor )
  99 {
 100     rVisitor.visit(*this);
 101 }
 102
 103 ConditionAtom::ConditionAtom(const Reference< XFastAttributeList >& xAttributes) :
 104     mbElse( false )
 105 {
 106     maIter.loadFromXAttr( xAttributes );
 107     maCond.loadFromXAttr( xAttributes );
 108 }
 109
 110 const std::vector<LayoutAtomPtr>& ConditionAtom::getChildren() const
 111 {
 112     bool bDecisionVar=true;
 113     // HACK
 114     if( maCond.mnFunc == XML_var && maCond.mnArg == XML_dir && maCond.mnOp == XML_equ && maCond.msVal != "norm" )
 115         bDecisionVar=false;
 116
 117     if( bDecisionVar )
 118         return mpChildNodes;
 119     else
 120         return mpElseChildNodes;
 121 }
 122
 123 void ConditionAtom::accept( LayoutAtomVisitor& rVisitor )
 124 {
 125     rVisitor.visit(*this);
 126 }
 127
 128 void ConditionAtom::addChild( const LayoutAtomPtr & pNode )
 129 {
 130     if( mbElse )
 131         mpElseChildNodes.push_back( pNode );
 132     else
 133         mpChildNodes.push_back( pNode );
 134 }
 135
 136 void ConstraintAtom::accept( LayoutAtomVisitor& rVisitor )
 137 {
 138     rVisitor.visit(*this);
 139 }
 140
 141 void AlgAtom::accept( LayoutAtomVisitor& rVisitor )
 142 {
 143     rVisitor.visit(*this);
 144 }
 145
 146 void AlgAtom::layoutShape( const ShapePtr& rShape,
 147                            const OUString& rName ) const
 148 {
 149     switch(mnType)
 150     {
 151         case XML_composite:
 152         {
 153             if( rShape->getChildren().empty() )
 154             {
 155                 rShape->setSize(awt::Size(50,50));
 156                 break;
 157             }
 158
 159             // just put stuff below each other
 160             const sal_Int32 nIncX=0;
 161             const sal_Int32 nIncY=1;
 162
 163             std::vector<ShapePtr>::const_iterator aCurrShape=rShape->getChildren().begin();
 164             const std::vector<ShapePtr>::const_iterator aLastShape=rShape->getChildren().end();
 165
 166             // find biggest shape
 167             awt::Size aMaxSize;
 168             while( aCurrShape != aLastShape )
 169             {
 170                 const awt::Size& sz=(*aCurrShape)->getSize();
 171
 172                 aMaxSize.Width = std::max(
 173                     aMaxSize.Width,
 174                     sz.Width);
 175                 aMaxSize.Height = std::max(
 176                     aMaxSize.Height,
 177                     sz.Height);
 178
 179                 ++aCurrShape;
 180             }
 181
 182             aCurrShape=rShape->getChildren().begin();
 183             const awt::Point aStartPos=(*aCurrShape)->getPosition();
 184             awt::Point aCurrPos=aStartPos;
 185             awt::Size  aTotalSize;
 186             aTotalSize.Width = aMaxSize.Width;
 187             while( aCurrShape != aLastShape )
 188             {
 189                 const awt::Size& sz=(*aCurrShape)->getSize();
 190                 (*aCurrShape)->setPosition(aCurrPos);
 191                 (*aCurrShape)->setSize(
 192                     awt::Size(aMaxSize.Width,
 193                               sz.Height));
 194
 195                 aTotalSize.Height = std::max(
 196                     aTotalSize.Height,
 197                     aCurrPos.Y + sz.Height);
 198
 199                 aCurrPos.X += nIncX*sz.Width;
 200                 aCurrPos.Y += nIncY*sz.Height;
 201
 202                 ++aCurrShape;
 203             }
 204
 205             rShape->setSize(aTotalSize);
 206             break;
 207         }
 208
 209         case XML_conn:
 210             break;
 211
 212         case XML_cycle:
 213         {
 214             if( rShape->getChildren().empty() )
 215             {
 216                 rShape->setSize(awt::Size(50,50));
 217                 break;
 218             }
 219
 220             const sal_Int32 nStartAngle=maMap.count(XML_stAng) ? maMap.find(XML_stAng)->second : 0;
 221             const sal_Int32 nSpanAngle=maMap.count(XML_spanAng) ? maMap.find(XML_spanAng)->second : 360;
 222
 223             std::vector<ShapePtr>::const_iterator aCurrShape=rShape->getChildren().begin();
 224             const std::vector<ShapePtr>::const_iterator aLastShape=rShape->getChildren().end();
 225             const sal_Int32 nShapes=aLastShape-aCurrShape;
 226
 227             // find biggest shape
 228             awt::Size aMaxSize;
 229             while( aCurrShape != aLastShape )
 230             {
 231                 const awt::Size& sz=(*aCurrShape)->getSize();
 232
 233                 aMaxSize.Width = std::max(
 234                     aMaxSize.Width,
 235                     sz.Width);
 236                 aMaxSize.Height = std::max(
 237                     aMaxSize.Height,
 238                     sz.Height);
 239
 240                 ++aCurrShape;
 241             }
 242
 243             // layout shapes
 244             const sal_Int32 nMaxDim=std::max(aMaxSize.Width,aMaxSize.Height);
 245             awt::Size aTotalSize;
 246             aCurrShape=rShape->getChildren().begin();
 247             for( sal_Int32 i=0; i<nShapes; ++i, ++aCurrShape )
 248             {
 249                 const awt::Size& sz=(*aCurrShape)->getSize();
 250
 251                 const double r=nShapes*nMaxDim/F_2PI * 360.0/nSpanAngle;
 252                 const awt::Point aCurrPos(
 253                     r + r*sin( (double(i)*nSpanAngle/nShapes + nStartAngle)*F_PI180 ),
 254                     r - r*cos( (double(i)*nSpanAngle/nShapes + nStartAngle)*F_PI180 ) );
 255                 (*aCurrShape)->setPosition(aCurrPos);
 256
 257                 aTotalSize.Width = std::max(
 258                     aTotalSize.Width,
 259                     aCurrPos.X + sz.Width);
 260                 aTotalSize.Height = std::max(
 261                     aTotalSize.Height,
 262                     aCurrPos.Y + sz.Height);
 263             }
 264
 265             rShape->setSize(aTotalSize);
 266             break;
 267         }
 268
 269         case XML_hierChild:
 270         case XML_hierRoot:
 271             break;
 272
 273         case XML_lin:
 274         {
 275             if( rShape->getChildren().empty() )
 276             {
 277                 rShape->setSize(awt::Size(50,50));
 278                 break;
 279             }
 280
 281             const sal_Int32 nDir=maMap.count(XML_linDir) ? maMap.find(XML_linDir)->second : XML_fromL;
 282             const sal_Int32 nIncX=nDir==XML_fromL ? 1 : (nDir==XML_fromR ? -1 : 0);
 283             const sal_Int32 nIncY=nDir==XML_fromT ? 1 : (nDir==XML_fromB ? -1 : 0);
 284
 285             std::vector<ShapePtr>::const_iterator aCurrShape=rShape->getChildren().begin();
 286             const std::vector<ShapePtr>::const_iterator aLastShape=rShape->getChildren().end();
 287             const awt::Point aStartPos=(*aCurrShape)->getPosition();
 288             awt::Point aCurrPos=aStartPos;
 289             awt::Size  aTotalSize;
 290             while( aCurrShape != aLastShape )
 291             {
 292                 const awt::Size& sz=(*aCurrShape)->getSize();
 293                 (*aCurrShape)->setPosition(aCurrPos);
 294
 295                 aTotalSize.Width = std::max(
 296                     aTotalSize.Width,
 297                     aCurrPos.X + sz.Width);
 298                 aTotalSize.Height = std::max(
 299                     aTotalSize.Height,
 300                     aCurrPos.Y + sz.Height);
 301
 302                 // HACK: the spacing is arbitrary
 303                 aCurrPos.X += nIncX*(sz.Width+5);
 304                 aCurrPos.Y += nIncY*(sz.Height+5);
 305
 306                 ++aCurrShape;
 307             }
 308
 309             rShape->setSize(aTotalSize);
 310             break;
 311         }
 312
 313         case XML_pyra:
 314         case XML_snake:
 315             break;
 316
 317         case XML_sp:
 318             // HACK. Handled one level higher. Or rather, planned to
 319             break;
 320
 321         case XML_tx:
 322         {
 323             TextBodyPtr pTextBody=rShape->getTextBody();
 324             if( !pTextBody ||
 325                 pTextBody->getParagraphs().empty() ||
 326                 pTextBody->getParagraphs().front()->getRuns().empty() )
 327             {
 328                 rShape->setSize(awt::Size(5,5));
 329                 break;
 330             }
 331
 332             // HACK - count chars & paragraphs to come up with *some*
 333             // notion of necessary size
 334             const sal_Int32 nHackyFontHeight=50;
 335             const sal_Int32 nHackyFontWidth=20;
 336             awt::Size aTotalSize;
 337             for( size_t nPara=0; nPara<pTextBody->getParagraphs().size(); ++nPara )
 338             {
 339                 aTotalSize.Height += nHackyFontHeight;
 340
 341                 sal_Int32 nLocalWidth=0;
 342                 for( size_t nRun=0; nRun<pTextBody->getParagraphs().at(nPara)->getRuns().size(); ++nRun )
 343                     nLocalWidth +=
 344                         pTextBody->getParagraphs().at(nPara)->getRuns().at(nRun)->getText().getLength()
 345                         * nHackyFontWidth;
 346
 347                 aTotalSize.Width = std::max(
 348                     aTotalSize.Width,
 349                     nLocalWidth);
 350             }
 351
 352             rShape->setSize(aTotalSize);
 353             break;
 354         }
 355
 356         default:
 357             break;
 358     }
 359
 360     SAL_INFO(
 361         "oox.drawingml",
 362         "Layouting shape " << rName << ": (" << rShape->getPosition().X << ","
 363         << rShape->getPosition().Y << "," << rShape->getSize().Width << ","
 364         << rShape->getSize().Height << ")");
 365 }
 366
 367 void LayoutNode::accept( LayoutAtomVisitor& rVisitor )
 368 {
 369     rVisitor.visit(*this);
 370 }
 371
 372 bool LayoutNode::setupShape( const ShapePtr& rShape, const Diagram& rDgm, sal_uInt32 nIdx ) const
 373 {
 374     // find the data node to grab text from
 375     DiagramData::PointsNameMap::const_iterator aDataNode=rDgm.getData()->getPointsPresNameMap().find(msName);
 376     if( aDataNode != rDgm.getData()->getPointsPresNameMap().end() &&
 377         aDataNode->second.size() > nIdx )
 378     {
 379         SAL_INFO(
 380             "oox.drawingml",
 381             "Filling content from " << nIdx << "th layout node named \""
 382                 << msName << "\", modelId \""
 383                 << aDataNode->second.at(nIdx)->msModelId << "\"");
 384
 385         // got the presentation node - now, need the actual data node:
 386         const DiagramData::StringMap::const_iterator aNodeName=rDgm.getData()->getPresOfNameMap().find(
 387             aDataNode->second.at(nIdx)->msModelId);
 388         if( aNodeName != rDgm.getData()->getPresOfNameMap().end() )
 389         {
 390             DiagramData::StringMap::value_type::second_type::const_iterator aVecIter=aNodeName->second.begin();
 391             const DiagramData::StringMap::value_type::second_type::const_iterator aVecEnd=aNodeName->second.end();
 392             while( aVecIter != aVecEnd )
 393             {
 394                 DiagramData::PointNameMap& rMap = rDgm.getData()->getPointNameMap();
 395                 DiagramData::PointNameMap::const_iterator aDataNode2 = rMap.find(aVecIter->first);
 396                 if (aDataNode2 == rMap.end())
 397                 {
 398                     //busted, skip it
 399                     ++aVecIter;
 400                     continue;
 401                 }
 402
 403                 if( aVecIter->second == 0 )
 404                 {
 405                     // grab shape attr from topmost element(s)
 406                     rShape->getShapeProperties() = aDataNode2->second->mpShape->getShapeProperties();
 407                     rShape->getLineProperties() = aDataNode2->second->mpShape->getLineProperties();
 408                     rShape->getFillProperties() = aDataNode2->second->mpShape->getFillProperties();
 409                     rShape->getCustomShapeProperties() = aDataNode2->second->mpShape->getCustomShapeProperties();
 410                     rShape->setMasterTextListStyle( aDataNode2->second->mpShape->getMasterTextListStyle() );
 411
 412                     SAL_INFO(
 413                         "oox.drawingml",
 414                         "Custom shape with preset type "
 415                             << (rShape->getCustomShapeProperties()
 416                                 ->getShapePresetType())
 417                             << " added for layout node named \"" << msName
 418                             << "\"");
 419                 }
 420
 421                 // append text with right outline level
 422                 if( aDataNode2->second->mpShape->getTextBody() &&
 423                     !aDataNode2->second->mpShape->getTextBody()->getParagraphs().empty() &&
 424                     !aDataNode2->second->mpShape->getTextBody()->getParagraphs().front()->getRuns().empty() )
 425                 {
 426                     TextBodyPtr pTextBody=rShape->getTextBody();
 427                     if( !pTextBody )
 428                     {
 429                         pTextBody.reset( new TextBody() );
 430
 431                         // also copy text attrs
 432                         pTextBody->getTextListStyle() =
 433                             aDataNode2->second->mpShape->getTextBody()->getTextListStyle();
 434                         pTextBody->getTextProperties() =
 435                             aDataNode2->second->mpShape->getTextBody()->getTextProperties();
 436
 437                         rShape->setTextBody(pTextBody);
 438                     }
 439
 440                     TextParagraph& rPara=pTextBody->addParagraph();
 441                     if( aVecIter->second != -1 )
 442                         rPara.getProperties().setLevel(aVecIter->second);
 443
 444                     rPara.addRun(
 445                         aDataNode2->second->mpShape->getTextBody()->getParagraphs().front()->getRuns().front());
 446                     rPara.getProperties().apply(
 447                         aDataNode2->second->mpShape->getTextBody()->getParagraphs().front()->getProperties());
 448                 }
 449
 450                 ++aVecIter;
 451             }
 452         }
 453         else
 454         {
 455             SAL_INFO(
 456                 "oox.drawingml",
 457                 "ShapeCreationVisitor::visit: no data node name found while"
 458                     " processing shape type "
 459                     << rShape->getCustomShapeProperties()->getShapePresetType()
 460                     << " for layout node named \"" << msName << "\"");
 461         }
 462
 463         // TODO(Q1): apply styling & coloring - taking
 464         // layout node's styleLbl for both style & color
 465         // now, but docs are a bit unclear on this
 466         if( !msStyleLabel.isEmpty() )
 467         {
 468             const DiagramQStyleMap::const_iterator aStyle=rDgm.getStyles().find(msStyleLabel);
 469             if( aStyle != rDgm.getStyles().end() )
 470             {
 471                 rShape->getShapeStyleRefs()[XML_fillRef] = aStyle->second.maFillStyle;
 472                 rShape->getShapeStyleRefs()[XML_lnRef] = aStyle->second.maLineStyle;
 473                 rShape->getShapeStyleRefs()[XML_effectRef] = aStyle->second.maEffectStyle;
 474                 rShape->getShapeStyleRefs()[XML_fontRef] = aStyle->second.maTextStyle;
 475                 Color aColor=aStyle->second.maTextStyle.maPhClr;
 476             }
 477
 478             const DiagramColorMap::const_iterator aColor=rDgm.getColors().find(msStyleLabel);
 479             if( aColor != rDgm.getColors().end() )
 480             {
 481                 const DiagramColor& rColor=aColor->second;
 482                 if( rColor.maFillColor.isUsed() )
 483                     rShape->getShapeStyleRefs()[XML_fillRef].maPhClr = rColor.maFillColor;
 484                 if( rColor.maLineColor.isUsed() )
 485                     rShape->getShapeStyleRefs()[XML_lnRef].maPhClr = rColor.maLineColor;
 486                 if( rColor.maEffectColor.isUsed() )
 487                     rShape->getShapeStyleRefs()[XML_effectRef].maPhClr = rColor.maEffectColor;
 488                 if( rColor.maTextFillColor.isUsed() )
 489                     rShape->getShapeStyleRefs()[XML_fontRef].maPhClr = rColor.maTextFillColor;
 490             }
 491         }
 492
 493         // even if no data node found, successful anyway. it's
 494         // contained at the layoutnode
 495         return true;
 496     }
 497     else
 498     {
 499         SAL_INFO(
 500             "oox.drawingml",
 501             "no text found while processing shape type "
 502                 << rShape->getCustomShapeProperties()->getShapePresetType()
 503                 << " for layout node named \"" << msName << "\"");
 504     }
 505
 506     return false;
 507 }
 508
 509 // Visitation
 510
 511 class ShapeLayoutingVisitor : public LayoutAtomVisitor
 512 {
 513     ShapePtr mpParentShape;
 514     OUString maName;
 515
 516     virtual void visit(ConstraintAtom& rAtom) override;
 517     virtual void visit(AlgAtom& rAtom) override;
 518     virtual void visit(ForEachAtom& rAtom) override;
 519     virtual void visit(ConditionAtom& rAtom) override;
 520     virtual void visit(ChooseAtom& rAtom) override;
 521     virtual void visit(LayoutNode& rAtom) override;
 522
 523 public:
 524     ShapeLayoutingVisitor(const ShapePtr& rParentShape,
 525                           const OUString& rName) :
 526         mpParentShape(rParentShape),
 527         maName(rName)
 528     {}
 529
 530     void defaultVisit(LayoutAtom& rAtom);
 531 };
 532
 533 class ShallowPresNameVisitor : public LayoutAtomVisitor
 534 {
 535     const Diagram& mrDgm;
 536     size_t mnCnt;
 537
 538     void defaultVisit(LayoutAtom& rAtom);
 539     virtual void visit(ConstraintAtom& rAtom) override;
 540     virtual void visit(AlgAtom& rAtom) override;
 541     virtual void visit(ForEachAtom& rAtom) override;
 542     virtual void visit(ConditionAtom& rAtom) override;
 543     virtual void visit(ChooseAtom& rAtom) override;
 544     virtual void visit(LayoutNode& rAtom) override;
 545
 546 public:
 547     explicit ShallowPresNameVisitor(const Diagram& rDgm) :
 548         mrDgm(rDgm),
 549         mnCnt(0)
 550     {}
 551
 552     size_t getCount() const
 553         { return mnCnt; }
 554 };
 555
 556 void ShapeCreationVisitor::defaultVisit(LayoutAtom& rAtom)
 557 {
 558     const std::vector<LayoutAtomPtr>& rChildren=rAtom.getChildren();
 559     std::for_each( rChildren.begin(), rChildren.end(),
 560         [this] (LayoutAtomPtr const& pAtom) { pAtom->accept(*this); } );
 561 }
 562
 563 void ShapeCreationVisitor::visit(ConstraintAtom& /*rAtom*/)
 564 {
 565     // TODO: eval the constraints
 566 }
 567
 568 void ShapeCreationVisitor::visit(AlgAtom& rAtom)
 569 {
 570     defaultVisit(rAtom);
 571 }
 572
 573 void ShapeCreationVisitor::visit(ForEachAtom& rAtom)
 574 {
 575     const std::vector<LayoutAtomPtr>& rChildren=rAtom.getChildren();
 576
 577     sal_Int32 nChildren=1;
 578     if( rAtom.iterator().mnPtType == XML_node )
 579     {
 580         // cound child data nodes - check all child Atoms for "name"
 581         // attribute that is contained in diagram's
 582         // getPointsPresNameMap()
 583         ShallowPresNameVisitor aVisitor(mrDgm);
 584         std::for_each( rChildren.begin(), rChildren.end(),
 585             [&] (LayoutAtomPtr const& pAtom) { pAtom->accept(aVisitor); } );
 586         nChildren = aVisitor.getCount();
 587     }
 588
 589     const sal_Int32 nCnt = std::min(
 590         nChildren,
 591         rAtom.iterator().mnCnt==-1 ? nChildren : rAtom.iterator().mnCnt);
 592
 593     const sal_Int32 nOldIdx=mnCurrIdx;
 594     const sal_Int32 nStep=rAtom.iterator().mnStep;
 595     for( mnCurrIdx=0; mnCurrIdx<nCnt && nStep>0; mnCurrIdx+=nStep )
 596     {
 597         // TODO there is likely some conditions
 598         std::for_each( rChildren.begin(), rChildren.end(),
 599             [this] (LayoutAtomPtr const& pAtom) { pAtom->accept(*this); } );
 600     }
 601
 602     // and restore idx
 603     mnCurrIdx = nOldIdx;
 604 }
 605
 606 void ShapeCreationVisitor::visit(ConditionAtom& rAtom)
 607 {
 608     defaultVisit(rAtom);
 609 }
 610
 611 void ShapeCreationVisitor::visit(ChooseAtom& rAtom)
 612 {
 613     defaultVisit(rAtom);
 614 }
 615
 616 void ShapeCreationVisitor::visit(LayoutNode& rAtom)
 617 {
 618     ShapePtr pCurrParent(mpParentShape);
 619     ShapePtr pCurrShape(rAtom.getShape());
 620     if( pCurrShape )
 621     {
 622         SAL_INFO(
 623             "oox.drawingml",
 624             "processing shape type "
 625                 << (pCurrShape->getCustomShapeProperties()
 626                     ->getShapePresetType()));
 627
 628         // TODO(F3): cloned shape shares all properties by reference,
 629         // don't change them!
 630         ShapePtr pClonedShape(
 631             new Shape( pCurrShape ));
 632
 633         if( rAtom.setupShape(pClonedShape, mrDgm, mnCurrIdx) )
 634         {
 635             pCurrParent->addChild(pClonedShape);
 636             pCurrParent = pClonedShape;
 637         }
 638     }
 639     else
 640     {
 641         SAL_WARN("oox.drawingml", "ShapeCreationVisitor::visit: no shape set while processing layoutnode named " << rAtom.getName() );
 642     }
 643
 644     // set new parent for children
 645     ShapePtr pPreviousParent(mpParentShape);
 646     mpParentShape=pCurrParent;
 647
 648     // process children
 649     defaultVisit(rAtom);
 650
 651     // restore parent
 652     mpParentShape=pPreviousParent;
 653
 654     // layout shapes - now all child shapes are created
 655     ShapeLayoutingVisitor aLayoutingVisitor(pCurrParent,
 656                                             rAtom.getName());
 657     aLayoutingVisitor.defaultVisit(rAtom);
 658 }
 659
 660 void ShapeLayoutingVisitor::defaultVisit(LayoutAtom& rAtom)
 661 {
 662     // visit all children, one of them needs to be the layout algorithm
 663     const std::vector<LayoutAtomPtr>& rChildren=rAtom.getChildren();
 664     std::for_each( rChildren.begin(), rChildren.end(),
 665         [this] (LayoutAtomPtr const& pAtom) { pAtom->accept(*this); } );
 666 }
 667
 668 void ShapeLayoutingVisitor::visit(ConstraintAtom& /*rAtom*/)
 669 {
 670     // stop processing
 671 }
 672
 673 void ShapeLayoutingVisitor::visit(AlgAtom& rAtom)
 674 {
 675     rAtom.layoutShape(mpParentShape, maName);
 676 }
 677
 678 void ShapeLayoutingVisitor::visit(ForEachAtom& /*rAtom*/)
 679 {
 680     // stop processing
 681 }
 682
 683 void ShapeLayoutingVisitor::visit(ConditionAtom& rAtom)
 684 {
 685     defaultVisit(rAtom);
 686 }
 687
 688 void ShapeLayoutingVisitor::visit(ChooseAtom& rAtom)
 689 {
 690     defaultVisit(rAtom);
 691 }
 692
 693 void ShapeLayoutingVisitor::visit(LayoutNode& /*rAtom*/)
 694 {
 695     // stop processing - only traverse Condition/Choose atoms
 696 }
 697
 698 void ShallowPresNameVisitor::defaultVisit(LayoutAtom& rAtom)
 699 {
 700     // visit all children, at least one of them needs to have proper
 701     // name set
 702     const std::vector<LayoutAtomPtr>& rChildren=rAtom.getChildren();
 703     std::for_each( rChildren.begin(), rChildren.end(),
 704         [this] (LayoutAtomPtr const& pAtom) { pAtom->accept(*this); } );
 705 }
 706
 707 void ShallowPresNameVisitor::visit(ConstraintAtom& /*rAtom*/)
 708 {
 709     // stop processing
 710 }
 711
 712 void ShallowPresNameVisitor::visit(AlgAtom& /*rAtom*/)
 713 {
 714     // stop processing
 715 }
 716
 717 void ShallowPresNameVisitor::visit(ForEachAtom& rAtom)
 718 {
 719     defaultVisit(rAtom);
 720 }
 721
 722 void ShallowPresNameVisitor::visit(ConditionAtom& rAtom)
 723 {
 724     defaultVisit(rAtom);
 725 }
 726
 727 void ShallowPresNameVisitor::visit(ChooseAtom& rAtom)
 728 {
 729     defaultVisit(rAtom);
 730 }
 731
 732 void ShallowPresNameVisitor::visit(LayoutNode& rAtom)
 733 {
 734     DiagramData::PointsNameMap::const_iterator aDataNode=
 735         mrDgm.getData()->getPointsPresNameMap().find(rAtom.getName());
 736     if( aDataNode != mrDgm.getData()->getPointsPresNameMap().end() )
 737         mnCnt = std::max(mnCnt,
 738                          aDataNode->second.size());
 739 }
 740
 741 } }
 742
 743 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */