-// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2011 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) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
-// 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.
+// 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.
//
-// 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.
+// 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
+// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESHGUI : GUI for SMESH component
// File : SMESHGUI.cxx
// Author : Nicolas REJNERI, Open CASCADE S.A.S.
#include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
+#ifdef HAVE_FINITE
+#undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
+#endif
#include "Python.h"
// SMESH includes
#include "SMESHGUI.h"
#include "SMESHGUI_VTKUtils.h"
#include "SMESHGUI_HypothesesUtils.h"
+#include <SMESH_version.h>
+
#include <SMESH_Client.hxx>
#include <SMESH_Actor.h>
#include <SMESH_ScalarBarActor.h>
else if ( theCommandID == 111 ) {
filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
}
- else if ( theCommandID == 140 ) {
+ else if ( theCommandID == 115 ) {
filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
}
+ else if ( theCommandID == 116 ) {
+ filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+ }
+ else if ( theCommandID == 117 ) {
+ filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
+ filter.append( QObject::tr( "All files (*)" ) );
+ }
QString anInitialPath = "";
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
}
break;
}
- case 140:
+ case 115:
{
// STL format
aMeshes->length( 1 );
}
break;
}
+ case 116:
+ {
+ // CGNS format
+ SMESH::DriverMED_ReadStatus res;
+ aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
+ if ( res != SMESH::DRS_OK ) {
+ errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
+ arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
+ }
+ break;
+ }
+ case 117:
+ {
+ // SAUV format
+ SMESH::DriverMED_ReadStatus res;
+ aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
+ if ( res != SMESH::DRS_OK ) {
+ errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
+ arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
+ }
+ break;
+ }
}
}
catch ( const SALOME::SALOME_Exception& S_ex ) {
}
}
+ //================================================================================
+ /*!
+ * \brief Export selected meshes or groups into a file
+ */
+ //================================================================================
+
void ExportMeshToFile( int theCommandID )
{
LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
if( aSel )
aSel->selectedObjects( selected );
+ const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
+ const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
+ const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
+ const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
+ const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
+ const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
+
// actually, the following condition can't be met (added for insurance)
if( selected.Extent() == 0 ||
- ( selected.Extent() > 1 && theCommandID != 122 && theCommandID != 125 ) )
+ ( selected.Extent() > 1 && !isMED && !isSTL ))
return;
+ // get mesh object from selection and check duplication of their names
bool hasDuplicatedMeshNames = false;
- QList< QPair< SMESH::SMESH_Mesh_var, QString > > aMeshList;
- QList< QPair< SMESH::SMESH_Mesh_var, QString > >::iterator aMeshIter;
+ QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
+ QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
SALOME_ListIteratorOfListIO It( selected );
- for( ; It.More(); It.Next() ) {
+ for( ; It.More(); It.Next() )
+ {
Handle(SALOME_InteractiveObject) anIObject = It.Value();
- SMESH::SMESH_Mesh_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>( anIObject );
+ SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
if ( aMeshItem->_is_nil() ) {
SUIT_MessageBox::warning( SMESHGUI::desktop(),
QObject::tr( "SMESH_WRN_WARNING" ),
QString aMeshName = anIObject->getName();
- // check for duplications
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
- if( aMeshName == (*aMeshIter).second ) {
- hasDuplicatedMeshNames = true;
- break;
+ // check for name duplications
+ if ( !hasDuplicatedMeshNames )
+ for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
+ if( aMeshName == (*aMeshIter).second ) {
+ hasDuplicatedMeshNames = true;
+ break;
+ }
}
- }
- aMeshList.append( QPair< SMESH::SMESH_Mesh_var, QString >( aMeshItem, aMeshName ) );
+ aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
}
- if( hasDuplicatedMeshNames ) {
+ if( hasDuplicatedMeshNames && isMED ) {
int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
}
aMeshIter = aMeshList.begin();
- SMESH::SMESH_Mesh_var aMesh = (*aMeshIter).first;
+ SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
+ SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
QString aMeshName = (*aMeshIter).second;
- QList<SALOMEDS::Color> aReservedColors;
-
- QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
- QMap<QString, SMESH::MED_VERSION> aFilterMap;
- QMap<QString, int> aFilterMapSTL;
- switch ( theCommandID ) {
- case 125:
- case 122:
- {
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
- SMESH::SMESH_Mesh_var aMeshItem = (*aMeshIter).first;
- if (aMeshItem->HasDuplicatedGroupNamesMED()) {
- int aRet = SUIT_MessageBox::warning
- (SMESHGUI::desktop(),
- QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
- QObject::tr("SMESH_BUT_YES"),
- QObject::tr("SMESH_BUT_NO"), 0, 1);
- if (aRet != 0)
- return;
- }
- }
- // PAL18696
- QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
- QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
- aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
- aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
- }
- break;
- case 124:
- case 121:
- aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
- break;
- case 126:
- case 123:
- {
- if (aMesh->NbPyramids()) {
+ if ( isMED || isCGNS || isSAUV )
+ {
+ // check for equal group names within each mesh
+ for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
+ SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
+ if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
int aRet = SUIT_MessageBox::warning
(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
+ QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
QObject::tr("SMESH_BUT_YES"),
QObject::tr("SMESH_BUT_NO"), 0, 1);
if (aRet != 0)
return;
}
- aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
}
- break;
- case 141:
- {
- // export STL
- /*
- there must be check on others mesh elements not equal triangles
- */
-// if (aMesh->NbTriangles() < 1) {
-// SUIT_MessageBox::warning
-// (SMESHGUI::desktop(),
-// QObject::tr("SMESH_WRN_WARNING"),
-// QObject::tr("SMESH_EXPORT_STL1").arg(aMeshName));
-// return;
-// }
-// if (!(aMesh->NbElements() - aMesh->NbTriangles())) {
-// int aRet = SUIT_MessageBox::warning
-// (SMESHGUI::desktop(),
-// QObject::tr("SMESH_WRN_WARNING"),
-// QObject::tr("SMESH_EXPORT_STL2").arg(aMeshName),
-// QObject::tr("SMESH_BUT_YES"),
-// QObject::tr("SMESH_BUT_NO"), 0, 1);
-// if (aRet != 0)
-// return;
-// }
-
- aFilterMapSTL.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 ); // 1 - ASCII mode
- aFilterMapSTL.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 ); // 0 - Binary mode
+ }
+ else if ( isUNV )
+ {
+ // warn the user about presence of not supported elements
+ SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
+ int nbPyramids = nbElems[ SMESH::Entity_Pyramid ] + nbElems[ SMESH::Entity_Quad_Pyramid ];
+ if ( nbPyramids > 0 ) {
+ int aRet = SUIT_MessageBox::warning
+ (SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
+ QObject::tr("SMESH_BUT_YES"),
+ QObject::tr("SMESH_BUT_NO"), 0, 1);
+ if (aRet != 0)
+ return;
}
- break;
- default:
- return;
}
+ // Get parameters of export operation
+
QString aFilename;
SMESH::MED_VERSION aFormat;
- // Init the parameter with the default value
+ // Init the parameters with the default values
bool aIsASCII_STL = true;
bool toCreateGroups = false;
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
bool toOverwrite = true;
+ QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
QString anInitialPath = "";
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
anInitialPath = QDir::currentPath();
- if ( theCommandID != 122 && theCommandID != 125 && theCommandID != 141) {
+ if ( isUNV || isDAT )
+ {
+ if ( isUNV )
+ aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
+ else
+ aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
- aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(), anInitialPath + QString("/") + aMeshName,
+ aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
+ anInitialPath + QString("/") + aMeshName,
aFilter, aTitle, false);
}
- else if(theCommandID == 141) { // Export to STL
+ else if ( isCGNS )// Export to CGNS
+ {
+ SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
+ fd->setWindowTitle( aTitle );
+ fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+ if ( !anInitialPath.isEmpty() )
+ fd->setDirectory( anInitialPath );
+ fd->selectFile(aMeshName);
+ SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
+ fd->setValidator( fv );
+
+ if ( fd->exec() )
+ aFilename = fd->selectedFile();
+ toOverwrite = fv->isOverwrite();
+
+ delete fd;
+ }
+ else if ( isSTL ) // Export to STL
+ {
+ QMap<QString, int> aFilterMap;
+ aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
+ aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
+
QStringList filters;
- QMap<QString, int>::const_iterator it = aFilterMapSTL.begin();
- for ( ; it != aFilterMapSTL.end(); ++it )
+ QMap<QString, int>::const_iterator it = aFilterMap.begin();
+ for ( ; it != aFilterMap.end(); ++it )
filters.push_back( it.key() );
SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
while (!is_ok) {
if ( fd->exec() )
aFilename = fd->selectedFile();
- aIsASCII_STL = (aFilterMapSTL[fd->selectedNameFilter()]) == 1 ? true: false;
+ aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
is_ok = true;
}
delete fd;
}
- else { // Export to MED
+ else if ( isMED || isSAUV ) // Export to MED or SAUV
+ {
+ QMap<QString, SMESH::MED_VERSION> aFilterMap;
+ //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
+ if ( isMED ) {
+ QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
+ //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
+ aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
+ }
+ else { // isSAUV
+ aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
+ aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
+ aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
+ }
+
QStringList filters;
QString aDefaultFilter;
QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
aDefaultFilter = it.key();
}
- //SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
fd->setWindowTitle( aTitle );
fd->setNameFilters( filters );
- //fd->setSelectedNameFilter( QObject::tr("MED 2.2 (*.med)") );
fd->selectNameFilter(aDefaultFilter);
fd->SetChecked(toCreateGroups);
if ( !anInitialPath.isEmpty() )
toOverwrite = fv->isOverwrite();
is_ok = true;
if ( !aFilename.isEmpty() ) {
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
- SMESH::SMESH_Mesh_var aMeshItem = (*aMeshIter).first;
- if( (aMeshItem->NbPolygons()>0 || aMeshItem->NbPolyhedrons()>0)
- && aFormat==SMESH::MED_V2_1) {
- int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
- QObject::tr("SMESH_WRN_WARNING"),
- QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
- QObject::tr("SMESH_BUT_YES"),
- QObject::tr("SMESH_BUT_NO"), 0, 1);
- if (aRet != 0) {
- is_ok = false;
- break;
+ // med-2.1 does not support poly elements
+ if ( aFormat==SMESH::MED_V2_1 )
+ for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
+ SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
+ SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
+ if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
+ nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
+ {
+ int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
+ QObject::tr("SMESH_BUT_YES"),
+ QObject::tr("SMESH_BUT_NO"), 0, 1);
+ if (aRet != 0) {
+ is_ok = false;
+ break;
+ }
}
}
- }
if( !toOverwrite ) {
+ // can't append to an existing using other format
SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
if( !isVersionOk || aVersion != aFormat ) {
}
}
}
-
if( !aMeshNamesCollisionList.isEmpty() ) {
QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
toCreateGroups = fd->IsChecked();
delete fd;
}
+ else
+ {
+ return;
+ }
+
+ // Perform export
+
if ( !aFilename.isEmpty() ) {
// Check whether the file already exists and delete it if yes
QFile aFile( aFilename );
SUIT_OverrideCursor wc;
try {
- bool Renumber = false;
- // PAL 14172 : Check of we have to renumber or not from the preferences before export
- if (resMgr)
- Renumber= resMgr->booleanValue("SMESH","renumbering");
- if (Renumber){
- SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
- aMeshEditor->RenumberNodes();
- aMeshEditor->RenumberElements();
- if ( SMESHGUI::automaticUpdate() )
- SMESH::UpdateView();
+ // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
+// bool Renumber = false;
+// // PAL 14172 : Check of we have to renumber or not from the preferences before export
+// if (resMgr)
+// Renumber= resMgr->booleanValue("SMESH","renumbering");
+// if (Renumber){
+// SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
+// aMeshEditor->RenumberNodes();
+// aMeshEditor->RenumberElements();
+// if ( SMESHGUI::automaticUpdate() )
+// SMESH::UpdateView();
+// }
+ if ( isMED )
+ {
+ aMeshIter = aMeshList.begin();
+ for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
+ {
+ SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
+ SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
+ if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
+ aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
+ aFormat, toOverwrite && aMeshIndex == 0 );
+ else
+ aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
+ aFormat, toOverwrite && aMeshIndex == 0 );
+ }
}
- switch ( theCommandID ) {
- case 125:
- case 122: {
- int aMeshIndex = 0;
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ ) {
- SMESH::SMESH_Mesh_var aMeshItem = (*aMeshIter).first;
- if( !aMeshItem->_is_nil() )
- aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups, aFormat, toOverwrite && aMeshIndex == 0 );
- }
+ else if ( isSAUV )
+ {
+ for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
+ {
+ SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
+ if( !aMeshItem->_is_nil() )
+ aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
+ }
+ }
+ else if ( isDAT )
+ {
+ if ( aMeshOrGroup->_is_equivalent( aMesh ))
+ aMesh->ExportDAT( aFilename.toLatin1().data() );
+ else
+ aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
+ }
+ else if ( isUNV )
+ {
+ if ( aMeshOrGroup->_is_equivalent( aMesh ))
+ aMesh->ExportUNV( aFilename.toLatin1().data() );
+ else
+ aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
+ }
+ else if ( isSTL )
+ {
+ if ( aMeshOrGroup->_is_equivalent( aMesh ))
+ aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
+ else
+ aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
+ }
+ else if ( isCGNS )
+ {
+ aMeshIter = aMeshList.begin();
+ for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
+ {
+ SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
+ SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
+ aMeshItem->ExportCGNS( aMeshOrGroup,
+ aFilename.toLatin1().data(),
+ toOverwrite && aMeshIndex == 0 );
}
- break;
- case 124:
- case 121:
- aMesh->ExportDAT( aFilename.toLatin1().data() );
- break;
- case 126:
- case 123:
- aMesh->ExportUNV( aFilename.toLatin1().data() );
- break;
- case 141:
- aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
- break;
- default:
- break;
}
}
catch (const SALOME::SALOME_Exception& S_ex){
anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B );
else if( aGroupObject->GetType() == SMESH::ELEM0D )
anActor->Set0DColor( aColor.R, aColor.G, aColor.B );
- else
- anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B );
+ else {
+ QColor c;
+ int delta;
+ SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
+ anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
+ }
}
}
}
return;
}
case 1132:{
- QColor c, e, b, n, c0D, o;
+ QColor c, e, b, n, c0D, o, outl, selection, preselection;
+ int delta;
int size0D = 0;
int Edgewidth = 0;
vtkFloatingPointType Shrink = 0.0;
if(IObject->hasEntry()){
if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
vtkFloatingPointType color[3];
- anActor->GetSufaceColor(color[0], color[1], color[2]);
+ anActor->GetSufaceColor(color[0], color[1], color[2],delta);
int c0 = int (color[0] * 255);
int c1 = int (color[1] * 255);
int c2 = int (color[2] * 255);
c2 = int (edgecolor[2] * 255);
e.setRgb(c0, c1, c2);
- vtkFloatingPointType backfacecolor[3];
- anActor->GetBackSufaceColor(backfacecolor[0], backfacecolor[1], backfacecolor[2]);
- c0 = int (backfacecolor[0] * 255);
- c1 = int (backfacecolor[1] * 255);
- c2 = int (backfacecolor[2] * 255);
- b.setRgb(c0, c1, c2);
-
vtkFloatingPointType nodecolor[3];
anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
c0 = int (nodecolor[0] * 255);
c2 = int (color0D[2] * 255);
c0D.setRgb(c0, c1, c2);
+ vtkFloatingPointType outlineColor[3];
+ anActor->GetOutlineColor(outlineColor[0], outlineColor[1], outlineColor[2]);
+ c0 = int (outlineColor[0] * 255);
+ c1 = int (outlineColor[1] * 255);
+ c2 = int (outlineColor[2] * 255);
+ outl.setRgb(c0, c1, c2);
+
+ vtkFloatingPointType hColor[3];
+ anActor->GetHighlightColor(hColor[0], hColor[1], hColor[2]);
+ c0 = int (hColor[0] * 255);
+ c1 = int (hColor[1] * 255);
+ c2 = int (hColor[2] * 255);
+ selection.setRgb(c0, c1, c2);
+
+ vtkFloatingPointType phColor[3];
+ anActor->GetPreHighlightColor(phColor[0], phColor[1], phColor[2]);
+ c0 = int (phColor[0] * 255);
+ c1 = int (phColor[1] * 255);
+ c2 = int (phColor[2] * 255);
+ preselection.setRgb(c0, c1, c2);
+
size0D = (int)anActor->Get0DSize();
if(size0D == 0)
size0D = 1;
aDlg->SetColor(1, c);
aDlg->SetColor(2, e);
aDlg->SetColor(3, n);
- aDlg->SetColor(4, b);
+ aDlg->SetColor(4, outl);
+ aDlg->SetDeltaBrightness(delta);
aDlg->SetColor(5, c0D);
aDlg->SetColor(6, o);
aDlg->SetIntValue(1, Edgewidth);
aDlg->SetIntValue(3, size0D);
aDlg->SetDoubleValue(1, faces_orientation_scale);
aDlg->SetBooleanValue(1, faces_orientation_3dvectors);
+ aDlg->SetColor(7, selection);
+ aDlg->SetColor(8, preselection);
aDlg->setCustomMarkerMap( theMarkerMap[ aStudy->StudyId() ] );
QColor color = aDlg->GetColor(1);
QColor edgecolor = aDlg->GetColor(2);
QColor nodecolor = aDlg->GetColor(3);
- QColor backfacecolor = aDlg->GetColor(4);
+ QColor outlinecolor = aDlg->GetColor(4);
QColor color0D = aDlg->GetColor(5);
QColor faces_orientation_color = aDlg->GetColor(6);
+ QColor selectioncolor = aDlg->GetColor(7);
+ QColor preSelectioncolor = aDlg->GetColor(8);
+ int delta = aDlg->GetDeltaBrightness();
/* Point marker */
theMarkerMap[ aStudy->StudyId() ] = aDlg->getCustomMarkerMap();
/* actor color and backface color */
anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
vtkFloatingPointType (color.green()) / 255.,
- vtkFloatingPointType (color.blue()) / 255.);
- anActor->SetBackSufaceColor(vtkFloatingPointType (backfacecolor.red()) / 255.,
- vtkFloatingPointType (backfacecolor.green()) / 255.,
- vtkFloatingPointType (backfacecolor.blue()) / 255.);
-
+ vtkFloatingPointType (color.blue()) / 255.,
+ delta);
/* edge color */
anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
vtkFloatingPointType (edgecolor.green()) / 255.,
vtkFloatingPointType (edgecolor.blue()) / 255.);
+ /* edge outline */
+ anActor->SetOutlineColor(vtkFloatingPointType (outlinecolor.red()) / 255.,
+ vtkFloatingPointType (outlinecolor.green()) / 255.,
+ vtkFloatingPointType (outlinecolor.blue()) / 255.);
+
+ /* selection */
+ anActor->SetHighlightColor(vtkFloatingPointType (selectioncolor.red()) / 255.,
+ vtkFloatingPointType (selectioncolor.green()) / 255.,
+ vtkFloatingPointType (selectioncolor.blue()) / 255.);
+ /* pre-selection */
+ anActor->SetPreHighlightColor(vtkFloatingPointType (preSelectioncolor.red()) / 255.,
+ vtkFloatingPointType (preSelectioncolor.green()) / 255.,
+ vtkFloatingPointType (preSelectioncolor.blue()) / 255.);
+
/* Shrink factor and size edges */
anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.);
{
return new SMESHGUI();
}
+
+ SMESHGUI_EXPORT char* getModuleVersion() {
+ return (char*)SMESH_VERSION_STR;
+ }
}
SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
OnEditDelete();
break;
- case 113: // IMPORT
+ case 116:
+ case 115:
+ case 117:
+ case 113:
case 112:
- case 111:
- case 140:
+ case 111: // IMPORT
{
if(checkLock(aStudy)) break;
::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
case 124:
case 125:
case 126:
+ case 140:
case 141:
+ case 142:
+ case 143:
+ case 144:
+ case 145:
{
::ExportMeshToFile(theCommandID);
break;
SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
aDlg->show();
}
+ else
+ {
+ SMESH::SMESH_GroupOnFilter_var aGroup =
+ SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
+ if (!aGroup->_is_nil()) {
+ SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
+ aDlg->show();
+ }
+ }
}
break;
}
createSMESHAction( 112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
createSMESHAction( 113, "MED", "", (Qt::CTRL+Qt::Key_M) );
createSMESHAction( 114, "NUM" );
+ createSMESHAction( 115, "STL" );
+ createSMESHAction( 116, "CGNS" );
+ createSMESHAction( 117, "SAUV" );
createSMESHAction( 121, "DAT" );
createSMESHAction( 122, "MED" );
createSMESHAction( 123, "UNV" );
createSMESHAction( 140, "STL" );
+ createSMESHAction( 142, "CGNS" );
+ createSMESHAction( 144, "SAUV" );
createSMESHAction( 124, "EXPORT_DAT" );
createSMESHAction( 125, "EXPORT_MED" );
createSMESHAction( 126, "EXPORT_UNV" );
createSMESHAction( 141, "EXPORT_STL" );
+ createSMESHAction( 143, "EXPORT_CGNS" );
+ createSMESHAction( 145, "EXPORT_SAUV" );
createSMESHAction( 150, "FILE_INFO" );
createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
createSMESHAction( 5105, "SEL_FILTER_LIB" );
createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
//createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
- createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" );
+ //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
createMenu( 111, importId, -1 );
createMenu( 112, importId, -1 );
createMenu( 113, importId, -1 );
- createMenu( 140, importId, -1 );
-
+ createMenu( 115, importId, -1 );
+#ifdef WITH_CGNS
+ createMenu( 116, importId, -1 );
+#endif
+ createMenu( 117, importId, -1 );
createMenu( 121, exportId, -1 );
createMenu( 122, exportId, -1 );
createMenu( 123, exportId, -1 );
- createMenu( 141, exportId, -1 ); // export to stl STL
-
+ createMenu( 140, exportId, -1 ); // export to STL
+#ifdef WITH_CGNS
+ createMenu( 142, exportId, -1 ); // export to CGNS
+#endif
+ createMenu( 144, exportId, -1 ); // export to SAUV
createMenu( separator(), fileId, 10 );
createMenu( 33, editId, -1 );
createMenu( separator(), meshId, -1 );
createMenu( 900, meshId, -1 );
//createMenu( 902, meshId, -1 );
- createMenu( 903, meshId, -1 );
+ //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
createMenu( 904, meshId, -1 );
createMenu( separator(), meshId, -1 );
createTool( separator(), meshTb );
createTool( 900, meshTb );
//createTool( 902, meshTb );
- createTool( 903, meshTb );
+ //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
createTool( 904, meshTb );
createTool( separator(), meshTb );
arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
subMesh = elems,
- mesh_group = mesh + " " + subMesh + " " + group,
+ mesh_part = mesh + " " + subMesh + " " + group,
+ mesh_group = mesh + " " + group,
hyp_alg = hypo + " " + algo;
// popup for object browser
createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
- //createPopupItem( 703, OB, subMesh, "&& isComputable" ); // CREATE_SUBMESH
createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
createPopupItem( 803, OB, group ); // EDIT_GROUP
- createPopupItem( 815, OB, group, "&& groupType = 'GroupOnGeom'" ); // EDIT_GROUP
+ createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
- createPopupItem( 214, OB, mesh_group ); // UPDATE
- createPopupItem( 900, OB, mesh_group ); // ADV_INFO
- //createPopupItem( 902, OB, mesh ); // STD_INFO
- createPopupItem( 903, OB, mesh_group ); // WHAT_IS
- createPopupItem( 904, OB, mesh ); // FIND_ELEM
+ createPopupItem( 214, OB, mesh_part ); // UPDATE
+ createPopupItem( 900, OB, mesh_part ); // ADV_INFO
+ createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( 801, OB, mesh ); // CREATE_GROUP
createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
- createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
+ createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
popupMgr()->insert( separator(), -1, 0 );
createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
popupMgr()->insert( separator(), -1, 0 );
- createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
- createPopupItem( 418, OB, mesh/*, "&& " + hasVolumes*/); // create 2D mesh on 3D
+ createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
+ createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
+ "&& dim>=2");
popupMgr()->insert( separator(), -1, 0 );
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
+ QString only_one_2D = only_one_non_empty + " && dim>1";
- createPopupItem( 125, OB, mesh, multiple_non_empty ); // EXPORT_MED
- createPopupItem( 126, OB, mesh, only_one_non_empty ); // EXPORT_UNV
- createPopupItem( 141, OB, mesh, only_one_non_empty ); // EXPORT_STL
- //createPopupItem( 33, OB, subMesh + " " + group ); // DELETE
- createPopupItem( 33, OB, mesh_group + " " + hyp_alg ); // DELETE
+ createPopupItem( 125, OB, mesh_group, multiple_non_empty ); // EXPORT_MED
+ createPopupItem( 126, OB, mesh_group, only_one_non_empty ); // EXPORT_UNV
+ createPopupItem( 141, OB, mesh_group, only_one_2D ); // EXPORT_STL
+#ifdef WITH_CGNS
+ createPopupItem( 143, OB, mesh_group, multiple_non_empty ); // EXPORT_CGNS
+#endif
+ createPopupItem( 145, OB, mesh_group, multiple_non_empty ); // EXPORT_SAUV
+ createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
popupMgr()->insert( separator(), -1, 0 );
// popup for viewer
createPopupItem( 805, View, elems ); // REMOVE
popupMgr()->insert( separator(), -1, 0 );
- createPopupItem( 214, View, mesh_group ); // UPDATE
- createPopupItem( 900, View, mesh_group ); // ADV_INFO
- //createPopupItem( 902, View, mesh ); // STD_INFO
- createPopupItem( 903, View, mesh_group ); // WHAT_IS
+ createPopupItem( 214, View, mesh_part ); // UPDATE
+ createPopupItem( 900, View, mesh_part ); // ADV_INFO
createPopupItem( 904, View, mesh ); // FIND_ELEM
popupMgr()->insert( separator(), -1, 0 );
int anId;
QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
QString aType = QString( "%1type in {%2}" ).arg( lc );
- aType = aType.arg( mesh_group );
+ aType = aType.arg( mesh_part );
QString aMeshInVTK = aClient + "&&" + aType;
aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
// import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
PyGILState_STATE gstate = PyGILState_Ensure();
- PyObject* pluginsmanager=PyImport_ImportModule((char*)"salome_pluginsmanager");
+ PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
if(pluginsmanager==NULL)
PyErr_Print();
else
setPreferenceProperty( dispgroup, "columns", 2 );
int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
QStringList modes;
- modes.append( "Wireframe" );
- modes.append( "Shading" );
- modes.append( "Nodes" );
- modes.append( "Shrink" );
+ modes.append( tr("MEN_WIRE") );
+ modes.append( tr("MEN_SHADE") );
+ modes.append( tr("MEN_NODES") );
+ modes.append( tr("MEN_SHRINK") );
QList<QVariant> indices;
indices.append( 0 );
indices.append( 1 );
setPreferenceProperty( arcgroup, "columns", 2 );
int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
QStringList quadraticModes;
- quadraticModes.append("Lines");
- quadraticModes.append("Arcs");
+ quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
+ quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
indices.clear();
indices.append( 0 );
indices.append( 1 );
setPreferenceProperty( notifyMode, "indexes", indices );
int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
- setPreferenceProperty( computeGroup, "columns", 2 );
+ setPreferenceProperty( infoGroup, "columns", 4 );
int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
modes.clear();
modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
indices.append( 1 );
setPreferenceProperty( elemInfo, "strings", modes );
setPreferenceProperty( elemInfo, "indexes", indices );
+ int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
+ setPreferenceProperty( nodesLim, "min", 0 );
+ setPreferenceProperty( nodesLim, "max", 10000000 );
+ setPreferenceProperty( nodesLim, "step", 10000 );
+ setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
setPreferenceProperty( segGroup, "columns", 2 );
setPreferenceProperty( precs[ii], "precision", 2 );
}
+ int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
+ setPreferenceProperty( previewGroup, "columns", 2 );
+ int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
+ setPreferenceProperty( chunkSize, "min", 0 );
+ setPreferenceProperty( chunkSize, "max", 1000 );
+ setPreferenceProperty( chunkSize, "step", 50 );
+
// Mesh tab ------------------------------------------------------------------------
int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
setPreferenceProperty( elemGroup, "columns", 2 );
- addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
- addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
- addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
+ int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
+
+ addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
+ addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
+
+ setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
setPreferenceProperty( grpGroup, "columns", 2 );
addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
- //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
- //setPreferenceProperty( sp, "hstretch", 0 );
- //setPreferenceProperty( sp, "vstretch", 0 );
-
int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
- int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
LightApp_Preferences::IntSpin, "SMESH", "element_width");
int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
setPreferenceProperty( size0d, "min", 1 );
setPreferenceProperty( size0d, "max", 10 );
- setPreferenceProperty( sp, "hstretch", 0 );
- setPreferenceProperty( sp, "vstretch", 0 );
-
setPreferenceProperty( elemW, "min", 1 );
setPreferenceProperty( elemW, "max", 5 );
// Colors (surface:edge:)
vtkFloatingPointType r, g, b;
-
- aSmeshActor->GetSufaceColor(r, g, b);
+ int delta;
+
+ aSmeshActor->GetSufaceColor(r, g, b, delta);
QString colorStr ("surface");
colorStr += gDigitsSep; colorStr += QString::number(r);
colorStr += gDigitsSep; colorStr += QString::number(g);
colorStr += gDigitsSep; colorStr += QString::number(b);
- aSmeshActor->GetBackSufaceColor(r, g, b);
colorStr += gDigitsSep; colorStr += "backsurface";
- colorStr += gDigitsSep; colorStr += QString::number(r);
- colorStr += gDigitsSep; colorStr += QString::number(g);
- colorStr += gDigitsSep; colorStr += QString::number(b);
+ colorStr += gDigitsSep; colorStr += QString::number(delta);
+
aSmeshActor->GetEdgeColor(r, g, b);
colorStr += gDigitsSep; colorStr += "edge";
colorStr += gDigitsSep; colorStr += QString::number(g);
colorStr += gDigitsSep; colorStr += QString::number(b);
+ aSmeshActor->GetOutlineColor(r, g, b);
+ colorStr += gDigitsSep; colorStr += "outline";
+ colorStr += gDigitsSep; colorStr += QString::number(r);
+ colorStr += gDigitsSep; colorStr += QString::number(g);
+ colorStr += gDigitsSep; colorStr += QString::number(b);
+
param = vtkParam + "Colors";
ip->setParameter(entry, param, colorStr.toLatin1().data());
// Colors
else if (paramNameStr == "Colors") {
QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
- if (colors.count() == 16) {
+ if (colors.count() == 16 || colors.count() == 18 ) {
if (colors[0] != "surface" || colors[4] != "backsurface" ||
- colors[8] != "edge" || colors[12] != "node") {
+ (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
+ (colors.count() == 18 && colors[14] != "outline")) {
MESSAGE("Invalid order of data in Colors, must be: "
- "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
+ "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b or surface:r:g:b:backsurface:delta:edge:r:g:b:node:r:g:b:outline:r:g:b");
}
else {
- aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
- aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
- aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
- aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
+ int delta = 0;
+ float er,eg,eb;
+ float nr,ng,nb;
+ vtkFloatingPointType otr,otg,otb;
+ //Old case backsurface color is independent
+ if( colors.count() == 16 ) {
+ QColor ffc;
+ SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
+ er = colors[9].toFloat();
+ eg = colors[10].toFloat();
+ eb = colors[11].toFloat();
+
+ nr = colors[13].toFloat();
+ ng = colors[14].toFloat();
+ nb = colors[15].toFloat();
+ SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
+ } else {
+ //New case backsurface color depends on surface color
+ delta = colors[5].toInt();
+
+ er = colors[7].toFloat();
+ eg = colors[8].toFloat();
+ eb = colors[9].toFloat();
+
+ nr = colors[11].toFloat();
+ ng = colors[12].toFloat();
+ nb = colors[13].toFloat();
+
+ otr = colors[15].toFloat();
+ otg = colors[16].toFloat();
+ otb = colors[17].toFloat();
+ }
+ aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
+ aSmeshActor->SetEdgeColor(er,eg,eb);
+ aSmeshActor->SetNodeColor(nr,ng,nb);
+ aSmeshActor->SetOutlineColor(otr,otg,otb);
}
}
}
*/
int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
{
- int tfont = addPreference( label, pId, LightApp_Preferences::Font, "VISU", param );
+ int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
// check type to prevent renaming of inappropriate objects
int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
if (aType == MESH || aType == GROUP ||
- aType == SUBMESH || aType == SUBMESH_COMPOUND ||
- aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
- aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
- aType == HYPOTHESIS || aType == ALGORITHM) {
- if ( !name.isEmpty() ) {
- SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
-
- // update name of group object and its actor
- Handle(SALOME_InteractiveObject) IObject =
- new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
-
- SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
- if( !aGroupObject->_is_nil() ) {
- aGroupObject->SetName( qPrintable(name) );
- if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
- anActor->setName( qPrintable(name) );
- }
- return true;
- }
+ aType == SUBMESH || aType == SUBMESH_COMPOUND ||
+ aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
+ aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
+ aType == HYPOTHESIS || aType == ALGORITHM) {
+ if ( !name.isEmpty() ) {
+ SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
+
+ // update name of group object and its actor
+ Handle(SALOME_InteractiveObject) IObject =
+ new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
+
+ SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
+ if( !aGroupObject->_is_nil() ) {
+ aGroupObject->SetName( qPrintable(name) );
+ if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
+ anActor->setName( qPrintable(name) );
+ }
+ return true;
+ }
}
}
}
