src/CurveCreator/CurveCreator_TreeView.cxx

   1 // Copyright (C) 2013  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.
   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 "CurveCreator_TreeView.h"
  21 #include "CurveCreator_Curve.hxx"
  22
  23 #include <SUIT_Session.h>
  24 #include <SUIT_ResourceMgr.h>
  25
  26 #include <QHeaderView>
  27 #include <QtAlgorithms>
  28
  29 #define ID_SECTION -1
  30
  31 CurveCreator_TreeViewModel::CurveCreator_TreeViewModel( CurveCreator_Curve* theCurve, QObject* parent ) :
  32   QAbstractItemModel(parent), myCurve(theCurve)
  33 {
  34   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
  35   QPixmap aSplineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
  36   QPixmap aPolylineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
  37   QPixmap aClosedSplineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_CLOSED_SPLINE")));
  38   QPixmap aClosedPolylineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_CLOSED_POLYLINE")));
  39   QPixmap aPointIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POINT")));
  40
  41 /*  QPixmap aSplineIcon(tr(":images/ICON_SPLINE"));
  42   QPixmap aPolylineIcon(tr(":images/ICON_POLYLINE"));
  43   QPixmap aClosedPolylineIcon(tr(":images/ICON_CLOSED_POLYLINE"));
  44   QPixmap aClosedSplineIcon(tr(":images/ICON_CLOSED_SPLINE"));
  45   QPixmap aPointIcon(tr(":images/ICON_POINT")); */
  46
  47   if( !aSplineIcon.isNull() )
  48     myCachedIcons[ICON_SPLINE] = aSplineIcon;
  49
  50   if( !aPolylineIcon.isNull() )
  51     myCachedIcons[ICON_POLYLINE] = aPolylineIcon;
  52
  53   if( !aPolylineIcon.isNull() )
  54     myCachedIcons[ICON_CLOSED_POLYLINE] = aClosedPolylineIcon;
  55
  56   if( !aPolylineIcon.isNull() )
  57     myCachedIcons[ICON_CLOSED_SPLINE] = aClosedSplineIcon;
  58
  59   if( !aPointIcon.isNull() )
  60     myCachedIcons[ICON_POINT] = aPointIcon;
  61
  62   setHeaderData(1, Qt::Horizontal, QVariant("Name"), Qt::DisplayRole);
  63   setHeaderData(2, Qt::Horizontal, QVariant("Nb points"), Qt::DisplayRole);
  64 }
  65
  66 int     CurveCreator_TreeViewModel::columnCount(const QModelIndex & parent ) const
  67 {
  68   if( parent.internalId() == ID_SECTION )
  69     return 2;
  70   else
  71     return 2;
  72 }
  73
  74 QVariant        CurveCreator_TreeViewModel::data(const QModelIndex & index, int role ) const
  75 {
  76   int aRow = index.row();
  77   int aColumn = index.column();
  78   if( myCurve ){
  79     if( index.internalId() == ID_SECTION ){
  80       if( role == Qt::DisplayRole ){
  81         if( aColumn == 0 )
  82           return QString::fromStdString(myCurve->getSectionName(aRow));
  83         else if( aColumn == 1 )
  84           return QString::number(myCurve->getNbPoints(aRow));
  85         return QVariant();
  86       }
  87       else if( role == Qt::DecorationRole ){
  88         if( aColumn == 0 ){
  89           CurveCreator::Type aSectionType = myCurve->getType(aRow);
  90           if( aSectionType == CurveCreator::Polyline ){
  91             if( myCurve->isClosed(aRow) ){
  92               return myCachedIcons[ICON_CLOSED_POLYLINE];
  93             }
  94             else{
  95               return myCachedIcons[ICON_POLYLINE];
  96             }
  97           }
  98           else{
  99             if( myCurve->isClosed(aRow) ){
 100               return myCachedIcons[ICON_CLOSED_SPLINE];
 101             }
 102             else{
 103               return myCachedIcons[ICON_SPLINE];
 104             }
 105           }
 106         }
 107       }
 108     }
 109 /*    else{
 110       if( role == Qt::DisplayRole ){
 111         if( aColumn == 1 )
 112           return QVariant();
 113         //                    return "Point";
 114         else if( aColumn == 0 ){
 115           CurveCreator::Coordinates aCoords = myCurve->getCoordinates(index.internalId(),index.row() );
 116           QString anOut;
 117           if( myCurve->getDimension() == CurveCreator::Dim2d ){
 118             anOut = QString(tr("X=%1, Y=%2")).arg(aCoords[0]).arg(aCoords[1]);
 119           }
 120           else{
 121             anOut = QString(tr("X=%1, Y=%2, Z=%3")).arg(aCoords[0]).arg(aCoords[1]).arg(aCoords[2]);
 122           }
 123           return anOut;
 124         }
 125       }
 126       else if( role == Qt::DecorationRole ){
 127         if( aColumn == 0 ){
 128           return myCachedIcons[ICON_POINT];
 129         }
 130       }
 131     }*/
 132   }
 133   return QVariant();
 134 }
 135
 136 QModelIndex     CurveCreator_TreeViewModel::index(int row, int column, const QModelIndex & parent ) const
 137 {
 138   if( parent.isValid() ){
 139     return createIndex(row, column, parent.row() );
 140   }
 141   else{
 142     QModelIndex aParent = createIndex(row, column, ID_SECTION );
 143     return aParent;
 144   }
 145   return QModelIndex();
 146 }
 147
 148 QModelIndex     CurveCreator_TreeViewModel::parent(const QModelIndex & theIndex) const
 149 {
 150   if( !theIndex.isValid() )
 151     return QModelIndex();
 152
 153   if( theIndex.internalId() == ID_SECTION ){
 154     return QModelIndex();
 155   }
 156   return createIndex( theIndex.internalId(), 0, ID_SECTION  );
 157 }
 158
 159 int     CurveCreator_TreeViewModel::rowCount(const QModelIndex & parent ) const
 160 {
 161   int aRowCnt = 0;
 162   if( myCurve != NULL ){
 163     if( !parent.isValid() ){
 164       //Points level
 165       aRowCnt =  myCurve->getNbSections();
 166     }
 167     else{
 168       //Section level
 169       if( parent.internalId() == ID_SECTION ){
 170         aRowCnt = myCurve->getNbPoints(parent.row());
 171       }
 172     }
 173   }
 174   return aRowCnt;
 175 }
 176
 177 QModelIndex CurveCreator_TreeViewModel::sectionIndex( int theSection ) const
 178 {
 179   return createIndex( theSection, 0, ID_SECTION );
 180 }
 181
 182 QModelIndex CurveCreator_TreeViewModel::nbPointsIndex( int theSection ) const
 183 {
 184   return createIndex( theSection, 1, ID_SECTION );
 185 }
 186
 187 QModelIndex CurveCreator_TreeViewModel::pointIndex( int theSection, int thePoint ) const
 188 {
 189   return createIndex( thePoint, 0, theSection );
 190 }
 191
 192 bool CurveCreator_TreeViewModel::isSection( const QModelIndex& theIndx ) const
 193 {
 194   if( theIndx.internalId() == ID_SECTION )
 195     return true;
 196   return false;
 197 }
 198
 199 int CurveCreator_TreeViewModel::getSection( const QModelIndex& theIndx ) const
 200 {
 201   if( theIndx.internalId() == ID_SECTION )
 202     return theIndx.row();
 203   return theIndx.internalId();
 204 }
 205
 206 int CurveCreator_TreeViewModel::getPoint( const QModelIndex& theIndx ) const
 207 {
 208   if( theIndx.internalId() == ID_SECTION )
 209     return -1;
 210   return theIndx.row();
 211 }
 212
 213 void CurveCreator_TreeViewModel::setCurve( CurveCreator_Curve* theCurve )
 214 {
 215   myCurve = theCurve;
 216   reset();
 217 }
 218
 219 /*****************************************************************************************/
 220 CurveCreator_TreeView::CurveCreator_TreeView( CurveCreator_Curve* theCurve, QWidget *parent) :
 221   QTreeView(parent)
 222 {
 223   header()->hide();
 224   header()->setResizeMode(QHeaderView::ResizeToContents);
 225   setUniformRowHeights(true);
 226   setContextMenuPolicy( Qt::CustomContextMenu );
 227   CurveCreator_TreeViewModel* aModel = new CurveCreator_TreeViewModel(theCurve, this);
 228   setModel(aModel);
 229   setSelectionBehavior(SelectRows);
 230   setSelectionMode(SingleSelection);
 231   setRootIsDecorated(false);
 232   setItemsExpandable(false);
 233   setAllColumnsShowFocus(true);
 234   connect( selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 235            this, SIGNAL(selectionChanged()) );
 236   connect( this, SIGNAL(activated(QModelIndex)), this, SLOT(onActivated(QModelIndex)));
 237 }
 238
 239 QList<int> CurveCreator_TreeView::getSelectedSections() const
 240 {
 241   QList<int> aSect;
 242   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 243   if( !aModel )
 244     return aSect;
 245 //  QModelIndexList anIndxs = selectionModel()->selectedIndexes();
 246   QModelIndexList anIndxs = selectionModel()->selectedRows();
 247   for( int i = 0 ; i < anIndxs.size() ; i++ ){
 248     if( aModel->isSection(anIndxs[i]) ){
 249       aSect << aModel->getSection( anIndxs[i] );
 250     }
 251   }
 252   qSort(aSect.begin(), aSect.end());
 253   return aSect;
 254 }
 255
 256 void CurveCreator_TreeView::pointsAdded( int theSection, int thePoint, int thePointsCnt )
 257 {
 258   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 259   if( aModel ){
 260     QModelIndex aSectIndx = aModel->sectionIndex( theSection );
 261     rowsInserted(aSectIndx, thePoint, thePoint + thePointsCnt - 1 );
 262 //    expand( aSectIndx );
 263     update( aModel->nbPointsIndex( theSection ) );
 264   }
 265 }
 266
 267 void CurveCreator_TreeView::pointDataChanged( int theSection, int thePoint )
 268 {
 269   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 270   if( aModel ){
 271     QModelIndex aPointIndx = aModel->pointIndex( theSection, thePoint );
 272     dataChanged( aPointIndx, aPointIndx );
 273   }
 274 }
 275
 276 void CurveCreator_TreeView::pointsRemoved( int theSection, int thePoint, int thePointsCnt )
 277 {
 278   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 279   if( aModel ){
 280     for( int i = 0 ; i < thePointsCnt ; i++ ){
 281       QModelIndex aSectIndx = aModel->pointIndex(theSection, thePoint + i);
 282       selectionModel()->select(aSectIndx,QItemSelectionModel::Deselect);
 283     }
 284     QModelIndex aSectIndx = aModel->sectionIndex( theSection );
 285     rowsRemoved(aSectIndx, thePoint, thePoint + thePointsCnt - 1 );
 286   }
 287 }
 288
 289 void CurveCreator_TreeView::sectionAdded( int theSection )
 290 {
 291   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 292   if( aModel ){
 293     rowsInserted(QModelIndex(), theSection, theSection );
 294   }
 295 }
 296
 297 void CurveCreator_TreeView::sectionChanged( int theSection, int aSectCnt )
 298 {
 299   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 300   if( aModel ){
 301     QModelIndex aFirstSectIndx = aModel->sectionIndex( theSection );
 302     QModelIndex aLastSectIndx = aModel->sectionIndex( theSection + aSectCnt - 1);
 303     dataChanged( aFirstSectIndx, aLastSectIndx );
 304   }
 305 }
 306
 307 void CurveCreator_TreeView::sectionsRemoved( int theSection, int theSectionCnt )
 308 {
 309   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 310   if( aModel ){
 311     for( int i = 0 ; i < theSectionCnt ; i++ ){
 312       QModelIndex aSectIndx = aModel->sectionIndex(theSection + i);
 313       this->selectionModel()->select(aSectIndx,QItemSelectionModel::Deselect);
 314     }
 315     rowsRemoved( QModelIndex(), theSection, theSection+theSectionCnt-1 );
 316   }
 317 }
 318
 319 void CurveCreator_TreeView::setIndexState( const QModelIndex& theIndx, bool& isExpanded, bool& isSelected, bool& isCurrent )
 320 {
 321   setExpanded( theIndx, isExpanded );
 322   QItemSelectionModel::SelectionFlags aFlag = QItemSelectionModel::Select;
 323   if( !isSelected ){
 324     aFlag = QItemSelectionModel::Deselect;
 325   }
 326   selectionModel()->select( theIndx, aFlag );
 327 }
 328
 329 void CurveCreator_TreeView::getIndexInfo( const QModelIndex& theIndx, bool& isExpand, bool& isSelected, bool& isCurrent )
 330 {
 331   isExpand = isExpanded(theIndx);
 332   isSelected = selectionModel()->isSelected(theIndx);
 333   isCurrent = (theIndx == selectionModel()->currentIndex());
 334 }
 335
 336 void CurveCreator_TreeView::swapIndexes( const QModelIndex& theFirst, const QModelIndex& theSecond )
 337 {
 338   bool isFirstSelected;
 339   bool isFirstExpanded;
 340   bool isFirstCurrent;
 341   getIndexInfo( theFirst, isFirstExpanded, isFirstSelected, isFirstCurrent );
 342
 343   bool isSecondSelected;
 344   bool isSecondExpanded;
 345   bool isSecondCurrent;
 346   getIndexInfo( theSecond, isSecondExpanded, isSecondSelected, isSecondCurrent );
 347
 348   setIndexState( theFirst, isSecondExpanded, isSecondSelected, isSecondCurrent );
 349   setIndexState( theSecond, isFirstExpanded, isFirstSelected, isFirstCurrent );
 350   dataChanged(theFirst,theFirst);
 351   dataChanged(theSecond,theSecond);
 352 }
 353
 354 void CurveCreator_TreeView::sectionsSwapped( int theSection, int theOffset )
 355 {
 356   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 357   if( aModel ){
 358     QModelIndex aFirstIndex = aModel->sectionIndex( theSection );
 359     QModelIndex aSecondIndex = aModel->sectionIndex( theSection + theOffset );
 360     swapIndexes( aFirstIndex, aSecondIndex );
 361   }
 362 }
 363
 364 void CurveCreator_TreeView::pointsSwapped( int theSection, int thePointNum, int theOffset )
 365 {
 366   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 367   if( aModel ){
 368     QModelIndex aFirstIndex = aModel->pointIndex( theSection, thePointNum );
 369     QModelIndex aSecondIndex = aModel->pointIndex( theSection, thePointNum + theOffset );
 370     swapIndexes( aFirstIndex, aSecondIndex );
 371   }
 372 }
 373
 374 void CurveCreator_TreeView::setSelectedSections( const QList<int>& theList )
 375 {
 376   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 377   if( aModel ){
 378     selectionModel()->clearSelection();
 379     for( int i = 0 ; i < theList.size() ; i++ ){
 380       QModelIndex aSectIndx = aModel->sectionIndex(theList[i]);
 381       selectionModel()->select(aSectIndx, QItemSelectionModel::Select );
 382     }
 383   }
 384 }
 385
 386 void CurveCreator_TreeView::setSelectedPoints( const QList< QPair<int, int> >& thePointsList )
 387 {
 388   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 389   if( aModel ){
 390     selectionModel()->clearSelection();
 391     for( int i = 0 ; i < thePointsList.size() ; i++ ){
 392       QModelIndex aSectIndx = aModel->pointIndex( thePointsList[i].first, thePointsList[i].second );
 393       selectionModel()->select(aSectIndx, QItemSelectionModel::Select );
 394     }
 395   }
 396 }
 397
 398 bool pointLessThan(const QPair<int,int> &s1, const QPair<int,int> &s2)
 399 {
 400   if( s1.first < s2.first )
 401     return true;
 402   if( s1.first > s2.first )
 403     return false;
 404   return s1.second < s2.second;
 405 }
 406
 407 QList< QPair< int, int > > CurveCreator_TreeView::getSelectedPoints() const
 408 {
 409   QList< QPair< int, int > > aPoints;
 410   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 411   if( !aModel )
 412     return aPoints;
 413   QModelIndexList anIndxs = selectionModel()->selectedIndexes();
 414   for( int i = 0 ; i < anIndxs.size() ; i++ ){
 415     if( !aModel->isSection( anIndxs[i] ) ){
 416       int aSect = aModel->getSection(anIndxs[i]);
 417       int aPointNum = aModel->getPoint(anIndxs[i]);
 418       QPair< int, int > aPoint = QPair<int,int>( aSect, aPointNum );
 419       aPoints.push_back( aPoint );
 420     }
 421   }
 422   qSort( aPoints.begin(), aPoints.end(), pointLessThan );
 423   return aPoints;
 424 }
 425
 426 CurveCreator_TreeView::SelectionType CurveCreator_TreeView::getSelectionType() const
 427 {
 428   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 429   if( !aModel )
 430     return ST_NOSEL;
 431   bool isPointSel = false;
 432   bool isSectSel = false;
 433   bool isOneSection = true;
 434   int aSectNum = -1;
 435   QModelIndexList aLst = selectionModel()->selectedIndexes();
 436   for( int i = 0 ; i < aLst.size() ; i++ ){
 437     if( aModel->isSection( aLst[i] ) ){
 438       isSectSel = true;
 439     }
 440     else{
 441       isPointSel = true;
 442       if( aSectNum == -1 ){
 443         aSectNum = aModel->getSection(aLst[i]);
 444       }
 445       else{
 446         if( aSectNum != aModel->getSection( aLst[i] ) ){
 447           isOneSection = false;
 448         }
 449       }
 450     }
 451   }
 452   if( isSectSel && !isPointSel )
 453     return ST_SECTIONS;
 454   if( isPointSel && !isSectSel ){
 455     if( isOneSection ){
 456       return ST_POINTS_ONE_SECTION;
 457     }
 458     return ST_POINTS;
 459   }
 460   if( isPointSel && isSectSel )
 461     return ST_MIXED;
 462   return ST_NOSEL;
 463 }
 464
 465 void CurveCreator_TreeView::onActivated( QModelIndex theIndx )
 466 {
 467   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 468   if( !aModel )
 469     return;
 470   int aSect = aModel->getSection(theIndx);
 471   if( aModel->isSection(theIndx) ){
 472     emit sectionEntered( aSect );
 473     return;
 474   }
 475   int aPointNum = aModel->getPoint( theIndx );
 476   emit pointEntered( aSect, aPointNum );
 477 }
 478
 479 void CurveCreator_TreeView::setCurve( CurveCreator_Curve* theCurve )
 480 {
 481   CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
 482   if( aModel )
 483     aModel->setCurve(theCurve);
 484   reset();
 485 }