src/ObjBrowser/OB_Browser.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, CEA/DEN, EDF R&D, PRINCIPIA R&D
   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.
   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/
  18 //
  19 #include "OB_Browser.h"
  20
  21 #include "OB_Filter.h"
  22 #include "OB_ListItem.h"
  23 #include "OB_ListView.h"
  24
  25 #include <qcursor.h>
  26 #include <qlayout.h>
  27 #include <qtooltip.h>
  28 #include <qpainter.h>
  29 #include <qwmatrix.h>
  30 #include <qlistview.h>
  31 #include <qpopupmenu.h>
  32
  33 /*!
  34     Class: OB_Browser::ToolTip
  35     Descr: Tool tip for OB_Browser.
  36 */
  37
  38 class OB_Browser::ToolTip : public QToolTip
  39 {
  40 public:
  41   ToolTip( OB_Browser* b, QWidget* p = 0 );
  42   virtual ~ToolTip();
  43
  44   void        maybeTip( const QPoint& );
  45
  46 private:
  47   OB_Browser* myBrowser;
  48 };
  49
  50 OB_Browser::ToolTip::ToolTip( OB_Browser* b, QWidget* p )
  51 : QToolTip( p ),
  52 myBrowser( b )
  53 {
  54 }
  55
  56 OB_Browser::ToolTip::~ToolTip()
  57 {
  58 }
  59
  60 void OB_Browser::ToolTip::maybeTip( const QPoint& pos )
  61 {
  62   if ( !parentWidget() || !myBrowser || !myBrowser->isShowToolTips() )
  63           return;
  64
  65   QListView* lv = myBrowser->listView();
  66
  67   QListViewItem* item = lv->itemAt( pos );
  68   SUIT_DataObject* obj = myBrowser->dataObject( item );
  69   if ( !obj )
  70     return;
  71
  72   QString aText = obj->toolTip();
  73
  74   if ( aText.isEmpty() )
  75     return;
  76
  77   QRect aRect = lv->itemRect( item );
  78
  79   tip( aRect, aText );
  80 }
  81
  82 /*!
  83     Class: OB_Browser
  84     Descr: Hierarchical tree object browser.
  85 */
  86
  87 OB_Browser::OB_Browser( QWidget* parent, SUIT_DataObject* root )
  88 : QFrame( parent ),
  89
  90 myRoot( 0 ),
  91 myTooltip( 0 ),
  92 myAutoOpenLevel( 0 ),
  93 myAutoUpdate( false ),
  94 myAutoDelObjs( false ),
  95 myRootDecorated( true )
  96 {
  97   myView = new OB_ListView( QtxListView::HeaderAuto, this );
  98   myView->setAppropriate( myView->addColumn( "Data" ), false );
  99   myView->setSorting( -1 );
 100   myView->setRootIsDecorated( true );
 101   myView->setSelectionMode( QListView::Extended );
 102   myView->installEventFilter( this );
 103   myView->viewport()->installEventFilter( this );
 104
 105   QVBoxLayout* main = new QVBoxLayout( this );
 106   main->addWidget( myView );
 107
 108   myShowToolTips = true;
 109   myTooltip = new ToolTip( this, myView->viewport() );
 110
 111   connect( myView, SIGNAL( dropped( QPtrList<QListViewItem>, QListViewItem*, int ) ),
 112            this, SLOT( onDropped( QPtrList<QListViewItem>, QListViewItem*, int ) ) );
 113   connect( myView, SIGNAL( selectionChanged() ), this, SIGNAL( selectionChanged() ) );
 114   connect( myView, SIGNAL( doubleClicked( QListViewItem* ) ),
 115            this, SLOT( onDoubleClicked( QListViewItem* ) ) );
 116
 117   setRootObject( root );
 118 }
 119
 120 OB_Browser::~OB_Browser()
 121 {
 122   myItems.clear();
 123   delete myTooltip;
 124 }
 125
 126 bool OB_Browser::rootIsDecorated() const
 127 {
 128   return myRootDecorated;
 129 }
 130
 131 void OB_Browser::setRootIsDecorated( const bool decor )
 132 {
 133   if ( decor == rootIsDecorated() )
 134     return;
 135
 136   myRootDecorated = decor;
 137   updateTree();
 138 }
 139
 140 int OB_Browser::autoOpenLevel() const
 141 {
 142   return myAutoOpenLevel;
 143 }
 144
 145 void OB_Browser::setAutoOpenLevel( const int level )
 146 {
 147   if ( myAutoOpenLevel == level )
 148     return;
 149
 150   myAutoOpenLevel = level;
 151
 152   autoOpenBranches();
 153 }
 154
 155 bool OB_Browser::isShowToolTips()
 156 {
 157   return myShowToolTips;
 158 }
 159
 160 void OB_Browser::setShowToolTips( const bool theDisplay )
 161 {
 162   myShowToolTips = theDisplay;
 163 }
 164
 165 bool OB_Browser::isAutoUpdate() const
 166 {
 167   return myAutoUpdate;
 168 }
 169
 170 void OB_Browser::setAutoUpdate( const bool on )
 171 {
 172   myAutoUpdate = on;
 173 }
 174
 175 bool OB_Browser::isAutoDeleteObjects() const
 176 {
 177   return myAutoDelObjs;
 178 }
 179
 180 void OB_Browser::setAutoDeleteObjects( const bool on )
 181 {
 182   myAutoDelObjs = on;
 183 }
 184
 185 SUIT_DataObject* OB_Browser::getRootObject() const
 186 {
 187   return myRoot;
 188 }
 189
 190 void OB_Browser::setRootObject( SUIT_DataObject* theRoot )
 191 {
 192   DataObjectKey curKey;
 193   DataObjectMap selObjs, openObjs;
 194   DataObjectKeyMap selKeys, openKeys;
 195
 196   int selNum = numberOfSelected();
 197
 198   SUIT_DataObject* curObj = 0;
 199   if ( theRoot )
 200     curObj = storeState( selObjs, openObjs, selKeys, openKeys, curKey );
 201
 202   removeConnections( myRoot );
 203   if ( myRoot != theRoot && isAutoDeleteObjects() )
 204     delete myRoot;
 205
 206   myRoot = theRoot;
 207
 208   createConnections( myRoot );
 209
 210   if ( myRoot )
 211     updateView( myRoot );
 212   else if ( listView() )
 213   {
 214     myItems.clear();
 215     listView()->clear();
 216   }
 217
 218   restoreState( selObjs, openObjs, curObj, selKeys, openKeys, curKey );
 219
 220   autoOpenBranches();
 221
 222   if ( selNum != numberOfSelected() )
 223     emit selectionChanged();
 224 }
 225
 226 int OB_Browser::numberOfSelected() const
 227 {
 228   int count = 0;
 229   if ( listView() )
 230   {
 231     for ( QListViewItemIterator it( listView() ); it.current(); ++it )
 232       if ( it.current()->isSelected() )
 233         count++;
 234   }
 235   return count;
 236 }
 237
 238 DataObjectList OB_Browser::getSelected() const
 239 {
 240   DataObjectList lst;
 241   getSelected( lst );
 242   return lst;
 243 }
 244
 245 void OB_Browser::getSelected( DataObjectList& theObjList ) const
 246 {
 247   theObjList.clear();
 248
 249   if ( !listView() )
 250     return;
 251
 252   for ( QListViewItemIterator it( listView() ); it.current(); ++it )
 253   {
 254     if ( it.current()->isSelected() )
 255     {
 256       SUIT_DataObject* obj = dataObject( it.current() );
 257       if ( obj )
 258         theObjList.append( obj );
 259     }
 260   }
 261 }
 262
 263 void OB_Browser::setSelected( const SUIT_DataObject* theObject, const bool append )
 264 {
 265   DataObjectList lst;
 266   lst.append( theObject );
 267   setSelected( lst, append );
 268 }
 269
 270 void OB_Browser::setSelected( const DataObjectList& theObjLst, const bool append )
 271 {
 272   QListView* lv = listView();
 273
 274   if ( !lv )
 275     return;
 276
 277   bool changed = false;
 278   bool block = lv->signalsBlocked();
 279   lv->blockSignals( true );
 280
 281   QMap<QListViewItem*, int> map;
 282   for ( DataObjectListIterator itr( theObjLst ); itr.current(); ++itr )
 283     map.insert( listViewItem( itr.current() ), 0 );
 284
 285   for ( QListViewItemIterator it( lv ); it.current(); ++it )
 286   {
 287     QListViewItem* item = it.current();
 288     if ( map.contains( item ) && !lv->isSelected( item ) )
 289     {
 290       changed = true;
 291       lv->setSelected( item, true );
 292     }
 293     if ( !append && !map.contains( item ) && lv->isSelected( item ) )
 294     {
 295       changed = true;
 296       lv->setSelected( item, false );
 297     }
 298   }
 299
 300   lv->blockSignals( block );
 301
 302   if ( changed )
 303   {
 304     int count = 0;
 305     QListViewItem* sel = 0;
 306     QListViewItem* cur = lv->currentItem();
 307     for ( QListViewItemIterator iter( lv ); iter.current() && !sel; ++iter, count++ )
 308     {
 309       if ( iter.current()->isSelected() && cur == iter.current() )
 310         sel = iter.current();
 311     }
 312
 313     for ( QListViewItemIterator itr( lv ); itr.current() && !sel; ++itr )
 314     {
 315       if ( itr.current()->isSelected() )
 316               sel = itr.current();
 317     }
 318
 319     if ( sel )
 320       lv->setCurrentItem( sel );
 321
 322     if ( sel && count == 1 )
 323       lv->ensureItemVisible( sel );
 324
 325     emit selectionChanged();
 326   }
 327 }
 328
 329 bool OB_Browser::isOpen( SUIT_DataObject* theObject ) const
 330 {
 331   bool res = false;
 332   if ( listView() )
 333     res = listView()->isOpen( listViewItem( theObject ) );
 334   return res;
 335 }
 336
 337 void OB_Browser::setOpen( SUIT_DataObject* theObject, const bool theOpen )
 338 {
 339   if ( listView() )
 340     listView()->setOpen( listViewItem( theObject ), theOpen );
 341 }
 342
 343 SUIT_DataObject* OB_Browser::dataObjectAt( const QPoint& pos ) const
 344 {
 345   SUIT_DataObject* obj = 0;
 346
 347   QListView* lv = listView();
 348   if ( lv )
 349     obj = dataObject( lv->itemAt( pos ) );
 350
 351   return obj;
 352 }
 353
 354 OB_Filter* OB_Browser::filter() const
 355 {
 356   return myView->filter();
 357 }
 358
 359 void OB_Browser::setFilter( OB_Filter* f )
 360 {
 361   myView->setFilter( f );
 362 }
 363
 364 int OB_Browser::addColumn( const QString& label, const int id, const int width )
 365 {
 366   return addColumn( QIconSet(), label, id, width );
 367 }
 368
 369 int OB_Browser::addColumn( const QIconSet& icon, const QString& label, const int id, const int width )
 370 {
 371   QListView* lv = listView();
 372   if ( !lv )
 373     return -1;
 374
 375   int theId = id;
 376   if ( theId < 0 )
 377   {
 378     while ( myColumnIds.contains( theId ) )
 379       theId++;
 380   }
 381
 382   if ( myColumnIds.contains( theId ) )
 383     return -1; // can not reuse id
 384
 385   int sec = -1;
 386   if ( icon.isNull() )
 387     sec = lv->addColumn( label, width );
 388   else
 389     sec = lv->addColumn( icon, label, width );
 390
 391   if ( sec == -1 )
 392     return -1;
 393
 394   myColumnIds.insert( theId, sec );
 395   updateText();
 396
 397   return theId;
 398 }
 399
 400 void OB_Browser::removeColumn( const int id )
 401 {
 402   QListView* lv = listView();
 403   if ( !lv || !myColumnIds.contains( id ) )
 404     return;
 405
 406   int sec = myColumnIds[id];
 407   lv->removeColumn( sec );
 408
 409   // update map of column indeces
 410   myColumnIds.remove( id );
 411   for ( QMap<int, int>::iterator it = myColumnIds.begin(); it != myColumnIds.end(); ++it )
 412   {
 413     if ( it.key() > id )
 414       it.data()--;
 415   }
 416   updateText();
 417 }
 418
 419 void OB_Browser::setNameTitle( const QString& label )
 420 {
 421   setNameTitle( QIconSet(), label );
 422 }
 423
 424 void OB_Browser::setNameTitle( const QIconSet& icon, const QString& label )
 425 {
 426   QListView* lv = listView();
 427   if ( !lv )
 428     return;
 429
 430   if ( icon.isNull() )
 431     lv->setColumnText( 0, label );
 432   else
 433     lv->setColumnText( 0, icon, label );
 434 }
 435
 436 void OB_Browser::setColumnTitle( const int id, const QString& label )
 437 {
 438   setColumnTitle( id, QIconSet(), label );
 439 }
 440
 441 void OB_Browser::setColumnTitle( const int id, const QIconSet& icon, const QString& label )
 442 {
 443   QListView* lv = listView();
 444   if ( !lv || !myColumnIds.contains( id ) )
 445     return;
 446
 447   if ( icon.isNull() )
 448     lv->setColumnText( myColumnIds[id], label );
 449   else
 450     lv->setColumnText( myColumnIds[id], icon, label );
 451 }
 452
 453 QString OB_Browser::nameTitle() const
 454 {
 455   return myView->columnText( 0 );
 456 }
 457
 458 QString OB_Browser::columnTitle( const int id ) const
 459 {
 460   QString txt;
 461   if ( myColumnIds.contains( id ) )
 462     txt = myView->columnText( myColumnIds[id] );
 463   return txt;
 464 }
 465
 466 bool OB_Browser::isColumnVisible( const int id ) const
 467 {
 468   return myColumnIds.contains( id ) && myView->isShown( myColumnIds[id] );
 469 }
 470
 471 void OB_Browser::setColumnShown( const int id, const bool on )
 472 {
 473   if ( !myColumnIds.contains( id ) )
 474     return;
 475
 476   myView->setShown( myColumnIds[id], on );
 477 }
 478
 479 void OB_Browser::setWidthMode( QListView::WidthMode mode )
 480 {
 481   for ( int i = 0, n = myView->columns(); i < n; i++ )
 482     myView->setColumnWidthMode( i, mode );
 483 }
 484
 485 QValueList<int> OB_Browser::columns() const
 486 {
 487   QValueList<int> lst;
 488   for ( QMap<int, int>::ConstIterator it = myColumnIds.begin(); it != myColumnIds.end(); ++it )
 489     lst.append( it.key() );
 490   return lst;
 491 }
 492
 493 bool OB_Browser::appropriateColumn( const int id ) const
 494 {
 495   bool res = false;
 496   if ( myColumnIds.contains( id ) )
 497     res = myView->appropriate( myColumnIds[id] );
 498   return res;
 499 }
 500
 501 void OB_Browser::setAppropriateColumn( const int id, const bool on )
 502 {
 503   if ( !myColumnIds.contains( id ) )
 504     return;
 505
 506   myView->setAppropriate( myColumnIds[id], on );
 507 }
 508
 509 void OB_Browser::updateTree( SUIT_DataObject* obj )
 510 {
 511   if ( !obj && !(obj = getRootObject()) )
 512     return;
 513
 514   DataObjectKey curKey;
 515   DataObjectMap selObjs, openObjs;
 516   DataObjectKeyMap selKeys, openKeys;
 517
 518   int selNum = numberOfSelected();
 519
 520   SUIT_DataObject* curObj = storeState( selObjs, openObjs, selKeys, openKeys, curKey );
 521
 522   updateView( obj );
 523
 524   restoreState( selObjs, openObjs, curObj, selKeys, openKeys, curKey );
 525
 526   autoOpenBranches();
 527
 528   if ( selNum != numberOfSelected() )
 529     emit selectionChanged();
 530 }
 531
 532 void OB_Browser::replaceTree( SUIT_DataObject* src, SUIT_DataObject* trg )
 533 {
 534   if ( !src || !trg || src == trg || src->root() != getRootObject() )
 535     return;
 536
 537   DataObjectKey curKey;
 538   DataObjectMap selObjs, openObjs;
 539   DataObjectKeyMap selKeys, openKeys;
 540
 541   int selNum = numberOfSelected();
 542
 543   SUIT_DataObject* curObj = storeState( selObjs, openObjs, selKeys, openKeys, curKey );
 544
 545   SUIT_DataObject* parent = src->parent();
 546   int pos = parent ? parent->childPos( src ) : -1;
 547
 548   src->setParent( 0 );
 549
 550   removeConnections( src );
 551   if ( isAutoDeleteObjects() )
 552     delete src;
 553
 554   if ( parent && pos != -1 )
 555     parent->insertChild( trg, pos );
 556
 557   trg->setParent( parent );
 558
 559   updateView( trg );
 560   createConnections( trg );
 561
 562   restoreState( selObjs, openObjs, curObj, selKeys, openKeys, curKey );
 563
 564   autoOpenBranches();
 565
 566   if ( selNum != numberOfSelected() )
 567     emit selectionChanged();
 568 }
 569
 570 void OB_Browser::updateView( const SUIT_DataObject* theStartObj )
 571 {
 572   QListView* lv = listView();
 573   if ( !lv )
 574     return;
 575
 576   if ( !theStartObj || theStartObj->root() != getRootObject() )
 577     return;
 578
 579   QListViewItem* after = 0;
 580   QListViewItem* parent = 0;
 581   QListViewItem* startItem = listViewItem( theStartObj );
 582
 583   if ( theStartObj->parent() )
 584     parent = listViewItem( theStartObj->parent() );
 585
 586   QListViewItem* prv = 0;
 587   QListViewItem* cur = parent ? parent->firstChild() : lv->firstChild();
 588   while ( !after && cur )
 589   {
 590     if ( cur == startItem )
 591       after = prv;
 592
 593     prv = cur;
 594     cur = cur->nextSibling();
 595   }
 596
 597   QPtrList<QListViewItem> delList;
 598   if ( !startItem && theStartObj == getRootObject() )
 599   {
 600     for ( QListViewItem* item = lv->firstChild(); item; item = item->nextSibling() )
 601       delList.append( item );
 602   }
 603   else
 604     delList.append( startItem );
 605
 606   for ( QPtrListIterator<QListViewItem> it( delList ); it.current(); ++it )
 607   {
 608     removeReferences( it.current() );
 609     delete it.current();
 610   }
 611
 612   // for myRoot object, if myShowRoot==false, then creating multiple top-level QListViewItem-s
 613   // (which will correspond to myRoot's children = Modules).
 614   if ( rootIsDecorated() && theStartObj == myRoot )
 615   {
 616     DataObjectList lst;
 617     theStartObj->children( lst );
 618     DataObjectListIterator it ( lst );
 619     // iterating backward to preserve the order of elements in the tree
 620     for ( it.toLast(); it.current(); --it )
 621       createTree( it.current(), 0, 0 );
 622   }
 623   else
 624     createTree( theStartObj, parent, after ? after : parent );
 625 }
 626
 627 QListViewItem* OB_Browser::createTree( const SUIT_DataObject* obj,
 628                                        QListViewItem* parent, QListViewItem* after )
 629 {
 630   if ( !obj )
 631     return 0;
 632
 633   QListViewItem* item = createItem( obj, parent, after );
 634
 635   DataObjectList lst;
 636   obj->children( lst );
 637   for ( DataObjectListIterator it ( lst ); it.current(); ++it )
 638     createTree( it.current(), item );
 639
 640   if ( item )
 641     item->setOpen( obj->isOpen() );
 642
 643   return item;
 644 }
 645
 646 QListViewItem* OB_Browser::createItem( const SUIT_DataObject* o,
 647                                        QListViewItem* parent, QListViewItem* after )
 648 {
 649   QListView* lv = listView();
 650
 651   if ( !lv || !o )
 652     return 0;
 653
 654   QListViewItem* item = 0;
 655   SUIT_DataObject* obj = (SUIT_DataObject*)o;
 656
 657   int type = -1;
 658
 659   switch ( obj->checkType() )
 660   {
 661   case SUIT_DataObject::CheckBox:
 662     type = QCheckListItem::CheckBox;
 663     break;
 664   case SUIT_DataObject::RadioButton:
 665     type = QCheckListItem::RadioButton;
 666     break;
 667   }
 668
 669   if ( parent )
 670   {
 671     if ( parent->childCount() && !after )
 672     {
 673       after = parent->firstChild();
 674       while ( after->nextSibling() )
 675         after = after->nextSibling();
 676     }
 677
 678     if ( after )
 679     {
 680       if ( type == -1 )
 681         item = new OB_ListItem( obj, parent, after );
 682       else
 683         item = new OB_CheckListItem( obj, parent, after, (QCheckListItem::Type)type );
 684     }
 685     else
 686     {
 687       if ( type == -1 )
 688         item = new OB_ListItem( obj, parent );
 689       else
 690         item = new OB_CheckListItem( obj, parent,  (QCheckListItem::Type)type );
 691     }
 692   }
 693   else // ROOT item
 694   {
 695     if ( type == -1 )
 696       item = new OB_ListItem( obj, lv );
 697     else
 698       item = new OB_CheckListItem( obj, lv,  (QCheckListItem::Type)type );
 699   }
 700
 701   myItems.insert( obj, item );
 702   obj->connect( this, SLOT( onDestroyed( SUIT_DataObject* ) ) );
 703
 704   updateText( item );
 705
 706   return item;
 707 }
 708
 709 void OB_Browser::adjustWidth()
 710 {
 711   if ( !listView() )
 712     return;
 713
 714   listView()->setColumnWidth( 0, 0 );
 715   if ( listView()->firstChild() )
 716     adjustWidth( listView()->firstChild() );
 717 }
 718
 719 void OB_Browser::adjustWidth( QListViewItem* item )
 720 {
 721   while ( item )
 722   {
 723     item->widthChanged( 0 );
 724     if ( item->isOpen() )
 725       adjustWidth( item->firstChild() );
 726     item = item->nextSibling();
 727   }
 728 }
 729
 730 SUIT_DataObject* OB_Browser::dataObject( const QListViewItem* item ) const
 731 {
 732   SUIT_DataObject* obj = 0;
 733
 734   if ( item && item->rtti() == OB_ListItem::RTTI() )
 735     obj = ((OB_ListItem*)item)->dataObject();
 736   else if ( item && item->rtti() == OB_CheckListItem::RTTI() )
 737     obj = ((OB_CheckListItem*)item)->dataObject();
 738
 739   return obj;
 740 }
 741
 742 QListViewItem* OB_Browser::listViewItem( const SUIT_DataObject* obj ) const
 743 {
 744   QListViewItem* item = 0;
 745
 746   if ( myItems.contains( (SUIT_DataObject*)obj ) )
 747     item = myItems[(SUIT_DataObject*)obj];
 748
 749   return item;
 750 }
 751
 752 QListView* OB_Browser::listView() const
 753 {
 754   return myView;
 755 }
 756
 757 void OB_Browser::removeReferences( QListViewItem* item )
 758 {
 759   if ( !item )
 760     return;
 761
 762   SUIT_DataObject* obj = dataObject( item );
 763   obj->disconnect( this, SLOT( onDestroyed( SUIT_DataObject* ) ) );
 764   myItems.remove( obj );
 765
 766   QListViewItem* i = item->firstChild();
 767   while ( i )
 768   {
 769     removeReferences( i );
 770     i = i->nextSibling();
 771   }
 772 }
 773
 774 void OB_Browser::createConnections( SUIT_DataObject* obj )
 775 {
 776   if ( !obj )
 777     return;
 778
 779   DataObjectList childList;
 780   obj->children( childList, true );
 781
 782   childList.prepend( obj );
 783
 784   for ( DataObjectListIterator it( childList ); it.current(); ++it )
 785     it.current()->connect( this, SLOT( onDestroyed( SUIT_DataObject* ) ) );
 786 }
 787
 788 void OB_Browser::removeConnections( SUIT_DataObject* obj )
 789 {
 790   if ( !obj )
 791     return;
 792
 793   DataObjectList childList;
 794   obj->children( childList, true );
 795
 796   childList.prepend( obj );
 797
 798   for ( DataObjectListIterator it( childList ); it.current(); ++it )
 799     it.current()->disconnect( this, SLOT( onDestroyed( SUIT_DataObject* ) ) );
 800 }
 801
 802 SUIT_DataObject* OB_Browser::storeState( DataObjectMap& selObjs, DataObjectMap& openObjs,
 803                                          DataObjectKeyMap& selKeys, DataObjectKeyMap& openKeys,
 804                                          DataObjectKey& curKey ) const
 805 {
 806   QListView* lv = listView();
 807   if ( !lv )
 808     return 0;
 809
 810   SUIT_DataObject* curObj = dataObject( lv->currentItem() );
 811
 812   curKey = objectKey( curObj );
 813
 814   for ( QListViewItemIterator it( lv ); it.current(); ++it )
 815   {
 816     SUIT_DataObject* obj = dataObject( it.current() );
 817     if ( !obj )
 818       continue;
 819
 820     selObjs.insert( obj, lv->isSelected( it.current() ) );
 821     openObjs.insert( obj, lv->isOpen( it.current() ) );
 822     if ( lv->isSelected( it.current() ) )
 823       selKeys.insert( objectKey( obj ), 0 );
 824     if ( lv->isOpen( it.current() ) )
 825       openKeys.insert( objectKey( obj ), 0 );
 826   }
 827
 828   return curObj;
 829 }
 830
 831 void OB_Browser::restoreState( const DataObjectMap& selObjs, const DataObjectMap& openObjs,
 832                                const SUIT_DataObject* curObj, const DataObjectKeyMap& selKeys,
 833                                const DataObjectKeyMap& openKeys, const DataObjectKey& curKey )
 834 {
 835   QListView* lv = listView();
 836   if ( !lv )
 837     return;
 838
 839   bool block = lv->signalsBlocked();
 840   lv->blockSignals( true );
 841
 842   QListViewItem* curItem = 0;
 843   for ( QListViewItemIterator it( lv ); it.current(); ++it )
 844   {
 845     QListViewItem* item = it.current();
 846     SUIT_DataObject* obj = dataObject( item );
 847
 848     if ( !obj )
 849       continue;
 850
 851     DataObjectKey key = objectKey( obj );
 852
 853     if ( selObjs.contains( obj ) )
 854     {
 855       if ( selObjs[obj] && !lv->isSelected( item ) )
 856         lv->setSelected( item, true );
 857     }
 858     else if ( !key.isNull() && selKeys.contains( key ) && !lv->isSelected( item ) )
 859       lv->setSelected( item, true );
 860
 861     if ( openObjs.contains( obj ) )
 862     {
 863       if ( openObjs[obj] )
 864         lv->setOpen( item, true );
 865     }
 866     else if ( !key.isNull() && openKeys.contains( key ) )
 867       lv->setOpen( item, true );
 868
 869     if ( !curItem && ( curObj == obj || ( !curKey.isNull() && curKey == key )) )
 870       curItem = item;
 871   }
 872
 873   if ( curItem )
 874     lv->setCurrentItem( curItem );
 875
 876   lv->blockSignals( block );
 877 }
 878
 879 OB_Browser::DataObjectKey OB_Browser::objectKey( QListViewItem* i ) const
 880 {
 881   return objectKey( dataObject( i ) );
 882 }
 883
 884 OB_Browser::DataObjectKey OB_Browser::objectKey( SUIT_DataObject* obj ) const
 885 {
 886   if ( !obj )
 887     return 0;
 888
 889   return DataObjectKey( obj->key() );
 890 }
 891
 892 void OB_Browser::keyPressEvent( QKeyEvent* e )
 893 {
 894   if ( e->key() == Qt::Key_F5 )
 895     updateTree();
 896
 897   QFrame::keyPressEvent( e );
 898 }
 899
 900 void OB_Browser::onExpand()
 901 {
 902   DataObjectList selected;
 903   getSelected( selected );
 904   for ( DataObjectListIterator itr( selected ); itr.current(); ++itr )
 905     expand( listViewItem( itr.current() ) );
 906 }
 907
 908 void OB_Browser::onColumnVisible( int id )
 909 {
 910   setColumnShown( id, !isColumnVisible( id ) );
 911 }
 912
 913 void OB_Browser::onDestroyed( SUIT_DataObject* obj )
 914 {
 915   removeObject( obj );
 916 }
 917
 918 void OB_Browser::onDropped( QPtrList<QListViewItem> items, QListViewItem* item, int action )
 919 {
 920   SUIT_DataObject* obj = dataObject( item );
 921   if ( !obj )
 922     return;
 923
 924   DataObjectList lst;
 925   for ( QPtrListIterator<QListViewItem> it( items ); it.current(); ++it )
 926   {
 927     SUIT_DataObject* o = dataObject( it.current() );
 928     if ( o )
 929       lst.append( o );
 930   }
 931
 932   if ( !lst.isEmpty() )
 933     emit dropped( lst, obj, action );
 934 }
 935
 936 void OB_Browser::updateText()
 937 {
 938   if ( myColumnIds.isEmpty() )
 939     return;
 940
 941   QListView* lv = listView();
 942   if ( !lv )
 943     return;
 944
 945   for ( QListViewItemIterator it( lv ); it.current(); ++it )
 946   {
 947     SUIT_DataObject* obj = dataObject( it.current() );
 948     if ( !obj )
 949       continue;
 950
 951     for( QMap<int, int>::iterator itr = myColumnIds.begin(); itr != myColumnIds.end(); ++itr )
 952       it.current()->setText( itr.data(), obj->text( itr.key() ) );
 953   }
 954 }
 955
 956 void OB_Browser::updateText( QListViewItem* item )
 957 {
 958   SUIT_DataObject* obj = dataObject( item );
 959   if ( !obj )
 960     return;
 961
 962   for( QMap<int, int>::iterator it = myColumnIds.begin(); it != myColumnIds.end(); ++it )
 963     item->setText( it.data(), obj->text( it.key() ) );
 964 }
 965
 966 bool OB_Browser::eventFilter( QObject* o, QEvent* e )
 967 {
 968   if ( o == myView && e->type() == QEvent::ContextMenu )
 969   {
 970     QContextMenuEvent* ce = (QContextMenuEvent*)e;
 971     if ( ce->reason() != QContextMenuEvent::Mouse )
 972       contextMenuRequest( ce );
 973     return true;
 974   }
 975   if ( o == myView->viewport() && e->type() == QEvent::MouseButtonRelease )
 976   {
 977     QMouseEvent* me = (QMouseEvent*)e;
 978     if ( me->button() == RightButton )
 979     {
 980       QContextMenuEvent ce( QContextMenuEvent::Mouse, me->pos(), me->globalPos(), me->state() );
 981       contextMenuRequest( &ce );
 982       return true;
 983     }
 984   }
 985
 986   return QFrame::eventFilter( o, e );
 987 }
 988
 989 void OB_Browser::contextMenuPopup( QPopupMenu* menu )
 990 {
 991 /*  QValueList<int> cols;
 992   for ( QMap<int, int>::ConstIterator it = myColumnIds.begin(); it != myColumnIds.end(); ++it )
 993   {
 994     if ( appropriateColumn( it.key() ) )
 995       cols.append( it.key() );
 996   }
 997
 998   uint num = menu->count();
 999   menu->setCheckable( true );
1000   for ( QValueList<int>::const_iterator iter = cols.begin(); iter != cols.end(); ++iter )
1001   {
1002     QString name = columnTitle( *iter );
1003     if ( name.isEmpty() )
1004       continue;
1005
1006     int id = menu->insertItem( name, this, SLOT( onColumnVisible( int ) ) );
1007     menu->setItemChecked( id, isColumnVisible( *iter ) );
1008     menu->setItemParameter( id, *iter );
1009   }
1010   if ( menu->count() != num )
1011     menu->insertSeparator();*/
1012
1013   DataObjectList selected;
1014   getSelected( selected );
1015
1016   bool closed = false;
1017   for ( DataObjectListIterator itr( selected ); itr.current() && !closed; ++itr )
1018     closed = hasClosed( listViewItem( itr.current() ) );
1019
1020   if ( closed )
1021   {
1022     menu->insertItem( tr( "MEN_EXPAND_ALL" ), this, SLOT( onExpand() ) );
1023     menu->insertSeparator();
1024   }
1025 }
1026
1027 void OB_Browser::expand( QListViewItem* item )
1028 {
1029   if ( !item )
1030     return;
1031
1032   item->setOpen( true );
1033   for ( QListViewItem* child = item->firstChild(); child; child = child->nextSibling() )
1034     expand( child );
1035 }
1036
1037 bool OB_Browser::hasClosed( QListViewItem* item ) const
1038 {
1039   if ( !item )
1040     return false;
1041
1042   if ( item->childCount() && !item->isOpen() )
1043     return true;
1044
1045   bool has = false;
1046   for ( QListViewItem* child = item->firstChild(); child && !has; child = child->nextSibling() )
1047     has = hasClosed( child );
1048
1049   return has;
1050 }
1051
1052 void OB_Browser::removeObject( SUIT_DataObject* obj, const bool autoUpd )
1053 {
1054   if ( !obj )
1055     return;
1056
1057   // Removing list view items from <myItems> recursively for all children.
1058   // Otherwise, "delete item" line will destroy all item's children,
1059   // and <myItems> will contain invalid pointers (see ~QListViewItem() description in Qt docs)
1060   DataObjectList childList;
1061   obj->children( childList, true );
1062   for ( DataObjectListIterator it( childList ); it.current(); ++it )
1063   {
1064     it.current()->disconnect( this, SLOT( onDestroyed( SUIT_DataObject* ) ) );
1065     myItems.remove( it.current() );
1066   }
1067
1068   QListViewItem* item = listViewItem( obj );
1069
1070   obj->disconnect( this, SLOT( onDestroyed( SUIT_DataObject* ) ) );
1071   myItems.remove( obj );
1072
1073   if ( obj == myRoot )
1074   {
1075     // remove all child list view items
1076     setRootObject( 0 );
1077     return;
1078   }
1079
1080   if ( !autoUpd )
1081     return;
1082
1083   if ( isAutoUpdate() )
1084   {
1085     SUIT_DataObject* pObj = item && item->parent() ? dataObject( item->parent() ) : 0;
1086     updateTree( pObj );
1087   }
1088   else
1089     delete item;
1090 }
1091
1092 void OB_Browser::autoOpenBranches()
1093 {
1094   int level = autoOpenLevel();
1095   QListView* lv = listView();
1096   if ( !lv || level < 1 )
1097     return;
1098
1099   QListViewItem* item = lv->firstChild();
1100   while ( item )
1101   {
1102     openBranch( item, level );
1103     item = item->nextSibling();
1104   }
1105 }
1106
1107 void OB_Browser::openBranch( QListViewItem* item, const int level )
1108 {
1109   if ( level < 1 )
1110     return;
1111
1112   while ( item )
1113   {
1114     item->setOpen( true );
1115     openBranch( item->firstChild(), level - 1 );
1116     item = item->nextSibling();
1117   }
1118 }
1119
1120 void OB_Browser::onDoubleClicked( QListViewItem* item )
1121 {
1122   if ( item )
1123     emit doubleClicked( dataObject( item ) );
1124 }