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