src/DependencyTree/DependencyTree_View.cxx

   1 // Copyright (C) 2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 // Internal includes
  21 #include "DependencyTree_View.h"
  22 #include "DependencyTree_Object.h"
  23 #include "DependencyTree_Arrow.h"
  24
  25 // GUI includes
  26 #include <SUIT_Session.h>
  27 #include <SUIT_ResourceMgr.h>
  28 #include <SalomeApp_Study.h>
  29 #include <QtxActionToolMgr.h>
  30 #include <LightApp_SelectionMgr.h>
  31 #include <SALOME_ListIteratorOfListIO.hxx>
  32
  33 // GEOM includes
  34 #include <GEOMBase.h>
  35
  36 // Qt includes
  37 #include <QApplication>
  38 #include <QWidgetAction>
  39
  40 DependencyTree_View::DependencyTree_View( QWidget* theParent )
  41 :GraphicsView_ViewPort( theParent ),
  42 myLevelsNumber(0),
  43 myMaxDownwardLevelsNumber(0),
  44 myMaxUpwardLevelsNumber(0),
  45 myIsUpdate( true )
  46 {
  47   SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
  48   if ( !app ) return;
  49
  50   SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
  51   myStudy = GeometryGUI::ClientStudyToStudy( study->studyDS());
  52
  53   mySelectionMgr = app->selectionMgr();
  54   if ( !mySelectionMgr ) return;
  55
  56   myMainEntries = new GEOM::string_array();
  57
  58   getNewTreeModel();
  59 }
  60
  61 DependencyTree_View::~DependencyTree_View()
  62 {
  63   clearView( true );
  64 }
  65
  66 //=================================================================================
  67 // function : init()
  68 // purpose  : this method is obligatory for initialize view frame actions
  69 //=================================================================================
  70 void DependencyTree_View::init( GraphicsView_ViewFrame* theViewFrame )
  71 {
  72   myNodesMovable = new QCheckBox( tr( "MOVE_NODES" ) );
  73   QWidgetAction* nodesMovableAction = new QWidgetAction( theViewFrame );
  74   nodesMovableAction->setDefaultWidget( myNodesMovable );
  75
  76   myDisplayAscendants = new QCheckBox( tr( "DISPLAY_ASCENDANTS" ) );
  77   QWidgetAction* displayAscendantsAction = new QWidgetAction( theViewFrame );
  78   displayAscendantsAction->setDefaultWidget( myDisplayAscendants  );
  79
  80   myDisplayDescendants = new QCheckBox(tr("DISPLAY_DESCENDANTS"));
  81   QWidgetAction* displayDescendantsAction = new QWidgetAction( theViewFrame );
  82   displayDescendantsAction->setDefaultWidget( myDisplayDescendants );
  83
  84   QLabel* hierarchyDepthLabel = new QLabel( tr( "HIERARCHY_DEPTH" ) );
  85   QWidgetAction* hierarchyDepthLabelAction = new QWidgetAction( theViewFrame );
  86   hierarchyDepthLabelAction->setDefaultWidget( hierarchyDepthLabel );
  87
  88   myLevelsNumber = checkMaxLevelsNumber();
  89
  90   myHierarchyDepth = new QSpinBox();
  91   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
  92   myHierarchyDepth->setSpecialValueText( tr( "SHOW_ALL" ) );
  93   myHierarchyDepth->setValue( 0 );
  94   QWidgetAction* hierarchyDepthAction = new QWidgetAction( theViewFrame );
  95   hierarchyDepthAction->setDefaultWidget( myHierarchyDepth );
  96
  97   updateButton = new QPushButton( tr( "UPDATE" ) );
  98   QWidgetAction* updateAction = new QWidgetAction( theViewFrame );
  99   updateAction->setDefaultWidget( updateButton );
 100
 101   QAction* separator1 = theViewFrame->toolMgr()->separator( false );
 102   QAction* separator2 = theViewFrame->toolMgr()->separator( false );
 103
 104   theViewFrame->toolMgr()->append( separator1, theViewFrame->getToolBarId() );
 105   theViewFrame->toolMgr()->append( hierarchyDepthLabelAction, theViewFrame->getToolBarId() );
 106   theViewFrame->toolMgr()->append( hierarchyDepthAction, theViewFrame->getToolBarId() );
 107   theViewFrame->toolMgr()->append( displayAscendantsAction, theViewFrame->getToolBarId() );
 108   theViewFrame->toolMgr()->append( displayDescendantsAction, theViewFrame->getToolBarId() );
 109   theViewFrame->toolMgr()->append( nodesMovableAction, theViewFrame->getToolBarId() );
 110
 111   theViewFrame->toolMgr()->append( separator2, theViewFrame->getToolBarId() );
 112   theViewFrame->toolMgr()->append( updateAction, theViewFrame->getToolBarId() );
 113
 114   connect( myNodesMovable, SIGNAL( toggled( bool ) ), this, SLOT( onMoveNodes( bool ) ) );
 115   connect( myHierarchyDepth, SIGNAL( valueChanged ( int ) ), this, SLOT( onHierarchyType() ) );
 116   connect( myDisplayAscendants , SIGNAL( toggled( bool ) ), this, SLOT( onHierarchyType() ) );
 117   connect( myDisplayDescendants, SIGNAL( toggled( bool ) ), this, SLOT( onHierarchyType() ) );
 118   connect( updateButton, SIGNAL( clicked() ), this, SLOT( onUpdateModel() ) );
 119
 120   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 121
 122   setPrefBackgroundColor( resMgr->colorValue( "Geometry", "dependency_tree_background_color", QColor( 255, 255, 255 ) ) );
 123   setNodesMovable( resMgr->booleanValue( "Geometry", "dependency_tree_move_nodes", true ) );
 124   setHierarchyType( resMgr->integerValue( "Geometry", "dependency_tree_hierarchy_type", 0 ) );
 125 }
 126
 127 //=================================================================================
 128 // function : updateModel()
 129 // purpose  : run all stage of dependency tree creation
 130 //=================================================================================
 131 void DependencyTree_View::updateModel( bool theUseSelectedObject, bool theUseOB )
 132 {
 133   getNewTreeModel( theUseSelectedObject, theUseOB );
 134   onHierarchyType();
 135 }
 136
 137 //=================================================================================
 138 // function : mouseMoveEvent()
 139 // purpose  : make some actions when mouse was moved
 140 //=================================================================================
 141 void DependencyTree_View::mouseMoveEvent( QMouseEvent *event )
 142 {
 143   QGraphicsView::mouseMoveEvent( event );
 144   ArrowsInfo::const_iterator i;
 145   for( i = myArrows.begin(); i != myArrows.end(); i++ ) {
 146     DependencyTree_Arrow* arrow = myArrows[ i->first ];
 147     arrow->update();
 148   }
 149 }
 150
 151 //=================================================================================
 152 // function : getViewName()
 153 // purpose  : return the name of current view
 154 //=================================================================================
 155 QString DependencyTree_View::getViewName() const
 156 {
 157   return tr( "DEPENDENCY_TREE" );
 158 }
 159
 160 //=================================================================================
 161 // function : getStudyId()
 162 // purpose  : return Id of current study
 163 //=================================================================================
 164 int DependencyTree_View::getStudyId() const
 165 {
 166   return myStudy->StudyId();
 167 }
 168
 169 //=================================================================================
 170 // function : getObjectByEntry()
 171 // purpose  : return DependencyTree_Object by entry
 172 //=================================================================================
 173 DependencyTree_Object* DependencyTree_View::getObjectByEntry( const std::string& theEntry )
 174 {
 175   return myTreeMap[ theEntry ];
 176 }
 177
 178 //=================================================================================
 179 // function : updateObjectName()
 180 // purpose  : update object name, having edited it in Object Browser
 181 //=================================================================================
 182 bool DependencyTree_View::updateObjectName( const std::string& theEntry )
 183 {
 184   bool res = false;
 185   for( initSelected(); moreSelected(); nextSelected() ) {
 186     if( DependencyTree_Object* aDepObject = dynamic_cast<DependencyTree_Object*>( selectedObject() ) ) {
 187       aDepObject->updateName();
 188       res = true;
 189     }
 190   }
 191   return res;
 192 }
 193
 194 //=================================================================================
 195 // function : setHierarchyType()
 196 // purpose  : set hierarchy type of dependency tree
 197 //=================================================================================
 198 void DependencyTree_View::setHierarchyType( const int theType )
 199 {
 200   myIsUpdate = false;
 201   switch( theType ) {
 202   case 0:
 203     myDisplayAscendants->setChecked( true );
 204     myDisplayDescendants->setChecked( true );
 205     break;
 206   case 1:
 207     myDisplayAscendants->setChecked( true );
 208     myDisplayDescendants->setChecked( false );
 209     break;
 210   case 2:
 211     myDisplayAscendants->setChecked( false );
 212     myDisplayDescendants->setChecked( true );
 213     break;
 214   }
 215   myIsUpdate = true;
 216   myLevelsNumber = checkMaxLevelsNumber();
 217   onHierarchyType();
 218 }
 219
 220 //=================================================================================
 221 // function : setNodesMovable()
 222 // purpose  : set possibility to move nodes or not
 223 //=================================================================================
 224 void DependencyTree_View::setNodesMovable( const bool theIsMovable )
 225 {
 226   myNodesMovable->setChecked( theIsMovable );
 227 }
 228
 229 //=================================================================================
 230 // function : setPrefBackgroundColor()
 231 // purpose  : set background color from preferences
 232 //=================================================================================
 233 void DependencyTree_View::setPrefBackgroundColor( const QColor& theColor )
 234 {
 235   if( isForegroundEnabled() )
 236   {
 237     setForegroundColor( theColor );
 238     updateForeground();
 239   }
 240   else
 241     setBackgroundColor( theColor );
 242 }
 243
 244 //=================================================================================
 245 // function : setNodeColor()
 246 // purpose  : set node color from preferences
 247 //=================================================================================
 248 void DependencyTree_View::setNodeColor( const QColor& theColor )
 249 {
 250   EntryObjectMap::const_iterator i;
 251   for( i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 252     DependencyTree_Object* object = myTreeMap[ i->first ];
 253     object->setColor( theColor );
 254   }
 255 }
 256
 257 //=================================================================================
 258 // function : setMainNodeColor()
 259 // purpose  : set main node color from preferences
 260 //=================================================================================
 261 void DependencyTree_View::setMainNodeColor( const QColor& theColor )
 262 {
 263   EntryObjectMap::const_iterator i;
 264   for( i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 265     DependencyTree_Object* object = myTreeMap[ i->first ];
 266     object->setMainObjectColor( theColor );
 267   }
 268 }
 269
 270 //=================================================================================
 271 // function : setSelectNodeColor()
 272 // purpose  : set selected node color from preferences
 273 //=================================================================================
 274 void DependencyTree_View::setSelectNodeColor( const QColor& theColor )
 275 {
 276   EntryObjectMap::const_iterator i;
 277   for( i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 278     DependencyTree_Object* object = myTreeMap[ i->first ];
 279     object->setSelectColor( theColor );
 280   }
 281 }
 282
 283 //=================================================================================
 284 // function : setArrowColor()
 285 // purpose  : set arrow color from preferences
 286 //=================================================================================
 287 void DependencyTree_View::setArrowColor( const QColor& theColor )
 288 {
 289   ArrowsInfo::const_iterator i;
 290   for( i = myArrows.begin(); i != myArrows.end(); i++ ) {
 291     DependencyTree_Arrow* arrow = myArrows[ i->first ];
 292     arrow->setColor( theColor );
 293   }
 294 }
 295
 296 //=================================================================================
 297 // function : setHighlightArrowColor()
 298 // purpose  : set highlighted arrow color from preferences
 299 //=================================================================================
 300 void DependencyTree_View::setHighlightArrowColor( const QColor& theColor )
 301 {
 302   ArrowsInfo::const_iterator i;
 303   for( i = myArrows.begin(); i != myArrows.end(); i++ ) {
 304     DependencyTree_Arrow* arrow = myArrows[ i->first ];
 305     arrow->setHighlightColor( theColor );
 306   }
 307 }
 308
 309 //=================================================================================
 310 // function : setSelectArrowColor()
 311 // purpose  : set selected arrow color from preferences
 312 //=================================================================================
 313 void DependencyTree_View::setSelectArrowColor( const QColor& theColor )
 314 {
 315   ArrowsInfo::const_iterator i;
 316   for( i = myArrows.begin(); i != myArrows.end(); i++ ) {
 317     DependencyTree_Arrow* arrow = myArrows[ i->first ];
 318     arrow->setSelectColor( theColor );
 319   }
 320 }
 321
 322 //=================================================================================
 323 // function : onRebuildModel()
 324 // purpose  : slot for updating tree model using selected objects in viewer
 325 //=================================================================================
 326 void DependencyTree_View::onRebuildModel()
 327 {
 328   updateModel( true, false );
 329 }
 330
 331 //=================================================================================
 332 // function : onUpdateModel()
 333 // purpose  : slot for updating tree model for main objects in viewer
 334 //=================================================================================
 335 void DependencyTree_View::onUpdateModel()
 336 {
 337   updateModel( false );
 338 }
 339
 340 //=================================================================================
 341 // function : onMoveNodes()
 342 // purpose  : slot for setting the possibility to move nodes in viewer
 343 //=================================================================================
 344 void DependencyTree_View::onMoveNodes( bool theIsMoveNodes )
 345 {
 346   EntryObjectMap::const_iterator i;
 347   for( i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 348     DependencyTree_Object* object = myTreeMap[ i->first ];
 349     if( object )
 350       object->setMovable( theIsMoveNodes );
 351   }
 352 }
 353
 354 //=================================================================================
 355 // function : onHierarchyType()
 356 // purpose  : slot for setting the hierarchy type of tree
 357 //=================================================================================
 358 void DependencyTree_View::onHierarchyType()
 359 {
 360   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
 361   if( myHierarchyDepth->value() > checkMaxLevelsNumber() )
 362     myHierarchyDepth->setValue( checkMaxLevelsNumber() );
 363
 364   if( myHierarchyDepth->value() == 0 )
 365     myLevelsNumber = myHierarchyDepth->maximum();
 366   else
 367     myLevelsNumber = myHierarchyDepth->value();
 368
 369   updateView();
 370 }
 371
 372 //=================================================================================
 373 // function : parseTree()
 374 // purpose  : parse created model to initialize all nodes and arrows
 375 //=================================================================================
 376 void DependencyTree_View::parseTree()
 377 {
 378   GEOMUtils::TreeModel::const_iterator i;
 379   for( i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 380     std::string objectEntry = i->first;
 381     addNode( objectEntry );
 382     parseTreeWard( i->second.first );
 383     if( i->second.first.size() > myMaxUpwardLevelsNumber )
 384       myMaxUpwardLevelsNumber = i->second.first.size();
 385     parseTreeWard( i->second.second );
 386     if( i->second.second.size() > myMaxDownwardLevelsNumber )
 387       myMaxDownwardLevelsNumber = i->second.second.size();
 388   }
 389
 390   for( i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 391     DependencyTree_Object* Main_object = myTreeMap[ i->first ];
 392     if( i->second.first.size() > 0 ) {
 393       GEOMUtils::LevelInfo Levelup = i->second.first.at(0);
 394       GEOMUtils::LevelInfo::const_iterator node;
 395       for( node = Levelup.begin(); node != Levelup.end(); node++ ) {
 396         DependencyTree_Object* object = myTreeMap[ node->first ];
 397         addArrow( Main_object, object );
 398       }
 399     }
 400     parseTreeWardArrow( i->second.first );
 401     parseTreeWardArrow( i->second.second );
 402   }
 403 }
 404
 405 //=================================================================================
 406 // function : parseTreeWard()
 407 // purpose  : parse tree ward to initialize all nodes of current ward
 408 //=================================================================================
 409 void DependencyTree_View::parseTreeWard( const GEOMUtils::LevelsList& theWard )
 410 {
 411   int levelsNumber = theWard.size();
 412   for( int level = 0; level < levelsNumber; level++ ) {
 413     GEOMUtils::LevelInfo levelInfo = theWard[ level ];
 414     GEOMUtils::LevelInfo::const_iterator node;
 415     for( node = levelInfo.begin(); node != levelInfo.end(); node++ )
 416       addNode( node->first );
 417   }
 418 }
 419
 420 //=================================================================================
 421 // function : parseTreeWardArrow()
 422 // purpose  : parse tree ward to initialize all arrows of current ward
 423 //=================================================================================
 424 void DependencyTree_View::parseTreeWardArrow( const GEOMUtils::LevelsList& theWard)
 425 {
 426   for( int j = 0; j < theWard.size(); j++ ) {
 427     GEOMUtils::LevelInfo Level = theWard.at(j);
 428     GEOMUtils::LevelInfo::const_iterator node;
 429     for( node = Level.begin(); node != Level.end(); node++ ) {
 430       DependencyTree_Object* object = myTreeMap[ node->first ];
 431       std::vector<std::string> Links = node->second;
 432       for( int link = 0; link < Links.size(); link++ ) {
 433         DependencyTree_Object* LinkObject = myTreeMap[ Links[ link ] ];
 434         if( object && LinkObject )
 435           addArrow( object, LinkObject );
 436       }
 437     }
 438   }
 439 }
 440
 441 //=================================================================================
 442 // function : addNode()
 443 // purpose  : add node to viewer
 444 //=================================================================================
 445 void DependencyTree_View::addNode( const std::string& theEntry )
 446 {
 447   if( !myTreeMap[theEntry] )
 448     myTreeMap[theEntry] = new DependencyTree_Object( theEntry );
 449 }
 450
 451 //=================================================================================
 452 // function : addArrow()
 453 // purpose  : add arrow to viewer
 454 //=================================================================================
 455 void DependencyTree_View::addArrow( DependencyTree_Object* startItem, DependencyTree_Object* endItem )
 456 {
 457   bool isFind = false;
 458
 459   ArrowsInfo::const_iterator i;
 460   for( i = myArrows.begin(); i != myArrows.end(); i++ ) {
 461     DependencyTree_Arrow* arrow = i->second;
 462     if( arrow->getStartItem() == startItem && arrow->getEndItem() == endItem )
 463       isFind = true;
 464     else if( arrow->getStartItem() == endItem && arrow->getEndItem() == startItem ) {
 465       arrow->setIsBiLink( true );
 466       isFind = true;
 467     }
 468   }
 469   if( !isFind ) {
 470     DependencyTree_Arrow *arrow = new DependencyTree_Arrow( startItem, endItem );
 471     myArrows[ std::pair<DependencyTree_Object*,DependencyTree_Object*>( startItem, endItem ) ] = arrow;
 472   }
 473 }
 474
 475 //=================================================================================
 476 // function : drawTree()
 477 // purpose  : redraw dependency tree using existing model
 478 //=================================================================================
 479 void DependencyTree_View::drawTree()
 480 {
 481   clearView( false );
 482   clearSelected();
 483
 484   // draw nodes on scene
 485   std::map< std::string, int > entryLevelMap;
 486   std::map< int, std::vector< std::string > > levelObjects;
 487   int currentLevel;
 488   int horDistance, verDistance;
 489   GEOMUtils::TreeModel::const_reverse_iterator i;
 490   for( i = myTreeModel.rbegin(); i != myTreeModel.rend(); i++ ) {
 491     currentLevel = 0;
 492     std::string objectEntry = i->first;
 493     DependencyTree_Object* objectItem = myTreeMap[ objectEntry ];
 494     horDistance = 100 + int( objectItem->boundingRect().width() );
 495     verDistance = 3 * int( objectItem->boundingRect().height() );
 496     if( isItemAdded( objectItem ) )
 497       currentLevel = entryLevelMap[ objectEntry ];
 498     else {
 499       addItem( objectItem );
 500       objectItem->unselect();
 501       entryLevelMap[ objectEntry ] = currentLevel;
 502       levelObjects[ currentLevel ].push_back( objectEntry );
 503     }
 504     objectItem->setIsMainObject( true );
 505
 506     if( myDisplayAscendants->isChecked() )
 507       drawWard( i->second.first, entryLevelMap, levelObjects, currentLevel, -1 );
 508     if( myDisplayDescendants->isChecked() )
 509       drawWard( i->second.second, entryLevelMap, levelObjects, currentLevel, 1 );
 510   }
 511
 512   std::map< int, std::vector< std::string > >::const_iterator level;
 513   for( level = levelObjects.begin(); level != levelObjects.end(); level++ ) {
 514     int step = -horDistance * ( level->second.size() - 1 ) / 2;
 515     for( int objIter = 0; objIter < level->second.size(); objIter++ ) {
 516       DependencyTree_Object* anObject = myTreeMap[ level->second.at( objIter ) ];
 517       anObject->setPos( step, verDistance * level->first );
 518       step += horDistance;
 519     }
 520   }
 521
 522   // draw arrows on scene
 523   GEOMUtils::TreeModel::const_iterator j;
 524   for( j = myTreeModel.begin(); j != myTreeModel.end(); j++ ) {
 525     DependencyTree_Object* Main_object = myTreeMap[ j->first ];
 526     if( j->second.first.size() > 0 ) {
 527       GEOMUtils::LevelInfo Levelup = j->second.first.at(0);
 528       if( myDisplayAscendants ->isChecked() ) {
 529         GEOMUtils::LevelInfo::const_iterator node;
 530         for( node = Levelup.begin(); node != Levelup.end(); node++ ) {
 531           DependencyTree_Object* object = myTreeMap[ node->first ];
 532           DependencyTree_Arrow* arrow =
 533             myArrows[ std::pair<DependencyTree_Object*,DependencyTree_Object*>( Main_object, object )];
 534           if( arrow && !isItemAdded( arrow ) )
 535             addItem( arrow );
 536         }
 537       }
 538     }
 539     if( myDisplayAscendants->isChecked() )
 540       drawWardArrows( j->second.first );
 541     if( myDisplayDescendants->isChecked() )
 542       drawWardArrows( j->second.second );
 543   }
 544 }
 545
 546 //=================================================================================
 547 // function : drawWard()
 548 // purpose  : draw nodes of dependency tree ward (ascendant or descendant)
 549 //=================================================================================
 550 void DependencyTree_View::drawWard( const GEOMUtils::LevelsList& theWard,
 551                                     std::map< std::string, int >& theEntryLevelMap,
 552                                     std::map< int, std::vector< std::string > >& theLevelObjects,
 553                                     int theCurrentLevel, const int theLevelStep )
 554 {
 555   for( int level = 0; level < theWard.size(); level++ ) {
 556     if( level >= myLevelsNumber )
 557       return;
 558     theCurrentLevel += theLevelStep;
 559     GEOMUtils::LevelInfo levelInfo = theWard.at( level );
 560     GEOMUtils::LevelInfo::const_iterator node;
 561     for( node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 562       DependencyTree_Object* object = myTreeMap[ node->first ];
 563       if( object && !isItemAdded( object ) ) {
 564         addItem( object );
 565         object->unselect();
 566         theEntryLevelMap[ node->first ] = theCurrentLevel;
 567         theLevelObjects[ theCurrentLevel ].push_back( node->first );
 568       }
 569     }
 570   }
 571 }
 572
 573 //=================================================================================
 574 // function : drawWardArrows()
 575 // purpose  : draw arrows of dependency tree ward (ascendant or descendant)
 576 //=================================================================================
 577 void DependencyTree_View::drawWardArrows( const GEOMUtils::LevelsList& theWard )
 578 {
 579   for( int j = 0; j < theWard.size(); j++ ) {
 580     if( j >= myLevelsNumber )
 581       break;
 582     GEOMUtils::LevelInfo Level = theWard.at(j);
 583     GEOMUtils::LevelInfo::const_iterator node;
 584     for( node = Level.begin(); node != Level.end(); node++ ) {
 585       DependencyTree_Object* object = myTreeMap[ node->first ];
 586       GEOMUtils::NodeLinks Links = node->second;
 587       for( int link = 0; link < Links.size(); link++ ) {
 588         DependencyTree_Object* LinkObject = myTreeMap[ Links[ link ] ];
 589         if( isItemAdded( object ) && isItemAdded( LinkObject ) ) {
 590           DependencyTree_Arrow* arrow = myArrows[ std::pair<DependencyTree_Object*,DependencyTree_Object*>( object, LinkObject ) ];
 591           if( arrow && !isItemAdded( arrow ) )
 592             addItem( arrow );
 593         }
 594       }
 595     }
 596   }
 597 }
 598
 599 //=================================================================================
 600 // function : updateView()
 601 // purpose  : update viewer using created dependency tree model
 602 //=================================================================================
 603 void DependencyTree_View::updateView()
 604 {
 605   if( !myIsUpdate )
 606     return;
 607
 608   drawTree();
 609   fitAll();
 610 }
 611
 612 //=================================================================================
 613 // function : clearView()
 614 // purpose  : clear viewer and initialize all variables
 615 //=================================================================================
 616 void DependencyTree_View::clearView( bool isClearModel )
 617 {
 618   EntryObjectMap::const_iterator objectIter;
 619   for( objectIter = myTreeMap.begin(); objectIter != myTreeMap.end(); objectIter++ ) {
 620     DependencyTree_Object* object = objectIter->second;
 621     if( object )
 622       if( isItemAdded( object ) )
 623         removeItem( object );
 624   }
 625
 626   ArrowsInfo::const_iterator arrowIter;
 627   for( arrowIter = myArrows.begin(); arrowIter != myArrows.end(); arrowIter++ ) {
 628     DependencyTree_Arrow* object = arrowIter->second;
 629     if( object )
 630       if( isItemAdded( object ) )
 631         removeItem( object );
 632   }
 633
 634   if( isClearModel ) {
 635     myTreeMap.clear();
 636     myArrows.clear();
 637     myTreeModel.clear();
 638     myLevelsNumber = 0;
 639     myMaxDownwardLevelsNumber = 0;
 640     myMaxUpwardLevelsNumber = 0;
 641     myIsUpdate = true;
 642   }
 643 }
 644
 645 //=================================================================================
 646 // function : getNewTreeModel()
 647 // purpose  : get dependency tree model from engine
 648 //=================================================================================
 649 void DependencyTree_View::getNewTreeModel( bool theUseSelectedObject, bool theUseOB )
 650 {
 651   GEOM::string_array_var objectsEntry = new GEOM::string_array();
 652   int iter = 0;
 653
 654   if( theUseSelectedObject ) {
 655     if( theUseOB ) {
 656       SALOME_ListIO mainObjects;
 657       mySelectionMgr->selectedObjects( mainObjects );
 658       // create a list of selected object entry
 659       objectsEntry->length( mainObjects.Extent() );
 660       for ( SALOME_ListIteratorOfListIO It( mainObjects ); It.More(); It.Next(), iter++ ) {
 661         Handle( SALOME_InteractiveObject ) io = It.Value();
 662         GEOM::GEOM_Object_var geomObject = GEOM::GEOM_Object::_nil();
 663         geomObject = GEOMBase::ConvertIOinGEOMObject( io );
 664         QString entry = geomObject->GetEntry();
 665         objectsEntry[ iter ] = entry.toLatin1().constData();
 666       }
 667     }
 668     else {
 669       objectsEntry->length( nbSelected() );
 670       for( initSelected(); moreSelected(); nextSelected(), iter++ )
 671         if( DependencyTree_Object* treeObject = dynamic_cast<DependencyTree_Object*>( selectedObject() ) )
 672           objectsEntry[ iter ] = treeObject->getEntry().c_str();
 673     }
 674     myMainEntries = objectsEntry;
 675   }
 676
 677   // get string which describes dependency tree structure
 678   SALOMEDS::TMPFile_var SeqFile =
 679     GeometryGUI::GetGeomGen()->GetDependencyTree( myStudy, myMainEntries );
 680   char* buf = (char*)&SeqFile[0];
 681
 682   clearView( true );
 683   mySelectionMgr->clearSelected();
 684
 685   // get dependency tree structure
 686   GEOMUtils::ConvertStringToTree( buf, myTreeModel );
 687
 688   parseTree();
 689 }
 690
 691 //=================================================================================
 692 // function : checkMaxLevelsNumber()
 693 // purpose  : calculate max levels number
 694 //=================================================================================
 695 int DependencyTree_View::checkMaxLevelsNumber()
 696 {
 697   if( myDisplayAscendants->isChecked() && myDisplayDescendants->isChecked() )
 698     return myMaxUpwardLevelsNumber > myMaxDownwardLevelsNumber ?
 699            myMaxUpwardLevelsNumber : myMaxDownwardLevelsNumber;
 700   else if( myDisplayAscendants ->isChecked() )
 701     return myMaxUpwardLevelsNumber;
 702   else if( myDisplayDescendants->isChecked() )
 703     return  myMaxDownwardLevelsNumber;
 704 }