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   aSelMgr->clearSelected();
  93 }
  94
  95 DependencyTree_View::~DependencyTree_View()
  96 {
  97
  98 }
  99
 100 void DependencyTree_View::drawArrows()
 101 {
 102         GEOMUtils::TreeModel::const_iterator i;
 103         for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 104                 DependencyTree_Object* Main_object = myTreeMap[i->first];
 105             if( i->second.first.size() > 0 ) {
 106                   GEOMUtils::LevelInfo Levelup = i->second.first.at(0);
 107                   if( myDisplayAscendants ->isChecked() ) {
 108                         GEOMUtils::LevelInfo::const_iterator node;
 109                     for (node = Levelup.begin(); node != Levelup.end(); node++ ) {
 110                       DependencyTree_Object* object = myTreeMap[node->first];
 111                       DependencyTree_Arrow* arrow = Arrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>(Main_object, object)];
 112                       if( arrow && !isItemAdded( arrow) )
 113                         addItem( arrow );
 114                     }
 115                   }
 116             }
 117                 if( myDisplayAscendants ->isChecked() )
 118        drawWardArrows( i->second.first );
 119                 if( myDisplayDescendants->isChecked() )
 120        drawWardArrows( i->second.second );
 121
 122           }
 123 }
 124
 125 void DependencyTree_View::drawWardArrows( GEOMUtils::LevelsList theWard )
 126 {
 127           for(int j = 0; j < theWard.size(); j++ ) {
 128                   if( j >= myLevelsNumber )
 129                 break;
 130                   GEOMUtils::LevelInfo Level = theWard.at(j);
 131                   GEOMUtils::LevelInfo::const_iterator node;
 132                   for (node = Level.begin(); node != Level.end(); node++ ) {
 133                     DependencyTree_Object* object = myTreeMap[node->first];
 134                     GEOMUtils::NodeLinks Links = node->second;
 135           for( int link = 0; link < Links.size(); link++ ) {
 136             DependencyTree_Object* LinkObject = myTreeMap[Links[link]];
 137             if( isItemAdded( object ) && isItemAdded( LinkObject ) ) {
 138                     DependencyTree_Arrow* arrow = Arrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>(object, LinkObject)];
 139                     if( arrow && !isItemAdded( arrow) )
 140                       addItem( arrow );
 141                }
 142           }
 143                   }
 144           }
 145 }
 146
 147 void DependencyTree_View::parseTree()
 148 {
 149
 150   GEOMUtils::TreeModel::const_iterator i;
 151   for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 152     std::string objectEntry = i->first;
 153     addNode( objectEntry );
 154     parseTreeWard( i->second.first );
 155     if( i->second.first.size() > myMaxUpwardLevelsNumber )
 156       myMaxUpwardLevelsNumber = i->second.first.size();
 157     parseTreeWard( i->second.second );
 158     if( i->second.second.size() > myMaxDownwardLevelsNumber )
 159       myMaxDownwardLevelsNumber = i->second.second.size();
 160   }
 161
 162   for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 163     DependencyTree_Object* Main_object = myTreeMap[i->first];
 164     if( i->second.first.size() > 0 ) {
 165       GEOMUtils::LevelInfo Levelup = i->second.first.at(0);
 166       GEOMUtils::LevelInfo::const_iterator node;
 167       for (node = Levelup.begin(); node != Levelup.end(); node++ ) {
 168         DependencyTree_Object* object = myTreeMap[node->first];
 169         addArrow( Main_object, object );
 170       }
 171     }
 172     parseTreeWardArrow( i->second.first );
 173     parseTreeWardArrow( i->second.second );
 174   }
 175
 176
 177 }
 178 void DependencyTree_View::parseTreeWard(const GEOMUtils::LevelsList theWard)
 179 {
 180   int levelsNumber = theWard.size();
 181   for( int level = 0; level < levelsNumber; level++ ) {
 182     GEOMUtils::LevelInfo levelInfo = theWard[ level ];
 183     GEOMUtils::LevelInfo::const_iterator node;
 184     for (node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 185       addNode( node->first );
 186     }
 187   }
 188 }
 189 void DependencyTree_View::parseTreeWardArrow(const GEOMUtils::LevelsList theWard)
 190 {
 191   for(int j = 0; j < theWard.size(); j++ ) {
 192           GEOMUtils::LevelInfo Level = theWard.at(j);
 193           GEOMUtils::LevelInfo::const_iterator node;
 194     for (node = Level.begin(); node != Level.end(); node++ ) {
 195       DependencyTree_Object* object = myTreeMap[node->first];
 196       std::vector<std::string> Links = node->second;
 197       for( int link = 0; link < Links.size(); link++ ) {
 198         DependencyTree_Object* LinkObject = myTreeMap[Links[link]];
 199         if( object && LinkObject )
 200           addArrow( object, LinkObject );
 201       }
 202     }
 203   }
 204 }
 205 //void DependencyTree_View::parseData( QString& theData )
 206 //{
 207 //        int cursor = 0;
 208 //
 209 //        while( theData.indexOf('-',cursor) != -1 ) //find next selected object
 210 //        {
 211 //          int objectIndex = theData.indexOf( '-', cursor );
 212 //          QString objectEntry = theData.mid( cursor, objectIndex - cursor );
 213 //          //addNode( objectEntry );
 214 //          std::cout<<"\n\nMainObject = " << objectEntry.toStdString() <<std::endl;
 215 //          cursor = objectIndex;
 216 //
 217 //          int upwardIndexBegin = theData.indexOf("{",cursor) + 1;
 218 //          int upwardIndexFinish = theData.indexOf("}",upwardIndexBegin);
 219 //          std::cout<<"  Upward:" << std::endl;
 220 //          LevelsList upwardList = parseWard( theData, cursor );
 221 //          if( upwardList.size() > myMaxUpwardLevelsNumber )
 222 //            myMaxUpwardLevelsNumber = upwardList.size();
 223 //          std::cout<<"  Downward:" << std::endl;
 224 //          LevelsList downwardList = parseWard( theData, cursor );
 225 //          if( downwardList.size() > myMaxDownwardLevelsNumber )
 226 //            myMaxDownwardLevelsNumber = downwardList.size();
 227 //
 228 //          myTreeModel[objectEntry] = QPair<LevelsList,LevelsList>( upwardList, downwardList );
 229 //        }
 230 //}
 231
 232 void DependencyTree_View::addNode( const std::string& theEntry )
 233 {
 234   if( !myTreeMap[theEntry] )
 235     myTreeMap[theEntry] = new DependencyTree_Object( theEntry );
 236 }
 237
 238 void DependencyTree_View::addArrow( DependencyTree_Object *startItem, DependencyTree_Object *endItem )
 239 {
 240   bool isFind = false;
 241
 242   std::cout << "   " << startItem->getEntry() << "   " << endItem->getEntry() << std::endl;
 243   std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator i;
 244   for (i = Arrows.begin(); i != Arrows.end(); i++ ) {
 245           DependencyTree_Arrow* arrow = i->second;
 246     if( arrow->getStartItem() == startItem && arrow->getEndItem() == endItem ) {
 247       isFind = true;
 248       std::cout<<" theSame " << std::endl;
 249     }
 250     else if( arrow->getStartItem() == endItem && arrow->getEndItem() == startItem ) {
 251       arrow->setIsBiLink( true );
 252       std::cout<<" Bilink " << std::endl;
 253       isFind = true;
 254     }
 255   }
 256
 257   if( !isFind ) {
 258           DependencyTree_Arrow *arrow = new DependencyTree_Arrow(startItem, endItem);
 259             //Arrows.append( arrow );
 260             //addItem(arrow);
 261             Arrows[std::pair<DependencyTree_Object*,DependencyTree_Object*>( startItem, endItem )] = arrow;
 262             std::cout<<" addArrow " << std::endl;
 263   }
 264 }
 265
 266 //DependencyTree_View::LevelsList DependencyTree_View::parseWard( const QString& theData, int& theCursor )
 267 //{
 268 //        int indexStart = theData.indexOf( "{", theCursor ) + 1;
 269 //        int indexEnd = theData.indexOf( "}", indexStart );
 270 //
 271 //        QString ward = theData.mid( indexStart, indexEnd - indexStart );
 272 //        QStringList levelsListStr = ward.split( ';' );
 273 //        LevelsList levelsListData;
 274 //        for( int level = 0; level < levelsListStr.size(); level++ ) {
 275 //          std::cout<<"    Level" << level + 1 << ":" << std::endl;
 276 //          QStringList namesListStr = levelsListStr[level].split( ',' );
 277 //          LevelInfo levelInfoData;
 278 //          for( int node = 0; node < namesListStr.size(); node++ ) {
 279 //            QStringList linksListStr = namesListStr[node].split( '_' );
 280 //            QString nodeItem = linksListStr[0];
 281 //            if( !nodeItem.isEmpty() ) {
 282 //              //addNode( nodeItem );
 283 //              NodeLinks linksListData;
 284 //              std::cout<<"      " << nodeItem.toStdString() << " - ";
 285 //              for( int link = 1; link < linksListStr.size(); link++ ) {
 286 //                QString linkItem = linksListStr[link];
 287 //                //addNode( linkItem );
 288 //                linksListData.append( linkItem );
 289 //                std::cout << linkItem.toStdString() << ", ";
 290 //              }// Links
 291 //              levelInfoData[nodeItem] = linksListData;
 292 //              std::cout << std::endl;
 293 //            }
 294 //          }// Level's objects
 295 //          levelsListData.append(levelInfoData);
 296 //        }// Levels
 297 //
 298 //        theCursor = indexEnd + 1;
 299 //
 300 //        return levelsListData;
 301 //}
 302
 303 void DependencyTree_View::drawTree()
 304 {
 305
 306   int horDistance, verDistance;
 307   myCurrentLevel = 0;
 308     GEOMUtils::TreeModel::const_iterator i;
 309     for (i = myTreeModel.begin(); i != myTreeModel.end(); i++ ) {
 310       myCurrentLevel = 0;
 311       std::string objectEntry = i->first;
 312       DependencyTree_Object* objectItem = myTreeMap[ objectEntry ];
 313       horDistance = 100 + int( objectItem->boundingRect().width() );
 314       verDistance = 3 * int( objectItem->boundingRect().height() );
 315       if( isItemAdded( objectItem ) ) {
 316         myCurrentLevel = myLevelMap[ objectEntry ];
 317       }
 318       else {
 319         addItem( objectItem );
 320         myLevelMap[ objectEntry ] = myCurrentLevel;
 321         myLevelsObject[ myCurrentLevel ].push_back( objectEntry );
 322       }
 323       objectItem->setIsMainObject( true );
 324
 325       int levelposition = myCurrentLevel;
 326       if( myDisplayAscendants ->isChecked() ){
 327         drawWard( i->second.first, -1 );
 328         myCurrentLevel = levelposition;
 329       }
 330       if( myDisplayDescendants->isChecked() )
 331         drawWard( i->second.second, 1 );
 332       }
 333
 334                 std::map< int, std::vector<std::string> >::const_iterator j;
 335                 for (j = myLevelsObject.begin(); j != myLevelsObject.end(); j++ ) {
 336                   int step = -horDistance*( j->second.size() - 1 )/2;
 337                         std::cout<<"\n\n LEVEL = " << j->first << std::endl;
 338                   for( int object = 0; object < j->second.size(); object++ ) {
 339                          if( myIsCompute ) {
 340                           std::cout << j->second.at( object ) << ", ";
 341                          DependencyTree_Object* anObject = myTreeMap[ j->second.at( object ) ];
 342                          anObject->setPos( step, verDistance*j->first );
 343                          step += horDistance;
 344                          //sleep(1);
 345                          }
 346                   }
 347                 }
 348   centerOn( scene()->sceneRect().center() );
 349   fitAll( true );
 350
 351 }
 352
 353 void DependencyTree_View::drawWard( const GEOMUtils::LevelsList theWard, const int theLevelStep )
 354 {
 355         std::cout << "\n\n myLevelsNumber2 = " << myLevelsNumber << std::endl;
 356           int levelsNumber = theWard.size();
 357         std::cout << "\n\n levelsNumber = " << levelsNumber << std::endl;
 358           for( int level = 0; level < levelsNumber; level++ ) {
 359                   if( level >= myLevelsNumber )
 360                 return;
 361             myCurrentLevel += theLevelStep;
 362             GEOMUtils::LevelInfo levelInfo = theWard.at( level );
 363             GEOMUtils::LevelInfo::const_iterator node;
 364                 for (node = levelInfo.begin(); node != levelInfo.end(); node++ ) {
 365               DependencyTree_Object* object = myTreeMap[ node->first ];
 366               if( !isItemAdded( object ) ) {
 367                 addItem( object );
 368                 myLevelMap[ node->first ] = myCurrentLevel;
 369                 myLevelsObject[ myCurrentLevel ].push_back( node->first );
 370               }
 371             }
 372          }
 373
 374 }
 375
 376 void DependencyTree_View::onUpdateTree()
 377 {
 378   myLevelMap.clear();
 379   myLevelsObject.clear();
 380
 381
 382   std::map<std::string,DependencyTree_Object*>::const_iterator i;
 383         for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 384                 DependencyTree_Object* object = myTreeMap[ i->first ];
 385                 if( isItemAdded( object ) && object )
 386           removeItem( object );
 387
 388         }
 389
 390    std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 391    for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 392      DependencyTree_Arrow* object = Arrows[ j->first ];
 393      if( isItemAdded( object ) && object )
 394        removeItem( object );
 395    }
 396
 397   drawTree();
 398   drawArrows();
 399 }
 400
 401
 402 int DependencyTree_View::checkMaxLevelsNumber()
 403 {
 404   if( myDisplayAscendants ->isChecked() && myDisplayDescendants->isChecked() )
 405     return myMaxUpwardLevelsNumber>myMaxDownwardLevelsNumber?myMaxUpwardLevelsNumber:myMaxDownwardLevelsNumber;
 406   else if( myDisplayAscendants ->isChecked() )
 407     return myMaxUpwardLevelsNumber;
 408   else if( myDisplayDescendants->isChecked() )
 409     return  myMaxDownwardLevelsNumber;
 410 }
 411
 412
 413 void DependencyTree_View::init( GraphicsView_ViewFrame* theViewFrame )
 414 {
 415           SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 416
 417           std::string Data = "MainObject1-upward{up11_up21_up22,up12_up23,up13_up24;up21_up11,up22_up21_up12,up23_up23,up24}"
 418                                  "downward{down11_MainObject1,down12_MainObject1;down21_down11,down22_down12,down23_down12,down24_down24_down11,down25_down12;down31_down11_down23,down32_down25}"
 419                                  "down23-upward{down12_MainObject1;MainObject1_up11_up12_up13;up11_up21_up22,up12_up23,up13_up24;up21,up22_up21_up12,up23,up24}"
 420                                  "downward{down31_down11_down23}"
 421                                  "MainObject2-upward{up21,newup11_newup31,newup12_newup21;newup21_newup31LongName;newup31LongName}downward{newdown11_MainObject2,newdown12_MainObject2,newdown13_MainObject2;newdown21_newdown13,down21;newdown31_newdown11}"
 422                                  "MainObject3-upward{moUP1_moUP4,moUP2_moUP3;moUP4,moUP3_down23}downward{moDOWN1_MainObject3}";
 423
 424
 425           //GEOMUtils::ConvertStringToTree( Data, myTreeModel );
 426
 427
 428
 429 //        GEOMUtils::TreeModel::const_iterator i;
 430 //        for ( i = aTreeModel.begin(); i != aTreeModel.end(); i++ ) {
 431 //          std::string objectEntry = i->first;
 432 //          std::cout << "\n\n Main object = " << objectEntry << std::endl;
 433 //        }
 434 //  parseData( Data );
 435   parseTree();
 436
 437
 438   myNodesMovable = new QCheckBox( tr( "MOVE_NODES" ) );
 439   QWidgetAction* moveNodesAction = new QWidgetAction( theViewFrame );
 440   moveNodesAction->setDefaultWidget( myNodesMovable );
 441
 442   myDisplayAscendants  = new QCheckBox( tr( "DISPLAY_ASCENDANTS" ));
 443   myDisplayAscendants ->setChecked( true );
 444   QWidgetAction* ShowParentsAction = new QWidgetAction(theViewFrame);
 445   ShowParentsAction->setDefaultWidget( myDisplayAscendants  );
 446
 447   myDisplayDescendants = new QCheckBox(tr("DISPLAY_DESCENDANTS"));
 448   QWidgetAction* ShowChildrenAction = new QWidgetAction(theViewFrame);
 449   ShowChildrenAction->setDefaultWidget( myDisplayDescendants );
 450
 451   myLevelsNumber = checkMaxLevelsNumber();
 452   std::cout << "\n\n myLevelsNumber1 = " << myLevelsNumber << std::endl;
 453   myHierarchyDepth = new QSpinBox();
 454   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
 455   myHierarchyDepth->setValue( 0 );
 456   myHierarchyDepth->setSpecialValueText( "All" );
 457   QWidgetAction* LevelsAction = new QWidgetAction(theViewFrame);
 458   LevelsAction->setDefaultWidget( myHierarchyDepth );
 459
 460   QLabel* LevelsLabel = new QLabel( tr("HIERARCHY_DEPTH") );
 461   QWidgetAction* LevelsLebelAction = new QWidgetAction(theViewFrame);
 462   LevelsLebelAction->setDefaultWidget( LevelsLabel );
 463
 464
 465   QPushButton* UpdateButton = new QPushButton(tr("Update"));
 466   QWidgetAction* UpdateAction = new QWidgetAction(theViewFrame);
 467   UpdateAction->setDefaultWidget( UpdateButton );
 468
 469   cancelButton = new QPushButton(tr("CANCEL"));
 470   cancelButton->setCheckable(true);
 471   cancelButton->setVisible( false );
 472   cancelAction = new QWidgetAction(theViewFrame);
 473   cancelAction->setDefaultWidget( cancelButton );
 474   cancelAction->setVisible(false);
 475
 476   progressBar  = new QProgressBar(this);
 477   progressBar->setMinimum( 0 );
 478   progressBar->setMaximum( 1000 );
 479   progressBar->setFixedWidth(100);
 480   progressAction = new QWidgetAction(theViewFrame);
 481   progressAction->setDefaultWidget( progressBar );
 482   progressAction->setVisible(false);
 483
 484   QAction* separator = theViewFrame->toolMgr()->separator(false);
 485   theViewFrame->toolMgr()->append( separator, theViewFrame->getToolBarId() );
 486   theViewFrame->toolMgr()->append( moveNodesAction, theViewFrame->getToolBarId() );
 487   theViewFrame->toolMgr()->append( LevelsLebelAction, theViewFrame->getToolBarId() );
 488   theViewFrame->toolMgr()->append( LevelsAction, theViewFrame->getToolBarId() );
 489   theViewFrame->toolMgr()->append( ShowParentsAction, theViewFrame->getToolBarId() );
 490   theViewFrame->toolMgr()->append( ShowChildrenAction, theViewFrame->getToolBarId() );
 491   QAction* separator2 = theViewFrame->toolMgr()->separator(false);
 492   theViewFrame->toolMgr()->append( separator2, theViewFrame->getToolBarId() );
 493   theViewFrame->toolMgr()->append( UpdateAction, theViewFrame->getToolBarId() );
 494   std::cout<<"\n\n\n\n ToolBarId = " << theViewFrame->getToolBarId() << std::endl;
 495   theViewFrame->toolMgr()->append( progressAction, theViewFrame->getToolBarId() );
 496   theViewFrame->toolMgr()->append( cancelAction, theViewFrame->getToolBarId() );
 497
 498   connect(cancelButton, SIGNAL(clicked()), this, SLOT(onCancel()));
 499
 500   connect( myHierarchyDepth, SIGNAL( valueChanged ( int ) ), this, SLOT( onHierarchyType() ) );
 501   connect( myDisplayAscendants , SIGNAL( toggled(bool) ), this, SLOT( onHierarchyType() ) );
 502   connect( myDisplayDescendants, SIGNAL( toggled(bool) ), this, SLOT( onHierarchyType() ) );
 503   connect( UpdateButton, SIGNAL( clicked() ), this, SLOT( updateView() ) );
 504   connect( myNodesMovable, SIGNAL( toggled(bool) ), this, SLOT( onMoveNodes( bool ) ) );
 505
 506   setPrefBackgroundColor( resMgr->colorValue( "Geometry", "dependency_tree_background_color", QColor( 255, 255, 255 ) ) );
 507   setNodesMovable( resMgr->booleanValue( "Geometry", "dependency_tree_move_nodes", true ) );
 508   setHierarchyType( resMgr->integerValue( "Geometry", "dependency_tree_hierarchy_type", 0 ) );
 509
 510
 511 }
 512
 513 void DependencyTree_View::onMoveNodes( bool theIsMoveNodes )
 514 {
 515   std::map<std::string,DependencyTree_Object*>::const_iterator i;
 516   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 517     DependencyTree_Object* object = myTreeMap[ i->first ];
 518     if( object )
 519       object->setMovable( theIsMoveNodes );
 520   }
 521 }
 522
 523 void DependencyTree_View::onHierarchyType()
 524 {
 525   myHierarchyDepth->setRange( 0, checkMaxLevelsNumber() );
 526   if( myHierarchyDepth->value() > checkMaxLevelsNumber() )
 527     myHierarchyDepth->setValue( checkMaxLevelsNumber() );
 528
 529   if( myHierarchyDepth->value() == 0 )
 530     myLevelsNumber = myHierarchyDepth->maximum();
 531   else
 532     myLevelsNumber = myHierarchyDepth->value();
 533
 534   updateView();
 535 }
 536 void DependencyTree_View::updateView()
 537 {
 538
 539   if( !myIsUpdate )
 540     return;
 541
 542           myLevelMap.clear();
 543           myLevelsObject.clear();
 544
 545
 546           std::map<std::string,DependencyTree_Object*>::const_iterator i;
 547                 for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 548                         DependencyTree_Object* object = myTreeMap[ i->first ];
 549                         if( isItemAdded( object ) && object )
 550                   removeItem( object );
 551
 552                 }
 553
 554
 555                    std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 556                    for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 557                      DependencyTree_Arrow* object = Arrows[ j->first ];
 558                      if( isItemAdded( object ) && object )
 559                        removeItem( object );
 560                    }
 561
 562
 563
 564
 565         iter = 0;
 566   qthread = new DependencyTree_ComputeDlg_QThread(this);// = DependencyTree_ComputeDlg_QThread(this);// const_cast<DependencyTree_View*>(this) );
 567   cancelAction->setVisible( true );
 568   progressAction->setVisible(true);
 569   myNodesMovable->setEnabled(false);
 570   myHierarchyDepth->setEnabled( false);
 571   myDisplayAscendants->setEnabled( false );
 572   myDisplayDescendants->setEnabled( false );
 573   myTimer = startTimer(100); // millisecs
 574   qthread->start();
 575 }
 576
 577 void DependencyTree_View::onRedrawTree()
 578 {
 579   drawTree();
 580   drawArrows();
 581 }
 582 void DependencyTree_View::onCancel()
 583 {
 584   qthread->cancel();
 585   cancelButton->setText( tr("CANCELING"));
 586   cancelButton->setEnabled(false);
 587   killTimer( myTimer );
 588   qthread->killTimer( myTimer );
 589   qthread->deleteLater();
 590
 591 }
 592
 593 void DependencyTree_View::timerEvent(QTimerEvent *event)
 594 {
 595   if ( !cancelButton->isChecked() ) // not yet cancelled
 596    // progressBar->setValue( progressBar->maximum() * qthread.getMesh()->GetComputeProgress() );
 597           progressBar->setValue( iter++ );
 598
 599   if(!myIsCompute || qthread->isFinished())
 600   {
 601           cancelAction->setVisible( false );
 602           progressAction->setVisible(false);
 603           cancelButton->setText( tr("CANCEL"));
 604           cancelButton->setEnabled(true);
 605           myNodesMovable->setEnabled( true );
 606           myHierarchyDepth->setEnabled( true );
 607           myDisplayAscendants->setEnabled( true );
 608           myDisplayDescendants->setEnabled( true );
 609   }
 610
 611   event->accept();
 612 }
 613
 614 void DependencyTree_View::closeEvent(QCloseEvent *event)
 615 {
 616   if(qthread->isRunning())
 617   {
 618       event->ignore();
 619       return;
 620     }
 621   event->accept();
 622 }
 623
 624 void DependencyTree_View::setIsCompute( bool theIsCompute )
 625 {
 626   myIsCompute = theIsCompute;
 627 }
 628
 629 void DependencyTree_View::setHierarchyType( const int theType )
 630 {
 631   myIsUpdate = false;
 632   switch( theType ) {
 633   case 0:
 634     myDisplayAscendants->setChecked( true );
 635     myDisplayDescendants->setChecked( true );
 636     break;
 637   case 1:
 638     myDisplayAscendants->setChecked( true );
 639     myDisplayDescendants->setChecked( false );
 640     break;
 641   case 2:
 642     myDisplayAscendants->setChecked( false );
 643     myDisplayDescendants->setChecked( true );
 644     break;
 645   }
 646   myIsUpdate = true;
 647   onHierarchyType();
 648 }
 649
 650 void DependencyTree_View::setNodesMovable( const bool theIsMovable )
 651 {
 652   myNodesMovable->setChecked( theIsMovable );
 653 }
 654
 655 void DependencyTree_View::setPrefBackgroundColor( const QColor& theColor )
 656 {
 657   if( isForegroundEnabled() )
 658   {
 659     setForegroundColor( theColor );
 660     updateForeground();
 661   }
 662   else
 663     setBackgroundColor( theColor );
 664 }
 665
 666 void DependencyTree_View::setNodeColor( const QColor& theColor )
 667 {
 668   std::map<std::string,DependencyTree_Object*>::const_iterator i;
 669   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 670     DependencyTree_Object* object = myTreeMap[ i->first ];
 671     object->setColor( theColor );
 672   }
 673 }
 674
 675 void DependencyTree_View::setMainNodeColor( const QColor& theColor )
 676 {
 677           std::map<std::string,DependencyTree_Object*>::const_iterator i;
 678   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 679     DependencyTree_Object* object = myTreeMap[ i->first ];
 680     object->setMainObjectColor( theColor );
 681   }
 682 }
 683
 684 void DependencyTree_View::setSelectNodeColor( const QColor& theColor )
 685 {
 686           std::map<std::string,DependencyTree_Object*>::const_iterator i;
 687   for (i = myTreeMap.begin(); i != myTreeMap.end(); i++ ) {
 688     DependencyTree_Object* object = myTreeMap[ i->first ];
 689     object->setSelectColor( theColor );
 690   }
 691 }
 692
 693 void DependencyTree_View::setArrowColor( const QColor& theColor )
 694 {
 695   std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 696   for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 697     DependencyTree_Arrow* arrow = Arrows[ j->first ];
 698     arrow->setColor( theColor );
 699   }
 700 }
 701
 702 void DependencyTree_View::setHighlightArrowColor( const QColor& theColor )
 703 {
 704           std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 705   for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 706     DependencyTree_Arrow* arrow = Arrows[ j->first ];
 707     arrow->setHighlightColor( theColor );
 708   }
 709 }
 710
 711 void DependencyTree_View::setSelectArrowColor( const QColor& theColor )
 712 {
 713           std::map<std::pair<DependencyTree_Object*,DependencyTree_Object*>, DependencyTree_Arrow* >::const_iterator j;
 714   for (j = Arrows.begin(); j != Arrows.end(); j++ ) {
 715     DependencyTree_Arrow* arrow = Arrows[ j->first ];
 716     arrow->setSelectColor( theColor );
 717   }
 718 }
 719
 720 int DependencyTree_View::select( const QRectF& theRect, bool theIsAppend )
 721 {
 722         GraphicsView_ViewPort::select( theRect, theIsAppend );
 723
 724     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
 725
 726     LightApp_SelectionMgr* aSelMgr = app->selectionMgr();
 727
 728     // get selection
 729     SALOME_ListIO listIO;
 730 aSelMgr->clearSelected();
 731     SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>(app->activeStudy());
 732     SALOMEDS::Study_var aStudyDS = GeometryGUI::ClientStudyToStudy( study->studyDS());
 733     int StudyId = aStudyDS->StudyId();
 734     for( initSelected(); moreSelected(); nextSelected() )
 735       if( DependencyTree_Object* aDepObject = dynamic_cast<DependencyTree_Object*>( selectedObject() ) ) {
 736           GEOM::_objref_GEOM_BaseObject* object = GeometryGUI::GetGeomGen()->GetObject( StudyId, aDepObject->getEntry().c_str() );
 737           CORBA::String_var aChildEntry = object->GetStudyEntry();
 738       Handle(SALOME_InteractiveObject) tmpIO =
 739         new SALOME_InteractiveObject( aChildEntry.in(), "GEOM", "TEMP_IO");
 740       listIO.Append(tmpIO);
 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