X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_Tool.cxx;h=45e356eba33aecb89808930ffa822a9753b8dbb1;hb=d6e19029f8b41f295db878e9aecf451c2edda4af;hp=4650f24e36a5c2bd2115d005c9576c8ea7762f70;hpb=bd1a4992da8d54929ec556df6db4e7e0ebbfbbd7;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_Tool.cxx b/src/HYDROGUI/HYDROGUI_Tool.cxx index 4650f24e..45e356eb 100644 --- a/src/HYDROGUI/HYDROGUI_Tool.cxx +++ b/src/HYDROGUI/HYDROGUI_Tool.cxx @@ -1,12 +1,8 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE -// -// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// +// 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. +// 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 @@ -29,29 +25,49 @@ #include #include -#include +#include +#include +#include +#include + +#include #include +#include + #include #include #include +#include +#include + #include +#include #include +#include #include #include #include -#include +#include + +#include + +#include +#include #include +#include // Definition of this id allows to use 'latin1' (Qt alias for 'ISO-8859-1') // encoding instead of default 'System' #define USE_LATIN1_ENCODING +// #define DEB_GROUPS 1 + QString HYDROGUI_Tool::ToQString( const TCollection_AsciiString& src ) { #ifdef USE_LATIN1_ENCODING @@ -132,35 +148,52 @@ Handle(TCollection_HExtendedString) HYDROGUI_Tool::ToHExtString( const QString& return new TCollection_HExtendedString( ToExtString( src ) ); } -void HYDROGUI_Tool::LambertToDouble( const int theDegrees, - const int theMinutes, - const double theSeconds, - double& theCoord ) +int HYDROGUI_Tool::GetActiveStudyId() { - // ouv: check the case of negative degrees - theCoord = theDegrees * 3600 + theMinutes * 60 + theSeconds; + if( SUIT_Session* aSession = SUIT_Session::session() ) + if( SUIT_Application* anApp = aSession->activeApplication() ) + if( SUIT_Study* aStudy = anApp->activeStudy() ) + return aStudy->id(); + return 0; } -void HYDROGUI_Tool::DoubleToLambert( const double theCoord, - int& theDegrees, - int& theMinutes, - double& theSeconds ) +QString HYDROGUI_Tool::GetTempDir( const bool theToCreate ) { - // ouv: check the case of negative degrees - theDegrees = int( theCoord / 3600 ); - - double aRemainder = theCoord - theDegrees * 3600; - theMinutes = int( aRemainder / 60 ); + QString aRes; - theSeconds = aRemainder - theMinutes * 60; -} + char* tmpdir = getenv ( "HYDRO_TMP_DIR" ); + if ( tmpdir ) + { + // try to create folder if it does not exist + QFileInfo fi( tmpdir ); + if ( !fi.exists() && theToCreate ) + { + if ( QDir().mkdir( tmpdir ) ) + QFile::setPermissions( tmpdir, (QFile::Permissions)0x4FFFF ); + QFileInfo fi( tmpdir ); + if ( !fi.exists() || !fi.isWritable() ) + tmpdir = 0; + } + } + if ( !tmpdir ) + tmpdir = getenv ( "TEMP" ); + if ( !tmpdir ) + tmpdir = getenv ( "TMP" ); + if ( !tmpdir ) + { +#ifdef WNT + tmpdir = "C:\\"; +#else + tmpdir = "/tmp"; +#endif + } + aRes = tmpdir; + + QFileInfo fi( aRes ); + if ( !fi.exists() || !fi.isWritable() ) + aRes = QString::null; -bool HYDROGUI_Tool::IsEqual( const Handle(HYDROData_Object)& theObj1, - const Handle(HYDROData_Object)& theObj2 ) -{ - if( !theObj1.IsNull() && !theObj2.IsNull() ) - return theObj1->Label() == theObj2->Label(); //ouv: check that the names can be used here - return false; + return aRes; } void HYDROGUI_Tool::SetActiveViewManager( HYDROGUI_Module* theModule, @@ -173,39 +206,74 @@ void HYDROGUI_Tool::SetActiveViewManager( HYDROGUI_Module* theModule, aWorkstack->setActiveWindow( aViewWindow ); } -void HYDROGUI_Tool::GetPrsSubObjects( HYDROGUI_Module* theModule, - HYDROData_SequenceOfObjects& theSeq ) +bool HYDROGUI_Tool::IsObjectHasPresentation( const Handle(HYDROData_Entity)& theObject, + const QString& theViewerType ) { - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); - if( aDocument.IsNull() ) - return; + if ( theObject.IsNull() ) + return false; - HYDROData_Iterator anIterator( aDocument, KIND_IMAGE ); - for( ; anIterator.More(); anIterator.Next() ) + ObjectKind anObjectKind = theObject->GetKind(); + if ( theViewerType.isEmpty() || theViewerType == OCCViewer_Viewer::Type() ) { - Handle(HYDROData_Object) anObject = anIterator.Current(); - if( !anObject.IsNull() ) - theSeq.Append( anObject ); + if ( anObjectKind == KIND_IMAGE || + anObjectKind == KIND_POLYLINEXY || + anObjectKind == KIND_POLYLINE || + anObjectKind == KIND_IMMERSIBLE_ZONE || + anObjectKind == KIND_REGION || + anObjectKind == KIND_ZONE || + anObjectKind == KIND_OBSTACLE || + anObjectKind == KIND_PROFILE || + anObjectKind == KIND_STREAM || + anObjectKind == KIND_CHANNEL || + anObjectKind == KIND_DIGUE || + anObjectKind == KIND_DUMMY_3D || + anObjectKind == KIND_BATHYMETRY || + anObjectKind == KIND_LAND_COVER +#ifdef DEB_GROUPS + || anObjectKind == KIND_SHAPES_GROUP || + anObjectKind == KIND_SPLITTED_GROUP +#endif + ) + { + return true; + } + } + + if ( theViewerType.isEmpty() || theViewerType == SVTK_Viewer::Type() ) + { + if ( anObjectKind == KIND_BATHYMETRY ) + return true; } - anIterator = HYDROData_Iterator( aDocument, KIND_POLYLINE ); - for( ; anIterator.More(); anIterator.Next() ) + if ( theViewerType.isEmpty() || theViewerType == GraphicsView_Viewer::Type() ) { - Handle(HYDROData_Object) anObject = anIterator.Current(); - if( !anObject.IsNull() ) - theSeq.Append( anObject ); + if ( anObjectKind == KIND_IMAGE || + anObjectKind == KIND_POLYLINEXY ) + return true; } - anIterator = HYDROData_Iterator( aDocument, KIND_ZONE ); - for( ; anIterator.More(); anIterator.Next() ) + return false; +} + +void HYDROGUI_Tool::GetPrsSubObjects( HYDROGUI_Module* theModule, + HYDROData_SequenceOfObjects& theSeq ) +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); + if( !aDocument.IsNull() ) { - Handle(HYDROData_Object) anObject = anIterator.Current(); - if( !anObject.IsNull() ) + HYDROData_Iterator anIterator( aDocument ); + for( ; anIterator.More(); anIterator.Next() ) + { + Handle(HYDROData_Entity) anObject = anIterator.Current(); + if ( !IsObjectHasPresentation( anObject ) ) + continue; + theSeq.Append( anObject ); + } } } -HYDROGUI_Prs* HYDROGUI_Tool::GetPresentation( const Handle(HYDROData_Object)& theObj, +HYDROGUI_Prs* HYDROGUI_Tool::GetPresentation( const Handle(HYDROData_Entity)& theObj, const GraphicsView_ObjectList& theObjects ) { if( !theObj.IsNull() ) @@ -215,7 +283,7 @@ HYDROGUI_Prs* HYDROGUI_Tool::GetPresentation( const Handle(HYDROData_Object)& th { if( HYDROGUI_Prs* aPrs = dynamic_cast( anIter.next() ) ) { - Handle(HYDROData_Object) anObj = aPrs->getObject(); + Handle(HYDROData_Entity) anObj = aPrs->getObject(); if( IsEqual( anObj, theObj ) ) return aPrs; } @@ -252,7 +320,7 @@ HYDROData_SequenceOfObjects HYDROGUI_Tool::GetSelectedObjects( HYDROGUI_Module* { if( LightApp_DataOwner* anOwner = dynamic_cast( aSUITOwner ) ) { - Handle(HYDROData_Object) anObject = aModel->objectByEntry( anOwner->entry() ); + Handle(HYDROData_Entity) anObject = aModel->objectByEntry( anOwner->entry() ); if( !anObject.IsNull() ) { QString aName = anObject->GetName(); @@ -267,7 +335,7 @@ HYDROData_SequenceOfObjects HYDROGUI_Tool::GetSelectedObjects( HYDROGUI_Module* return aSeq; } -Handle(HYDROData_Object) HYDROGUI_Tool::GetSelectedObject( HYDROGUI_Module* theModule ) +Handle(HYDROData_Entity) HYDROGUI_Tool::GetSelectedObject( HYDROGUI_Module* theModule ) { HYDROData_SequenceOfObjects aSeq = GetSelectedObjects( theModule ); if( !aSeq.IsEmpty() ) @@ -275,6 +343,43 @@ Handle(HYDROData_Object) HYDROGUI_Tool::GetSelectedObject( HYDROGUI_Module* theM return NULL; } +HYDROData_SequenceOfObjects HYDROGUI_Tool::GetGeometryObjects( + HYDROGUI_Module* theModule ) +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); + + HYDROData_SequenceOfObjects aResSeq; + + HYDROData_Iterator anIter( aDocument ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Entity) anObj = anIter.Current(); + if ( !HYDROData_Tool::IsGeometryObject( anObj ) ) + continue; + + aResSeq.Append( anObj ); + } + + return aResSeq; +} + +HYDROData_SequenceOfObjects HYDROGUI_Tool::GetLandCovers( HYDROGUI_Module* theModule ) +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); + + HYDROData_SequenceOfObjects aResSeq; + + HYDROData_Iterator anIter( aDocument ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Entity) anObj = anIter.Current(); + if ( !anObj.IsNull() && anObj->IsKind( STANDARD_TYPE(HYDROData_LandCover) )) + aResSeq.Append( anObj ); + } + + return aResSeq; +} + ObjectKind HYDROGUI_Tool::GetSelectedPartition( HYDROGUI_Module* theModule ) { HYDROGUI_DataModel* aModel = theModule->getDataModel(); @@ -294,30 +399,68 @@ ObjectKind HYDROGUI_Tool::GetSelectedPartition( HYDROGUI_Module* theModule ) { anEntry.remove( aPrefix ); for( ObjectKind anObjectKind = KIND_UNKNOWN + 1; anObjectKind <= KIND_LAST; anObjectKind++ ) - if( HYDROGUI_DataModel::partitionName( anObjectKind ) == anEntry ) + if( HYDROGUI_DataModel::tr( HYDROGUI_DataModel::partitionName( anObjectKind ).toAscii() ) == anEntry ) return anObjectKind; } } return KIND_UNKNOWN; } -Handle(HYDROData_Object) HYDROGUI_Tool::FindObjectByName( HYDROGUI_Module* theModule, - const QString& theName, - const ObjectKind theObjectKind ) +QStringList HYDROGUI_Tool::GetSelectedGeomObjects( HYDROGUI_Module* theModule, + QList theTypes ) { - Handle(HYDROData_Object) anObject; - if ( theName.isEmpty() ) - return anObject; + QStringList anEntryList; + + // Get active SalomeApp_Study + SalomeApp_Study* aStudy = NULL; + if ( theModule && theModule->getApp() ) { + aStudy = dynamic_cast( theModule->getApp()->activeStudy() ); + } + if ( !aStudy ) { + return anEntryList; + } + + // Get selection + SUIT_SelectionMgr* aSelectionMgr = theModule->getApp()->selectionMgr(); + SUIT_DataOwnerPtrList anOwners; + aSelectionMgr->selected( anOwners ); + + // Check if the selected objects belong to GEOM and have a shape + foreach( SUIT_DataOwner* aSUITOwner, anOwners ) + { + if( LightApp_DataOwner* anOwner = dynamic_cast( aSUITOwner ) ) + { + QString anEntry = anOwner->entry(); + _PTR(SObject) aSObject( aStudy->studyDS()->FindObjectID(qPrintable(anEntry)) ); + if (aSObject) { + _PTR(SComponent) aSComponent = aSObject->GetFatherComponent(); + if ( aSComponent && aSComponent->ComponentDataType() == "GEOM" ) { + GEOM::GEOM_Object_var aGeomObj = + GEOMBase::GetObjectFromIOR( aSObject->GetIOR().c_str() ); + + if ( !aGeomObj->_is_nil() && aGeomObj->IsShape() && + theTypes.contains( aGeomObj->GetShapeType() ) ) { + anEntryList << anEntry; + } + } + } + } + } - QStringList aNamesList; - aNamesList << theName; + return anEntryList; +} - HYDROData_SequenceOfObjects aSeqOfObjs = FindObjectsByNames( theModule, aNamesList, theObjectKind ); - if( aSeqOfObjs.IsEmpty() ) - return anObject; +Handle(HYDROData_Entity) HYDROGUI_Tool::FindObjectByName( HYDROGUI_Module* theModule, + const QString& theName, + const ObjectKind theObjectKind ) +{ + Handle(HYDROData_Entity) aResObj; - anObject = aSeqOfObjs.First(); - return anObject; + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); + if ( !aDocument.IsNull() ) + aResObj = aDocument->FindObjectByName( theName, theObjectKind ); + + return aResObj; } HYDROData_SequenceOfObjects HYDROGUI_Tool::FindObjectsByNames( HYDROGUI_Module* theModule, @@ -325,62 +468,29 @@ HYDROData_SequenceOfObjects HYDROGUI_Tool::FindObjectsByNames( HYDROGUI_Module* const ObjectKind theObjectKind ) { HYDROData_SequenceOfObjects aResSeq; - if ( theNames.isEmpty() ) - return aResSeq; Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); - if( aDocument.IsNull() ) - return aResSeq; - - QStringList aNamesList = theNames; - - HYDROData_Iterator anIter( aDocument, theObjectKind ); - for( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Object) anObjectRef = anIter.Current(); - if( anObjectRef.IsNull() ) - continue; - - QString anObjName = anObjectRef->GetName(); - if ( anObjName.isEmpty() || !aNamesList.contains( anObjName ) ) - continue; - - aResSeq.Append( anObjectRef ); - - aNamesList.removeAll( anObjName ); - if ( aNamesList.isEmpty() ) - break; - } + if ( !aDocument.IsNull() ) + aResSeq = aDocument->FindObjectsByNames( theNames, theObjectKind ); return aResSeq; } QString HYDROGUI_Tool::GenerateObjectName( HYDROGUI_Module* theModule, const QString& thePrefix, - const QStringList& theUsedNames ) + const QStringList& theUsedNames, + const bool theIsTryToUsePurePrefix) { - QString aName; - int anId = 1; - while( anId < 100 ) - { - aName = QString( "%1_%2" ).arg( thePrefix ).arg( QString::number( anId++ ) ); - - if ( theUsedNames.contains( aName ) ) - continue; - - // check that there are no other objects with the same name in the document - Handle(HYDROData_Object) anObject = FindObjectByName( theModule, aName, KIND_UNKNOWN ); - if( anObject.IsNull() ) - break; - } - return aName; + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); + return HYDROData_Tool::GenerateObjectName( aDocument, thePrefix, theUsedNames, theIsTryToUsePurePrefix ); } -size_t HYDROGUI_Tool::GetActiveGraphicsViewId( HYDROGUI_Module* theModule ) +size_t HYDROGUI_Tool::GetActiveViewId( HYDROGUI_Module* theModule, + const QString& theViewId ) { size_t aViewId = 0; SUIT_ViewManager* aViewMgr = theModule->getApp()->activeViewManager(); - if( !aViewMgr || aViewMgr->getType() != GraphicsView_Viewer::Type() ) + if( !aViewMgr || ( !theViewId.isEmpty() && aViewMgr->getType() != theViewId ) ) return aViewId; if( SUIT_ViewModel* aViewer = aViewMgr->getViewModel() ) @@ -388,11 +498,22 @@ size_t HYDROGUI_Tool::GetActiveGraphicsViewId( HYDROGUI_Module* theModule ) return aViewId; } -QList HYDROGUI_Tool::GetGraphicsViewIdList( HYDROGUI_Module* theModule ) +size_t HYDROGUI_Tool::GetActiveGraphicsViewId( HYDROGUI_Module* theModule ) +{ + return GetActiveViewId( theModule, GraphicsView_Viewer::Type() ); +} + +size_t HYDROGUI_Tool::GetActiveOCCViewId( HYDROGUI_Module* theModule ) +{ + return GetActiveViewId( theModule, OCCViewer_Viewer::Type() ); +} + +QList getViewIdList( HYDROGUI_Module* theModule, + const QString& theViewId ) { QList aList; ViewManagerList aViewMgrs; - theModule->getApp()->viewManagers( GraphicsView_Viewer::Type(), aViewMgrs ); + theModule->getApp()->viewManagers( theViewId, aViewMgrs ); QListIterator anIter( aViewMgrs ); while( anIter.hasNext() ) { @@ -405,66 +526,133 @@ QList HYDROGUI_Tool::GetGraphicsViewIdList( HYDROGUI_Module* theModule ) return aList; } -void HYDROGUI_Tool::GetObjectReferences( const Handle(HYDROData_Image)& theImage, - HYDROData_SequenceOfObjects& theRefObjects, - QStringList& theRefNames ) +QList HYDROGUI_Tool::GetGraphicsViewIdList( HYDROGUI_Module* theModule ) { - if( theImage.IsNull() ) + return getViewIdList( theModule, GraphicsView_Viewer::Type() ); +} + +QList HYDROGUI_Tool::GetOCCViewIdList( HYDROGUI_Module* theModule ) +{ + return getViewIdList( theModule, OCCViewer_Viewer::Type() ); +} + +void HYDROGUI_Tool::setOCCActionShown( OCCViewer_ViewFrame* theViewFrame, + const int theActionId, + const bool isShown ) +{ + if ( !theViewFrame ) return; - for( int anIndex = 0, aNbRef = theImage->NbReferences(); anIndex < aNbRef; anIndex++ ) + OCCViewer_ViewWindow* aView = theViewFrame->getView( OCCViewer_ViewFrame::MAIN_VIEW ); + if ( aView ) { + aView->toolMgr()->setShown( theActionId, isShown ); + if ( theActionId == OCCViewer_ViewWindow::MaximizedId ) + theViewFrame->onMaximizedView( aView, true ); + } +} + +void HYDROGUI_Tool::setOCCActionShown( HYDROGUI_Module* theModule, + const int theActionId, + const bool isShown ) +{ + QList aList; + ViewManagerList aViewMgrs; + theModule->getApp()->viewManagers( OCCViewer_Viewer::Type(), aViewMgrs ); + QListIterator anIter( aViewMgrs ); + while( anIter.hasNext() ) { - Handle(HYDROData_Object) aRefObj = theImage->Reference( anIndex ); - if( !aRefObj.IsNull() && !aRefObj->IsRemoved() ) + if( SUIT_ViewManager* aViewMgr = anIter.next() ) { - QString aName = aRefObj->GetName(); - if( !theRefNames.contains( aName ) ) - { - theRefObjects.Append( aRefObj ); - theRefNames.append( aRefObj->GetName() ); - if( aRefObj->GetKind() == KIND_IMAGE ) - { - Handle(HYDROData_Image) aRefImage = Handle(HYDROData_Image)::DownCast( aRefObj ); - if( !aRefImage.IsNull() ) - GetObjectReferences( aRefImage, theRefObjects, theRefNames ); - } - } + OCCViewer_ViewFrame* aViewFrame = dynamic_cast + ( aViewMgr->getActiveView() ); + if ( aViewFrame ) + setOCCActionShown( aViewFrame, theActionId, isShown ); } } } -void HYDROGUI_Tool::GetObjectBackReferences( HYDROGUI_Module* theModule, - const Handle(HYDROData_Object)& theObj, - HYDROData_SequenceOfObjects& theBackRefObjects, - QStringList& theBackRefNames ) +void HYDROGUI_Tool::GetObjectReferences( const Handle(HYDROData_Entity)& theObj, + HYDROData_SequenceOfObjects& theRefObjects, + QStringList& theRefNames ) { if( theObj.IsNull() ) return; + HYDROData_SequenceOfObjects anAllRefObjects = theObj->GetAllReferenceObjects(); + theRefObjects.Append( anAllRefObjects ); + + for( int i = 1, n = anAllRefObjects.Length(); i <= n; ++i ) + { + Handle(HYDROData_Entity) aRefObj = theRefObjects.Value( i ); + if( aRefObj.IsNull() || aRefObj->IsRemoved() ) + continue; + + QString aRefObjectName = aRefObj->GetName(); + if( theRefNames.contains( aRefObjectName ) ) + continue; + + theRefObjects.Append( aRefObj ); + theRefNames.append( aRefObjectName ); + + GetObjectReferences( aRefObj, theRefObjects, theRefNames ); + } +} + +HYDROData_SequenceOfObjects HYDROGUI_Tool::GetObjectBackReferences( + HYDROGUI_Module* theModule, + const Handle(HYDROData_Entity)& theObj ) +{ + if( theObj.IsNull() ) + return HYDROData_SequenceOfObjects(); + + QString anObjName = theObj->GetName(); + + QMap aMapOfBackRefs = + GetObjectsBackReferences( theModule, QStringList() << anObjName ); + + return aMapOfBackRefs[ anObjName ]; +} + +QMap HYDROGUI_Tool::GetObjectsBackReferences( + HYDROGUI_Module* theModule, const QStringList& theObjectNames ) +{ + QMap aResMap; + + if( theObjectNames.isEmpty() ) + return aResMap; + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); if( aDocument.IsNull() ) - return; - - QString aName = theObj->GetName(); + return aResMap; - HYDROData_Iterator anIterator( aDocument, KIND_IMAGE ); + HYDROData_Iterator anIterator( aDocument ); for( ; anIterator.More(); anIterator.Next() ) { - Handle(HYDROData_Image) anImage = Handle(HYDROData_Image)::DownCast( anIterator.Current() ); - if( !anImage.IsNull() ) + Handle(HYDROData_Entity) anObject = anIterator.Current(); + if( anObject.IsNull() || anObject->IsRemoved() ) + continue; + + QString anObjectName = anObject->GetName(); + if ( theObjectNames.contains( anObjectName ) ) + continue; + + HYDROData_SequenceOfObjects aRefObjects = anObject->GetAllReferenceObjects(); + for ( int i = 1, n = aRefObjects.Length(); i <= n; ++i ) { - HYDROData_SequenceOfObjects aRefObjects; - QStringList aRefNames; - GetObjectReferences( anImage, aRefObjects, aRefNames ); - if( aRefNames.contains( aName ) ) - { - theBackRefObjects.Append( anImage ); - theBackRefNames.append( anImage->GetName() ); - } + Handle(HYDROData_Entity) aRefObject = aRefObjects.Value( i ); + if( aRefObject.IsNull() || aRefObject->IsRemoved() ) + continue; + + QString aRefObjectName = aRefObject->GetName(); + if ( !theObjectNames.contains( aRefObjectName ) ) + continue; + + aResMap[ aRefObjectName ].Append( anObject ); } } -} + return aResMap; +} QDockWidget* HYDROGUI_Tool::WindowDock( QWidget* wid ) { @@ -484,7 +672,14 @@ QDockWidget* HYDROGUI_Tool::WindowDock( QWidget* wid ) QColor HYDROGUI_Tool::GenerateFillingColor( HYDROGUI_Module* theModule, const QStringList& theZoneNames ) { - QColor aFillingColor( HYDROData_Zone::DefaultFillingColor() ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theModule->getStudyId() ); + return GenerateFillingColor( aDocument, theZoneNames ); +} + +QColor HYDROGUI_Tool::GenerateFillingColor( const Handle(HYDROData_Document)& theDoc, + const QStringList& theZoneNames ) +{ + QColor aFillingColor( HYDROData_ImmersibleZone::DefaultFillingColor() ); int aCounter = 0; int aR = 0, aG = 0, aB = 0; @@ -492,8 +687,8 @@ QColor HYDROGUI_Tool::GenerateFillingColor( HYDROGUI_Module* theModule, while( aZoneNameIter.hasNext() ) { const QString& aZoneName = aZoneNameIter.next(); - Handle(HYDROData_Zone) aRefZone = Handle(HYDROData_Zone)::DownCast( - FindObjectByName( theModule, aZoneName, KIND_ZONE ) ); + Handle(HYDROData_ImmersibleZone) aRefZone = + Handle(HYDROData_ImmersibleZone)::DownCast( theDoc->FindObjectByName( aZoneName, KIND_IMMERSIBLE_ZONE ) ); if( !aRefZone.IsNull() ) { QColor aRefColor = aRefZone->GetFillingColor(); @@ -512,3 +707,87 @@ QColor HYDROGUI_Tool::GenerateFillingColor( HYDROGUI_Module* theModule, return aFillingColor; } +QStringList HYDROGUI_Tool::FindExistingObjectsNames( const Handle(HYDROData_Document)& theDoc, + const ObjectKind theObjectKind, + bool isCheckValidProfile ) +{ + QStringList aNames; + + HYDROData_Iterator anIter( theDoc, theObjectKind ); + for ( ; anIter.More(); anIter.Next() ) { + Handle(HYDROData_Entity) anObject = anIter.Current(); + + bool isOK = !anObject.IsNull(); + + if( isOK && isCheckValidProfile ) + { + Handle_HYDROData_Profile aProfile = Handle_HYDROData_Profile::DownCast( anObject ); + if( !aProfile.IsNull() && !aProfile->IsValid() ) + isOK = false; + } + + if( isOK ) + aNames.append( anObject->GetName() ); + } + + return aNames; +} + +QString HYDROGUI_Tool::GetCoordinateString( const double theNumber, bool isInLocale ) +{ + if( isInLocale ) + { + static QLocale aLocale( QLocale::English, QLocale::France ); + return aLocale.toString( theNumber, 'f', 2 ); + } + else + return QString::number( theNumber, 'f', 2 ); +} + +Handle(Image_PixMap) HYDROGUI_Tool::Pixmap( const QImage& theImage ) +{ + Handle(Image_PixMap) pix; + if ( theImage.isNull() || theImage.format() == QImage::Format_Invalid ) + return pix; + + Handle(Image_PixMap) tmpPix = new Image_PixMap(); + tmpPix->SetTopDown( false ); + QImage anImage = theImage.mirrored(); + if ( !anImage.hasAlphaChannel() && anImage.allGray() ) + { + tmpPix->InitTrash( Image_PixMap::ImgGray, anImage.width(), anImage.height(), anImage.width() ); + for ( int r = 0; r < anImage.height(); r++ ) + { + Standard_Byte* aRowData = tmpPix->ChangeRow( anImage.height() - r - 1 ); + for ( int p = 0; p < anImage.width(); p++ ) + aRowData[p] = qRed( anImage.pixel( p, r ) ); + } + } + else + { + Image_PixMap::ImgFormat aFormat; + if ( anImage.hasAlphaChannel() ) + { + if ( anImage.format() != QImage::Format_ARGB32 ) + anImage = anImage.convertToFormat( QImage::Format_ARGB32 ); + aFormat = Image_PixMap::ImgRGBA; + } + else + { + if ( anImage.format() != QImage::Format_RGB888 ) + anImage = anImage.convertToFormat( QImage::Format_RGB888 ); + aFormat = Image_PixMap::ImgRGB; + } + + tmpPix->InitWrapper( aFormat, (Standard_Byte*)anImage.bits(), anImage.width(), anImage.height(), anImage.bytesPerLine() ); + } + + if ( !tmpPix.IsNull() ) + { + pix = new Image_PixMap(); + pix->InitCopy( *tmpPix.operator->() ); + pix->SetTopDown( tmpPix->IsTopDown() ); + } + + return pix; +}