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