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