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_Application.h>
  32 #include <SalomeApp_Study.h>
  33 #include <QtxActionToolMgr.h>
  34 #include <LightApp_SelectionMgr.h>
  35 #include <SALOME_ListIteratorOfListIO.hxx>
  36
  37 // Qt includes
  38 #include <QCloseEvent>
  39 #include <QTimerEvent>
  40 #include <QGraphicsScene>
  41
  42
  43 #include <iostream>
  44 int iter = 0;
  45
  46 DependencyTree_View::DependencyTree_View( QWidget* theParent )
  47 :GraphicsView_ViewPort(theParent),
  48 myMaxDownwardLevelsNumber(0),
  49 myMaxUpwardLevelsNumber(0),
  50 myLevelsNumber(0),
  51 myIsCompute(true),
  52 myIsUpdate( true )
  53 {
  54   SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
  55   if ( !app ) return;
  56
  57   SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>(app->activeStudy());
  58   SALOMEDS::Study_var myStudy = GeometryGUI::ClientStudyToStudy( study->studyDS());
  59
  60   LightApp_SelectionMgr* aSelMgr = app->selectionMgr();
  61   if ( !aSelMgr ) return;
  62
  63   SALOME_ListIO aSelList;
  64   aSelMgr->selectedObjects(aSelList);
  65
  66   GEOM::string_array_var ObjectIORs = new GEOM::string_array();
  67     ObjectIORs->length( aSelList.Extent());
  68     int aaa=0;
  69
  70    for ( SALOME_ListIteratorOfListIO It( aSelList ); It.More(); It.Next() ) {
  71     Handle( SALOME_InteractiveObject ) io = It.Value();
  72
  73
  74     GEOM::GEOM_Object_var myObject = GEOM::GEOM_Object::_nil();
  75     myObject = GEOMBase::ConvertIOinGEOMObject( io );
  76     QString ior = myObject->GetEntry();
  77     ObjectIORs[aaa] = ior.toLatin1().constData();
  78     aaa++;
  79
  80     std::cout << "\n\n IOR = " << ior.toStdString() << std::endl;
  81   }
  82
  83   SALOMEDS::TMPFile_var SeqFile =
  84   GeometryGUI::GetGeomGen()->GetDependencyTree( myStudy, ObjectIORs );
  85   char* buf;
  86   buf = (char*) &SeqFile[0];
  87
  88   std::cout << "\n\n\n\n\n TREE = " << buf << std::endl;
  89
  90   GEOMUtils::ConvertStringToTree( buf, myTreeModel );
  91
  92 }
  93
  94 DependencyTree_View::~DependencyTree_View()
  95 {
  96
  97 }
  98
  99 void DependencyTree_View::drawArrows()
 100 {
 101         GEOMUtils::TreeModel::const_iterator i;
 102         for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 103                 DependencyTree_Object* Main_object = myTreeMap[i->first];
 104             if( i->second.first.size() > 0 ) {
 105                   GEOMUtils::LevelInfo Levelup = i->second.first.at(0);
 106                   if( myDisplayAscendants ->isChecked() ) {
 107                         GEOMUtils::LevelInfo::const_iterator node;
 108                     for (node = Levelup.begin(); node != Levelup.end(); node++ ) {
 109                       DependencyTree_Object* object = myTreeMap[node->first];
 110                       DependencyTree_Arrow* arrow = Arrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>(Main_object, object)];
 111                       if( arrow && !isItemAdded( arrow) )
 112                         addItem( arrow );
 113                     }
 114                   }
 115             }
 116                 if( myDisplayAscendants ->isChecked() )
 117        drawWardArrows( i->second.first );
 118                 if( myDisplayDescendants->isChecked() )
 119        drawWardArrows( i->second.second );
 120
 121           }
 122 }
 123
 124 void DependencyTree_View::drawWardArrows( GEOMUtils::LevelsList theWard )
 125 {
 126           for(int j = 0; j < theWard.size(); j++ ) {
 127                   if( j >= myLevelsNumber )
 128                 break;
 129                   GEOMUtils::LevelInfo Level = theWard.at(j);
 130                   GEOMUtils::LevelInfo::const_iterator node;
 131                   for (node = Level.begin(); node != Level.end(); node++ ) {
 132                     DependencyTree_Object* object = myTreeMap[node->first];
 133                     GEOMUtils::NodeLinks Links = node->second;
 134           for( int link = 0; link < Links.size(); link++ ) {
 135             DependencyTree_Object* LinkObject = myTreeMap[Links[link]];
 136             if( isItemAdded( object ) && isItemAdded( LinkObject ) ) {
 137                     DependencyTree_Arrow* arrow = Arrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>(object, LinkObject)];
 138                     if( arrow && !isItemAdded( arrow) )
 139                       addItem( arrow );
 140                }
 141           }
 142                   }
 143           }
 144 }
 145
 146 void DependencyTree_View::parseTree()
 147 {
 148
 149   GEOMUtils::TreeModel::const_iterator i;
 150   for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 151     std::string objectEntry = i->first;
 152     addNode( objectEntry );
 153     parseTreeWard( i->second.first );
 154     if( i->second.first.size() > myMaxUpwardLevelsNumber )
 155       myMaxUpwardLevelsNumber = i->second.first.size();
 156     parseTreeWard( i->second.second );
 157     if( i->second.second.size() > myMaxDownwardLevelsNumber )
 158       myMaxDownwardLevelsNumber = i->second.second.size();
 159   }
 160
 161   for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 162     DependencyTree_Object* Main_object = myTreeMap[i->first];
 163     if( i->second.first.size() > 0 ) {
 164       GEOMUtils::LevelInfo Levelup = i->second.first.at(0);
 165       GEOMUtils::LevelInfo::const_iterator node;
 166       for (node = Levelup.begin(); node != Levelup.end(); node++ ) {
 167         DependencyTree_Object* object = myTreeMap[node->first];
 168         addArrow( Main_object, object );
 169       }
 170     }
 171     parseTreeWardArrow( i->second.first );
 172     parseTreeWardArrow( i->second.second );
 173   }
 174
 175
 176 }
 177 void DependencyTree_View::parseTreeWard(const GEOMUtils::LevelsList theWard)
 178 {
 179   int levelsNumber = theWard.size();
 180   for( int level = 0; level < levelsNumber; level++ ) {
 181     GEOMUtils::LevelInfo levelInfo = theWard[ level ];
 182     GEOMUtils::LevelInfo::const_iterator node;
 183     for (node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 184       addNode( node->first );
 185     }
 186   }
 187 }
 188 void DependencyTree_View::parseTreeWardArrow(const GEOMUtils::LevelsList theWard)
 189 {
 190   for(int j = 0; j < theWard.size(); j++ ) {
 191           GEOMUtils::LevelInfo Level = theWard.at(j);
 192           GEOMUtils::LevelInfo::const_iterator node;
 193     for (node = Level.begin(); node != Level.end(); node++ ) {
 194       DependencyTree_Object* object = myTreeMap[node->first];
 195       std::vector<std::string> Links = node->second;
 196       for( int link = 0; link < Links.size(); link++ ) {
 197         DependencyTree_Object* LinkObject = myTreeMap[Links[link]];
 198         if( object && LinkObject )
 199           addArrow( object, LinkObject );
 200       }
 201     }
 202   }
 203 }
 204 //void DependencyTree_View::parseData( QString& theData )
 205 //{
 206 //        int cursor = 0;
 207 //
 208 //        while( theData.indexOf('-',cursor) != -1 ) //find next selected object
 209 //        {
 210 //          int objectIndex = theData.indexOf( '-', cursor );
 211 //          QString objectEntry = theData.mid( cursor, objectIndex - cursor );
 212 //          //addNode( objectEntry );
 213 //          std::cout<<"\n\nMainObject = " << objectEntry.toStdString() <<std::endl;
 214 //          cursor = objectIndex;
 215 //
 216 //          int upwardIndexBegin = theData.indexOf("{",cursor) + 1;
 217 //          int upwardIndexFinish = theData.indexOf("}",upwardIndexBegin);
 218 //          std::cout<<"  Upward:" << std::endl;
 219 //          LevelsList upwardList = parseWard( theData, cursor );
 220 //          if( upwardList.size() > myMaxUpwardLevelsNumber )
 221 //            myMaxUpwardLevelsNumber = upwardList.size();
 222 //          std::cout<<"  Downward:" << std::endl;
 223 //          LevelsList downwardList = parseWard( theData, cursor );
 224 //          if( downwardList.size() > myMaxDownwardLevelsNumber )
 225 //            myMaxDownwardLevelsNumber = downwardList.size();
 226 //
 227 //          myTreeModel[objectEntry] = QPair<LevelsList,LevelsList>( upwardList, downwardList );
 228 //        }
 229 //}
 230
 231 void DependencyTree_View::addNode( const std::string& theEntry )
 232 {
 233   if( !myTreeMap[theEntry] )
 234     myTreeMap[theEntry] = new DependencyTree_Object( theEntry );
 235 }
 236
 237 void DependencyTree_View::addArrow( DependencyTree_Object *startItem, DependencyTree_Object *endItem )
 238 {
 239   bool isFind = false;
 240
 241   std::cout << "   " << startItem->getEntry() << "   " << endItem->getEntry() << std::endl;
 242   std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator i;
 243   for (i = Arrows.begin(); i != Arrows.end(); i++ ) {
 244           DependencyTree_Arrow* arrow = i->second;
 245     if( arrow->getStartItem() == startItem && arrow->getEndItem() == endItem ) {
 246       isFind = true;
 247       std::cout<<" theSame " << std::endl;
 248     }
 249     else if( arrow->getStartItem() == endItem && arrow->getEndItem() == startItem ) {
 250       arrow->setIsBiLink( true );
 251       std::cout<<" Bilink " << std::endl;
 252       isFind = true;
 253     }
 254   }
 255
 256   if( !isFind ) {
 257           DependencyTree_Arrow *arrow = new DependencyTree_Arrow(startItem, endItem);
 258             //Arrows.append( arrow );
 259             //addItem(arrow);
 260             Arrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>( startItem, endItem )] = arrow;
 261             std::cout<<" addArrow " << std::endl;
 262   }
 263 }
 264
 265 //DependencyTree_View::LevelsList DependencyTree_View::parseWard( const QString& theData, int& theCursor )
 266 //{
 267 //        int indexStart = theData.indexOf( "{", theCursor ) + 1;
 268 //        int indexEnd = theData.indexOf( "}", indexStart );
 269 //
 270 //        QString ward = theData.mid( indexStart, indexEnd - indexStart );
 271 //        QStringList levelsListStr = ward.split( ';' );
 272 //        LevelsList levelsListData;
 273 //        for( int level = 0; level < levelsListStr.size(); level++ ) {
 274 //          std::cout<<"    Level" << level + 1 << ":" << std::endl;
 275 //          QStringList namesListStr = levelsListStr[level].split( ',' );
 276 //          LevelInfo levelInfoData;
 277 //          for( int node = 0; node < namesListStr.size(); node++ ) {
 278 //            QStringList linksListStr = namesListStr[node].split( '_' );
 279 //            QString nodeItem = linksListStr[0];
 280 //            if( !nodeItem.isEmpty() ) {
 281 //              //addNode( nodeItem );
 282 //              NodeLinks linksListData;
 283 //              std::cout<<"      " << nodeItem.toStdString() << " - ";
 284 //              for( int link = 1; link < linksListStr.size(); link++ ) {
 285 //                QString linkItem = linksListStr[link];
 286 //                //addNode( linkItem );
 287 //                linksListData.append( linkItem );
 288 //                std::cout << linkItem.toStdString() << ", ";
 289 //              }// Links
 290 //              levelInfoData[nodeItem] = linksListData;
 291 //              std::cout << std::endl;
 292 //            }
 293 //          }// Level's objects
 294 //          levelsListData.append(levelInfoData);
 295 //        }// Levels
 296 //
 297 //        theCursor = indexEnd + 1;
 298 //
 299 //        return levelsListData;
 300 //}
 301
 302 void DependencyTree_View::drawTree()
 303 {
 304
 305   int horDistance, verDistance;
 306   myCurrentLevel = 0;
 307     GEOMUtils::TreeModel::const_iterator i;
 308     for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 309       myCurrentLevel = 0;
 310       std::string objectEntry = i->first;
 311       DependencyTree_Object* objectItem = myTreeMap[ objectEntry ];
 312       horDistance = 100 + int( objectItem->boundingRect().width() );
 313       verDistance = 3 * int( objectItem->boundingRect().height() );
 314       if( isItemAdded( objectItem ) ) {
 315         myCurrentLevel = myLevelMap[ objectEntry ];
 316       }
 317       else {
 318         addItem( objectItem );
 319         myLevelMap[ objectEntry ] = myCurrentLevel;
 320         myLevelsObject[ myCurrentLevel ].push_back( objectEntry );
 321       }
 322       objectItem->setIsMainObject( true );
 323
 324       int levelposition = myCurrentLevel;
 325       if( myDisplayAscendants ->isChecked() ){
 326         drawWard( i->second.first, -1 );
 327         myCurrentLevel = levelposition;
 328       }
 329       if( myDisplayDescendants->isChecked() )
 330         drawWard( i->second.second, 1 );
 331       }
 332
 333                 std::map< int, std::vector<std::string> >::const_iterator j;
 334                 for (j = myLevelsObject.begin(); j != myLevelsObject.end(); j++ ) {
 335                   int step = -horDistance*( j->second.size() - 1 )/2;
 336                         std::cout<<"\n\n LEVEL = " << j->first << std::endl;
 337                   for( int object = 0; object < j->second.size(); object++ ) {
 338                          if( myIsCompute ) {
 339                           std::cout << j->second.at( object ) << ", ";
 340                          DependencyTree_Object* anObject = myTreeMap[ j->second.at( object ) ];
 341                          anObject->setPos( step, verDistance*j->first );
 342                          step += horDistance;
 343                          //sleep(1);
 344                          }
 345                   }
 346                 }
 347   centerOn( scene()->sceneRect().center() );
 348
 349 }
 350
 351 void DependencyTree_View::drawWard( const GEOMUtils::LevelsList theWard, const int theLevelStep )
 352 {
 353         std::cout << "\n\n myLevelsNumber2 = " << myLevelsNumber << std::endl;
 354           int levelsNumber = theWard.size();
 355         std::cout << "\n\n levelsNumber = " << levelsNumber << std::endl;
 356           for( int level = 0; level < levelsNumber; level++ ) {
 357                   if( level >= myLevelsNumber )
 358                 return;
 359             myCurrentLevel += theLevelStep;
 360             GEOMUtils::LevelInfo levelInfo = theWard.at( level );
 361             GEOMUtils::LevelInfo::const_iterator node;
 362                 for (node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 363               DependencyTree_Object* object = myTreeMap[ node->first ];
 364               if( !isItemAdded( object ) ) {
 365                 std::cout<< "\n\n\n addItem = " << object->getEntry() << std::endl;
 366                 addItem( object );
 367                 myLevelMap[ node->first ] = myCurrentLevel;
 368                 myLevelsObject[ myCurrentLevel ].push_back( node->first );
 369               }
 370             }
 371          }
 372
 373 }
 374
 375 void DependencyTree_View::onUpdateTree()
 376 {
 377   myLevelMap.clear();
 378   myLevelsObject.clear();
 379
 380
 381   std::map<std::string,DependencyTree_Object*>::const_iterator i;
 382         for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 383                 DependencyTree_Object* object = myTreeMap[ i->first ];
 384                 if( isItemAdded( object ) && object )
 385           removeItem( object );
 386
 387         }
 388
 389    std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 390    for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 391      DependencyTree_Arrow* object = Arrows[ j->first ];
 392      if( isItemAdded( object ) && object )
 393        removeItem( object );
 394    }
 395
 396   drawTree();
 397   drawArrows();
 398 }
 399
 400
 401 int DependencyTree_View::checkMaxLevelsNumber()
 402 {
 403   if( myDisplayAscendants ->isChecked() && myDisplayDescendants->isChecked() )
 404     return myMaxUpwardLevelsNumber>myMaxDownwardLevelsNumber?myMaxUpwardLevelsNumber:myMaxDownwardLevelsNumber;
 405   else if( myDisplayAscendants ->isChecked() )
 406     return myMaxUpwardLevelsNumber;
 407   else if( myDisplayDescendants->isChecked() )
 408     return  myMaxDownwardLevelsNumber;
 409 }
 410
 411
 412 void DependencyTree_View::init( GraphicsView_ViewFrame* theViewFrame )
 413 {
 414           SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 415
 416           std::string Data = "MainObject1-upward{up11_up21_up22,up12_up23,up13_up24;up21_up11,up22_up21_up12,up23_up23,up24}"
 417                                  "downward{down11_MainObject1,down12_MainObject1;down21_down11,down22_down12,down23_down12,down24_down24_down11,down25_down12;down31_down11_down23,down32_down25}"
 418                                  "down23-upward{down12_MainObject1;MainObject1_up11_up12_up13;up11_up21_up22,up12_up23,up13_up24;up21,up22_up21_up12,up23,up24}"
 419                                  "downward{down31_down11_down23}"
 420                                  "MainObject2-upward{up21,newup11_newup31,newup12_newup21;newup21_newup31LongName;newup31LongName}downward{newdown11_MainObject2,newdown12_MainObject2,newdown13_MainObject2;newdown21_newdown13,down21;newdown31_newdown11}"
 421                                  "MainObject3-upward{moUP1_moUP4,moUP2_moUP3;moUP4,moUP3_down23}downward{moDOWN1_MainObject3}";
 422
 423
 424           //GEOMUtils::ConvertStringToTree( Data, myTreeModel );
 425
 426
 427
 428 //        GEOMUtils::TreeModel::const_iterator i;
 429 //        for ( i = aTreeModel.begin(); i != aTreeModel.end(); i++ ) {
 430 //          std::string objectEntry = i->first;
 431 //          std::cout << "\n\n Main object = " << objectEntry << std::endl;
 432 //        }
 433 //  parseData( Data );
 434   parseTree();
 435
 436
 437   myNodesMovable = new QCheckBox( tr( "MOVE_NODES" ) );
 438   QWidgetAction* moveNodesAction = new QWidgetAction( theViewFrame );
 439   moveNodesAction->setDefaultWidget( myNodesMovable );
 440
 441   myDisplayAscendants  = new QCheckBox( tr( "DISPLAY_ASCENDANTS" ));
 442   myDisplayAscendants ->setChecked( true );
 443   QWidgetAction* ShowParentsAction = new QWidgetAction(theViewFrame);
 444   ShowParentsAction->setDefaultWidget( myDisplayAscendants  );
 445
 446   myDisplayDescendants = new QCheckBox(tr("DISPLAY_DESCENDANTS"));
 447   QWidgetAction* ShowChildrenAction = new QWidgetAction(theViewFrame);
 448   ShowChildrenAction->setDefaultWidget( myDisplayDescendants );
 449
 450   myLevelsNumber = checkMaxLevelsNumber();
 451   std::cout << "\n\n myLevelsNumber1 = " << myLevelsNumber << std::endl;
 452   myHierarchyDepth = new QSpinBox();
 453   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
 454   myHierarchyDepth->setValue( 0 );
 455   myHierarchyDepth->setSpecialValueText( "All" );
 456   QWidgetAction* LevelsAction = new QWidgetAction(theViewFrame);
 457   LevelsAction->setDefaultWidget( myHierarchyDepth );
 458
 459   QLabel* LevelsLabel = new QLabel( tr("HIERARCHY_DEPTH") );
 460   QWidgetAction* LevelsLebelAction = new QWidgetAction(theViewFrame);
 461   LevelsLebelAction->setDefaultWidget( LevelsLabel );
 462
 463
 464   QPushButton* UpdateButton = new QPushButton(tr("Update"));
 465   QWidgetAction* UpdateAction = new QWidgetAction(theViewFrame);
 466   UpdateAction->setDefaultWidget( UpdateButton );
 467
 468   cancelButton = new QPushButton(tr("CANCEL"));
 469   cancelButton->setCheckable(true);
 470   cancelButton->setVisible( false );
 471   cancelAction = new QWidgetAction(theViewFrame);
 472   cancelAction->setDefaultWidget( cancelButton );
 473   cancelAction->setVisible(false);
 474
 475   progressBar  = new QProgressBar(this);
 476   progressBar->setMinimum( 0 );
 477   progressBar->setMaximum( 1000 );
 478   progressBar->setFixedWidth(100);
 479   progressAction = new QWidgetAction(theViewFrame);
 480   progressAction->setDefaultWidget( progressBar );
 481   progressAction->setVisible(false);
 482
 483   QAction* separator = theViewFrame->toolMgr()->separator(false);
 484   theViewFrame->toolMgr()->append( separator, theViewFrame->getToolBarId() );
 485   theViewFrame->toolMgr()->append( moveNodesAction, theViewFrame->getToolBarId() );
 486   theViewFrame->toolMgr()->append( LevelsLebelAction, theViewFrame->getToolBarId() );
 487   theViewFrame->toolMgr()->append( LevelsAction, theViewFrame->getToolBarId() );
 488   theViewFrame->toolMgr()->append( ShowParentsAction, theViewFrame->getToolBarId() );
 489   theViewFrame->toolMgr()->append( ShowChildrenAction, theViewFrame->getToolBarId() );
 490   QAction* separator2 = theViewFrame->toolMgr()->separator(false);
 491   theViewFrame->toolMgr()->append( separator2, theViewFrame->getToolBarId() );
 492   theViewFrame->toolMgr()->append( UpdateAction, theViewFrame->getToolBarId() );
 493   std::cout<<"\n\n\n\n ToolBarId = " << theViewFrame->getToolBarId() << std::endl;
 494   theViewFrame->toolMgr()->append( progressAction, theViewFrame->getToolBarId() );
 495   theViewFrame->toolMgr()->append( cancelAction, theViewFrame->getToolBarId() );
 496
 497   connect(cancelButton, SIGNAL(clicked()), this, SLOT(onCancel()));
 498
 499   connect( myHierarchyDepth, SIGNAL( valueChanged ( int ) ), this, SLOT( onHierarchyType() ) );
 500   connect( myDisplayAscendants , SIGNAL( toggled(bool) ), this, SLOT( onHierarchyType() ) );
 501   connect( myDisplayDescendants, SIGNAL( toggled(bool) ), this, SLOT( onHierarchyType() ) );
 502   connect( UpdateButton, SIGNAL( clicked() ), this, SLOT( updateView() ) );
 503   connect( myNodesMovable, SIGNAL( toggled(bool) ), this, SLOT( onMoveNodes( bool ) ) );
 504
 505   setPrefBackgroundColor( resMgr->colorValue( "Geometry", "dependency_tree_background_color", QColor( 255, 255, 255 ) ) );
 506   setNodesMovable( resMgr->booleanValue( "Geometry", "dependency_tree_move_nodes", true ) );
 507   setHierarchyType( resMgr->integerValue( "Geometry", "dependency_tree_hierarchy_type", 0 ) );
 508
 509 }
 510
 511 void DependencyTree_View::onMoveNodes( bool theIsMoveNodes )
 512 {
 513   std::map<std::string,DependencyTree_Object*>::const_iterator i;
 514   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 515     DependencyTree_Object* object = myTreeMap[ i->first ];
 516     if( object )
 517       object->setMovable( theIsMoveNodes );
 518   }
 519 }
 520
 521 void DependencyTree_View::onHierarchyType()
 522 {
 523   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
 524   if( myHierarchyDepth->value() > checkMaxLevelsNumber() )
 525     myHierarchyDepth->setValue( checkMaxLevelsNumber() );
 526
 527   if( myHierarchyDepth->value() == 0 )
 528     myLevelsNumber = myHierarchyDepth->maximum();
 529   else
 530     myLevelsNumber = myHierarchyDepth->value();
 531
 532   updateView();
 533 }
 534 void DependencyTree_View::updateView()
 535 {
 536
 537   if( !myIsUpdate )
 538     return;
 539
 540           myLevelMap.clear();
 541           myLevelsObject.clear();
 542
 543
 544           std::map<std::string,DependencyTree_Object*>::const_iterator i;
 545                 for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 546                         DependencyTree_Object* object = myTreeMap[ i->first ];
 547                         if( isItemAdded( object ) && object )
 548                   removeItem( object );
 549
 550                 }
 551
 552
 553                    std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 554                    for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 555                      DependencyTree_Arrow* object = Arrows[ j->first ];
 556                      if( isItemAdded( object ) && object )
 557                        removeItem( object );
 558                    }
 559
 560
 561
 562
 563         iter = 0;
 564   qthread = new DependencyTree_ComputeDlg_QThread(this);// = DependencyTree_ComputeDlg_QThread(this);// const_cast<DependencyTree_View*>(this) );
 565   cancelAction->setVisible( true );
 566   progressAction->setVisible(true);
 567   startTimer(100); // millisecs
 568   qthread->start();
 569 }
 570
 571 void DependencyTree_View::onRedrawTree()
 572 {
 573   drawTree();
 574   drawArrows();
 575 }
 576 void DependencyTree_View::onCancel()
 577 {
 578   qthread->cancel();
 579   cancelButton->setText( tr("CANCELING"));
 580   cancelButton->setEnabled(false);
 581 }
 582
 583 void DependencyTree_View::timerEvent(QTimerEvent *event)
 584 {
 585   if ( !cancelButton->isChecked() ) // not yet cancelled
 586    // progressBar->setValue( progressBar->maximum() * qthread.getMesh()->GetComputeProgress() );
 587           progressBar->setValue( iter++ );
 588
 589   if(!myIsCompute || qthread->isFinished())
 590   {
 591           cancelAction->setVisible( false );
 592           progressAction->setVisible(false);
 593           cancelButton->setText( tr("CANCEL"));
 594           cancelButton->setEnabled(true);
 595   }
 596
 597   event->accept();
 598 }
 599
 600 void DependencyTree_View::closeEvent(QCloseEvent *event)
 601 {
 602   if(qthread->isRunning())
 603   {
 604       event->ignore();
 605       return;
 606     }
 607   event->accept();
 608 }
 609
 610 void DependencyTree_View::setIsCompute( bool theIsCompute )
 611 {
 612   myIsCompute = theIsCompute;
 613 }
 614
 615 void DependencyTree_View::setHierarchyType( const int theType )
 616 {
 617   myIsUpdate = false;
 618   switch( theType ) {
 619   case 0:
 620     myDisplayAscendants->setChecked( true );
 621     myDisplayDescendants->setChecked( true );
 622     break;
 623   case 1:
 624     myDisplayAscendants->setChecked( true );
 625     myDisplayDescendants->setChecked( false );
 626     break;
 627   case 2:
 628     myDisplayAscendants->setChecked( false );
 629     myDisplayDescendants->setChecked( true );
 630     break;
 631   }
 632   myIsUpdate = true;
 633   onHierarchyType();
 634 }
 635
 636 void DependencyTree_View::setNodesMovable( const bool theIsMovable )
 637 {
 638   myNodesMovable->setChecked( theIsMovable );
 639 }
 640
 641 void DependencyTree_View::setPrefBackgroundColor( const QColor& theColor )
 642 {
 643   if( isForegroundEnabled() )
 644   {
 645     setForegroundColor( theColor );
 646     updateForeground();
 647   }
 648   else
 649     setBackgroundColor( theColor );
 650 }
 651
 652 void DependencyTree_View::setNodeColor( const QColor& theColor )
 653 {
 654   std::map<std::string,DependencyTree_Object*>::const_iterator i;
 655   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 656     DependencyTree_Object* object = myTreeMap[ i->first ];
 657     object->setColor( theColor );
 658   }
 659 }
 660
 661 void DependencyTree_View::setMainNodeColor( const QColor& theColor )
 662 {
 663           std::map<std::string,DependencyTree_Object*>::const_iterator i;
 664   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 665     DependencyTree_Object* object = myTreeMap[ i->first ];
 666     object->setMainObjectColor( theColor );
 667   }
 668 }
 669
 670 void DependencyTree_View::setSelectNodeColor( const QColor& theColor )
 671 {
 672           std::map<std::string,DependencyTree_Object*>::const_iterator i;
 673   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 674     DependencyTree_Object* object = myTreeMap[ i->first ];
 675     object->setSelectColor( theColor );
 676   }
 677 }
 678
 679 void DependencyTree_View::setArrowColor( const QColor& theColor )
 680 {
 681   std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 682   for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 683     DependencyTree_Arrow* arrow = Arrows[ j->first ];
 684     arrow->setColor( theColor );
 685   }
 686 }
 687
 688 void DependencyTree_View::setHighlightArrowColor( const QColor& theColor )
 689 {
 690           std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 691   for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 692     DependencyTree_Arrow* arrow = Arrows[ j->first ];
 693     arrow->setHighlightColor( theColor );
 694   }
 695 }
 696
 697 void DependencyTree_View::setSelectArrowColor( const QColor& theColor )
 698 {
 699           std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 700   for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 701     DependencyTree_Arrow* arrow = Arrows[ j->first ];
 702     arrow->setSelectColor( theColor );
 703   }
 704 }
 705
 706 int DependencyTree_View::select( const QRectF& theRect, bool theIsAppend )
 707 {
 708         GraphicsView_ViewPort::select( theRect, theIsAppend );
 709
 710 //    SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 711 //
 712 //    LightApp_SelectionMgr* aSelMgr = app->selectionMgr();
 713 //
 714 //    // get selection
 715 //    SALOME_ListIO listIO;
 716 //
 717 //    SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>(app->activeStudy());
 718 //    SALOMEDS::Study_var aStudyDS = GeometryGUI::ClientStudyToStudy( study->studyDS());
 719 //    int StudyId = aStudyDS->StudyId();
 720 //    for( initSelected(); moreSelected(); nextSelected() )
 721 //      if( DependencyTree_Object* aDepObject = dynamic_cast<DependencyTree_Object*>( selectedObject() ) ) {
 722 //
 723 //          _PTR(SObject) SO ( aStudyDS->FindObjectID( aDepObject->getEntry().c_str() ) );
 724 //          if ( SO ) { //;&& QString(SO->GetID().c_str()) == QString(SO->GetFatherComponent()->GetID().c_str()) ) {
 725 //            _PTR(SComponent) SC ( SO->GetFatherComponent() );
 726 //            // if component is selected
 727 //            _PTR(ChildIterator) anIter ( aStudyDS->NewChildIterator( SO ) );
 728 //            anIter->InitEx( true );
 729 //            while( anIter->More() ) {
 730 //              _PTR(SObject) valSO ( anIter->Value() );
 731 //              _PTR(SObject) refSO;
 732 //              if ( !valSO->ReferencedObject( refSO ) ) {
 733 //                listIO.Append( new SALOME_InteractiveObject(valSO->GetID().c_str(),
 734 //                                                            SC->ComponentDataType().c_str(),
 735 //                                                            valSO->GetName().c_str()) );
 736 //              }
 737 //              anIter->Next();
 738 //            }
 739 //            break;
 740 //          }
 741 //      }
 742 //  aSelMgr->setSelectedObjects( listIO, true );
 743 }
 744
 745 //================================================================================
 746 //================================================================================
 747
 748 DependencyTree_ComputeDlg_QThread::DependencyTree_ComputeDlg_QThread(DependencyTree_View* theView)
 749 {
 750   myView = theView;
 751 }
 752
 753 void DependencyTree_ComputeDlg_QThread::run()
 754 {
 755   myView->setIsCompute( true );
 756   myView->onRedrawTree();
 757 }
 758
 759 bool DependencyTree_ComputeDlg_QThread::result()
 760 {
 761
 762 }
 763
 764 void DependencyTree_ComputeDlg_QThread::cancel()
 765 {
 766   myView->setIsCompute( false );
 767 }
 768
 769 ////================================================================================
 770 ////================================================================================
 771 //
 772 //DependencyTree_ComputeDlg_QThreadQDialog::DependencyTree_ComputeDlg_QThreadQDialog(QWidget* parent,
 773 //              DependencyTree_View* theView)
 774 //  : QDialog(parent,
 775 //            Qt::WindowSystemMenuHint |
 776 //            Qt::WindowCloseButtonHint |
 777 //            Qt::Dialog |
 778 //            Qt::WindowMaximizeButtonHint),
 779 //    qthread( theView )
 780 //{
 781 //  // --
 782 //  setWindowTitle(tr("TITLE"));
 783 //  setMinimumWidth( 200 );
 784 //
 785 //  cancelButton = new QPushButton(tr("CANCEL"));
 786 //  cancelButton->setDefault(true);
 787 //  cancelButton->setCheckable(true);
 788 //
 789 //  progressBar  = new QProgressBar(this);
 790 //  progressBar->setMinimum( 0 );
 791 //  progressBar->setMaximum( 1000 );
 792 //
 793 //  QGridLayout* layout = new QGridLayout(this);
 794 //  layout->setMargin( 11 );
 795 //  layout->setSpacing( 6 );
 796 //  int row = 0;
 797 //  layout->addWidget(progressBar,  row++, 0, 1, 2);
 798 //  layout->addWidget(cancelButton, row++, 0, 1, 2);
 799 //  adjustSize();
 800 //  update();
 801 //
 802 //  connect(cancelButton, SIGNAL(clicked()), this, SLOT(onCancel()));
 803 //  // --
 804 //  startTimer(300); // millisecs
 805 //  qthread.start();
 806 //}
 807 //
 808 //bool DependencyTree_ComputeDlg_QThreadQDialog::result()
 809 //{
 810 //  return qthread.result();
 811 //}
 812 //
 813 //void DependencyTree_ComputeDlg_QThreadQDialog::onCancel()
 814 //{
 815 //  qthread.cancel();
 816 //  cancelButton->setText( tr("CANCELING"));
 817 //  cancelButton->setEnabled(false);
 818 //}
 819 //
 820 //void DependencyTree_ComputeDlg_QThreadQDialog::timerEvent(QTimerEvent *event)
 821 //{
 822 //  if ( !cancelButton->isChecked() ) // not yet cancelled
 823 //   // progressBar->setValue( progressBar->maximum() * qthread.getMesh()->GetComputeProgress() );
 824 //        progressBar->setValue( 10 );
 825 //
 826 //  if(qthread.isFinished())
 827 //  {
 828 //    close();
 829 //  }
 830 //
 831 //  event->accept();
 832 //}
 833 //
 834 //void DependencyTree_ComputeDlg_QThreadQDialog::closeEvent(QCloseEvent *event)
 835 //{
 836 //  if(qthread.isRunning())
 837 //  {
 838 //      event->ignore();
 839 //      return;
 840 //    }
 841 //  event->accept();
 842 //}
 843 //
 844
 845