QString aCalculName = GetObjPyName();
- AssignmentMode aMode = GetAssignmentMode();
+ AssignmentMode aMode = GetAssignmentMode();
QString aModeStr = aMode==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC";
aResList << QString( "%0.SetAssignmentMode( %1 )" ).arg( aCalculName ).arg( aModeStr );
+ AssignmentMode aModeLC = GetAssignmentLandCoverMode();
+ QString aModeLCStr = aModeLC==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC";
+ aResList << QString( "%0.SetAssignmentLandCoverMode( %1 )" ).arg( aCalculName ).arg( aModeLCStr );
+
HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
HYDROData_SequenceOfObjects::Iterator anIter( aGeomObjects );
for ( ; anIter.More(); anIter.Next() )
if( aMode==AUTOMATIC )
DumpRulesToPython( aCalculName, aResList );
+ if( aModeLC==AUTOMATIC )
+ DumpLandCoverRulesToPython( aCalculName, aResList );
aResList << QString( "" );
aResList << "# Start the algorithm of the partition and assignment";
{
// Now we restore the
// - regions and zones order
- DumpRegionsToPython( aResList, theTreatedObjects, GetRegions( false ) );
+ DumpRegionsToPython( aResList, theTreatedObjects, GetRegions( false ) );
+ }
+
+ if( aModeLC==MANUAL )
+ {
+ // Now we restore the
// - land cover regions and zones order
DumpRegionsToPython( aResList, theTreatedObjects, GetRegions( true ) );
}
switch( GetAssignmentMode() )
{
case MANUAL:
- CreateRegionsDef( aDocument, aZonesList, false );
+ CreateRegionsDef( aDocument, aZonesList, false );
+ break;
+ case AUTOMATIC:
+ CreateRegionsAuto( aDocument, aZonesList, false );
+ break;
+ }
+
+ switch( GetAssignmentLandCoverMode() )
+ {
+ case MANUAL:
CreateRegionsDef( aDocument, aLandCoverZonesList, true );
break;
case AUTOMATIC:
- CreateRegionsAuto( aDocument, aZonesList, false );
CreateRegionsAuto( aDocument, aLandCoverZonesList, true );
break;
}
+
CreateEdgeGroupsDef( aDocument, anEdgesList );
}
return HYDROData_PriorityQueue::DumpRules( aRulesLab );
}
+QString HYDROData_CalculationCase::DumpLandCoverRules() const
+{
+ TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomLandCoverRules );
+ return HYDROData_PriorityQueue::DumpRules( aRulesLab );
+}
+
void HYDROData_CalculationCase::SetAssignmentMode( AssignmentMode theMode )
{
TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentMode );
HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript );
}
+void HYDROData_CalculationCase::DumpLandCoverRulesToPython( const QString& theCalcCaseName,
+ QStringList& theScript ) const
+{
+ TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomLandCoverRules );
+ HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript );
+}
+
HYDROData_Warning HYDROData_CalculationCase::GetLastWarning() const
{
return myLastWarning;
HYDRODATA_EXPORT AssignmentMode GetAssignmentLandCoverMode() const;
HYDRODATA_EXPORT QString DumpRules() const;
+ HYDRODATA_EXPORT QString DumpLandCoverRules() const;
HYDRODATA_EXPORT HYDROData_Warning GetLastWarning() const;
const HYDROData_SplitToZonesTool::SplitDataList& theEdges );
void DumpRulesToPython( const QString& theCalcCaseName, QStringList& theScript ) const;
+ void DumpLandCoverRulesToPython( const QString& theCalcCaseName, QStringList& theScript ) const;
void SetWarning( HYDROData_WarningType theType = WARN_OK, const QString& theData = "" );
aMap->SetReal( theType, theCoefficient );
}
+void HYDROData_StricklerTable::GetCoefficientRange( double& theMin, double& theMax ) const
+{
+ theMin = 0;
+ theMax = 0;
+
+ Handle(TDataStd_NamedData) aMap = Map();
+ Standard_Boolean isFirst = Standard_True;
+ for ( TDataStd_DataMapIteratorOfDataMapOfStringReal it( aMap->GetRealsContainer() ); it.More(); it.Next() ) {
+ Standard_Real aValue = it.Value();
+ if ( theMin == 0 || aValue < theMin ) {
+ theMin = aValue;
+ }
+ if ( theMax == 0 || aValue > theMax ) {
+ theMax = aValue;
+ }
+ }
+}
+
TColStd_SequenceOfExtendedString HYDROData_StricklerTable::GetTypes() const
{
TColStd_SequenceOfExtendedString aSeq;
return aSeq;
}
+bool HYDROData_StricklerTable::HasType( const TCollection_ExtendedString& theType ) const
+{
+ Handle(TDataStd_NamedData) aMap = Map();
+
+ return !aMap.IsNull() && aMap->HasReal( theType );
+}
+
void HYDROData_StricklerTable::Clear()
{
Handle(TDataStd_NamedData) aMap = Map();
HYDRODATA_EXPORT double Get( const TCollection_ExtendedString& theType, double theDefault ) const;
HYDRODATA_EXPORT void Set( const TCollection_ExtendedString& theType, double theCoefficient );
+ HYDRODATA_EXPORT void GetCoefficientRange( double& theMin, double& theMax ) const;
+
HYDRODATA_EXPORT TColStd_SequenceOfExtendedString GetTypes() const;
+ HYDRODATA_EXPORT bool HasType( const TCollection_ExtendedString& theType ) const;
+
HYDRODATA_EXPORT void Clear();
HYDRODATA_EXPORT virtual QStringList DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const;
HYDROGUI_ObjListBox.h
HYDROGUI_RecognizeContoursDlg.h
HYDROGUI_RecognizeContoursOp.h
+ HYDROGUI_LandCoverColoringOp.h
+ HYDROGUI_ShapeLandCover.h
)
QT4_WRAP_CPP(PROJECT_HEADERS_MOC ${PROJECT_HEADERS})
HYDROGUI_ObjListBox.cxx
HYDROGUI_RecognizeContoursDlg.cxx
HYDROGUI_RecognizeContoursOp.cxx
+ HYDROGUI_LandCoverColoringOp.cxx
+ HYDROGUI_ShapeLandCover.cxx
)
add_definitions(
connect( anAddBtn, SIGNAL( clicked() ), SIGNAL( addLandCovers() ) );
connect( aRemoveBtn, SIGNAL( clicked() ), SIGNAL( removeLandCovers() ) );
- connect( myLandCovers, SIGNAL( orderLandCoverChanged() ), SLOT( onOrderLandCoverChanged() ) );
+ connect( myLandCovers, SIGNAL( orderChanged() ), SLOT( onOrderLandCoverChanged() ) );
return aPage;
}
return ( anAnswer == QMessageBox::Yes );
}
+bool HYDROGUI_CalculationOp::confirmLandCoverRegionsChange() const
+{
+ // Check if the case is already modified or not
+ bool isConfirmed = myEditedObject->IsMustBeUpdated();
+ if ( !isConfirmed )
+ {
+ // If not modified check if the case has already defined regions with land cover zones
+ HYDROData_SequenceOfObjects aSeq = myEditedObject->GetRegions( true );
+ if ( aSeq.Length() > 0 )
+ {
+ // If there are already defined land cover zones then ask a user to confirm land cover zones recalculation
+ isConfirmed = ( SUIT_MessageBox::question( module()->getApp()->desktop(),
+ tr( "REGIONS_CHANGED" ),
+ tr( "CONFIRM_LAND_COVER_PARTITION_RECALCULATION_REGIONS" ),
+ QMessageBox::Yes | QMessageBox::No,
+ QMessageBox::No ) == QMessageBox::Yes );
+ }
+ else
+ {
+ isConfirmed = true; // No regions - no land cover zones - nothing to recalculate
+ }
+ }
+ return isConfirmed;
+}
+
bool HYDROGUI_CalculationOp::confirmLandCoverModeChange() const
{
// Check if the case is already modified or not
bool isConfirmed = myEditedObject->IsMustBeUpdated();
if ( !isConfirmed )
{
- // If not modified check if the case has already defined regions with zones
- // TODO: adapt HYDROData_CalculationCase class to process regions constructed for land covers
- /*HYDROData_SequenceOfObjects aSeq = myEditedObject->GetLandCoverRegions();
+ // If not modified check if the case has already defined regions with land cover zones
+ HYDROData_SequenceOfObjects aSeq = myEditedObject->GetRegions( true );
if ( aSeq.Length() > 0 )
- {*/
- // If there are already defined zones then ask a user to confirm zones recalculation
+ {
+ // If there are already defined land cover zones then ask a user to confirm land cover zones recalculation
isConfirmed = ( SUIT_MessageBox::question( module()->getApp()->desktop(),
tr( "MODE_CHANGED" ),
tr( "CONFIRM_LAND_COVER_PARTITION_RECALCULATION_MODE" ),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No ) == QMessageBox::Yes );
- /*}
+ }
else
{
- isConfirmed = true; // No regions - no zones - nothing to recalculate
- }*/
+ isConfirmed = true; // No regions - no land cover zones - nothing to recalculate
+ }
}
return isConfirmed;
}
bool isConfirmed = myEditedObject->IsMustBeUpdated();
if ( !isConfirmed )
{
- // If not modified check if the case has already defined regions with zones
- // TODO: adapt HYDROData_CalculationCase class to process regions constructed for land covers
- /*HYDROData_SequenceOfObjects aSeq = myEditedObject->GetLandCoverRegions();
+ // If not modified check if the case has already defined regions with land cover zones
+ HYDROData_SequenceOfObjects aSeq = myEditedObject->GetRegions( true );
if ( aSeq.Length() > 0 )
- {*/
- // If there are already defined zones then ask a user to confirm zones recalculation
+ {
+ // If there are already defined land cover zones then ask a user to confirm land cover zones recalculation
isConfirmed = ( SUIT_MessageBox::question( module()->getApp()->desktop(),
tr( "ORDER_CHANGED" ),
tr( "CONFIRM_LAND_COVER_PARTITION_RECALCULATION_REGIONS" ),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No ) == QMessageBox::Yes );
- /*}
+ }
else
{
- isConfirmed = true; // No regions - no zones - nothing to recalculate
- }*/
+ isConfirmed = true; // No regions - no land cover zones - nothing to recalculate
+ }
}
return isConfirmed;
}
}
}
aPanel->setStricklerTableNames( aList, anEntryList );
+ bool anUpdateState = myEditedObject->IsMustBeUpdated();
if ( !aList.isEmpty() )
aPanel->setStricklerTable( aList.at( 0 ), false );
+ myEditedObject->SetToUpdate( anUpdateState );
// Fill in list widget with all available land covers
aSeq = HYDROGUI_Tool::GetLandCovers( module() );
if ( anIsToUpdate )
{
myShowZones = true;
- myEditedObject->Update();
+ myEditedObject->SetToUpdate( false );
AssignDefaultZonesColors( true );
// Add land covers selected in the module browser to the calculation case
QStringList aSelectedList = aPanel->getSelectedAvailableLandCovers();
- if ( aSelectedList.isEmpty() || !confirmRegionsChange() )
+ if ( aSelectedList.isEmpty() || !confirmLandCoverRegionsChange() )
return;
QStringList anAddedList;
return;
QStringList aSelectedList = aPanel->getSelectedLandCovers();
- if ( aSelectedList.isEmpty() || !confirmRegionsChange() )
+ if ( aSelectedList.isEmpty() || !confirmLandCoverRegionsChange() )
return;
for (int i = 0; i < aSelectedList.length(); i++)
bool confirmOrderChange() const;
bool confirmContinueWithWarning( const HYDROData_Warning& theWarning ) const;
+ bool confirmLandCoverRegionsChange() const;
bool confirmLandCoverModeChange() const;
bool confirmLandCoverOrderChange() const;
isOnlyZones = aModelObj->GetKind()==KIND_ZONE;
if( !isOnlyZones )
break;
+
+ SUIT_DataObject* aParentObj = aHydroObj->parent();
+ if ( aParentObj )
+ {
+ isOnlyZones = aParentObj->childCount() > 1;
+ if( !isOnlyZones )
+ break;
+ }
}
else
{
return;
}
- QString aFileName = myFileDlg->selectedFile();
- if ( aFileName.isEmpty() )
- {
- abort();
- return;
- }
-
- QString anExt = aFileName.split('.', QString::SkipEmptyParts).back();
+ QStringList aFileNames = myFileDlg->selectedFiles();
+ bool IsImported = false;
+
+ QApplication::setOverrideCursor( Qt::WaitCursor );
+ startDocOperation();
- if (anExt == "sx")
+ foreach (QString aFileName, aFileNames)
{
- QApplication::setOverrideCursor( Qt::WaitCursor );
+ if ( aFileName.isEmpty() )
+ continue;
- startDocOperation();
+ QString anExt = aFileName.split('.', QString::SkipEmptyParts).back();
- HYDROData_SinusX aSinusXImporter;
- NCollection_Sequence<Handle_HYDROData_Entity> anEntities;
- if (aSinusXImporter.Import(aFileName, doc(), anEntities))
+ if (anExt == "sx")
{
- UpdateView(anEntities);
- commitDocOperation();
- commit();
- }
- else
- {
- abort();
+ HYDROData_SinusX aSinusXImporter;
+ NCollection_Sequence<Handle_HYDROData_Entity> anEntities;
+ if (aSinusXImporter.Import(aFileName, doc(), anEntities))
+ {
+ UpdateView(anEntities);
+ IsImported = true;
+ }
}
}
+ if (IsImported)
+ {
+ commitDocOperation();
+ commit();
+ }
+ else
+ abort();
+
module()->update( UF_Model | UF_VTKViewer | UF_VTK_Forced | UF_VTK_Init );
QApplication::restoreOverrideCursor();
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "HYDROGUI_LandCoverColoringOp.h"
+
+#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
+#include "HYDROGUI_Operations.h"
+#include "HYDROGUI_Tool.h"
+#include "HYDROGUI_UpdateFlags.h"
+
+#include <HYDROData_Iterator.h>
+#include <HYDROData_Bathymetry.h>
+#include <HYDROData_StricklerTable.h>
+
+#include <LightApp_Application.h>
+
+#include <OCCViewer_ViewModel.h>
+#include <OCCViewer_ViewManager.h>
+
+
+HYDROGUI_LandCoverColoringOp::HYDROGUI_LandCoverColoringOp( HYDROGUI_Module* theModule, int theId )
+: HYDROGUI_Operation( theModule ),
+ myId( theId )
+{
+ QString aName;
+ switch( myId )
+ {
+ case LandCoverScalarMapModeOnId: aName = tr( "LC_SCALARMAP_COLORING_ON" ); break;
+ case LandCoverScalarMapModeOffId: aName = tr( "LC_SCALARMAP_COLORING_OFF" ); break;
+ default: break;
+ }
+ setName( aName );
+}
+
+HYDROGUI_LandCoverColoringOp::~HYDROGUI_LandCoverColoringOp()
+{
+}
+
+void HYDROGUI_LandCoverColoringOp::startOperation()
+{
+ HYDROGUI_Operation::startOperation();
+
+ HYDROGUI_Module* aModule = module();
+
+ LightApp_Application* anApp = module()->getApp();
+ OCCViewer_ViewManager* aViewManager =
+ dynamic_cast<OCCViewer_ViewManager*>( anApp->getViewManager( OCCViewer_Viewer::Type(), false ) );
+
+ size_t aViewId = (size_t)aViewManager->getViewModel();
+
+ Handle(HYDROData_StricklerTable) aTable;
+
+ if ( myId == LandCoverScalarMapModeOnId ) {
+ aTable = Handle(HYDROData_StricklerTable)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) );
+ if ( !aTable.IsNull() ) {
+ aModule->setLandCoverColoringTable( aViewId, aTable );
+ }
+ } else if ( myId == LandCoverScalarMapModeOffId ) {
+ aModule->setLandCoversScalarMapModeOff( aViewId );
+ }
+
+ // Hide bathymetries
+ HYDROData_Iterator anIterator( doc(), KIND_BATHYMETRY );
+ for( ; anIterator.More(); anIterator.Next() ) {
+ Handle(HYDROData_Bathymetry) aBath =
+ Handle(HYDROData_Bathymetry)::DownCast( anIterator.Current() );
+ if ( !aBath.IsNull() && aModule->isObjectVisible( aViewId, aBath ) ) {
+ aModule->setObjectVisible( aViewId, aBath, false );
+ }
+ }
+
+ aModule->getOCCDisplayer()->SetToUpdateColorScale();
+ aModule->update( UF_OCCViewer );
+ commit();
+}
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef HYDROGUI_LandCoverColoringOp_H
+#define HYDROGUI_LandCoverColoringOp_H
+
+#include "HYDROGUI_Operation.h"
+
+/**
+ * \class HYDROGUI_LandCoverColoringOp
+ * \brief The class intended for scalar map coloring of Land Covers
+ */
+class HYDROGUI_LandCoverColoringOp : public HYDROGUI_Operation
+{
+ Q_OBJECT
+
+public:
+
+ HYDROGUI_LandCoverColoringOp( HYDROGUI_Module* theModule, int theId );
+ virtual ~HYDROGUI_LandCoverColoringOp();
+
+protected:
+ virtual void startOperation();
+
+private:
+ int myId;
+};
+
+#endif
#include "HYDROGUI_LandCoverDlg.h"
#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
#include "HYDROGUI_Shape.h"
#include "HYDROGUI_Tool.h"
#include "HYDROGUI_UpdateFlags.h"
}
module()->setIsToUpdate( aZoneObj );
+ module()->getOCCDisplayer()->SetToUpdateColorScale();
theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer;
#include <HYDROData_Profile.h>
#include <HYDROData_Lambert93.h>
#include <HYDROData_Polyline3D.h>
+#include <HYDROData_StricklerTable.h>
#include <HYDROData_OperationsFactory.h>
}
if ( !anIsObjectCanBeColored )
- anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject );
+ anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject, this );
}
// Check if all selected objects are profiles
theMenu->addAction( action( ExportStricklerTableFromFileId ) );
theMenu->addAction( action( DuplicateStricklerTableId ) );
theMenu->addSeparator();
+
+ if ( !isLandCoversScalarMapModeOn( anActiveViewId ) &&
+ !getObjectShapes( anActiveViewId, KIND_LAND_COVER ).isEmpty() ) {
+ theMenu->addAction( action( LandCoverScalarMapModeOnId ) );
+ theMenu->addSeparator();
+ }
}
else if( anIsLandCover )
{
theMenu->addSeparator();
theMenu->addAction( action( SetZLevelId ) );
theMenu->addSeparator();
+
+ if ( isLandCoversScalarMapModeOn( anActiveViewId ) ) {
+ theMenu->addAction( action( LandCoverScalarMapModeOffId ) );
+ theMenu->addSeparator();
+ }
}
if( anIsObjectBrowser || anIsGraphicsView || anIsOCCView || anIsVTKView )
if ( visState != Qtx::UnpresentableState )
treeModel->setVisibilityState( id, theState ? Qtx::ShownState : Qtx::HiddenState );
}
+
+ if ( theObject->GetKind() == KIND_BATHYMETRY && theState ) {
+ setLandCoversScalarMapModeOff( theViewId );
+ } else if ( theObject->GetKind() == KIND_LAND_COVER && theState ) {
+ getOCCDisplayer()->SetToUpdateColorScale();
+ }
}
}
if ( anOCCViewManager )
{
OCCViewer_Viewer* anOCCViewer = anOCCViewManager->getOCCViewer();
- if ( anOCCViewer )
- removeViewShapes( (size_t)anOCCViewer );
+ if ( anOCCViewer ) {
+ int aViewerId = (size_t)anOCCViewer;
+ removeViewShapes( aViewerId );
+ setLandCoversScalarMapModeOff( aViewerId );
+ }
}
if ( getVTKDisplayer()->IsApplicable( theViewManager ) )
update( UF_OCCViewer | ( visState == Qtx::ShownState ? UF_FitAll : 0 ) );
}
+
+Handle(HYDROData_StricklerTable) HYDROGUI_Module::getLandCoverColoringTable( const int theViewId ) const
+{
+ Handle(HYDROData_StricklerTable) aTable;
+
+ if ( myLandCoverColoringMap.contains( theViewId ) ) {
+ aTable = myLandCoverColoringMap.value( theViewId );
+ }
+
+ return aTable;
+}
+
+void HYDROGUI_Module::setLandCoverColoringTable( const int theViewId,
+ const Handle(HYDROData_StricklerTable)& theTable )
+{
+ if ( !theTable.IsNull() ) {
+ myLandCoverColoringMap.insert( theViewId, theTable );
+ }
+}
+
+void HYDROGUI_Module::setLandCoversScalarMapModeOff( const int theViewId )
+{
+ myLandCoverColoringMap.remove( theViewId );
+}
+
+bool HYDROGUI_Module::isLandCoversScalarMapModeOn( const int theViewId ) const
+{
+ return myLandCoverColoringMap.contains( theViewId );
+}
class SUIT_ViewWindow;
class SUIT_ViewManager;
+class Handle(HYDROData_StricklerTable);
+
class HYDROGUI_DataModel;
class HYDROGUI_Displayer;
class HYDROGUI_OCCDisplayer;
typedef QList<HYDROGUI_VTKPrs*> ListOfVTKPrs;
typedef QMap<int,ListOfVTKPrs> ViewId2ListOfVTKPrs;
+ typedef QMap<int, Handle(HYDROData_StricklerTable)> ViewId2StricklerTable;
+
public:
HYDROGUI_Module();
virtual ~HYDROGUI_Module();
*/
QCursor getPrefEditCursor() const;
+ /**
+ * Returns Strickler table used for Land Cover scalar map coloring in the given view.
+ * @param theViewId the view id
+ * @return the Strickler table used for scalar map coloring of Land Covers in the given view;
+ null - if scalar map coloring is off for the view
+ */
+ Handle(HYDROData_StricklerTable) getLandCoverColoringTable( const int theViewId ) const;
+
+ /**
+ * Set Strickler table to be used for Land Cover scalar map coloring in the given view.
+ * @param theViewId the view id
+ * @param theTable the Strickler table
+ */
+ void setLandCoverColoringTable( const int theViewId,
+ const Handle(HYDROData_StricklerTable)& theTable );
+ /**
+ * Set Land Cover scalar map coloring mode off for the given view.
+ * @param theViewId the view id
+ */
+ void setLandCoversScalarMapModeOff( const int theViewId );
+
+ /**
+ * Check if Land Cover scalar map coloring mode is on in the given view.
+ * @param theViewId the view id
+ * @return true if the mode is on, false if the mode is off
+ */
+ bool isLandCoversScalarMapModeOn( const int theViewId ) const;
+
protected:
CAM_DataModel* createDataModel();
bool myIsUpdateEnabled;
QStringList myGeomObjectsToImport; ///< entries of GEOM objects to be imported
+
+ ViewId2StricklerTable myLandCoverColoringMap;
};
#endif
#include "HYDROGUI_Tool.h"
#include <HYDROGUI_ShapeImage.h>
#include <HYDROGUI_ShapeBathymetry.h>
+#include <HYDROGUI_ShapeLandCover.h>
#include "HYDROGUI_Operation.h"
#include "HYDROGUI_DataObject.h"
#include "HYDROGUI_ZLayers.h"
+
#include <HYDROData_Bathymetry.h>
+#include <HYDROData_LandCover.h>
+#include <HYDROData_StricklerTable.h>
#include <AIS_InteractiveContext.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
module()->removeObjectShape( (size_t)aViewer, anObj );
}
aViewer->update();
- UpdateColorScale( aViewer );
+ if ( !module()->isLandCoversScalarMapModeOn( (size_t)aViewer ) ) {
+ UpdateColorScale( aViewer );
+ }
}
HYDROGUI_Shape* HYDROGUI_OCCDisplayer::createShape( const int theViewerId,
aResShape = new HYDROGUI_ShapeImage( theContext, Handle_HYDROData_Image::DownCast( theObject ) );
else if( theObject->IsKind( STANDARD_TYPE( HYDROData_Bathymetry ) ) )
aResShape = new HYDROGUI_ShapeBathymetry( this, theContext, Handle_HYDROData_Bathymetry::DownCast( theObject ) );
+ else if( theObject->IsKind( STANDARD_TYPE( HYDROData_LandCover ) ) ) {
+ bool isScalarMode = module()->isLandCoversScalarMapModeOn( theViewerId );
+ aResShape = new HYDROGUI_ShapeLandCover( this, theContext, Handle_HYDROData_LandCover::DownCast( theObject ), -1, isScalarMode );
+ }
else
aResShape = new HYDROGUI_Shape( theContext, theObject );
void HYDROGUI_OCCDisplayer::UpdateColorScale( const OCCViewer_Viewer* theViewer )
{
- if( !myToUpdateColorScale )
+ if( !myToUpdateColorScale || !theViewer )
return;
-
+
OCCViewer_ViewWindow* aWnd = dynamic_cast<OCCViewer_ViewWindow*>( theViewer->getViewManager()->getActiveView() );
Handle(V3d_View) aView = aWnd->getViewPort()->getView();
-
+
int aViewerId = (size_t)theViewer;//TODO: check if viewer id is correct
- QList<HYDROGUI_Shape*> aShapes = module()->getObjectShapes( aViewerId, KIND_BATHYMETRY );
+ bool isLandCoverColoringOn = module()->isLandCoversScalarMapModeOn( aViewerId );
+
+ QList<HYDROGUI_Shape*> aLandCoverShapes = module()->getObjectShapes( aViewerId, KIND_LAND_COVER );
+ QList<HYDROGUI_Shape*> aBathShapes = module()->getObjectShapes( aViewerId, KIND_BATHYMETRY );
- bool isDisplayColorScale = !aShapes.empty();
+ bool isDisplayColorScale = !aBathShapes.empty() || isLandCoverColoringOn;
Standard_Real anXPos = 0.05; //TODO
Standard_Real anYPos = 0.1; //TODO
Standard_Real aWidth = 0.2; //TODO
Standard_Integer aNbIntervals = 20; //TODO
TCollection_ExtendedString aColorScaleTitle = "";//TODO
- Standard_Real aColorScaleMin = 0, aColorScaleMax = 1, aMin, aMax;
- bool isFirst = true;
- foreach( HYDROGUI_Shape* aShape, aShapes )
- {
- HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
- if( !aBathShape || !aBathShape->isVisible() )
- continue;
+ Standard_Real aColorScaleMin = 0, aColorScaleMax = 1;
+
+ // Get range
+ Handle(HYDROData_StricklerTable) aTable;
+ TColStd_SequenceOfExtendedString aTableTypes;
+ if ( isLandCoverColoringOn ) {
+ aTable = module()->getLandCoverColoringTable( aViewerId );
+ if ( !aTable.IsNull() ) {
+ aColorScaleTitle = TCollection_ExtendedString( aTable->GetName().toLatin1().constData() );
+ aTable->GetCoefficientRange( aColorScaleMin, aColorScaleMax );
+ aTableTypes = aTable->GetTypes();
+ }
+ } else {
+ Standard_Real aMin, aMax;
+ bool isFirst = true;
+ foreach( HYDROGUI_Shape* aShape, aBathShapes )
+ {
+ HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
+ if( !aBathShape || !aBathShape->isVisible() )
+ continue;
- aBathShape->GetRange( aMin, aMax );
+ aBathShape->GetRange( aMin, aMax );
- if( isFirst || aMin < aColorScaleMin )
- aColorScaleMin = aMin;
- if( isFirst || aMax > aColorScaleMax )
- aColorScaleMax = aMax;
+ if( isFirst || aMin < aColorScaleMin )
+ aColorScaleMin = aMin;
+ if( isFirst || aMax > aColorScaleMax )
+ aColorScaleMax = aMax;
- isFirst = false;
+ isFirst = false;
+ }
}
+ Handle(Aspect_ColorScale) aColorScale;
if( isDisplayColorScale )
{
- Handle(Aspect_ColorScale) aColorScale = aView->ColorScale();
+ aColorScale = aView->ColorScale();
if( !aColorScale.IsNull() )
{
aColorScale->SetXPosition( anXPos );
aColorScale->SetTitle( aColorScaleTitle );
aColorScale->SetRange( aColorScaleMin, aColorScaleMax );
- foreach( HYDROGUI_Shape* aShape, aShapes )
- {
- HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
- if( !aBathShape || !aBathShape->isVisible() )
- continue;
+ if ( !isLandCoverColoringOn ) {
+ foreach( HYDROGUI_Shape* aShape, aBathShapes ) {
+ HYDROGUI_ShapeBathymetry* aBathShape = dynamic_cast<HYDROGUI_ShapeBathymetry*>( aShape );
+ if( !aBathShape || !aBathShape->isVisible() )
+ continue;
- aBathShape->UpdateWithColorScale( aColorScale );
+ aBathShape->UpdateWithColorScale( aColorScale );
+ }
}
}
if( !aView->ColorScaleIsDisplayed() )
aView->ColorScaleErase();
}
+ foreach( HYDROGUI_Shape* aShape, aLandCoverShapes ) {
+ HYDROGUI_ShapeLandCover* aLandCoverShape =
+ dynamic_cast<HYDROGUI_ShapeLandCover*>( aShape );
+
+ if ( !aLandCoverShape || !aLandCoverShape->isVisible() ) {
+ continue;
+ }
+
+ Handle(HYDROData_LandCover) aLandCover =
+ Handle(HYDROData_LandCover)::DownCast( aLandCoverShape->getObject() );
+
+ if ( aLandCover.IsNull() ) {
+ continue;
+ }
+
+ QColor aUndefinedColor( Qt::gray );
+ QColor aColor = isLandCoverColoringOn ? aUndefinedColor : aLandCover->GetFillingColor();
+
+ if ( isLandCoverColoringOn && !aTable.IsNull() ) {
+ TCollection_ExtendedString aStricklerType =
+ aLandCover->GetStricklerType().toLatin1().constData();
+
+ if ( aTable->HasType( aStricklerType ) ) {
+ double aStricklerCoeff = aTable->Get( aStricklerType, 0 );
+ Quantity_Color aShapeColor;
+ if ( aColorScale->FindColor( aStricklerCoeff, aShapeColor ) ) {
+ aColor = QColor( aShapeColor.Red() * 255,
+ aShapeColor.Green() * 255,
+ aShapeColor.Blue() * 255 );
+ }
+ }
+ }
+
+ aLandCoverShape->setFillingColor( aColor, true, true );
+ aLandCoverShape->setScalarMapModeEnabled( isLandCoverColoringOn );
+ theViewer->getAISContext()->Redisplay( aLandCoverShape->getAISObject() );
+ //theViewer->getAISContext()->UpdateCurrentViewer(); //@MZN
+ //theViewer->getAISContext()->UpdateCurrent();
+ //theViewer->getAISContext()->UpdateSelected( true );
+ }
+
myToUpdateColorScale = false;
}
void purgeObjects( const int theViewerId );
void UpdateColorScale( const OCCViewer_Viewer* );
-
+
private:
/**
* \brief Creates new OCC shape.
#include "HYDROGUI_ExportSinusXOp.h"
#include "HYDROGUI_MergePolylinesOp.h"
#include "HYDROGUI_SplitPolylinesOp.h"
+#include "HYDROGUI_LandCoverColoringOp.h"
#include <HYDROData_Document.h>
#include <HYDROData_Obstacle.h>
createAction( SplitPolylinesId, "SPLIT_POLYLINES", "SPLIT_POLYLINES_ICO" );
createAction( MergePolylinesId, "MERGE_POLYLINES", "MERGE_POLYLINES_ICO" );
+
+ createAction( LandCoverScalarMapModeOnId, "LC_SCALARMAP_COLORING_ON" );
+ createAction( LandCoverScalarMapModeOffId, "LC_SCALARMAP_COLORING_OFF" );
}
void HYDROGUI_Module::createMenus()
case MergePolylinesId:
anOp = new HYDROGUI_MergePolylinesOp( aModule );
break;
+ case LandCoverScalarMapModeOnId:
+ case LandCoverScalarMapModeOffId:
+ anOp = new HYDROGUI_LandCoverColoringOp( aModule, theId );
+ break;
}
if( !anOp )
SplitPolylinesId,
MergePolylinesId,
+
+ LandCoverScalarMapModeOnId,
+ LandCoverScalarMapModeOffId
};
#endif
myList->setModel( aFilteredModel );
- // Buttons top, up, down, bottom
- SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
- myTop = new QPushButton( this );
- myTop->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_TOP_ICO" ) ) );
- myTop->setIconSize( QSize( theArrowIconSize, theArrowIconSize ) );
- myTop->setToolTip( tr( "TOP_TLT" ) );
- myUp = new QPushButton( this );
- myUp->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_UP_ICO" ) ) );
- myUp->setIconSize( myTop->iconSize() );
- myUp->setToolTip( tr( "UP_TLT" ) );
- myDown = new QPushButton( this );
- myDown->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_DOWN_ICO" ) ) );
- myDown->setIconSize( myTop->iconSize() );
- myDown->setToolTip( tr( "DOWN_TLT" ) );
- myBottom = new QPushButton( this );
- myBottom->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_BOTTOM_ICO" ) ) );
- myBottom->setIconSize( myTop->iconSize() );
- myBottom->setToolTip( tr( "BOTTOM_TLT" ) );
-
- // Layout
- // buttons
- QVBoxLayout* aListButtonsLayout = new QVBoxLayout();
- aListButtonsLayout->addWidget( myTop );
- aListButtonsLayout->addWidget( myUp );
- aListButtonsLayout->addWidget( myDown );
- aListButtonsLayout->addWidget( myBottom );
- aListButtonsLayout->addStretch();
- // main
+ // Add list to the main layout
aMainLayout->addWidget( myList );
- aMainLayout->addLayout( aListButtonsLayout );
-
- // Connections
- QSignalMapper* aSignalMapper = new QSignalMapper( this );
- aSignalMapper->setMapping( myTop, HYDROGUI_ListModel::Top );
- aSignalMapper->setMapping( myUp, HYDROGUI_ListModel::Up );
- aSignalMapper->setMapping( myDown, HYDROGUI_ListModel::Down );
- aSignalMapper->setMapping( myBottom, HYDROGUI_ListModel::Bottom );
- connect( myTop, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
- connect( myUp, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
- connect( myDown, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
- connect( myBottom, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
- connect( aSignalMapper, SIGNAL( mapped( int ) ), this, SLOT( onMove( int ) ) );
+
+ // Buttons top, up, down, bottom
+ if ( theArrowIconSize > 0 ) {
+ SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
+ myTop = new QPushButton( this );
+ myTop->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_TOP_ICO" ) ) );
+ myTop->setIconSize( QSize( theArrowIconSize, theArrowIconSize ) );
+ myTop->setToolTip( tr( "TOP_TLT" ) );
+ myUp = new QPushButton( this );
+ myUp->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_UP_ICO" ) ) );
+ myUp->setIconSize( myTop->iconSize() );
+ myUp->setToolTip( tr( "UP_TLT" ) );
+ myDown = new QPushButton( this );
+ myDown->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_DOWN_ICO" ) ) );
+ myDown->setIconSize( myTop->iconSize() );
+ myDown->setToolTip( tr( "DOWN_TLT" ) );
+ myBottom = new QPushButton( this );
+ myBottom->setIcon( aResMgr->loadPixmap( "HYDRO", tr( "ARROW_BOTTOM_ICO" ) ) );
+ myBottom->setIconSize( myTop->iconSize() );
+ myBottom->setToolTip( tr( "BOTTOM_TLT" ) );
+
+ // Add buttons to the main layout
+ QVBoxLayout* aListButtonsLayout = new QVBoxLayout();
+ aListButtonsLayout->addWidget( myTop );
+ aListButtonsLayout->addWidget( myUp );
+ aListButtonsLayout->addWidget( myDown );
+ aListButtonsLayout->addWidget( myBottom );
+ aListButtonsLayout->addStretch();
+
+ aMainLayout->addLayout( aListButtonsLayout );
+
+ // Buttons connections
+ QSignalMapper* aSignalMapper = new QSignalMapper( this );
+ aSignalMapper->setMapping( myTop, HYDROGUI_ListModel::Top );
+ aSignalMapper->setMapping( myUp, HYDROGUI_ListModel::Up );
+ aSignalMapper->setMapping( myDown, HYDROGUI_ListModel::Down );
+ aSignalMapper->setMapping( myBottom, HYDROGUI_ListModel::Bottom );
+ connect( myTop, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
+ connect( myUp, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
+ connect( myDown, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
+ connect( myBottom, SIGNAL( clicked() ), aSignalMapper, SLOT( map() ) );
+ connect( aSignalMapper, SIGNAL( mapped( int ) ), this, SLOT( onMove( int ) ) );
+ } else {
+ myTop = myUp = myDown = myBottom = 0;
+ }
connect ( myList->selectionModel(), SIGNAL( selectionChanged( QItemSelection, QItemSelection ) ),
this, SIGNAL( selectionChanged() ) );
void HYDROGUI_OrderedListWidget::setOrderingEnabled( const bool theIsToEnable )
{
// enable/disable arrow buttons
- myTop->setEnabled( theIsToEnable );
- myUp->setEnabled( theIsToEnable );
- myDown->setEnabled( theIsToEnable );
- myBottom->setEnabled( theIsToEnable );
+ if ( myTop && myUp && myDown && myBottom ) {
+ myTop->setEnabled( theIsToEnable );
+ myUp->setEnabled( theIsToEnable );
+ myDown->setEnabled( theIsToEnable );
+ myBottom->setEnabled( theIsToEnable );
+ }
// enable/disable drag and drop
myList->setDragEnabled( theIsToEnable );
#include <gp_GTrsf.hxx>
#include <QDialog>
+#include <QDir>
#include <QTemporaryFile>
/**
// Create temporary graphics file
QImage aQImage = myImage->Image();
- myTmpImageFile = new QTemporaryFile( anImageName );
+ myTmpImageFile = new QTemporaryFile( QDir::tempPath() + QDir::separator() + anImageName );
if ( !myTmpImageFile->open() ||
!aQImage.save( myTmpImageFile->fileName(), "PNG", 100 ) ) {
abort();
{
}
-bool HYDROGUI_SetColorOp::CanObjectBeColored( const Handle(HYDROData_Entity)& theObject )
+bool HYDROGUI_SetColorOp::CanObjectBeColored( const Handle(HYDROData_Entity)& theObject,
+ HYDROGUI_Module* theModule )
{
if ( theObject.IsNull() )
return false;
- return theObject->IsKind( STANDARD_TYPE(HYDROData_Object) ) ||
- theObject->IsKind( STANDARD_TYPE(HYDROData_IPolyline) ) ||
- theObject->IsKind( STANDARD_TYPE(HYDROData_LandCover) );
+ bool isCanBeColored = false;
+ if ( theObject->IsKind( STANDARD_TYPE(HYDROData_LandCover) ) ) {
+ size_t anActiveViewId = HYDROGUI_Tool::GetActiveOCCViewId( theModule );
+ isCanBeColored = !theModule->isLandCoversScalarMapModeOn( anActiveViewId );
+ }
+
+ return isCanBeColored ||
+ theObject->IsKind( STANDARD_TYPE(HYDROData_Object) ) ||
+ theObject->IsKind( STANDARD_TYPE(HYDROData_IPolyline) );
}
void HYDROGUI_SetColorOp::startOperation()
// Get the selected object
//myEditedObject = Handle(HYDROData_Object)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) );
myEditedObject = HYDROGUI_Tool::GetSelectedObject( module() );
- if ( !CanObjectBeColored( myEditedObject ) )
+ if ( !CanObjectBeColored( myEditedObject, module() ) )
{
abort();
return;
virtual ~HYDROGUI_SetColorOp();
- static bool CanObjectBeColored( const Handle(HYDROData_Entity)& theObject );
+ static bool CanObjectBeColored( const Handle(HYDROData_Entity)& theObject,
+ HYDROGUI_Module* theModule );
protected:
virtual void startOperation();
setShape( aCompound, false, false );
}
- else if ( myObject->IsKind( STANDARD_TYPE(HYDROData_LandCover) ) )
- {
- Handle(HYDROData_LandCover) aLandCoverObj =
- Handle(HYDROData_LandCover)::DownCast( myObject );
-
- TopoDS_Shape aLandCoverShape = aLandCoverObj->GetShape();
- if ( !aLandCoverShape.IsNull() ) {
- setShape( aLandCoverShape, false, false );
- }
-
- QColor aFillingColor = aLandCoverObj->GetFillingColor();
- QColor aBorderColor = aLandCoverObj->GetBorderColor();
-
- setFillingColor( aFillingColor, false, false );
- setBorderColor( aBorderColor, false, false );
- }
}
if ( myShape.IsNull() || !isVisible() )
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "HYDROGUI_ShapeLandCover.h"
+#include "HYDROGUI_OCCDisplayer.h"
+
+#include <HYDROData_LandCover.h>
+
+#include <AIS_InteractiveContext.hxx>
+
+HYDROGUI_ShapeLandCover::HYDROGUI_ShapeLandCover( HYDROGUI_OCCDisplayer* theDisplayer,
+ const Handle(AIS_InteractiveContext)& theContext,
+ const Handle_HYDROData_LandCover& theLandCover,
+ const int theZLayer,
+ const bool theIsScalarMode )
+: HYDROGUI_Shape( theContext, theLandCover, theZLayer ),
+ myDisplayer( theDisplayer ),
+ myIsScalarMapMode( theIsScalarMode )
+{
+}
+
+HYDROGUI_ShapeLandCover::~HYDROGUI_ShapeLandCover()
+{
+}
+
+void HYDROGUI_ShapeLandCover::update( bool theIsUpdateViewer, bool isDeactivateSelection )
+{
+ setIsToUpdate( false );
+
+ Handle(HYDROData_LandCover) aLandCoverObj =
+ Handle(HYDROData_LandCover)::DownCast( getObject() );
+
+ TopoDS_Shape aLandCoverShape = aLandCoverObj->GetShape();
+ if ( !aLandCoverShape.IsNull() ) {
+ setShape( aLandCoverShape, false, false );
+ }
+
+ if ( !myIsScalarMapMode ) {
+ QColor aFillingColor = aLandCoverObj->GetFillingColor();
+ QColor aBorderColor = aLandCoverObj->GetBorderColor();
+
+ setFillingColor( aFillingColor, false, false );
+ setBorderColor( aBorderColor, false, false );
+ } else {
+ updateShape( false, false );
+ }
+
+ HYDROGUI_Shape::update( theIsUpdateViewer, isDeactivateSelection );
+}
+
+void HYDROGUI_ShapeLandCover::setScalarMapModeEnabled( const bool theIsToEnable )
+{
+ myIsScalarMapMode = theIsToEnable;
+}
+
+void HYDROGUI_ShapeLandCover::setVisible( const bool theState,
+ const bool theIsUpdateViewer )
+{
+ HYDROGUI_Shape::setVisible( theState, theIsUpdateViewer );
+ myDisplayer->SetToUpdateColorScale();
+}
+
+void HYDROGUI_ShapeLandCover::displayShape( const bool theIsUpdateViewer )
+{
+ HYDROGUI_Shape::displayShape( theIsUpdateViewer );
+ myDisplayer->SetToUpdateColorScale();
+}
+
+void HYDROGUI_ShapeLandCover::display( const bool theIsUpdateViewer )
+{
+ HYDROGUI_Shape::display( theIsUpdateViewer );
+ myDisplayer->SetToUpdateColorScale();
+}
+
+void HYDROGUI_ShapeLandCover::erase( const bool theIsUpdateViewer )
+{
+ HYDROGUI_Shape::erase( theIsUpdateViewer );
+ myDisplayer->SetToUpdateColorScale();
+}
--- /dev/null
+// Copyright (C) 2014-2015 EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef HYDROGUI_SHAPE_LANDCOVER_H
+#define HYDROGUI_SHAPE_LANDCOVER_H
+
+#include <HYDROGUI_Shape.h>
+
+class Handle_HYDROData_LandCover;
+class HYDROGUI_OCCDisplayer;
+
+class HYDROGUI_ShapeLandCover : public HYDROGUI_Shape
+{
+public:
+ HYDROGUI_ShapeLandCover( HYDROGUI_OCCDisplayer* theDisplayer,
+ const Handle(AIS_InteractiveContext)& theContext,
+ const Handle_HYDROData_LandCover& theLandCover,
+ const int theZLayer = -1,
+ const bool theIsScalarMode = false );
+ virtual ~HYDROGUI_ShapeLandCover();
+
+ virtual void update( bool isUpdateViewer,
+ bool isDeactivateSelection );
+
+ virtual void display( const bool theIsUpdateViewer = true );
+ virtual void erase( const bool theIsUpdateViewer = true );
+
+ virtual void setVisible( const bool theState,
+ const bool theIsUpdateViewer = true );
+
+ /**
+ * Enable/disable scalar map coloring mode.
+ * @param theIsToEnable if true - scalar map coloring mode willbe enbaled, if false - disabled
+ */
+ virtual void setScalarMapModeEnabled( const bool theIsToEnable );
+
+protected:
+ virtual void displayShape( const bool theIsUpdateViewer );
+
+private:
+ HYDROGUI_OCCDisplayer* myDisplayer;
+ bool myIsScalarMapMode;
+};
+
+#endif
#include <GraphicsView_Viewer.h>
#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
#include "HYDROGUI_Operations.h"
#include "HYDROGUI_Tool.h"
#include "HYDROGUI_UpdateFlags.h"
#include "HYDROGUI_StreamDlg.h"
+#include "HYDROGUI_ListSelector.h"
+#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OrderedListWidget.h"
#include "HYDROGUI_Tool.h"
+#include <HYDROData_Profile.h>
+
+#include <LightApp_Application.h>
+#include <LightApp_SelectionMgr.h>
+
#include <QComboBox>
#include <QGroupBox>
#include <QLabel>
anAxisLayout->addWidget( new QLabel( tr( "STREAM_HYDRAULIC_AXIS" ) ) );
anAxisLayout->addWidget( myAxes );
- myProfiles = new QListWidget( aParamGroup );
- myProfiles->setSelectionMode( QListWidget::ExtendedSelection );
- myProfiles->setEditTriggers( QListWidget::NoEditTriggers );
- myProfiles->setViewMode( QListWidget::ListMode );
- myProfiles->setSortingEnabled( false );
-
+ myProfiles = new HYDROGUI_OrderedListWidget( aParamGroup, 0 );
+ myProfiles->setHiddenObjectsShown(true);
+ myProfiles->setVisibilityIconShown(false);
+ myProfiles->setContentsMargins(QMargins());
+ myProfiles->setOrderingEnabled( false );
+
myAddButton = new QPushButton( aParamGroup );
myAddButton->setText( tr("ADD") );
myRemoveButton = new QPushButton( aParamGroup );
addWidget( aParamGroup );
addStretch();
+ // Create selector
+ if ( module() ) {
+ HYDROGUI_ListSelector* aListSelector =
+ new HYDROGUI_ListSelector( myProfiles, module()->getApp()->selectionMgr() );
+ aListSelector->setAutoBlock( true );
+ }
+
// Connect signals and slots
connect( myAxes, SIGNAL( currentIndexChanged( const QString & ) ),
this, SIGNAL( AxisChanged( const QString& ) ) );
myObjectName->clear();
myAxes->clear();
- myProfiles->clear();
+ myProfiles->setObjects( HYDROGUI_ListModel::Object2VisibleList() );
myAddButton->setEnabled( false );
myRemoveButton->setEnabled( false );
myProfiles->setUpdatesEnabled( false );
- myProfiles->clear();
+ HYDROGUI_ListModel::Object2VisibleList aProfiles;
foreach ( const QString& aProfileName, theProfiles ) {
- QListWidgetItem* aListItem = new QListWidgetItem( aProfileName, myProfiles );
- aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
+ Handle(HYDROData_Profile) anObject = Handle(HYDROData_Profile)::DownCast(
+ HYDROGUI_Tool::FindObjectByName( module(), aProfileName ) );
+ if ( !anObject.IsNull() ) {
+ aProfiles.append( HYDROGUI_ListModel::Object2Visible( anObject, true ) );
+ }
}
- myRemoveButton->setEnabled( myProfiles->count() > 0 );
+ myProfiles->setObjects( aProfiles );
+
+ myRemoveButton->setEnabled( myProfiles->getObjects().count() > 0 );
myProfiles->setUpdatesEnabled( true );
void HYDROGUI_StreamDlg::onRemoveProfiles()
{
- QStringList aSelectedProfiles;
-
- QList<QListWidgetItem*> aSelectedItems = myProfiles->selectedItems();
- foreach( const QListWidgetItem* anItem, aSelectedItems ) {
- QString aProfileName = anItem->text();
- if ( !aProfileName.isEmpty() ) {
- aSelectedProfiles << aProfileName;
- }
- }
+ QStringList aSelectedProfiles = myProfiles->getSelectedNames();
emit RemoveProfiles( aSelectedProfiles );
}
#include "HYDROGUI_InputPanel.h"
+class HYDROGUI_OrderedListWidget;
+
class QComboBox;
class QGroupBox;
class QLineEdit;
QGroupBox* myObjectNameGroup;
QLineEdit* myObjectName;
- QComboBox* myAxes;
- QListWidget* myProfiles;
- QPushButton* myRemoveButton;
- QPushButton* myAddButton;
+ QComboBox* myAxes;
+ HYDROGUI_OrderedListWidget* myProfiles;
+ QPushButton* myRemoveButton;
+ QPushButton* myAddButton;
};
#endif
void HYDROGUI_StreamOp::onRemoveProfiles( const QStringList& theProfilesToRemove )
{
QStringList aToRemove = theProfilesToRemove;
-
- // Take the Object Browser selection into account
- HYDROData_SequenceOfObjects aSelectedObjects = HYDROGUI_Tool::GetSelectedObjects( module() );
- for( int i = 1, n = aSelectedObjects.Length(); i <= n; i++ )
- {
- Handle(HYDROData_Profile) aProfile =
- Handle(HYDROData_Profile)::DownCast( aSelectedObjects.Value( i ) );
- if ( aProfile.IsNull() )
- continue;
-
- QString aProfileName = aProfile->GetName();
- aToRemove.append( aProfileName );
- }
-
+
aToRemove.removeDuplicates();
if ( aToRemove.isEmpty() )
return;
#include "HYDROGUI_StricklerTableDlg.h"
#include "HYDROGUI_DataObject.h"
+#include "HYDROGUI_Module.h"
+#include "HYDROGUI_OCCDisplayer.h"
#include "HYDROGUI_Operations.h"
#include "HYDROGUI_Tool.h"
+#include "HYDROGUI_UpdateFlags.h"
#include <HYDROData_Document.h>
{
QString anEntry = HYDROGUI_DataObject::dataObjectEntry( aStricklerTableObj );
theBrowseObjectsEntries.append( anEntry );
+ } else {
+ module()->getOCCDisplayer()->SetToUpdateColorScale();
}
- theUpdateFlags |= UF_ObjBrowser;
+ theUpdateFlags |= UF_ObjBrowser | UF_OCCViewer;
return true;
}
<translation>Recognize contours</translation>
</message>
+ <message>
+ <source>MEN_LC_SCALARMAP_COLORING_ON</source>
+ <translation>Use as scalar scale</translation>
+ </message>
+ <message>
+ <source>DSK_LC_SCALARMAP_COLORING_ON</source>
+ <translation>Use the table as a scalar scale for Land Covers coloring</translation>
+ </message>
+ <message>
+ <source>STB_LC_SCALARMAP_COLORING_ON</source>
+ <translation>Use as scalar scale</translation>
+ </message>
+
+ <message>
+ <source>MEN_LC_SCALARMAP_COLORING_OFF</source>
+ <translation>Scalar map mode off</translation>
+ </message>
+ <message>
+ <source>DSK_LC_SCALARMAP_COLORING_OFF</source>
+ <translation>Turn off Land Covers scalar map coloring mode</translation>
+ </message>
+ <message>
+ <source>STB_LC_SCALARMAP_COLORING_OFF</source>
+ <translation>Scalar map mode off</translation>
+ </message>
+
</context>
<context>
%End
QString DumpRules();
+ QString DumpLandCoverRules();
void SetAssignmentMode( AssignmentMode theMode );
AssignmentMode GetAssignmentMode() const;
+ void SetAssignmentLandCoverMode( AssignmentMode theMode );
+ AssignmentMode GetAssignmentLandCoverMode() const;
+
protected:
/**
