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