// Activate the automatic mode
setMode( HYDROData_CalculationCase::AUTOMATIC );
+
+ // Reset the priority widget state
+ QList<Handle(HYDROData_Object)> anObjects;
+ myPriorityWidget->setObjects( anObjects );
}
QWizardPage* HYDROGUI_CalculationDlg::createObjectsPage() {
// automatic names generation for regions and zones
myEditedObject->SetName( aNewCaseName );
- // Set objects in the specified order
+ // Set parameters for automatic mode
int aMode = aPanel->getMode();
if ( aMode == HYDROData_CalculationCase::AUTOMATIC ) {
+ // Set objects in the specified order
myEditedObject->RemoveGeometryObjects();
foreach ( const QString& aName, aPanel->getAllGeomObjects() ) {
Handle(HYDROData_Object) anObject = Handle(HYDROData_Object)::DownCast(
myEditedObject->AddGeometryObject( anObject );
}
- }
- aPanel->setMoveZonesEnabled( aMode == HYDROData_CalculationCase::MANUAL );
- // Set priority rules
- myEditedObject->ClearRules();
- foreach ( const HYDROData_CustomRule& aRule, aPanel->getRules() ) {
- myEditedObject->AddRule( aRule.Object1, aRule.Priority,
- aRule.Object2, aRule.MergeType );
+ // Set priority rules
+ myEditedObject->ClearRules();
+ foreach ( const HYDROData_CustomRule& aRule, aPanel->getRules() ) {
+ myEditedObject->AddRule( aRule.Object1, aRule.Priority,
+ aRule.Object2, aRule.MergeType );
+ }
}
-
+ aPanel->setMoveZonesEnabled( aMode == HYDROData_CalculationCase::MANUAL );
+
if ( myEditedObject->IsMustBeUpdated() )
{
myShowZones = true;
}
} else if ( theRole == Qt::UserRole ) {
if ( aColumn == 0 || aColumn == 2 ) {
- aVariant = getAvailableObjects();
+ QStringList aNames;
+ HYDROData_CustomRule aRule = myRules.at( aRow );
+ Handle(HYDROData_Object) aUsedObject = aColumn == 0 ? aRule.Object2 : aRule.Object1;
+ if ( !aUsedObject.IsNull() ) {
+ aNames = getAvailablePairs( aUsedObject );
+ }
+ aVariant = aNames;
} else if ( aColumn == 1 ) {
QMap<QString, QVariant> aMap;
aMap.insert( priorityToString( LESS ), LESS );
}
}
if ( !anObject.IsNull() ) {
+ HYDROData_CustomRule anEditedRule = myRules[aRow];
+
if ( aColumn == 0 ) {
- myRules[aRow].Object1 = anObject;
+ anEditedRule.Object1 = anObject;
} else {
- myRules[aRow].Object2 = anObject;
+ anEditedRule.Object2 = anObject;
+ }
+
+ if ( !isUsed( anEditedRule.Object1, anEditedRule.Object2 ) ) {
+ myRules[aRow] = anEditedRule;
+ aRes = true;
+ } else {
+ emit showError( tr("ALREADY_EXISTS") );
}
-
- aRes = true;
}
} else if ( aColumn == 1 ) {
myRules[aRow].Priority = (HYDROData_PriorityType)theValue.toInt();
*/
void HYDROGUI_PriorityTableModel::setRules( const HYDROData_ListOfRules& theRules )
{
+ beginResetModel();
myRules = theRules;
-
- reset();
+ endResetModel();
}
/**
{
myObjects = theObjects;
+ beginResetModel();
+
+ // Remove rules which use objects which are no longer available
QMutableListIterator<HYDROData_CustomRule> anIter( myRules );
while ( anIter.hasNext() ) {
HYDROData_CustomRule aRule = anIter.next();
}
}
- reset();
+ endResetModel();
}
/**
- Create new rule.
+ Create new rule.
+ @return true if a rule has been created successfully
*/
-void HYDROGUI_PriorityTableModel::createNewRule()
+bool HYDROGUI_PriorityTableModel::createNewRule()
{
- if ( myObjects.count() < 2 ) {
- return;
+ if ( !canCreateNewRule() ) {
+ return false;
+ }
+
+ // Existing pairs of object indexes
+ QList<QPair<int, int>> aRules;
+ foreach( const HYDROData_CustomRule& aRule, getRules() ) {
+ int anIndex1 = myObjects.indexOf( aRule.Object1 );
+ int anIndex2 = myObjects.indexOf( aRule.Object2 );
+ if ( anIndex1 >= 0 && anIndex2 >= 0 ) {
+ aRules << QPair<int, int>( anIndex1, anIndex2 );
+ aRules << QPair<int, int>( anIndex2, anIndex1 );
+ }
+ }
+
+ // Try to find new pair of objects
+ Handle(HYDROData_Object) anObject1, anObject2;
+
+ int aNbObjects = myObjects.count();
+ for ( int anIndex1 = 0; anIndex1 < aNbObjects; anIndex1++ ) {
+ bool isFound = false;
+
+ for ( int anIndex2 = 0; anIndex2 < aNbObjects; anIndex2++ ) {
+ if ( anIndex1 == anIndex2 ) {
+ continue;
+ }
+
+ if ( !aRules.contains( QPair<int, int>( anIndex1, anIndex2 ) ) ) {
+ anObject1 = myObjects.at( anIndex1 );
+ anObject2 = myObjects.at( anIndex2 );
+ isFound = true;
+ break;
+ }
+ }
+
+ if ( isFound ) {
+ break;
+ }
+ }
+
+ // Create a new rule
+ bool isCreated = false;
+
+ if ( !anObject1.IsNull() && !anObject2.IsNull() ) {
+ HYDROData_CustomRule aNewRule;
+ aNewRule.Object1 = anObject1;
+ aNewRule.Object2 = anObject2;
+ aNewRule.Priority = LESS;
+ aNewRule.MergeType = HYDROData_Zone::Merge_ZMIN;
+
+ beginResetModel();
+ myRules << aNewRule;
+ endResetModel();
+
+ isCreated = true;
}
- HYDROData_CustomRule aNewRule;
- aNewRule.Object1 = myObjects.at(0);
- aNewRule.Object2 = myObjects.at(1);
- aNewRule.Priority = LESS;
- aNewRule.MergeType = HYDROData_Zone::Merge_ZMIN;
+ return isCreated;
+}
- myRules << aNewRule;
+/**
+ Check if a new rule can be created.
+ @return true if a new rule could be created
+ */
+bool HYDROGUI_PriorityTableModel::canCreateNewRule() const
+{
+ int aNbObjects = myObjects.count();
- reset();
+ return ( myRules.count() < (aNbObjects - 1)*aNbObjects/2 );
}
/**
*/
bool HYDROGUI_PriorityTableModel::removeRows ( int theRow, int theCount, const QModelIndex & theParent )
{
- bool aRes = false;
+ if ( myRules.isEmpty() || theRow < 0 || theRow >= myRules.count() ) {
+ return false;
+ }
- if ( theRow + theCount <= myRules.count() ) {
- for ( int i = 1; i <= theCount; i++ ) {
- myRules.removeAt( theRow );
- }
- aRes = true;
- reset();
+ int aLastRow = theRow + theCount - 1;
+ if ( aLastRow > myRules.count() ) {
+ aLastRow = myRules.count() - 1;
+ }
+
+ beginRemoveRows( theParent, theRow, aLastRow );
+
+ // Remove the corresponding rules
+ for ( int i = 1; i <= theCount; i++ ) {
+ myRules.removeAt( theRow );
}
+ endRemoveRows();
+
return true;
}
/**
- Get available objects.
+ Remove all data from the model.
+ @return true if at least one row is removed
+ */
+bool HYDROGUI_PriorityTableModel::removeAll()
+{
+ return removeRows( 0, rowCount() );
+}
+
+/**
+ Get available pairs for the given object.
+ @param theObject the object
@return the list of object names
*/
-QStringList HYDROGUI_PriorityTableModel::getAvailableObjects() const
+QStringList HYDROGUI_PriorityTableModel::getAvailablePairs( const Handle(HYDROData_Object)& theObject ) const
{
QStringList aNames;
foreach ( const Handle(HYDROData_Object) anObj, myObjects ) {
- if ( !anObj.IsNull() ) {
+ if ( !anObj.IsNull() && anObj->GetName() != theObject->GetName() ) {
aNames << anObj->GetName();
}
}
/**
Remove the rows.
@params theRows the list of rows to remove
+ @return true if at least one row is removed
*/
-void HYDROGUI_PriorityTableModel::removeRows ( const QList<int> theRows )
+bool HYDROGUI_PriorityTableModel::removeRows ( const QList<int> theRows )
{
QList<int> aSortedRows = theRows;
qSort( aSortedRows );
aNbRemoved++;
}
}
+
+ return ( aNbRemoved > 0 );
}
/**
return QString();
};
}
+
+/**
+ Check if the given pair of objects is already used.
+ @return true if the pair is used
+ */
+bool HYDROGUI_PriorityTableModel::isUsed( const Handle(HYDROData_Object)& theObj1,
+ const Handle(HYDROData_Object)& theObj2 ) const
+{
+ bool isUsed = false;
+
+ foreach ( const HYDROData_CustomRule& aRule, myRules ) {
+ if ( ( aRule.Object1->GetName() == theObj1->GetName() &&
+ aRule.Object2->GetName() == theObj2->GetName() ) ||
+ ( aRule.Object1->GetName() == theObj2->GetName() &&
+ aRule.Object2->GetName() == theObj1->GetName() ) ) {
+ isUsed = true;
+ break;
+ }
+ }
+
+ return isUsed;
+}
\ No newline at end of file
Qt::Orientation theOrientation,
int theRole = Qt::DisplayRole ) const;
- virtual bool removeRows ( int theRow, int theCount, const QModelIndex & theParent = QModelIndex() );
+ virtual bool removeRows( int theRow, int theCount, const QModelIndex & theParent = QModelIndex() );
+
+ bool removeRows( const QList<int> theRows );
+ bool removeAll();
- void removeRows ( const QList<int> theRows );
+ void setObjects( const QList<Handle(HYDROData_Object)>& theObjects );
void setRules( const HYDROData_ListOfRules& theObjects );
HYDROData_ListOfRules getRules() const;
- void setObjects( const QList<Handle(HYDROData_Object)>& theObjects );
-
- void createNewRule();
-
+ bool createNewRule();
+ bool canCreateNewRule() const;
+
protected:
- QStringList getAvailableObjects() const;
+ bool isUsed( const Handle(HYDROData_Object)& theObj1,
+ const Handle(HYDROData_Object)& theObj2 ) const;
+
+ QStringList getAvailablePairs( const Handle(HYDROData_Object)& theObject ) const;
QString priorityToString( const int thePriority ) const;
QString mergeTypeToString( const int theMergeType ) const;
+signals:
+ void showError( const QString& theMsg );
+
private:
friend class test_HYDROGUI_PriorityTableModel;
#include "HYDROData_PriorityQueue.h"
+#include <SUIT_MessageBox.h>
+
#include <QComboBox>
#include <QLayout>
#include <QStyledItemDelegate>
if ( aComboBox ) {
int aColumn = theIndex.column();
if ( aColumn == 0 || aColumn == 2 ) {
- theModel->setData( theIndex, aComboBox->currentText() );
+ QString aCurrentText = theIndex.data( Qt::EditRole ).toString();
+ QString aNewText = aComboBox->currentText();
+ if ( aNewText != aCurrentText ) {
+ theModel->setData( theIndex, aNewText );
+ }
} else {
theModel->setData( theIndex, aComboBox->itemData( aComboBox->currentIndex() ) );
}
myAdd->setText( tr( "ADD" ) );
myRemove = new QToolButton;
myRemove->setText( tr( "REMOVE" ) );
- myRemove->setEnabled( false );
-
+ myClear = new QToolButton;
+ myClear->setText( tr( "CLEAR_ALL" ) );
+
// Table view
myTable = new QTableView( this );
myTable->setItemDelegate( new Delegate( this ) );
myTable->setEditTriggers( QAbstractItemView::DoubleClicked | QAbstractItemView::SelectedClicked );
// Set the custom model
- myTable->setModel( new HYDROGUI_PriorityTableModel() );
+ HYDROGUI_PriorityTableModel* aModel = new HYDROGUI_PriorityTableModel();
+ myTable->setModel( aModel );
// Layout
// buttons
aButtonsLayout->addWidget( myAdd );
aButtonsLayout->addWidget( myRemove );
aButtonsLayout->addStretch( 1 );
+ aButtonsLayout->addWidget( myClear );
// main
aMainLayout->addLayout( aButtonsLayout );
aMainLayout->addWidget( myTable );
+ // Update controls
+ updateControls();
+
// Connections
connect( myAdd, SIGNAL( clicked() ), this, SLOT( onAddRule() ) );
connect( myRemove, SIGNAL( clicked() ), this, SLOT( onRemoveRule() ) );
+ connect( myClear, SIGNAL( clicked() ), this, SLOT( onClearRules() ) );
+
connect ( myTable->selectionModel(), SIGNAL( selectionChanged( QItemSelection, QItemSelection ) ),
this, SLOT( onSelectionChanged() ) );
+
+ connect( aModel, SIGNAL( showError( const QString& ) ), this, SLOT( onShowError( const QString& ) ) );
}
/**
}
/**
- Adds the new rule.
+ Add the new default constructed rule.
*/
void HYDROGUI_PriorityWidget::onAddRule()
{
HYDROGUI_PriorityTableModel* aModel =
dynamic_cast<HYDROGUI_PriorityTableModel*>( myTable->model() );
- if( aModel ) {
- aModel->createNewRule();
+ if ( aModel ) {
+ if (aModel->createNewRule()) {
+ updateControls();
+ }
}
- myTable->resizeColumnsToContents();
- onSelectionChanged();
}
/**
- Removes the selected rule.
+ Remove the selected rule.
*/
void HYDROGUI_PriorityWidget::onRemoveRule()
{
foreach ( const QModelIndex& anIndex, aSelectedIndexes ) {
aRows << anIndex.row();
}
- aModel->removeRows( aRows );
+
+ if ( aModel->removeRows( aRows ) ) {
+ updateControls();
+ }
+ }
+}
+
+/**
+ Clear all rules.
+ */
+void HYDROGUI_PriorityWidget::onClearRules()
+{
+ HYDROGUI_PriorityTableModel* aModel =
+ dynamic_cast<HYDROGUI_PriorityTableModel*>( myTable->model() );
+ if ( aModel && aModel->removeAll() ) {
+ updateControls();
}
- myTable->resizeColumnsToContents();
- onSelectionChanged();
}
/**
dynamic_cast<HYDROGUI_PriorityTableModel*>( myTable->model() );
if( aModel ) {
aModel->setObjects( theObjects );
+ updateControls();
}
}
Set rules.
@param theRules the list of rules
*/
-void HYDROGUI_PriorityWidget::setRules( const HYDROData_ListOfRules& theRules ) const
+void HYDROGUI_PriorityWidget::setRules( const HYDROData_ListOfRules& theRules )
{
HYDROGUI_PriorityTableModel* aModel =
dynamic_cast<HYDROGUI_PriorityTableModel*>( myTable->model() );
if( aModel ) {
aModel->setRules( theRules );
+ updateControls();
}
- myTable->resizeColumnsToContents();
}
/**
{
QModelIndexList aSelectedIndexes = myTable->selectionModel()->selectedRows();
myRemove->setEnabled( aSelectedIndexes.count() > 0 );
+}
+
+/**
+ Update GUI controls state.
+ */
+void HYDROGUI_PriorityWidget::updateControls()
+{
+ HYDROGUI_PriorityTableModel* aModel =
+ dynamic_cast<HYDROGUI_PriorityTableModel*>( myTable->model() );
+ if( aModel ) {
+ myAdd->setEnabled( aModel->canCreateNewRule() );
+ bool isTableNotEmpty = aModel->rowCount() > 0;
+ myClear->setEnabled( isTableNotEmpty );
+ if ( isTableNotEmpty ) {
+ myTable->resizeColumnsToContents();
+ }
+ }
+ onSelectionChanged();
+}
+
+/**
+ Show error message.
+ */
+void HYDROGUI_PriorityWidget::onShowError( const QString& theMsg ) {
+ SUIT_MessageBox::critical( this, tr( "ERROR" ), theMsg );
}
\ No newline at end of file
void setObjects( const QList<Handle(HYDROData_Object)>& theObjects );
HYDROData_ListOfRules getRules() const;
- void setRules( const HYDROData_ListOfRules& theRules ) const;
+ void setRules( const HYDROData_ListOfRules& theRules );
+
+protected:
+ void updateControls();
protected slots:
void onAddRule();
void onRemoveRule();
+ void onClearRules();
void onSelectionChanged();
+ void onShowError( const QString& theMsg );
+
private:
QTableView* myTable; ///< the table view
QToolButton* myAdd; ///< the add rule button
QToolButton* myRemove; ///< the remove rule button
+ QToolButton* myClear; ///< the clear all rules button
};
#endif
<source>REMOVE</source>
<translation>Remove</translation>
</message>
+ <message>
+ <source>CLEAR_ALL</source>
+ <translation>Clear all</translation>
+ </message>
</context>
<context>
<source>BATHYMETRY</source>
<translation>Bathymetry</translation>
</message>
+ <message>
+ <source>ALREADY_EXISTS</source>
+ <translation>The selected objects combination already exists.</translation>
+ </message>
</context>
</TS>
