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 #include "DependencyTree_View.h"
  21 #include "DependencyTree_Object.h"
  22 #include "DependencyTree_Arrow.h"
  23
  24 #include <GEOM_InteractiveObject.hxx>
  25 #include <GeometryGUI.h>
  26 #include <GEOMBase.h>
  27
  28 // GUI includes
  29 #include <SUIT_Session.h>
  30 #include <SUIT_ResourceMgr.h>
  31 #include <SalomeApp_Study.h>
  32 #include <QtxActionToolMgr.h>
  33 #include <LightApp_SelectionMgr.h>
  34 #include <SALOME_ListIteratorOfListIO.hxx>
  35
  36 // Qt includes
  37 #include <QCloseEvent>
  38 #include <QApplication>
  39 #include <QGraphicsScene>
  40
  41 #define DRAW_EVENT  ( QEvent::User + 1 )
  42
  43 #include <iostream>
  44
  45 DependencyTree_View::DependencyTree_View( QWidget* theParent )
  46 :GraphicsView_ViewPort(theParent),
  47 myMaxDownwardLevelsNumber(0),
  48 myMaxUpwardLevelsNumber(0),
  49 myLevelsNumber(0),
  50 myIsCompute(true),
  51 myIsUpdate( true ),
  52 myTotalCost(0),
  53 myComputedCost(0)
  54 {
  55   SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
  56   if ( !app ) return;
  57
  58   SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
  59   myStudy = GeometryGUI::ClientStudyToStudy( study->studyDS());
  60
  61   mySelectionMgr = app->selectionMgr();
  62   if ( !mySelectionMgr ) return;
  63
  64   getNewTreeModel();
  65 }
  66
  67 DependencyTree_View::~DependencyTree_View()
  68 {
  69 }
  70
  71 void DependencyTree_View::init( GraphicsView_ViewFrame* theViewFrame )
  72 {
  73   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  74
  75   myNodesMovable = new QCheckBox( tr( "MOVE_NODES" ) );
  76   QWidgetAction* nodesMovableAction = new QWidgetAction( theViewFrame );
  77   nodesMovableAction->setDefaultWidget( myNodesMovable );
  78
  79   myDisplayAscendants = new QCheckBox( tr( "DISPLAY_ASCENDANTS" ) );
  80   QWidgetAction* ShowParentsAction = new QWidgetAction( theViewFrame );
  81   ShowParentsAction->setDefaultWidget( myDisplayAscendants  );
  82
  83   myDisplayDescendants = new QCheckBox(tr("DISPLAY_DESCENDANTS"));
  84   QWidgetAction* ShowChildrenAction = new QWidgetAction(theViewFrame);
  85   ShowChildrenAction->setDefaultWidget( myDisplayDescendants );
  86
  87   QLabel* hierarchyDepthLabel = new QLabel( tr( "HIERARCHY_DEPTH" ) );
  88   QWidgetAction* hierarchyDepthLabelAction = new QWidgetAction(theViewFrame);
  89   hierarchyDepthLabelAction->setDefaultWidget( hierarchyDepthLabel );
  90
  91   myLevelsNumber = checkMaxLevelsNumber();
  92
  93   myHierarchyDepth = new QSpinBox();
  94   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
  95   myHierarchyDepth->setSpecialValueText( tr( "SHOW_ALL" ) );
  96   myHierarchyDepth->setValue( 0 );
  97   QWidgetAction* hierarchyDepthAction = new QWidgetAction( theViewFrame );
  98   hierarchyDepthAction->setDefaultWidget( myHierarchyDepth );
  99
 100   updateButton = new QPushButton( tr( "UPDATE" ) );
 101   QWidgetAction* updateAction = new QWidgetAction( theViewFrame );
 102   updateAction->setDefaultWidget( updateButton );
 103
 104   QPushButton* cancelButton = new QPushButton( tr( "CANCEL" ) );
 105   cancelButton->setCheckable( true );
 106   cancelAction = new QWidgetAction( theViewFrame );
 107   cancelAction->setDefaultWidget( cancelButton );
 108   cancelAction->setVisible( false );
 109
 110   QProgressBar* progressBar = new QProgressBar( this );
 111   progressBar->setMinimum( 0 );
 112   progressBar->setMaximum( 100 );
 113   progressBar->setFixedWidth( 100 );
 114   progressAction = new QWidgetAction( theViewFrame );
 115   progressAction->setDefaultWidget( progressBar );
 116   progressAction->setVisible( false );
 117
 118   QAction* separator1 = theViewFrame->toolMgr()->separator( false );
 119   QAction* separator2 = theViewFrame->toolMgr()->separator( false );
 120
 121   theViewFrame->toolMgr()->append( separator1, theViewFrame->getToolBarId() );
 122   theViewFrame->toolMgr()->append( nodesMovableAction, theViewFrame->getToolBarId() );
 123   theViewFrame->toolMgr()->append( hierarchyDepthLabelAction, theViewFrame->getToolBarId() );
 124   theViewFrame->toolMgr()->append( hierarchyDepthAction, theViewFrame->getToolBarId() );
 125   theViewFrame->toolMgr()->append( ShowParentsAction, theViewFrame->getToolBarId() );
 126   theViewFrame->toolMgr()->append( ShowChildrenAction, theViewFrame->getToolBarId() );
 127
 128   theViewFrame->toolMgr()->append( separator2, theViewFrame->getToolBarId() );
 129   theViewFrame->toolMgr()->append( updateAction, theViewFrame->getToolBarId() );
 130   theViewFrame->toolMgr()->append( progressAction, theViewFrame->getToolBarId() );
 131   theViewFrame->toolMgr()->append( cancelAction, theViewFrame->getToolBarId() );
 132
 133   connect( myNodesMovable, SIGNAL( toggled( bool ) ), this, SLOT( onMoveNodes( bool ) ) );
 134   connect( myHierarchyDepth, SIGNAL( valueChanged ( int ) ), this, SLOT( onHierarchyType() ) );
 135   connect( myDisplayAscendants , SIGNAL( toggled( bool ) ), this, SLOT( onHierarchyType() ) );
 136   connect( myDisplayDescendants, SIGNAL( toggled( bool ) ), this, SLOT( onHierarchyType() ) );
 137   connect( updateButton, SIGNAL( clicked() ), this, SLOT( updateView() ) );
 138   connect( cancelButton, SIGNAL( clicked() ), this, SLOT( onCancel() ) );
 139
 140   setPrefBackgroundColor( resMgr->colorValue( "Geometry", "dependency_tree_background_color", QColor( 255, 255, 255 ) ) );
 141   setNodesMovable( resMgr->booleanValue( "Geometry", "dependency_tree_move_nodes", true ) );
 142   setHierarchyType( resMgr->integerValue( "Geometry", "dependency_tree_hierarchy_type", 0 ) );
 143 }
 144
 145 void DependencyTree_View::updateModel()
 146 {
 147   getNewTreeModel();
 148
 149   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 150
 151   setPrefBackgroundColor( resMgr->colorValue( "Geometry", "dependency_tree_background_color", QColor( 255, 255, 255 ) ) );
 152   setNodesMovable( resMgr->booleanValue( "Geometry", "dependency_tree_move_nodes", true ) );
 153   setHierarchyType( resMgr->integerValue( "Geometry", "dependency_tree_hierarchy_type", 0 ) );
 154 }
 155
 156 void DependencyTree_View::drawTree()
 157 {
 158   myComputedCost = 0;
 159   calcTotalCost();
 160   std::cout << "\n\n\n TOTAL COST = " << myTotalCost << std::endl;
 161
 162   clearSelected();
 163   clearView( false );
 164
 165   // draw nodes on scene
 166   std::map< std::string, int > entryLevelMap;
 167   std::map< int, std::vector< std::string > > levelObjects;
 168   int currentLevel;
 169   int horDistance, verDistance;
 170   GEOMUtils::TreeModel::const_reverse_iterator i;
 171   for( i = myTreeModel.rbegin(); i != myTreeModel.rend(); i++ ) {
 172         if( !myIsCompute )
 173       return;
 174     currentLevel = 0;
 175     myComputedCost++;
 176     std::string objectEntry = i->first;
 177     DependencyTree_Object* objectItem = myTreeMap[ objectEntry ];
 178     horDistance = 100 + int( objectItem->boundingRect().width() );
 179     verDistance = 3 * int( objectItem->boundingRect().height() );
 180     if( isItemAdded( objectItem ) )
 181       currentLevel = entryLevelMap[ objectEntry ];
 182     else {
 183       addItem( objectItem );
 184       objectItem->unselect();
 185       entryLevelMap[ objectEntry ] = currentLevel;
 186       levelObjects[ currentLevel ].push_back( objectEntry );
 187     }
 188     objectItem->setIsMainObject( true );
 189
 190     if( myDisplayAscendants->isChecked() )
 191       drawWard( i->second.first, entryLevelMap, levelObjects, currentLevel, -1 );
 192     if( myDisplayDescendants->isChecked() )
 193       drawWard( i->second.second, entryLevelMap, levelObjects, currentLevel, 1 );
 194   }
 195
 196   std::map< int, std::vector< std::string > >::const_iterator level;
 197   for( level = levelObjects.begin(); level != levelObjects.end(); level++ ) {
 198     int step = -horDistance * ( level->second.size() - 1 ) / 2;
 199     std::cout<<"\n\n LEVEL = " << level->first << std::endl;
 200     for( int objIter = 0; objIter < level->second.size(); objIter++ ) {
 201         std::cout << level->second.at( objIter ) << ", ";
 202         DependencyTree_Object* anObject = myTreeMap[ level->second.at( objIter ) ];
 203         anObject->setPos( step, verDistance * level->first );
 204         step += horDistance;
 205     }
 206   }
 207
 208   // draw arrows on scene
 209   GEOMUtils::TreeModel::const_iterator j;
 210   for( j = myTreeModel.begin(); j != myTreeModel.end(); j++ ) {
 211     DependencyTree_Object* Main_object = myTreeMap[ j->first ];
 212     if( j->second.first.size() > 0 ) {
 213       GEOMUtils::LevelInfo Levelup = j->second.first.at(0);
 214       if( myDisplayAscendants ->isChecked() ) {
 215         GEOMUtils::LevelInfo::const_iterator node;
 216         for (node = Levelup.begin(); node != Levelup.end(); node++ ) {
 217           DependencyTree_Object* object = myTreeMap[node->first];
 218           DependencyTree_Arrow* arrow = myArrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>(Main_object, object)];
 219           if( arrow && !isItemAdded( arrow) )
 220             addItem( arrow );
 221         }
 222       }
 223     }
 224     if( myDisplayAscendants->isChecked() )
 225       drawWardArrows( j->second.first );
 226     if( myDisplayDescendants->isChecked() )
 227       drawWardArrows( j->second.second );
 228   }
 229   std::cout << "\n ComputedCost = " << myComputedCost << std::endl;
 230 }
 231
 232 int DependencyTree_View::select( const QRectF& theRect, bool theIsAppend )
 233 {
 234   GraphicsView_ViewPort::select( theRect, theIsAppend );
 235
 236   mySelectionMgr->clearSelected();
 237
 238   // get selection
 239   SALOME_ListIO listIO;
 240   int StudyId = myStudy->StudyId();
 241   for( initSelected(); moreSelected(); nextSelected() )
 242     if( DependencyTree_Object* treeObject = dynamic_cast<DependencyTree_Object*>( selectedObject() ) ) {
 243       CORBA::String_var studyEntry = treeObject->getGeomObject()->GetStudyEntry();
 244       Handle(SALOME_InteractiveObject) tmpIO =
 245         new SALOME_InteractiveObject( studyEntry.in(), "GEOM", "TEMP_IO");
 246       listIO.Append( tmpIO );
 247     }
 248   mySelectionMgr->setSelectedObjects( listIO, true );
 249 }
 250
 251 void DependencyTree_View::customEvent ( QEvent * event )
 252 {
 253   if( event->type() == DRAW_EVENT ) {
 254         //qthread->sleepDraw();
 255
 256         std::cout << "\n\n\n DRAW_EVENT!!! " << std::endl;
 257     QPushButton* cancelButton = dynamic_cast<QPushButton*>( cancelAction->defaultWidget() );
 258     QProgressBar* progressBar = dynamic_cast<QProgressBar*>( progressAction->defaultWidget() );
 259
 260     std::cout << "\n\n *** myIsCompute " << myIsCompute << std::endl;
 261     if ( !cancelButton->isChecked() ) {
 262       std::cout << "\n\n *** getComputeProgress = " << getComputeProgress() << std::endl;
 263       progressBar->setValue( progressBar->maximum() * getComputeProgress() );
 264
 265     }
 266
 267     std::cout << "\n\n *** qthread->isFinished() = " << qthread->isFinished() << std::endl;
 268     if( !myIsCompute || qthread->isFinished() ) {
 269       changeWidgetState( false );
 270       cancelButton->setChecked( false );
 271       progressBar->setValue(0);
 272     }
 273   }
 274   event->accept();
 275 }
 276
 277 void DependencyTree_View::addItem( QGraphicsItem* theObject )
 278 {
 279   GraphicsView_ViewPort::addItem( theObject );
 280   qthread->sleepDraw();
 281   SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 282   QApplication::postEvent( this, new QEvent( ( QEvent::Type )DRAW_EVENT ) );
 283 }
 284
 285 void DependencyTree_View::mouseMoveEvent(QMouseEvent *event)
 286 {
 287   QGraphicsView::mouseMoveEvent( event );
 288   ArrowsInfo::const_iterator j;
 289   for (j = myArrows.begin(); j != myArrows.end(); j++ ) {
 290     DependencyTree_Arrow* arrow = myArrows[ j->first ];
 291     arrow->update();
 292   }
 293 }
 294
 295 void DependencyTree_View::setHierarchyType( const int theType )
 296 {
 297   myIsUpdate = false;
 298   switch( theType ) {
 299   case 0:
 300     myDisplayAscendants->setChecked( true );
 301     myDisplayDescendants->setChecked( true );
 302     break;
 303   case 1:
 304     myDisplayAscendants->setChecked( true );
 305     myDisplayDescendants->setChecked( false );
 306     break;
 307   case 2:
 308     myDisplayAscendants->setChecked( false );
 309     myDisplayDescendants->setChecked( true );
 310     break;
 311   }
 312   myIsUpdate = true;
 313
 314   myLevelsNumber = checkMaxLevelsNumber();
 315
 316   onHierarchyType();
 317 }
 318
 319 void DependencyTree_View::setNodesMovable( const bool theIsMovable )
 320 {
 321   myNodesMovable->setChecked( theIsMovable );
 322 }
 323
 324 void DependencyTree_View::setPrefBackgroundColor( const QColor& theColor )
 325 {
 326   if( isForegroundEnabled() )
 327   {
 328     setForegroundColor( theColor );
 329     updateForeground();
 330   }
 331   else
 332     setBackgroundColor( theColor );
 333 }
 334
 335 void DependencyTree_View::setNodeColor( const QColor& theColor )
 336 {
 337   EntryObjectMap::const_iterator i;
 338   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 339     DependencyTree_Object* object = myTreeMap[ i->first ];
 340     object->setColor( theColor );
 341   }
 342 }
 343
 344 void DependencyTree_View::setMainNodeColor( const QColor& theColor )
 345 {
 346   EntryObjectMap::const_iterator i;
 347   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 348     DependencyTree_Object* object = myTreeMap[ i->first ];
 349     object->setMainObjectColor( theColor );
 350   }
 351 }
 352
 353 void DependencyTree_View::setSelectNodeColor( const QColor& theColor )
 354 {
 355   EntryObjectMap::const_iterator i;
 356   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 357     DependencyTree_Object* object = myTreeMap[ i->first ];
 358     object->setSelectColor( theColor );
 359   }
 360 }
 361
 362 void DependencyTree_View::setArrowColor( const QColor& theColor )
 363 {
 364   ArrowsInfo::const_iterator j;
 365   for (j = myArrows.begin(); j != myArrows.end(); j++ ) {
 366     DependencyTree_Arrow* arrow = myArrows[ j->first ];
 367     arrow->setColor( theColor );
 368   }
 369 }
 370
 371 void DependencyTree_View::setHighlightArrowColor( const QColor& theColor )
 372 {
 373         ArrowsInfo::const_iterator j;
 374   for (j = myArrows.begin(); j != myArrows.end(); j++ ) {
 375     DependencyTree_Arrow* arrow = myArrows[ j->first ];
 376     arrow->setHighlightColor( theColor );
 377   }
 378 }
 379
 380 void DependencyTree_View::setSelectArrowColor( const QColor& theColor )
 381 {
 382         ArrowsInfo::const_iterator j;
 383   for (j = myArrows.begin(); j != myArrows.end(); j++ ) {
 384     DependencyTree_Arrow* arrow = myArrows[ j->first ];
 385     arrow->setSelectColor( theColor );
 386   }
 387 }
 388
 389 void DependencyTree_View::setIsCompute( bool theIsCompute )
 390 {
 391   myIsCompute = theIsCompute;
 392 }
 393
 394 bool DependencyTree_View::getIsCompute()
 395 {
 396   return myIsCompute;
 397 }
 398
 399 //void DependencyTree_View::timerEvent(QTimerEvent *event)
 400 //{
 401 //  QPushButton* cancelButton = dynamic_cast<QPushButton*>( cancelAction->defaultWidget() );
 402 //  QProgressBar* progressBar = dynamic_cast<QProgressBar*>( progressAction->defaultWidget() );
 403 //
 404 //  std::cout << "TIMER! " << std::endl;
 405 //  if ( !cancelButton->isChecked() )
 406 //    progressBar->setValue( progressBar->maximum() * getComputeProgress() );
 407 //
 408 //  if( !myIsCompute || qthread->isFinished() ) {
 409 //    changeWidgetState( false );
 410 //    killTimer( myTimer );
 411 //    cancelButton->setChecked( false );
 412 //    progressBar->setValue(0);
 413 //  }
 414 //  event->accept();
 415 //}
 416
 417 void DependencyTree_View::closeEvent( QCloseEvent* event )
 418 {
 419   if(qthread->isRunning())
 420   {
 421     event->ignore();
 422     return;
 423   }
 424   event->accept();
 425 }
 426
 427 void DependencyTree_View::updateView()
 428 {
 429   if( !myIsUpdate )
 430     return;
 431
 432 //  clearView( false );
 433
 434   qthread = new DependencyTree_ComputeDlg_QThread( this );
 435
 436   changeWidgetState( true );
 437
 438   //myTimer = startTimer( 100 ); // millisecs
 439   qthread->start();
 440 }
 441
 442 void DependencyTree_View::onMoveNodes( bool theIsMoveNodes )
 443 {
 444   EntryObjectMap::const_iterator i;
 445   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 446     DependencyTree_Object* object = myTreeMap[ i->first ];
 447     if( object )
 448       object->setMovable( theIsMoveNodes );
 449   }
 450 }
 451
 452 void DependencyTree_View::onHierarchyType()
 453 {
 454   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
 455   if( myHierarchyDepth->value() > checkMaxLevelsNumber() )
 456     myHierarchyDepth->setValue( checkMaxLevelsNumber() );
 457
 458   if( myHierarchyDepth->value() == 0 )
 459     myLevelsNumber = myHierarchyDepth->maximum();
 460   else
 461     myLevelsNumber = myHierarchyDepth->value();
 462
 463   updateView();
 464 }
 465
 466 void DependencyTree_View::onCancel()
 467 {
 468   qthread->cancel();
 469   //qthread->deleteLater();
 470 }
 471
 472 void DependencyTree_View::addNode( const std::string& theEntry )
 473 {
 474   if( !myTreeMap[theEntry] )
 475     myTreeMap[theEntry] = new DependencyTree_Object( theEntry );
 476 }
 477
 478 void DependencyTree_View::addArrow( DependencyTree_Object *startItem, DependencyTree_Object *endItem )
 479 {
 480   bool isFind = false;
 481
 482   std::cout << "   " << startItem->getEntry() << "   " << endItem->getEntry() << std::endl;
 483   ArrowsInfo::const_iterator i;
 484   for (i = myArrows.begin(); i != myArrows.end(); i++ ) {
 485           DependencyTree_Arrow* arrow = i->second;
 486     if( arrow->getStartItem() == startItem && arrow->getEndItem() == endItem ) {
 487       isFind = true;
 488       std::cout<<" theSame " << std::endl;
 489     }
 490     else if( arrow->getStartItem() == endItem && arrow->getEndItem() == startItem ) {
 491       arrow->setIsBiLink( true );
 492       std::cout<<" Bilink " << std::endl;
 493       isFind = true;
 494     }
 495   }
 496
 497   if( !isFind ) {
 498           DependencyTree_Arrow *arrow = new DependencyTree_Arrow(startItem, endItem);
 499             myArrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>( startItem, endItem )] = arrow;
 500             std::cout<<" addArrow " << std::endl;
 501   }
 502 }
 503
 504 void DependencyTree_View::parseTree()
 505 {
 506
 507   GEOMUtils::TreeModel::const_iterator i;
 508   for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 509     std::string objectEntry = i->first;
 510     addNode( objectEntry );
 511     parseTreeWard( i->second.first );
 512     if( i->second.first.size() > myMaxUpwardLevelsNumber )
 513       myMaxUpwardLevelsNumber = i->second.first.size();
 514     parseTreeWard( i->second.second );
 515     if( i->second.second.size() > myMaxDownwardLevelsNumber )
 516       myMaxDownwardLevelsNumber = i->second.second.size();
 517   }
 518
 519   for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 520     DependencyTree_Object* Main_object = myTreeMap[i->first];
 521     if( i->second.first.size() > 0 ) {
 522       GEOMUtils::LevelInfo Levelup = i->second.first.at(0);
 523       GEOMUtils::LevelInfo::const_iterator node;
 524       for (node = Levelup.begin(); node != Levelup.end(); node++ ) {
 525         DependencyTree_Object* object = myTreeMap[node->first];
 526         addArrow( Main_object, object );
 527       }
 528     }
 529     parseTreeWardArrow( i->second.first );
 530     parseTreeWardArrow( i->second.second );
 531   }
 532
 533
 534 }
 535 void DependencyTree_View::parseTreeWard(const GEOMUtils::LevelsList theWard)
 536 {
 537   int levelsNumber = theWard.size();
 538   for( int level = 0; level < levelsNumber; level++ ) {
 539     GEOMUtils::LevelInfo levelInfo = theWard[ level ];
 540     GEOMUtils::LevelInfo::const_iterator node;
 541     for (node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 542       addNode( node->first );
 543     }
 544   }
 545 }
 546 void DependencyTree_View::parseTreeWardArrow(const GEOMUtils::LevelsList theWard)
 547 {
 548   for(int j = 0; j < theWard.size(); j++ ) {
 549           GEOMUtils::LevelInfo Level = theWard.at(j);
 550           GEOMUtils::LevelInfo::const_iterator node;
 551     for (node = Level.begin(); node != Level.end(); node++ ) {
 552       DependencyTree_Object* object = myTreeMap[node->first];
 553       std::vector<std::string> Links = node->second;
 554       for( int link = 0; link < Links.size(); link++ ) {
 555         DependencyTree_Object* LinkObject = myTreeMap[Links[link]];
 556         if( object && LinkObject )
 557           addArrow( object, LinkObject );
 558       }
 559     }
 560   }
 561 }
 562
 563 void DependencyTree_View::drawWard( const GEOMUtils::LevelsList& theWard,
 564                                     std::map< std::string, int >& theEntryLevelMap,
 565                                     std::map< int, std::vector< std::string > >& theLevelObjects,
 566                                     int theCurrentLevel, const int theLevelStep )
 567 {
 568   for( int level = 0; level < theWard.size(); level++ ) {
 569     if( level >= myLevelsNumber || !myIsCompute )
 570       return;
 571     myComputedCost++;
 572     theCurrentLevel += theLevelStep;
 573     GEOMUtils::LevelInfo levelInfo = theWard.at( level );
 574     GEOMUtils::LevelInfo::const_iterator node;
 575     for (node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 576       DependencyTree_Object* object = myTreeMap[ node->first ];
 577       if( !isItemAdded( object ) ) {
 578         addItem( object );
 579         object->unselect();
 580         theEntryLevelMap[ node->first ] = theCurrentLevel;
 581         theLevelObjects[ theCurrentLevel ].push_back( node->first );
 582       }
 583     }
 584   }
 585 }
 586
 587 void DependencyTree_View::drawWardArrows( GEOMUtils::LevelsList theWard )
 588 {
 589   for(int j = 0; j < theWard.size(); j++ ) {
 590     if( j >= myLevelsNumber || !myIsCompute )
 591       break;
 592     myComputedCost++;
 593     GEOMUtils::LevelInfo Level = theWard.at(j);
 594     GEOMUtils::LevelInfo::const_iterator node;
 595     for (node = Level.begin(); node != Level.end(); node++ ) {
 596       DependencyTree_Object* object = myTreeMap[node->first];
 597       GEOMUtils::NodeLinks Links = node->second;
 598       for( int link = 0; link < Links.size(); link++ ) {
 599         DependencyTree_Object* LinkObject = myTreeMap[Links[link]];
 600         if( isItemAdded( object ) && isItemAdded( LinkObject ) ) {
 601           DependencyTree_Arrow* arrow = myArrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>(object, LinkObject)];
 602           if( arrow && !isItemAdded( arrow) )
 603             addItem( arrow );
 604         }
 605       }
 606     }
 607   }
 608 }
 609
 610 void DependencyTree_View::getNewTreeModel()
 611 {
 612   clearView( true );
 613
 614   SALOME_ListIO aSelList;
 615   mySelectionMgr->selectedObjects( aSelList );
 616
 617   // create a list of selected object entry
 618   GEOM::string_array_var objectsEntry = new GEOM::string_array();
 619   objectsEntry->length( aSelList.Extent());
 620   int iter = 0;
 621   for ( SALOME_ListIteratorOfListIO It( aSelList ); It.More(); It.Next(), iter++ ) {
 622     Handle( SALOME_InteractiveObject ) io = It.Value();
 623     GEOM::GEOM_Object_var geomObject = GEOM::GEOM_Object::_nil();
 624     geomObject = GEOMBase::ConvertIOinGEOMObject( io );
 625     QString entry = geomObject->GetEntry();
 626     objectsEntry[ iter ] = entry.toLatin1().constData();
 627   }
 628
 629   // get string which describes dependency tree structure
 630   SALOMEDS::TMPFile_var SeqFile =
 631     GeometryGUI::GetGeomGen()->GetDependencyTree( myStudy, objectsEntry );
 632   char* buf = (char*) &SeqFile[0];
 633
 634   std::cout << "\n\n\n\n\n TREE = " << buf << std::endl;
 635
 636   // get dependency tree structure
 637   GEOMUtils::ConvertStringToTree( buf, myTreeModel );
 638
 639   mySelectionMgr->clearSelected();
 640
 641   parseTree();
 642
 643 }
 644
 645 void DependencyTree_View::clearView( bool isClearModel )
 646 {
 647   EntryObjectMap::const_iterator objectIter;
 648   for( objectIter = myTreeMap.begin(); objectIter != myTreeMap.end(); objectIter++ ) {
 649     DependencyTree_Object* object = objectIter->second;
 650     if( isItemAdded( object ) && object )
 651       removeItem( object );
 652   }
 653
 654   ArrowsInfo::const_iterator arrowIter;
 655   for( arrowIter = myArrows.begin(); arrowIter != myArrows.end(); arrowIter++ ) {
 656     DependencyTree_Arrow* object = arrowIter->second;
 657     if( isItemAdded( object ) && object )
 658       removeItem( object );
 659   }
 660   if( isClearModel ) {
 661     myTreeMap.clear();
 662     myArrows.clear();
 663     myTreeModel.clear();
 664     myMaxDownwardLevelsNumber = 0;
 665     myMaxUpwardLevelsNumber = 0;
 666     myLevelsNumber = 0;
 667     myIsCompute = true;
 668     myIsUpdate = true;
 669   }
 670 }
 671
 672 int DependencyTree_View::checkMaxLevelsNumber()
 673 {
 674   if( myDisplayAscendants->isChecked() && myDisplayDescendants->isChecked() )
 675     return myMaxUpwardLevelsNumber>myMaxDownwardLevelsNumber?myMaxUpwardLevelsNumber:myMaxDownwardLevelsNumber;
 676   else if( myDisplayAscendants ->isChecked() )
 677     return myMaxUpwardLevelsNumber;
 678   else if( myDisplayDescendants->isChecked() )
 679     return  myMaxDownwardLevelsNumber;
 680 }
 681
 682 void DependencyTree_View::calcTotalCost()
 683 {
 684   myTotalCost = myTreeModel.size();
 685   GEOMUtils::TreeModel::const_iterator i;
 686   for( i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 687     if( myDisplayAscendants->isChecked() )
 688       myTotalCost += 2*( myLevelsNumber < i->second.first.size() ? myLevelsNumber : i->second.first.size() );
 689     if( myDisplayDescendants->isChecked() )
 690       myTotalCost += 2*( myLevelsNumber < i->second.second.size() ? myLevelsNumber : i->second.second.size() );
 691   }
 692 }
 693
 694 double DependencyTree_View::getComputeProgress()
 695 {
 696   return double( myComputedCost ) / double( myTotalCost );
 697 }
 698
 699 void DependencyTree_View::changeWidgetState( bool theIsCompute )
 700 {
 701   cancelAction->setVisible( theIsCompute );
 702   progressAction->setVisible( theIsCompute );
 703
 704   myHierarchyDepth->setEnabled( !theIsCompute );
 705   myDisplayAscendants->setEnabled( !theIsCompute );
 706   myDisplayDescendants->setEnabled( !theIsCompute );
 707   updateButton->setEnabled( !theIsCompute );
 708 }
 709
 710 DependencyTree_ComputeDlg_QThread::DependencyTree_ComputeDlg_QThread( DependencyTree_View* theView )
 711 {
 712   myView = theView;
 713 }
 714
 715 void DependencyTree_ComputeDlg_QThread::run()
 716 {
 717   myView->setIsCompute( true );
 718   myView->drawTree();
 719   myView->fitAll( true );
 720   SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 721   QApplication::postEvent( myView, new QEvent( ( QEvent::Type )DRAW_EVENT ) );
 722 }
 723
 724 void DependencyTree_ComputeDlg_QThread::sleepDraw()
 725 {
 726   msleep(10);
 727 }
 728
 729 void DependencyTree_ComputeDlg_QThread::cancel()
 730 {
 731   myView->setIsCompute( false );
 732 }