X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHGUI%2FSMESHGUI.cxx;h=72e11ab949126745820fdd0837672621ed1ab11f;hp=10e2d8820976b0972dd28381ac3be3523d3a4904;hb=1f73394bb7903d7c28698b05fe556e007c62d0ac;hpb=425391ca7c93d64b6a268241cad83b59756372dc diff --git a/src/SMESHGUI/SMESHGUI.cxx b/src/SMESHGUI/SMESHGUI.cxx index 10e2d8820..72e11ab94 100644 --- a/src/SMESHGUI/SMESHGUI.cxx +++ b/src/SMESHGUI/SMESHGUI.cxx @@ -1,73 +1,81 @@ -// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2012 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. -// SMESH includes +// File : SMESHGUI.cxx +// Author : Nicolas REJNERI, Open CASCADE S.A.S. +#include // 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_NodesDlg.h" -#include "SMESHGUI_TransparencyDlg.h" -#include "SMESHGUI_ClippingDlg.h" -#include "SMESHGUI_GroupDlg.h" -#include "SMESHGUI_RemoveNodesDlg.h" -#include "SMESHGUI_RemoveElementsDlg.h" -#include "SMESHGUI_MeshInfosDlg.h" -#include "SMESHGUI_StandardMeshInfosDlg.h" -#include "SMESHGUI_WhatIsDlg.h" -#include "SMESHGUI_Preferences_ColorDlg.h" -#include "SMESHGUI_Preferences_ScalarBarDlg.h" -#include "SMESHGUI_Hypotheses.h" -#include "SMESHGUI_MoveNodesDlg.h" #include "SMESHGUI_AddMeshElementDlg.h" #include "SMESHGUI_AddQuadraticElementDlg.h" +#include "SMESHGUI_BuildCompoundDlg.h" +#include "SMESHGUI_ClippingDlg.h" +#include "SMESHGUI_ComputeDlg.h" +#include "SMESHGUI_ConvToQuadOp.h" +#include "SMESHGUI_CreatePolyhedralVolumeDlg.h" +#include "SMESHGUI_DeleteGroupDlg.h" +#include "SMESHGUI_Displayer.h" +#include "SMESHGUI_MergeDlg.h" +#include "SMESHGUI_ExtrusionAlongPathDlg.h" +#include "SMESHGUI_ExtrusionDlg.h" +#include "SMESHGUI_FileInfoDlg.h" +#include "SMESHGUI_FileValidator.h" #include "SMESHGUI_FilterDlg.h" #include "SMESHGUI_FilterLibraryDlg.h" -#include "SMESHGUI_SingleEditDlg.h" -#include "SMESHGUI_MultiEditDlg.h" -#include "SMESHGUI_GroupOpDlg.h" +#include "SMESHGUI_FindElemByPointDlg.h" +#include "SMESHGUI_GroupDlg.h" #include "SMESHGUI_GroupOnShapeDlg.h" -#include "SMESHGUI_DeleteGroupDlg.h" -#include "SMESHGUI_SmoothingDlg.h" +#include "SMESHGUI_GroupOpDlg.h" +#include "SMESHGUI_Hypotheses.h" +#include "SMESHGUI_Make2DFrom3DOp.h" +#include "SMESHGUI_MakeNodeAtPointDlg.h" +#include "SMESHGUI_Measurements.h" +#include "SMESHGUI_MeshInfo.h" +#include "SMESHGUI_MeshOp.h" +#include "SMESHGUI_MeshOrderOp.h" +#include "SMESHGUI_MeshPatternDlg.h" +#include "SMESHGUI_MultiEditDlg.h" +#include "SMESHGUI_NodesDlg.h" +#include "SMESHGUI_Preferences_ColorDlg.h" +#include "SMESHGUI_Preferences_ScalarBarDlg.h" +#include "SMESHGUI_RemoveElementsDlg.h" +#include "SMESHGUI_RemoveNodesDlg.h" #include "SMESHGUI_RenumberingDlg.h" -#include "SMESHGUI_ExtrusionDlg.h" -#include "SMESHGUI_ExtrusionAlongPathDlg.h" #include "SMESHGUI_RevolutionDlg.h" -#include "SMESHGUI_TranslationDlg.h" #include "SMESHGUI_RotationDlg.h" -#include "SMESHGUI_SymmetryDlg.h" -#include "SMESHGUI_SewingDlg.h" -#include "SMESHGUI_EditMeshDlg.h" -#include "SMESHGUI_MeshPatternDlg.h" #include "SMESHGUI_Selection.h" -#include "SMESHGUI_CreatePolyhedralVolumeDlg.h" -#include "SMESHGUI_ConvToQuadOp.h" -#include "SMESHGUI_MeshOp.h" -#include "SMESHGUI_Displayer.h" -#include "SMESHGUI_MakeNodeAtPointDlg.h" -#include "SMESHGUI_BuildCompoundDlg.h" -#include "SMESHGUI_ComputeDlg.h" -#include "SMESHGUI_FileInfoDlg.h" -#include "SMESHGUI_Make2DFrom3DOp.h" +#include "SMESHGUI_SewingDlg.h" +#include "SMESHGUI_SingleEditDlg.h" +#include "SMESHGUI_SmoothingDlg.h" +#include "SMESHGUI_SymmetryDlg.h" +#include "SMESHGUI_TranslationDlg.h" +#include "SMESHGUI_ScaleDlg.h" +#include "SMESHGUI_TransparencyDlg.h" +#include "SMESHGUI_DuplicateNodesDlg.h" +#include "SMESHGUI_CopyMeshDlg.h" #include "SMESHGUI_Utils.h" #include "SMESHGUI_MeshUtils.h" @@ -77,15 +85,21 @@ #include "SMESHGUI_VTKUtils.h" #include "SMESHGUI_HypothesesUtils.h" +#include + #include #include +#include +#include #include +#include "SMESH_ControlsDef.hxx" // SALOME GUI includes #include #include #include #include +#include #include #include @@ -112,23 +126,32 @@ #include #include +#ifndef DISABLE_PLOT2DVIEWER +#include +#include +#endif + // IDL includes #include #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes) #include CORBA_CLIENT_HEADER(SMESH_MeshEditor) +#include CORBA_CLIENT_HEADER(SMESH_Measurements) // Qt includes // #define INCLUDE_MENUITEM_DEF // VSR commented ???????? +#include #include +#include // BOOST includes #include // VTK includes -#include #include #include #include +#include +#include // SALOME KERNEL includes #include @@ -141,6 +164,10 @@ #include #include +//To disable automatic genericobj management, the following line should be commented. +//Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx +#define WITHGENERICOBJ + //namespace{ // Declarations //============================================================= @@ -149,7 +176,7 @@ void ExportMeshToFile(int theCommandID); - void SetDisplayMode(int theCommandID); + void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap); void SetDisplayEntity(int theCommandID); @@ -165,14 +192,24 @@ std::string myExtension; if ( theCommandID == 113 ) { - filter.append( QObject::tr( "MED files (*.med)" ) ); - filter.append( QObject::tr( "All files (*)" ) ); + filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" ); + filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" ); } else if ( theCommandID == 112 ) { - filter.append( QObject::tr( "IDEAS files (*.unv)" ) ); + filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" ); } else if ( theCommandID == 111 ) { - filter.append( QObject::tr( "DAT files (*.dat)" ) ); + filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" ); + } + 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 = ""; @@ -188,6 +225,7 @@ _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); QStringList errors; + QStringList anEntryList; bool isEmpty = false; for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) { QString filename = *it; @@ -222,6 +260,39 @@ } break; } + case 115: + { + // STL format + aMeshes->length( 1 ); + aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() ); + if ( aMeshes[0]->_is_nil() ) { + errors.append( QString( "%1 :\n\t%2" ).arg( filename ). + arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) ); + } + 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 ) { @@ -237,6 +308,15 @@ aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" ); if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() ); + + anEntryList.append( aMeshSO->GetID().c_str() ); + +#ifdef WITHGENERICOBJ + // obj has been published in study. Its refcount has been incremented. + // It is safe to decrement its refcount + // so that it will be destroyed when the entry in study will be removed + aMeshes[i]->UnRegister(); +#endif } else { isEmpty = true; @@ -247,6 +327,11 @@ // update Object browser SMESHGUI::GetSMESHGUI()->updateObjBrowser(); + // browse to the published meshes + if( LightApp_Application* anApp = + dynamic_cast( SUIT_Session::session()->activeApplication() ) ) + anApp->browseObjects( anEntryList ); + // show Error message box if there were errors if ( errors.count() > 0 ) { SUIT_MessageBox::critical( SMESHGUI::desktop(), @@ -263,6 +348,12 @@ } } + //================================================================================ + /*! + * \brief Export selected meshes or groups into a file + */ + //================================================================================ + void ExportMeshToFile( int theCommandID ) { LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr(); @@ -270,132 +361,188 @@ if( aSel ) aSel->selectedObjects( selected ); - SMESH::SMESH_Mesh_var aMesh; - if(selected.Extent() == 1) - aMesh = SMESH::IObjectToInterface(selected.First()); - if ( aMesh->_is_nil() ) { - SUIT_MessageBox::warning( SMESHGUI::desktop(), - QObject::tr( "SMESH_WRN_WARNING" ), - QObject::tr( "SMESH_BAD_MESH_SELECTION" )); + 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 && !isMED && !isSTL )) return; - } - Handle(SALOME_InteractiveObject) anIObject = selected.First(); - QString aFilter, aTitle = QObject::tr("Export mesh"); - QMap aFilterMap; - QMap aFilterMapSTL; - switch ( theCommandID ) { - case 125: - case 122: - { - if (aMesh->HasDuplicatedGroupNamesMED()) { - int aRet = SUIT_MessageBox::warning - (SMESHGUI::desktop(), - QObject::tr("SMESH_WRN_WARNING"), - QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg(anIObject->getName()), - SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::Yes); - if (aRet != SUIT_MessageBox::Yes) - return; - } - // PAL18696 - QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2)); - QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2)); - aFilterMap.insert( QString("MED ") + v21 + " (*.med)", SMESH::MED_V2_1 ); - aFilterMap.insert( QString("MED ") + v22 + " (*.med)", SMESH::MED_V2_2 ); + // get mesh object from selection and check duplication of their names + bool hasDuplicatedMeshNames = false; + 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() ) + { + Handle(SALOME_InteractiveObject) anIObject = It.Value(); + SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface(anIObject); + if ( aMeshItem->_is_nil() ) { + SUIT_MessageBox::warning( SMESHGUI::desktop(), + QObject::tr( "SMESH_WRN_WARNING" ), + QObject::tr( "SMESH_BAD_MESH_SELECTION" )); + return; } - break; - case 124: - case 121: - aFilter = QObject::tr("DAT files (*.dat)"); - break; - case 126: - case 123: - { - if (aMesh->NbPyramids()) { + + QString aMeshName = anIObject->getName(); + + // 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_IDSource_var, QString >( aMeshItem, aMeshName ) ); + } + + if( hasDuplicatedMeshNames && isMED ) { + int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(), + QObject::tr("SMESH_WRN_WARNING"), + QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"), + QObject::tr("SMESH_BUT_YES"), + QObject::tr("SMESH_BUT_NO"), 0, 1); + if (aRet != 0) + return; + } + + aMeshIter = aMeshList.begin(); + SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first; + SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh(); + QString aMeshName = (*aMeshIter).second; + + 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(anIObject->getName()), - SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::Yes); - if (aRet != SUIT_MessageBox::Yes) + 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 (*.unv)"); } - break; - case 140: - 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(anIObject->getName())); + } + else if ( isUNV ) + { + // warn the user about presence of not supported elements + SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo(); + int nbNotSupported = ( nbElems[ SMESH::Entity_Pyramid ] + + nbElems[ SMESH::Entity_Quad_Pyramid ] + + nbElems[ SMESH::Entity_Hexagonal_Prism ] + + nbElems[ SMESH::Entity_Polygon ] + + nbElems[ SMESH::Entity_Polyhedra ] ); + if ( nbNotSupported > 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; - } - if (!(aMesh->NbElements() - aMesh->NbTriangles())) { - int aRet = SUIT_MessageBox::warning - (SMESHGUI::desktop(), - QObject::tr("SMESH_WRN_WARNING"), - QObject::tr("SMESH_EXPORT_STL2").arg(anIObject->getName()), - SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::Yes); - if (aRet != SUIT_MessageBox::Yes) - return; - } - - aFilterMapSTL.insert( QObject::tr("STL ASCII (*.stl)"), 1 ); // 1 - ASCII mode - aFilterMapSTL.insert( QObject::tr("STL Binary (*.stl)"), 0 ); // 0 - Binary mode } - 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(); if ( resMgr ) 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 != 140 && 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("/") + anIObject->getName(), + aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(), + anInitialPath + QString("/") + aMeshName, aFilter, aTitle, false); } - else if(theCommandID == 140 || 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 aFilterMap; + aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 ); + aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 ); + QStringList filters; - QMap::const_iterator it = aFilterMapSTL.begin(); - for ( ; it != aFilterMapSTL.end(); ++it ) + QMap::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 ); fd->setWindowTitle( aTitle ); - fd->setFilters( filters ); - fd->selectFilter( QObject::tr("STL ASCII (*.stl)") ); + fd->setNameFilters( filters ); + fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" ); if ( !anInitialPath.isEmpty() ) fd->setDirectory( anInitialPath ); - fd->selectFile(anIObject->getName()); + fd->selectFile(aMeshName); bool is_ok = false; while (!is_ok) { if ( fd->exec() ) aFilename = fd->selectedFile(); - aIsASCII_STL = (aFilterMapSTL[fd->selectedFilter()]) == 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 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::const_iterator it = aFilterMap.begin(); @@ -405,76 +552,180 @@ 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->setFilters( filters ); - //fd->setSelectedFilter( QObject::tr("MED 2.2 (*.med)") ); - fd->selectFilter(aDefaultFilter); + fd->setNameFilters( filters ); + fd->selectNameFilter(aDefaultFilter); fd->SetChecked(toCreateGroups); if ( !anInitialPath.isEmpty() ) fd->setDirectory( anInitialPath ); - fd->selectFile(anIObject->getName()); + fd->selectFile(aMeshName); + + SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd ); + fd->setValidator( fv ); + bool is_ok = false; while (!is_ok) { if ( fd->exec() ) aFilename = fd->selectedFile(); - aFormat = aFilterMap[fd->selectedFilter()]; + else { + aFilename = QString::null; + break; + } + aFormat = aFilterMap[fd->selectedNameFilter()]; + toOverwrite = fv->isOverwrite(); is_ok = true; - if ( !aFilename.isEmpty() - && (aMesh->NbPolygons()>0 || aMesh->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(anIObject->getName()), - SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::Yes); - if (aRet != SUIT_MessageBox::Yes) { - is_ok = false; + if ( !aFilename.isEmpty() ) { + // 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 ) { + int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(), + QObject::tr("SMESH_WRN_WARNING"), + QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename), + QObject::tr("SMESH_BUT_YES"), + QObject::tr("SMESH_BUT_NO"), 0, 1); + if (aRet == 0) + toOverwrite = true; + else + is_ok = false; + } + + QStringList aMeshNamesCollisionList; + SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() ); + for( int i = 0, n = aMeshNames->length(); i < n; i++ ) { + QString anExistingMeshName( aMeshNames[ i ] ); + for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) { + QString anExportMeshName = (*aMeshIter).second; + if( anExportMeshName == anExistingMeshName ) { + aMeshNamesCollisionList.append( anExportMeshName ); + break; + } + } + } + if( !aMeshNamesCollisionList.isEmpty() ) { + QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " ); + int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(), + QObject::tr("SMESH_WRN_WARNING"), + QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString), + QObject::tr("SMESH_BUT_YES"), + QObject::tr("SMESH_BUT_NO"), + QObject::tr("SMESH_BUT_CANCEL"), 0, 2); + if (aRet == 0) + toOverwrite = true; + else if (aRet == 2) + is_ok = false; + } } } } 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 ); - if ( aFile.exists() ) + if ( aFile.exists() && toOverwrite ) aFile.remove(); 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: - aMesh->ExportToMED( aFilename.toLatin1().data(), toCreateGroups, aFormat ); - break; - case 124: - case 121: - aMesh->ExportDAT( aFilename.toLatin1().data() ); - break; - case 126: - case 123: - aMesh->ExportUNV( aFilename.toLatin1().data() ); - break; - case 140: - case 141: - aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL ); - break; - default: - break; + 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 ); + } } } catch (const SALOME::SALOME_Exception& S_ex){ @@ -558,35 +809,228 @@ if( aMainObject->_is_nil() ) return; - aMainObject->SetAutoColor( true ); - - QList aReservedColors; + aMainObject->SetAutoColor( true ); // mesh groups are re-colored here SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups(); for( int i = 0, n = aListOfGroups.length(); i < n; i++ ) { SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i]; - SALOMEDS::Color aCurrentColor = aGroupObject->GetColor(); - - SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors ); - aGroupObject->SetColor( aColor ); - aReservedColors.append( aColor ); - + SALOMEDS::Color aColor = aGroupObject->GetColor(); _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject); - if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) - { - if( aGroupObject->GetType() == SMESH::NODE ) - anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); - else if( aGroupObject->GetType() == SMESH::EDGE ) - anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); - else - anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B ); + if (aGroupSObject) { + if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) { + if( aGroupObject->GetType() == SMESH::NODE ) + anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); + else if( aGroupObject->GetType() == SMESH::EDGE ) + anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); + else if( aGroupObject->GetType() == SMESH::ELEM0D ) + anActor->Set0DColor( 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 ); + } + } } } SMESH::RepaintCurrentView(); } + QString functorToString( SMESH::Controls::FunctorPtr f ) + { + QString type = QObject::tr( "UNKNOWN_CONTROL" ); + if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) ) + type = QObject::tr( "VOLUME_3D_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) ) + type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" ); + else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) ) + type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" ); + else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) ) + type = QObject::tr( "MINIMUMANGLE_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) ) + type = QObject::tr( "ASPECTRATIO_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) ) + type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) ) + type = QObject::tr( "WARP_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) ) + type = QObject::tr( "TAPER_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) ) + type = QObject::tr( "SKEW_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) ) + type = QObject::tr( "AREA_ELEMENTS" ); + else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) ) + type = QObject::tr( "LENGTH_EDGES" ); + else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) ) + type = QObject::tr( "LENGTH2D_EDGES" ); + else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) ) + type = QObject::tr( "MULTI_BORDERS" ); + else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) ) + type = QObject::tr( "MULTI2D_BORDERS" ); + else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) ) + type = QObject::tr( "FREE_NODES" ); + else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) ) + type = QObject::tr( "FREE_EDGES" ); + else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) ) + type = QObject::tr( "FREE_BORDERS" ); + else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) ) + type = QObject::tr( "FREE_FACES" ); + else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) ) + type = QObject::tr( "BARE_BORDER_VOLUME" ); + else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) ) + type = QObject::tr( "BARE_BORDER_FACE" ); + else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) ) + type = QObject::tr( "OVER_CONSTRAINED_VOLUME" ); + else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) ) + type = QObject::tr( "OVER_CONSTRAINED_FACE" ); + else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) ) + type = QObject::tr( "EQUAL_NODE" ); + else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) ) + type = QObject::tr( "EQUAL_EDGE" ); + else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) ) + type = QObject::tr( "EQUAL_FACE" ); + else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) ) + type = QObject::tr( "EQUAL_VOLUME" ); + return type; + } + + void SaveDistribution() + { + LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr(); + SALOME_ListIO selected; + if ( aSel ) + aSel->selectedObjects( selected ); + + if ( selected.Extent() == 1 ) { + Handle(SALOME_InteractiveObject) anIO = selected.First(); + if ( anIO->hasEntry() ) { + SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ); + if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) { + SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor(); + SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor(); + if ( aScalarBarActor && aFunctor ) { + SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast( aFunctor.get() ); + if ( aNumFun ) { + std::vector elements; + SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface(anIO); + if ( mesh->_is_nil() ) { + SMESH::SMESH_IDSource_var idSource = + SMESH::IObjectToInterface(anIO); + if ( !idSource->_is_nil() ) + { + SMESH::long_array_var ids = idSource->GetIDs(); + elements.resize( ids->length() ); + for ( unsigned i = 0; i < elements.size(); ++i ) + elements[i] = ids[i]; + } + } + int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors(); + vtkLookupTable* lookupTable = + static_cast(aScalarBarActor->GetLookupTable()); + double * minmax = lookupTable->GetRange(); + std::vector nbEvents; + std::vector funValues; + aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax ); + QString anInitialPath = ""; + if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() ) + anInitialPath = QDir::currentPath(); + QString aMeshName = anIO->getName(); + QStringList filter; + filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" ); + filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" ); + QString aFilename = anInitialPath + "/" + aMeshName + "_" + + functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt"; + aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(), + aFilename, + filter, + QObject::tr( "SMESH_SAVE_DISTRIBUTION" ), + false ); + if ( !aFilename.isEmpty() ) { + QFile f( aFilename ); + if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) { + QTextStream out( &f ); + out << "# Mesh: " << aMeshName << endl; + out << "# Control: " << functorToString( aFunctor ) << endl; + out << "#" << endl; + out.setFieldWidth( 10 ); + for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ ) + out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl; + f.close(); + } + } + } + } + } + } + } + } + + void ShowDistribution() { + LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr(); + SALOME_ListIO selected; + if ( aSel ) + aSel->selectedObjects( selected ); + + if ( selected.Extent() == 1 ) { + Handle(SALOME_InteractiveObject) anIO = selected.First(); + if ( anIO->hasEntry() ) { + SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ); + if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) { + SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor(); + aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility()); + } + } + } + } + +#ifndef DISABLE_PLOT2DVIEWER + void PlotDistribution() { + SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() ); + if( !app ) + return; + + LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr(); + SALOME_ListIO selected; + if ( aSel ) + aSel->selectedObjects( selected ); + + if ( selected.Extent() == 1 ) { + Handle(SALOME_InteractiveObject) anIO = selected.First(); + if ( anIO->hasEntry() ) { + //Find Actor by entry before getting Plot2d viewer, + //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer + SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ); + + SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary + + if( !aViewManager ) + return; + + SPlot2d_Viewer* aView = dynamic_cast(aViewManager->getViewModel()); + if ( !aView ) + return; + + Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame(); + if ( !aPlot ) + return; + + if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) { + SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram(); + QString functorName = functorToString( anActor->GetFunctor()); + QString aHistogramName("%1 : %2"); + aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName); + aHistogram->setName(aHistogramName); + aHistogram->setHorTitle(functorName); + aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT")); + aPlot->displayObject(aHistogram, true); + } + } + } + } +#endif //DISABLE_PLOT2DVIEWER + void DisableAutoColor(){ LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr(); SALOME_ListIO selected; @@ -602,7 +1046,7 @@ } } - void SetDisplayMode(int theCommandID){ + void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap){ SALOME_ListIO selected; SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() ); if( !app ) @@ -613,122 +1057,223 @@ if( !aSel || !appStudy ) return; + if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection + if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) { + aModule->EmitSignalDeactivateDialog(); + if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) ) + (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show(); + } + return; + } + _PTR(Study) aStudy = appStudy->studyDS(); aSel->selectedObjects( selected ); if(selected.Extent() >= 1){ switch(theCommandID){ - case 1134:{ - SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog(); - (new SMESHGUI_ClippingDlg( SMESHGUI::GetSMESHGUI() ))->show(); - return; - } case 1133:{ SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog(); (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show(); return; - }} - SALOME_ListIteratorOfListIO It( selected ); - for( ; It.More(); It.Next()){ - Handle(SALOME_InteractiveObject) IObject = It.Value(); - if(IObject->hasEntry()){ - if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){ - switch(theCommandID){ - case 211: - anActor->SetRepresentation(SMESH_Actor::eEdge); - break; - case 212: - anActor->SetRepresentation(SMESH_Actor::eSurface); - break; - case 213: - if(anActor->IsShrunk()) - anActor->UnShrink(); - else - anActor->SetShrink(); - break; - case 215: - anActor->SetRepresentation(SMESH_Actor::ePoint); - break; - case 231: - if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines) - anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines); - break; - case 232: - if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs) - anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs); - break; - case 1132:{ + } + case 1132:{ + QColor c, e, b, n, c0D, o, outl, selection, preselection; + int delta; + int size0D = 0; + int Edgewidth = 0; + vtkFloatingPointType Shrink = 0.0; + vtkFloatingPointType faces_orientation_scale = 0.0; + bool faces_orientation_3dvectors = false; + + VTK::MarkerType aMarkerTypeCurrent = VTK::MT_NONE; + VTK::MarkerScale aMarkerScaleCurrent = VTK::MS_NONE; + int aMarkerTextureCurrent = 0; + + SALOME_ListIteratorOfListIO It( selected ); + for( ; It.More(); It.Next()){ + Handle(SALOME_InteractiveObject) IObject = It.Value(); + 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); - QColor c(c0, c1, c2); + c.setRgb(c0, c1, c2); vtkFloatingPointType edgecolor[3]; anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]); c0 = int (edgecolor[0] * 255); c1 = int (edgecolor[1] * 255); c2 = int (edgecolor[2] * 255); - QColor e(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); - QColor b(c0, c1, c2); + e.setRgb(c0, c1, c2); vtkFloatingPointType nodecolor[3]; anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]); c0 = int (nodecolor[0] * 255); c1 = int (nodecolor[1] * 255); c2 = int (nodecolor[2] * 255); - QColor n(c0, c1, c2); - - int Edgewidth = (int)anActor->GetLineWidth(); + n.setRgb(c0, c1, c2); + + vtkFloatingPointType color0D[3]; + anActor->Get0DColor(color0D[0], color0D[1], color0D[2]); + c0 = int (color0D[0] * 255); + c1 = int (color0D[1] * 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; + Edgewidth = (int)anActor->GetLineWidth(); if(Edgewidth == 0) Edgewidth = 1; - int intValue = int(anActor->GetNodeSize()); - vtkFloatingPointType Shrink = anActor->GetShrinkFactor(); - - SMESHGUI_Preferences_ColorDlg *aDlg = - new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() ); - aDlg->SetColor(1, c); - aDlg->SetColor(2, e); - aDlg->SetColor(3, n); - aDlg->SetColor(4, b); - aDlg->SetIntValue(1, Edgewidth); - aDlg->SetIntValue(2, intValue); - aDlg->SetIntValue(3, int(Shrink*100.)); - if(aDlg->exec()){ - QColor color = aDlg->GetColor(1); - QColor edgecolor = aDlg->GetColor(2); - QColor nodecolor = aDlg->GetColor(3); - QColor backfacecolor = aDlg->GetColor(4); + Shrink = anActor->GetShrinkFactor(); + + vtkFloatingPointType faces_orientation_color[3]; + anActor->GetFacesOrientationColor(faces_orientation_color); + c0 = int (faces_orientation_color[0] * 255); + c1 = int (faces_orientation_color[1] * 255); + c2 = int (faces_orientation_color[2] * 255); + o.setRgb(c0, c1, c2); + + faces_orientation_scale = anActor->GetFacesOrientationScale(); + faces_orientation_3dvectors = anActor->GetFacesOrientation3DVectors(); + + aMarkerTypeCurrent = anActor->GetMarkerType(); + aMarkerScaleCurrent = anActor->GetMarkerScale(); + aMarkerTextureCurrent = anActor->GetMarkerTexture(); + + // even if there are multiple objects in the selection, + // we need only the first one to get values for the dialog + break; + } + } + } + + SMESHGUI_Preferences_ColorDlg *aDlg = + new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() ); + aDlg->SetColor(1, c); + aDlg->SetColor(2, e); + aDlg->SetColor(3, n); + aDlg->SetColor(4, outl); + aDlg->SetDeltaBrightness(delta); + aDlg->SetColor(5, c0D); + aDlg->SetColor(6, o); + aDlg->SetIntValue(1, Edgewidth); + aDlg->SetIntValue(2, int(Shrink*100.)); + 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() ] ); + + if( aMarkerTypeCurrent != VTK::MT_USER ) + aDlg->setStandardMarker( aMarkerTypeCurrent, aMarkerScaleCurrent ); + else + aDlg->setCustomMarker( aMarkerTextureCurrent ); + + if(aDlg->exec()){ + QColor color = aDlg->GetColor(1); + QColor edgecolor = aDlg->GetColor(2); + QColor nodecolor = aDlg->GetColor(3); + 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(); + + SALOME_ListIteratorOfListIO It( selected ); + for( ; It.More(); It.Next()){ + Handle(SALOME_InteractiveObject) IObject = It.Value(); + if(IObject->hasEntry()){ + if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){ /* 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(3) / 100.); + anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.); anActor->SetLineWidth(aDlg->GetIntValue(1)); /* Nodes color and size */ anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255., vtkFloatingPointType (nodecolor.green()) / 255., vtkFloatingPointType (nodecolor.blue()) / 255.); - anActor->SetNodeSize(aDlg->GetIntValue(2)); + + /* 0D elements */ + anActor->Set0DColor(vtkFloatingPointType (color0D.red()) / 255., + vtkFloatingPointType (color0D.green()) / 255., + vtkFloatingPointType (color0D.blue()) / 255.); + anActor->Set0DSize(aDlg->GetIntValue(3)); + + /* Faces orientation */ + vtkFloatingPointType c[3] = {vtkFloatingPointType(faces_orientation_color.redF()), + vtkFloatingPointType(faces_orientation_color.greenF()), + vtkFloatingPointType(faces_orientation_color.blueF())}; + anActor->SetFacesOrientationColor(c); + anActor->SetFacesOrientationScale(aDlg->GetDoubleValue(1)); + anActor->SetFacesOrientation3DVectors(aDlg->GetBooleanValue(1)); + + VTK::MarkerType aMarkerTypeNew = aDlg->getMarkerType(); + VTK::MarkerScale aMarkerScaleNew = aDlg->getStandardMarkerScale(); + int aMarkerTextureNew = aDlg->getCustomMarkerID(); + if( aMarkerTypeNew != VTK::MT_USER ) + anActor->SetMarkerStd( aMarkerTypeNew, aMarkerScaleNew ); + else { + const VTK::MarkerMap& aMarkerMap = theMarkerMap[ aStudy->StudyId() ]; + VTK::MarkerMap::const_iterator anIter = aMarkerMap.find( aMarkerTextureNew ); + if( anIter != aMarkerMap.end() ) + anActor->SetMarkerTexture( aMarkerTextureNew, anIter->second.second ); + } SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface(IObject); if( !aGroupObject->_is_nil() ) @@ -748,11 +1293,45 @@ aGroupColor.B = (float)aColor.blue() / 255.0; aGroupObject->SetColor( aGroupColor ); } - - delete aDlg; } + } + } + SMESH::RepaintCurrentView(); + } + delete aDlg; + return; + } + } + SALOME_ListIteratorOfListIO It( selected ); + for( ; It.More(); It.Next()){ + Handle(SALOME_InteractiveObject) IObject = It.Value(); + if(IObject->hasEntry()){ + if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){ + switch(theCommandID){ + case 211: + anActor->SetRepresentation(SMESH_Actor::eEdge); break; - }} + case 212: + anActor->SetRepresentation(SMESH_Actor::eSurface); + break; + case 213: + if(anActor->IsShrunk()) + anActor->UnShrink(); + else + anActor->SetShrink(); + break; + case 215: + anActor->SetRepresentation(SMESH_Actor::ePoint); + break; + case 231: + if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines) + anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines); + break; + case 232: + if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs) + anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs); + break; + } } } } @@ -770,78 +1349,103 @@ if( !selected.IsEmpty() ){ Handle(SALOME_InteractiveObject) anIO = selected.First(); if(!anIO.IsNull()){ - QString aTitle; SMESH_Actor::eControl aControl = SMESH_Actor::eNone; - if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())){ + if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) { switch ( theCommandID ){ case 6001: - aTitle = QObject::tr( "LENGTH_EDGES" ); aControl = SMESH_Actor::eLength; break; case 6018: - aTitle = QObject::tr( "LENGTH2D_EDGES" ); aControl = SMESH_Actor::eLength2D; break; case 6002: - aTitle = QObject::tr( "FREE_EDGES" ); aControl = SMESH_Actor::eFreeEdges; break; case 6003: - aTitle = QObject::tr( "FREE_BORDERS" ); aControl = SMESH_Actor::eFreeBorders; break; case 6004: - aTitle = QObject::tr( "MULTI_BORDERS" ); aControl = SMESH_Actor::eMultiConnection; break; case 6005: - aTitle = QObject::tr( "FREE_NODES" ); aControl = SMESH_Actor::eFreeNodes; break; case 6019: - aTitle = QObject::tr( "MULTI2D_BORDERS" ); aControl = SMESH_Actor::eMultiConnection2D; break; case 6011: - aTitle = QObject::tr( "AREA_ELEMENTS" ); aControl = SMESH_Actor::eArea; break; case 6012: - aTitle = QObject::tr( "TAPER_ELEMENTS" ); aControl = SMESH_Actor::eTaper; break; case 6013: - aTitle = QObject::tr( "ASPECTRATIO_ELEMENTS" ); aControl = SMESH_Actor::eAspectRatio; break; case 6017: - aTitle = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" ); aControl = SMESH_Actor::eAspectRatio3D; break; case 6014: - aTitle = QObject::tr( "MINIMUMANGLE_ELEMENTS" ); aControl = SMESH_Actor::eMinimumAngle; break; case 6015: - aTitle = QObject::tr( "WARP_ELEMENTS" ); aControl = SMESH_Actor::eWarping; break; case 6016: - aTitle = QObject::tr( "SKEW_ELEMENTS" ); aControl = SMESH_Actor::eSkew; break; case 6009: - aTitle = QObject::tr( "SMESH_VOLUME" ); aControl = SMESH_Actor::eVolume3D; break; case 6021: - aTitle = QObject::tr( "FREE_FACES" ); aControl = SMESH_Actor::eFreeFaces; break; + case 6022: + aControl = SMESH_Actor::eMaxElementLength2D; + break; + case 6023: + aControl = SMESH_Actor::eMaxElementLength3D; + break; + case 6024: + aControl = SMESH_Actor::eBareBorderVolume; + break; + case 6025: + aControl = SMESH_Actor::eBareBorderFace; + break; + case 6026: + aControl = SMESH_Actor::eOverConstrainedVolume; + break; + case 6027: + aControl = SMESH_Actor::eOverConstrainedFace; + break; + case 6028: + aControl = SMESH_Actor::eCoincidentNodes; + break; + case 6029: + aControl = SMESH_Actor::eCoincidentElems1D; + break; + case 6030: + aControl = SMESH_Actor:: eCoincidentElems2D; + break; + case 6031: + aControl = SMESH_Actor::eCoincidentElems3D; + break; } + anActor->SetControlMode(aControl); - anActor->GetScalarBarActor()->SetTitle(aTitle.toLatin1().data()); + anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() ); SMESH::RepaintCurrentView(); +#ifndef DISABLE_PLOT2DVIEWER + if(anActor->GetPlot2Histogram()) { + SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram(); + QString functorName = functorToString( anActor->GetFunctor()); + QString aHistogramName("%1 : %2"); + aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName); + aHistogram->setName(aHistogramName); + aHistogram->setHorTitle(functorName); + SMESH::ProcessIn2DViewers(anActor); + } +#endif } } } @@ -974,13 +1578,13 @@ return; SalomeApp_Application* anApp = dynamic_cast( SUIT_Session::session()->activeApplication() ); - SUIT_ViewManager* vm = anApp->activeViewManager(); - int nbSf = vm->getViewsCount(); + // Put the whole hierarchy of sub-objects of the selected SO's into a list and + // then treat them all starting from the deepest objects (at list back) + std::list< _PTR(SObject) > listSO; SALOME_ListIteratorOfListIO It(selected); - - aStudyBuilder->NewCommand(); // There is a transaction - for( ; It.More(); It.Next()){ // loop on selected IO's + for( ; It.More(); It.Next()) // loop on selected IO's + { Handle(SALOME_InteractiveObject) IObject = It.Value(); if(IObject->hasEntry()) { _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry()); @@ -996,10 +1600,6 @@ if ( aSO && aSO->ReferencedObject( aRefSObject ) ) aSO = aRefSObject; // Delete main Object instead of reference - // put the whole hierarchy of sub-objects of the selected SO into a list and - // then treat them all starting from the deepest objects (at list back) - - std::list< _PTR(SObject) > listSO; listSO.push_back( aSO ); std::list< _PTR(SObject) >::iterator itSO = listSO.begin(); for ( ; itSO != listSO.end(); ++itSO ) { @@ -1007,17 +1607,44 @@ for (it->InitEx(false); it->More(); it->Next()) listSO.push_back( it->Value() ); } + } + } + // Check if none of objects to delete is referred from outside + std::list< _PTR(SObject) >::reverse_iterator ritSO; + for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO ) + { + _PTR(SObject) SO = *ritSO; + if ( !SO ) continue; + std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO ); + for (size_t i = 0; i < aReferences.size(); i++) { + _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent(); + std::string type = aComponent->ComponentDataType(); + if ( type != "SMESH" ) + { + SUIT_MessageBox::warning( anApp->desktop(), + QObject::tr("WRN_WARNING"), + QObject::tr("DEP_OBJECT") ); + return; // outside SMESH, there is an object depending on a SMESH object + } + } + } - // treat SO's in the list starting from the back - - std::list< _PTR(SObject) >::reverse_iterator ritSO = listSO.rbegin(); - for ( ; ritSO != listSO.rend(); ++ritSO ) { - _PTR(SObject) SO = *ritSO; - if ( !SO ) continue; - std::string anEntry = SO->GetID(); - - /** Erase graphical object **/ - if(SO->FindAttribute(anAttr, "AttributeIOR")){ + // Treat SO's in the list starting from the back + aStudyBuilder->NewCommand(); // There is a transaction + for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO ) + { + _PTR(SObject) SO = *ritSO; + if ( !SO ) continue; + std::string anEntry = SO->GetID(); + + /** Erase graphical object **/ + if(SO->FindAttribute(anAttr, "AttributeIOR")){ + ViewManagerList aViewMenegers = anApp->viewManagers(); + ViewManagerList::const_iterator it = aViewMenegers.begin(); + for( ; it != aViewMenegers.end(); it++) { + SUIT_ViewManager* vm = *it; + int nbSf = vm ? vm->getViewsCount() : 0; + if(vm) { QVector aViews = vm->getViews(); for(int i = 0; i < nbSf; i++){ SUIT_ViewWindow *sf = aViews[i]; @@ -1026,41 +1653,41 @@ } } } + } + } + /** Remove an object from data structures **/ + SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO )); + SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO )); + if ( !aGroup->_is_nil() ) { // DELETE GROUP + SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh(); + aMesh->RemoveGroup( aGroup ); + } + else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH + SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather(); + aMesh->RemoveSubMesh( aSubMesh ); - /** Remove an object from data structures **/ - SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO )); - SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO )); - if ( !aGroup->_is_nil() ) { // DELETE GROUP - SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh(); - aMesh->RemoveGroup( aGroup ); - } - else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH - SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather(); - aMesh->RemoveSubMesh( aSubMesh ); - - _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh); - if (aMeshSO) - SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0); - } - else { - IObject = new SALOME_InteractiveObject - ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() ); - QString objType = CheckTypeObject(IObject); - if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS - SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject); - aStudyBuilder->RemoveObjectWithChildren( SO ); - } - else {// default action: remove SObject from the study + _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh); + if (aMeshSO) + SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0); + } + else { + Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject + ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() ); + QString objType = CheckTypeObject(IObject); + if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS + SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject); + aStudyBuilder->RemoveObjectWithChildren( SO ); + } + else {// default action: remove SObject from the study // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy); //op->start(); - aStudyBuilder->RemoveObjectWithChildren( SO ); - //op->finish(); - } - } - } /* listSO back loop */ - } /* IObject->hasEntry() */ - } /* more/next */ + aStudyBuilder->RemoveObjectWithChildren( SO ); + //op->finish(); + } + } + } /* listSO back loop */ + aStudyBuilder->CommitCommand(); /* Clear any previous selection */ @@ -1069,13 +1696,17 @@ SMESHGUI::GetSMESHGUI()->updateObjBrowser(); } -//} +//} namespace extern "C" { SMESHGUI_EXPORT CAM_Module* createModule() { return new SMESHGUI(); } + + SMESHGUI_EXPORT char* getModuleVersion() { + return (char*)SMESH_VERSION_STR; + } } SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil(); @@ -1093,6 +1724,7 @@ LightApp_Module( "SMESH" ) { CORBA::Boolean anIsEmbeddedMode; myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode); + MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode); // 0019923: EDF 765 SMESH : default values of hypothesis SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this); @@ -1100,6 +1732,14 @@ LightApp_Module( "SMESH" ) myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg ); nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 ); myComponentSMESH->SetDefaultNbSegments( nbSeg ); + + const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" }; + for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i ) + if ( aResourceMgr->hasValue( "SMESH", options[i] )) + { + QString val = aResourceMgr->stringValue( "SMESH", options[i] ); + myComponentSMESH->SetOption( options[i], val.toLatin1().constData() ); + } } myActiveDialogBox = 0; @@ -1107,8 +1747,15 @@ LightApp_Module( "SMESH" ) myState = -1; myDisplayer = 0; + myEventCallbackCommand = vtkCallbackCommand::New(); + myEventCallbackCommand->Delete(); + myEventCallbackCommand->SetClientData( this ); + myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents ); + myPriority = 0.0; + SMESH::GetFilterManager(); SMESH::GetPattern(); + SMESH::GetMeasurements(); /* load resources for all available meshers */ SMESH::InitAvailableHypotheses(); @@ -1121,8 +1768,12 @@ LightApp_Module( "SMESH" ) //============================================================================= SMESHGUI::~SMESHGUI() { - SMESH::GetFilterManager()->Destroy(); +#ifdef WITHGENERICOBJ + SMESH::GetFilterManager()->UnRegister(); + SMESH::GetMeasurements()->UnRegister(); +#endif SMESH::GetFilterManager() = SMESH::FilterManager::_nil(); + SMESH::GetMeasurements() = SMESH::Measurements::_nil(); } //============================================================================= @@ -1139,13 +1790,22 @@ LightApp_SelectionMgr* SMESHGUI::selectionMgr() return 0; } -bool SMESHGUI::automaticUpdate() +//============================================================================= +/*! + * + */ +//============================================================================= +bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded) { SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr(); if ( !resMgr ) return false; - return resMgr->booleanValue( "SMESH", "auto_update", false ); + bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false ); + long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 ); + bool exceeded = updateLimit > 0 && requestedSize > updateLimit; + if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded; + return autoUpdate && !exceeded; } //============================================================================= @@ -1304,6 +1964,22 @@ SalomeApp_Study* SMESHGUI::activeStudy() return NULL; } +//============================================================================= +/*! + * + */ +//============================================================================= +void SMESHGUI::Modified( bool theIsUpdateActions ) +{ + if( SalomeApp_Application* app = dynamic_cast( SUIT_Session::session()->activeApplication() ) ) { + if( SalomeApp_Study* appStudy = dynamic_cast( app->activeStudy() ) ) { + appStudy->Modified(); + if( theIsUpdateActions ) + app->updateActions(); + } + } +} + //============================================================================= /*! * @@ -1381,9 +2057,12 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) OnEditDelete(); break; - case 113: // IMPORT + case 116: + case 115: + case 117: + case 113: case 112: - case 111: + case 111: // IMPORT { if(checkLock(aStudy)) break; ::ImportMeshesFromFile(GetSMESHGen(),theCommandID); @@ -1417,6 +2096,10 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) case 126: case 140: case 141: + case 142: + case 143: + case 144: + case 145: { ::ExportMeshToFile(theCommandID); break; @@ -1434,6 +2117,9 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) if( anIO->hasEntry() ) { if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) { anActor->SetControlMode( SMESH_Actor::eNone ); +#ifndef DISABLE_PLOT2DVIEWER + SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer); +#endif } } } @@ -1444,6 +2130,28 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this ); break; } + case 2021: + { + // dump control distribution data to the text file + ::SaveDistribution(); + break; + } + + case 2022: + { + // show/ distribution + ::ShowDistribution(); + break; + } + +#ifndef DISABLE_PLOT2DVIEWER + case 2023: + { + // plot distribution + ::PlotDistribution(); + break; + } +#endif // Auto-color case 1136: @@ -1456,22 +2164,22 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) case 1134: // Clipping case 1133: // Tranparency - case 1132: // Colors / Size + case 1132: // Display preferences (colors, shrink size, line width, ...) // Display Mode case 215: // Nodes case 213: // Nodes case 212: // Nodes case 211: // Nodes - ::SetDisplayMode(theCommandID); + ::SetDisplayMode(theCommandID, myMarkerMap); break; //2D quadratic representation case 231: case 232: - ::SetDisplayMode(theCommandID); + ::SetDisplayMode(theCommandID, myMarkerMap); break; - + // Display Entity case 216: // 0D elements case 217: // Edges @@ -1538,7 +2246,10 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) aSel->selectedObjects( sel_objects ); if( theCommandID==302 ) + { + MESSAGE("anAction = SMESH::eDisplayOnly"); startOperation( myEraseAll ); + } extractContainers( sel_objects, to_process ); @@ -1549,20 +2260,26 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) if (vtkwnd) { SALOME_ListIteratorOfListIO It( to_process ); for ( ; It.More(); It.Next()) { + MESSAGE("---"); Handle(SALOME_InteractiveObject) IOS = It.Value(); if (IOS->hasEntry()) { + MESSAGE("---"); if (!SMESH::UpdateView(anAction, IOS->getEntry())) { SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged(); break; // PAL16774 (Crash after display of many groups) } if (anAction == SMESH::eDisplayOnly) + { + MESSAGE("anAction = SMESH::eDisplayOnly"); anAction = SMESH::eDisplay; + } } } } // PAL13338 + PAL15161 --> if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) { + MESSAGE("anAction = SMESH::eDisplayOnly"); SMESH::UpdateView(); SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged(); } @@ -1573,12 +2290,13 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) } if (anAction == SMESH::eErase) { + MESSAGE("anAction == SMESH::eErase"); SALOME_ListIO l1; aSel->setSelectedObjects( l1 ); } else aSel->setSelectedObjects( to_process ); - + break; } @@ -1609,23 +2327,10 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) break; } - case 406: // MOVE NODE - { - if ( !vtkwnd ) - { - SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), - tr( "NOT_A_VTK_VIEWER" ) ); - break; - } - - if(checkLock(aStudy)) break; - ( new SMESHGUI_MoveNodesDlg( this ) )->show(); - break; - } - case 701: // COMPUTE MESH case 711: // PRECOMPUTE MESH case 712: // EVALUATE MESH + case 713: // MESH ORDER { if (checkLock(aStudy)) break; startOperation( theCommandID ); @@ -1637,6 +2342,13 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) case 704: // Edit mesh/sub-mesh startOperation( theCommandID ); break; + case 705: // copy mesh + { + if (checkLock(aStudy)) break; + EmitSignalDeactivateDialog(); + ( new SMESHGUI_CopyMeshDlg( this ) )->show(); + } + break; case 710: // Build compound mesh { if (checkLock(aStudy)) break; @@ -1674,9 +2386,10 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show(); break; } - case 409: // Change orientation - case 410: // Union of triangles - case 411: // Cutting of quadrangles + case 409: // Change orientation + case 410: // Union of triangles + case 411: // Cutting of quadrangles + case 419: // Splitting volumes into tetrahedra { if ( !vtkwnd ) { @@ -1694,6 +2407,8 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) aDlg = new SMESHGUI_ChangeOrientationDlg(this); else if ( theCommandID == 410 ) aDlg = new SMESHGUI_UnionOfTrianglesDlg(this); + else if ( theCommandID == 419 ) + aDlg = new SMESHGUI_CuttingIntoTetraDlg(this); else aDlg = new SMESHGUI_CuttingOfQuadsDlg(this); @@ -1851,24 +2566,33 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME); // create group for each type o elements QString aName = IObject->getName(); + QStringList anEntryList; if (aNodes->length() > 0) { SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes"); aGroup->Add(aNodes.inout()); + if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) ) + anEntryList.append( aSObject->GetID().c_str() ); } if (aEdges->length() > 0) { SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges"); aGroup->Add(aEdges.inout()); + if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) ) + anEntryList.append( aSObject->GetID().c_str() ); } if (aFaces->length() > 0) { SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces"); aGroup->Add(aFaces.inout()); + if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) ) + anEntryList.append( aSObject->GetID().c_str() ); } if (aVolumes->length() > 0) { SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes"); aGroup->Add(aVolumes.inout()); + if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) ) + anEntryList.append( aSObject->GetID().c_str() ); } updateObjBrowser(); - + anApp->browseObjects( anEntryList ); } catch(const SALOME::SALOME_Exception & S_ex){ SalomeApp_Tools::QtCatchCorbaException(S_ex); @@ -1968,6 +2692,15 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true ); aDlg->show(); } + else + { + SMESH::SMESH_GroupOnFilter_var aGroup = + SMESH::IObjectToInterface(It.Value()); + if (!aGroup->_is_nil()) { + SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true ); + aDlg->show(); + } + } } break; } @@ -2032,7 +2765,9 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) } case 900: // MESH INFOS + case 903: // WHAT IS { + int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo; EmitSignalDeactivateDialog(); LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr(); SALOME_ListIO selected; @@ -2040,50 +2775,23 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) aSel->selectedObjects( selected ); if ( selected.Extent() > 1 ) { // a dlg for each IO - SALOME_ListIO IOs; - SALOME_ListIteratorOfListIO It (selected); + SALOME_ListIteratorOfListIO It( selected ); for ( ; It.More(); It.Next() ) { - IOs.Clear(); IOs.Append( It.Value() ); - aSel->setSelectedObjects( IOs ); - ( new SMESHGUI_MeshInfosDlg( this ) )->show(); + SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page ); + dlg->showInfo( It.Value() ); + dlg->show(); } - // restore selection - aSel->setSelectedObjects( selected ); } - else - ( new SMESHGUI_MeshInfosDlg( this ) )->show(); - break; - } - - case 902: // STANDARD MESH INFOS - { - EmitSignalDeactivateDialog(); - LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr(); - SALOME_ListIO selected; - if( aSel ) - aSel->selectedObjects( selected ); - - if ( selected.Extent() > 1 ) { // a dlg for each IO - SALOME_ListIO IOs; - SALOME_ListIteratorOfListIO It (selected); - for ( ; It.More(); It.Next() ) { - IOs.Clear(); - IOs.Append( It.Value() ); - aSel->setSelectedObjects( IOs ); - ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show(); - } - // restore selection - aSel->setSelectedObjects( selected ); + else { + SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page ); + dlg->show(); } - else - ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show(); break; } - case 903: // WHAT IS + case 904: // FIND ELEM { - EmitSignalDeactivateDialog(); - ( new SMESHGUI_WhatIsDlg( this ) )->show(); + startOperation( theCommandID ); break; } @@ -2121,71 +2829,6 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) } break; } - - case 1101: // RENAME - { - if ( checkLock( aStudy ) ) - break; - - LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr(); - SALOME_ListIO selected; - if( aSel ) - aSel->selectedObjects( selected ); - - bool isAny = false; // is there any appropriate object selected - - SALOME_ListIteratorOfListIO It( selected ); - for ( ; It.More(); It.Next() ) - { - Handle(SALOME_InteractiveObject) IObject = It.Value(); - _PTR(SObject) obj = aStudy->FindObjectID( IObject->getEntry() ); - _PTR(GenericAttribute) anAttr; - _PTR(AttributeName) aName; - if ( obj ) - { - if ( obj->FindAttribute(anAttr, "AttributeName") ) - { - aName = anAttr; - QString newName = QString(aName->Value().c_str()); - - // check type to prevent renaming of inappropriate objects - int aType = SMESHGUI_Selection::type(IObject->getEntry(), 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) - { - isAny = true; - newName = LightApp_NameDlg::getName(desktop(), newName); - if ( !newName.isEmpty() ) - { - SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), newName.toLatin1().data()); - - // update name of group object and its actor - SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface(IObject); - if( !aGroupObject->_is_nil() ) - { - aGroupObject->SetName( newName.toLatin1().data() ); - if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( IObject->getEntry() ) ) - anActor->setName( newName.toLatin1().data() ); - } - - updateObjBrowser(); - } - } - } - } - } // for - - if (!isAny) { - SUIT_MessageBox::warning(desktop(), - QObject::tr("SMESH_WRN_WARNING"), - QObject::tr("SMESH_WRN_NO_APPROPRIATE_SELECTION")); - } - break; - } - case 1102: // REMOVE HYPOTHESIS / ALGORITHMS { if(checkLock(aStudy)) break; @@ -2208,36 +2851,42 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) } case 4009: // ELEM0D - case 4010: // GEOM::EDGE + case 4010: // EDGE case 4021: // TRIANGLE case 4022: // QUAD case 4023: // POLYGON case 4031: // TETRA case 4032: // HEXA + case 4133: // PENTA + case 4134: // PYRAMID + case 4135: // OCTA12 { if(checkLock(aStudy)) break; if ( vtkwnd ) { EmitSignalDeactivateDialog(); - SMDSAbs_ElementType type = SMDSAbs_Edge; - int nbNodes = 2; + SMDSAbs_EntityType type = SMDSEntity_Edge; switch (theCommandID) { - case 4009: // ELEM0D - type = SMDSAbs_0DElement; nbNodes = 1; break; - case 4021: // TRIANGLE - type = SMDSAbs_Face; nbNodes = 3; break; - case 4022: // QUAD - type = SMDSAbs_Face; nbNodes = 4; break; - case 4031: // TETRA - type = SMDSAbs_Volume; nbNodes = 4; break; - case 4023: // POLYGON - type = SMDSAbs_Face; nbNodes = 5; break; // 5 - identificator for POLYGON - case 4032: // HEXA - type = SMDSAbs_Volume; nbNodes = 8; break; - case 4033: // POLYHEDRE - type = SMDSAbs_Volume; nbNodes = 9; break; // 9 - identificator for POLYHEDRE + case 4009: + type = SMDSEntity_0D; break; + case 4021: + type = SMDSEntity_Triangle; break; + case 4022: + type = SMDSEntity_Quadrangle; break; + case 4031: + type = SMDSEntity_Tetra; break; + case 4023: + type = SMDSEntity_Polygon; break; + case 4032: + type = SMDSEntity_Hexa; break; + case 4133: + type = SMDSEntity_Penta; break; + case 4134: + type = SMDSEntity_Pyramid; break; + case 4135: + type = SMDSEntity_Hexagonal_Prism; break; default:; } - ( new SMESHGUI_AddMeshElementDlg( this, type, nbNodes ) )->show(); + ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show(); } else { SUIT_MessageBox::warning(desktop(), @@ -2261,31 +2910,37 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) case 4034: // QUADRATIC EDGE case 4035: // QUADRATIC TRIANGLE case 4036: // QUADRATIC QUADRANGLE + case 4136: // BIQUADRATIC QUADRANGLE case 4037: // QUADRATIC TETRAHEDRON case 4038: // QUADRATIC PYRAMID case 4039: // QUADRATIC PENTAHEDRON case 4040: // QUADRATIC HEXAHEDRON + case 4140: // TRIQUADRATIC HEXAHEDRON { if(checkLock(aStudy)) break; if ( vtkwnd ) { EmitSignalDeactivateDialog(); - int type; + SMDSAbs_EntityType type; switch (theCommandID) { case 4034: - type = QUAD_EDGE; break; + type = SMDSEntity_Quad_Edge; break; case 4035: - type = QUAD_TRIANGLE; break; + type = SMDSEntity_Quad_Triangle; break; case 4036: - type = QUAD_QUADRANGLE; break; + type = SMDSEntity_Quad_Quadrangle; break; + case 4136: + type = SMDSEntity_BiQuad_Quadrangle; break; case 4037: - type = QUAD_TETRAHEDRON; break; + type = SMDSEntity_Quad_Tetra; break; case 4038: - type = QUAD_PYRAMID; break; + type = SMDSEntity_Quad_Pyramid; break; case 4039: - type = QUAD_PENTAHEDRON; break; + type = SMDSEntity_Quad_Penta; break; case 4040: - type = QUAD_HEXAHEDRON; + type = SMDSEntity_Quad_Hexa; + case 4140: + type = SMDSEntity_TriQuad_Hexa; break; default:; } @@ -2341,7 +2996,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) SMESH::IObjectToInterface(IOS); if ( aMesh->_is_nil()) continue; try { - SMESH::UpdateView(SMESH::eErase, IOS->getEntry()); + SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true); aMesh->Clear(); _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh); SMESH::ModifiedMesh( aMeshSObj, false, true); @@ -2351,7 +3006,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) for ( anIter->InitEx(true); anIter->More(); anIter->Next() ) { _PTR(SObject) so = anIter->Value(); - SMESH::UpdateView(SMESH::eErase, so->GetID().c_str()); + SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true); } } catch (const SALOME::SALOME_Exception& S_ex){ @@ -2364,6 +3019,44 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) updateObjBrowser(); break; } + case 4044: // REMOVE ORPHAN NODES + { + if(checkLock(aStudy)) break; + SALOME_ListIO selected; + if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() ) + aSel->selectedObjects( selected ); + if ( selected.Extent() == 1 ) { + Handle(SALOME_InteractiveObject) anIO = selected.First(); + SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO); + if ( !aMesh->_is_nil() ) { + bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(), + tr( "SMESH_WARNING" ), + tr( "REMOVE_ORPHAN_NODES_QUESTION"), + SUIT_MessageBox::Yes | + SUIT_MessageBox::No, + SUIT_MessageBox::No ) == SUIT_MessageBox::Yes; + if( confirm ) { + try { + SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor(); + int removed = aMeshEditor->RemoveOrphanNodes(); + SUIT_MessageBox::information(SMESHGUI::desktop(), + tr("SMESH_INFORMATION"), + tr("NB_NODES_REMOVED").arg(removed)); + if ( removed > 0 ) { + SMESH::UpdateView(); + SMESHGUI::Modified(); + } + } + catch (const SALOME::SALOME_Exception& S_ex) { + SalomeApp_Tools::QtCatchCorbaException(S_ex); + } + catch (...) { + } + } + } + } + break; + } case 4051: // RENUMBERING NODES { if(checkLock(aStudy)) break; @@ -2449,7 +3142,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) if(checkLock(aStudy)) break; if(vtkwnd) { EmitSignalDeactivateDialog(); - ( new SMESHGUI_EditMeshDlg( this, 0 ) )->show(); + ( new SMESHGUI_MergeDlg( this, 0 ) )->show(); } else { SUIT_MessageBox::warning(SMESHGUI::desktop(), @@ -2462,7 +3155,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) if (checkLock(aStudy)) break; if (vtkwnd) { EmitSignalDeactivateDialog(); - ( new SMESHGUI_EditMeshDlg( this, 1 ) )->show(); + ( new SMESHGUI_MergeDlg( this, 1 ) )->show(); } else { SUIT_MessageBox::warning(SMESHGUI::desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK")); @@ -2474,6 +3167,34 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) startOperation( 4067 ); break; + case 4068: // SCALE + { + if(checkLock(aStudy)) break; + if ( vtkwnd ) { + EmitSignalDeactivateDialog(); + ( new SMESHGUI_ScaleDlg( this ) )->show(); + } + else { + SUIT_MessageBox::warning(SMESHGUI::desktop(), + tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK")); + } + break; + } + + case 4069: // DUPLICATE NODES + { + if(checkLock(aStudy)) break; + if ( vtkwnd ) { + EmitSignalDeactivateDialog(); + ( new SMESHGUI_DuplicateNodesDlg( this ) )->show(); + } + else { + SUIT_MessageBox::warning(SMESHGUI::desktop(), + tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK")); + } + break; + } + case 5105: // Library of selection filters { static QList aTypes; @@ -2508,6 +3229,16 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) case 6005: case 6009: case 6021: + case 6022: + case 6023: + case 6024: + case 6025: + case 6026: + case 6027: + case 6028: + case 6029: + case 6030: + case 6031: if ( vtkwnd ) { LightApp_SelectionMgr* mgr = selectionMgr(); @@ -2558,8 +3289,9 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) LightApp_SelectionMgr* mgr = selectionMgr(); SALOME_ListIO selected; mgr->selectedObjects( selected ); - if (selected.Extent() == 1) { - Handle(SALOME_InteractiveObject) anIObject = selected.First(); + SALOME_ListIteratorOfListIO it(selected); + for( ; it.More(); it.Next()) { + Handle(SALOME_InteractiveObject) anIObject = it.Value(); if(anIObject->hasEntry()) if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){ anActor->SetCellsLabeled( !anActor->GetCellsLabeled() ); @@ -2567,6 +3299,15 @@ bool SMESHGUI::OnGUIEvent( int theCommandID ) } break; } + case 501: + case 502: + { + int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox; + EmitSignalDeactivateDialog(); + SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page ); + dlg->show(); + break; + } } anApp->updateActions(); //SRN: To update a Save button in the toolbar @@ -2622,7 +3363,8 @@ void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO // function : createSMESHAction // purpose : //======================================================================= -void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id, const int key, const bool toggle ) +void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id, + const int key, const bool toggle, const QString& shortcutAction ) { QIcon icon; QWidget* parent = application()->desktop(); @@ -2639,7 +3381,8 @@ void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QStr menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ), status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() ); - createAction( id, tooltip, icon, menu, status_bar, key, parent, toggle, this, SLOT( OnGUIEvent() ) ); + createAction( id, tooltip, icon, menu, status_bar, key, parent, + toggle, this, SLOT( OnGUIEvent() ), shortcutAction ); } //======================================================================= @@ -2697,14 +3440,21 @@ void SMESHGUI::initialize( CAM_Application* app ) 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" ); @@ -2712,9 +3462,11 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" ); createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" ); createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" ); + createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" ); createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" ); createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" ); createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" ); + createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" ); createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" ); createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" ); createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" ); @@ -2728,11 +3480,22 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" ); 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( 902, "STD_INFO", "ICON_STD_INFO" ); + //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 ); createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true ); + createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true ); + createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true ); + createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true ); + createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true ); + createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true ); + createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true ); + createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true ); + createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true ); + createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true ); + createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true ); createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true ); createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true ); createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true ); @@ -2754,8 +3517,22 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" ); createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" ); createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" ); - createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" ); - createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" ); + createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" ); + createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" ); + createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" ); + createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" ); + createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" ); + createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" ); + createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" ); + createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" ); + createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" ); + createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" ); + createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" ); + createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" ); + createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" ); + createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" ); + createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" ); + createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" ); createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" ); createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" ); createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" ); @@ -2765,8 +3542,9 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" ); createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" ); createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" ); - createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MESH_THROU_POINT" ); - createSMESHAction( 406, "MOVE", "ICON_DLG_MOVE_NODE" ); + createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" ); + createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" ); + createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" ); createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" ); createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" ); createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" ); @@ -2779,8 +3557,14 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" ); createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" ); createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" ); + createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" ); createSMESHAction( 200, "RESET" ); createSMESHAction( 201, "SCALAR_BAR_PROP" ); + createSMESHAction( 2021, "SAVE_DISTRIBUTION" ); + createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true ); +#ifndef DISABLE_PLOT2DVIEWER + createSMESHAction( 2023, "PLOT_DISTRIBUTION" ); +#endif createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true ); createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true ); createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true ); @@ -2797,7 +3581,6 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true ); createSMESHAction( 1100, "EDIT_HYPO" ); - createSMESHAction( 1101, "RENAME", "", Qt::Key_F2 ); createSMESHAction( 1102, "UNASSIGN" ); createSMESHAction( 9010, "NUM_NODES", "", 0, true ); createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true ); @@ -2810,31 +3593,31 @@ void SMESHGUI::initialize( CAM_Application* app ) createSMESHAction( 1137, "DISABLE_AUTO_COLOR" ); createSMESHAction( 2000, "CTRL" ); - createSMESHAction( 300, "ERASE" ); - createSMESHAction( 301, "DISPLAY" ); + createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" ); + createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" ); + + createSMESHAction( 300, "HIDE" ); + createSMESHAction( 301, "SHOW" ); createSMESHAction( 302, "DISPLAY_ONLY" ); - createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" ); - createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" ); - createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" ); - createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" ); - createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" ); - createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" ); - createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" ); - createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" ); // ----- create menu -------------- - int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ), - editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ), - toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ), - meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ), - ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ), - modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ), - viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 ); + int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ), + editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ), + toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ), + meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ), + ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ), + modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ), + measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ), + viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 ); createMenu( separator(), fileId ); int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ), exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ), + nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ), + edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ), + faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ), + volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ), addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ), removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ), renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ), @@ -2843,12 +3626,19 @@ void SMESHGUI::initialize( CAM_Application* app ) createMenu( 111, importId, -1 ); createMenu( 112, importId, -1 ); createMenu( 113, 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( 140, 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 ); @@ -2859,10 +3649,12 @@ void SMESHGUI::initialize( CAM_Application* app ) createMenu( 703, meshId, -1 ); createMenu( 704, meshId, -1 ); createMenu( 710, meshId, -1 ); + createMenu( 705, meshId, -1 ); createMenu( separator(), meshId, -1 ); createMenu( 701, meshId, -1 ); createMenu( 711, meshId, -1 ); createMenu( 712, meshId, -1 ); + createMenu( 713, meshId, -1 ); createMenu( separator(), meshId, -1 ); createMenu( 801, meshId, -1 ); createMenu( 806, meshId, -1 ); @@ -2876,32 +3668,38 @@ void SMESHGUI::initialize( CAM_Application* app ) createMenu( separator(), meshId, -1 ); createMenu( 814, meshId, -1 ); createMenu( separator(), meshId, -1 ); - createMenu( 813, meshId, -1 ); - createMenu( separator(), meshId, -1 ); createMenu( 900, meshId, -1 ); - createMenu( 902, meshId, -1 ); - createMenu( 903, meshId, -1 ); + //createMenu( 902, meshId, -1 ); + //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command) + createMenu( 904, meshId, -1 ); createMenu( separator(), meshId, -1 ); - createMenu( 6003, ctrlId, -1 ); - createMenu( 6001, ctrlId, -1 ); - createMenu( 6004, ctrlId, -1 ); - createMenu( separator(), ctrlId, -1 ); - createMenu( 6005, ctrlId, -1 ); - createMenu( 6002, ctrlId, -1 ); - createMenu( 6018, ctrlId, -1 ); - createMenu( 6019, ctrlId, -1 ); - createMenu( 6011, ctrlId, -1 ); - createMenu( 6012, ctrlId, -1 ); - createMenu( 6013, ctrlId, -1 ); - createMenu( 6014, ctrlId, -1 ); - createMenu( 6015, ctrlId, -1 ); - createMenu( 6016, ctrlId, -1 ); - createMenu( separator(), ctrlId, -1 ); - createMenu( 6017, ctrlId, -1 ); - createMenu( 6009, ctrlId, -1 ); - createMenu( 6021, ctrlId, -1 ); - createMenu( separator(), ctrlId, -1 ); + createMenu( 6005, nodeId, -1 ); + createMenu( 6028, nodeId, -1 ); + createMenu( 6002, edgeId, -1 ); + createMenu( 6003, edgeId, -1 ); + createMenu( 6001, edgeId, -1 ); + createMenu( 6004, edgeId, -1 ); + createMenu( 6029, edgeId, -1 ); + createMenu( 6021, faceId, -1 ); + createMenu( 6025, faceId, -1 ); + createMenu( 6027, faceId, -1 ); + createMenu( 6018, faceId, -1 ); + createMenu( 6019, faceId, -1 ); + createMenu( 6011, faceId, -1 ); + createMenu( 6012, faceId, -1 ); + createMenu( 6013, faceId, -1 ); + createMenu( 6014, faceId, -1 ); + createMenu( 6015, faceId, -1 ); + createMenu( 6016, faceId, -1 ); + createMenu( 6022, faceId, -1 ); + createMenu( 6030, faceId, -1 ); + createMenu( 6017, volumeId, -1 ); + createMenu( 6009, volumeId, -1 ); + createMenu( 6023, volumeId, -1 ); + createMenu( 6024, volumeId, -1 ); + createMenu( 6026, volumeId, -1 ); + createMenu( 6031, volumeId, -1 ); createMenu( 4000, addId, -1 ); createMenu( 4009, addId, -1 ); @@ -2911,18 +3709,27 @@ void SMESHGUI::initialize( CAM_Application* app ) createMenu( 4023, addId, -1 ); createMenu( 4031, addId, -1 ); createMenu( 4032, addId, -1 ); + createMenu( 4133, addId, -1 ); + createMenu( 4134, addId, -1 ); + createMenu( 4135, addId, -1 ); createMenu( 4033, addId, -1 ); createMenu( separator(), addId, -1 ); createMenu( 4034, addId, -1 ); createMenu( 4035, addId, -1 ); createMenu( 4036, addId, -1 ); + createMenu( 4136, addId, -1 ); createMenu( 4037, addId, -1 ); createMenu( 4038, addId, -1 ); createMenu( 4039, addId, -1 ); createMenu( 4040, addId, -1 ); + createMenu( 4140, addId, -1 ); createMenu( 4041, removeId, -1 ); createMenu( 4042, removeId, -1 ); + createMenu( 4044, removeId, -1 ); + createMenu( separator(), removeId, -1 ); + createMenu( 813, removeId, -1 ); + createMenu( separator(), removeId, -1 ); createMenu( 4043, removeId, -1 ); createMenu( 4051, renumId, -1 ); @@ -2931,17 +3738,19 @@ void SMESHGUI::initialize( CAM_Application* app ) createMenu( 4061, transfId, -1 ); createMenu( 4062, transfId, -1 ); createMenu( 4063, transfId, -1 ); + createMenu( 4068, transfId, -1 ); createMenu( 4064, transfId, -1 ); createMenu( 4065, transfId, -1 ); createMenu( 4066, transfId, -1 ); + createMenu( 4069, transfId, -1 ); - createMenu( 406, modifyId, -1 ); createMenu( 4067,modifyId, -1 ); createMenu( 407, modifyId, -1 ); createMenu( 408, modifyId, -1 ); createMenu( 409, modifyId, -1 ); createMenu( 410, modifyId, -1 ); createMenu( 411, modifyId, -1 ); + createMenu( 419, modifyId, -1 ); createMenu( 412, modifyId, -1 ); createMenu( 413, modifyId, -1 ); createMenu( 416, modifyId, -1 ); @@ -2950,6 +3759,8 @@ void SMESHGUI::initialize( CAM_Application* app ) createMenu( 417, modifyId, -1 ); createMenu( 418, modifyId, -1 ); + createMenu( 501, measureId, -1 ); + createMenu( 502, measureId, -1 ); createMenu( 214, viewId, -1 ); // ----- create toolbars -------------- @@ -2963,10 +3774,12 @@ void SMESHGUI::initialize( CAM_Application* app ) createTool( 703, meshTb ); createTool( 704, meshTb ); createTool( 710, meshTb ); + createTool( 705, meshTb ); createTool( separator(), meshTb ); createTool( 701, meshTb ); createTool( 711, meshTb ); createTool( 712, meshTb ); + createTool( 713, meshTb ); createTool( separator(), meshTb ); createTool( 801, meshTb ); createTool( 806, meshTb ); @@ -2975,16 +3788,23 @@ void SMESHGUI::initialize( CAM_Application* app ) //createTool( 815, meshTb ); createTool( separator(), meshTb ); createTool( 900, meshTb ); - createTool( 902, meshTb ); - createTool( 903, meshTb ); + //createTool( 902, meshTb ); + //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command) + createTool( 904, meshTb ); createTool( separator(), meshTb ); - createTool( 6001, ctrlTb ); + createTool( 6005, ctrlTb ); + createTool( 6028, ctrlTb ); + createTool( separator(), ctrlTb ); + createTool( 6002, ctrlTb ); createTool( 6003, ctrlTb ); + createTool( 6001, ctrlTb ); createTool( 6004, ctrlTb ); + createTool( 6029, ctrlTb ); createTool( separator(), ctrlTb ); - createTool( 6005, ctrlTb ); - createTool( 6002, ctrlTb ); + createTool( 6021, ctrlTb ); + createTool( 6025, ctrlTb ); + createTool( 6027, ctrlTb ); createTool( 6018, ctrlTb ); createTool( 6019, ctrlTb ); createTool( 6011, ctrlTb ); @@ -2993,10 +3813,15 @@ void SMESHGUI::initialize( CAM_Application* app ) createTool( 6014, ctrlTb ); createTool( 6015, ctrlTb ); createTool( 6016, ctrlTb ); + createTool( 6022, ctrlTb ); + createTool( 6030, ctrlTb ); createTool( separator(), ctrlTb ); createTool( 6017, ctrlTb ); createTool( 6009, ctrlTb ); - createTool( 6021, ctrlTb ); + createTool( 6023, ctrlTb ); + createTool( 6024, ctrlTb ); + createTool( 6026, ctrlTb ); + createTool( 6031, ctrlTb ); createTool( separator(), ctrlTb ); createTool( 4000, addRemTb ); @@ -3007,18 +3832,24 @@ void SMESHGUI::initialize( CAM_Application* app ) createTool( 4023, addRemTb ); createTool( 4031, addRemTb ); createTool( 4032, addRemTb ); + createTool( 4133, addRemTb ); + createTool( 4134, addRemTb ); + createTool( 4135, addRemTb ); createTool( 4033, addRemTb ); createTool( separator(), addRemTb ); createTool( 4034, addRemTb ); createTool( 4035, addRemTb ); createTool( 4036, addRemTb ); + createTool( 4136, addRemTb ); createTool( 4037, addRemTb ); createTool( 4038, addRemTb ); createTool( 4039, addRemTb ); createTool( 4040, addRemTb ); + createTool( 4140, addRemTb ); createTool( separator(), addRemTb ); createTool( 4041, addRemTb ); createTool( 4042, addRemTb ); + createTool( 4044, addRemTb ); createTool( 4043, addRemTb ); createTool( separator(), addRemTb ); createTool( 4051, addRemTb ); @@ -3027,18 +3858,20 @@ void SMESHGUI::initialize( CAM_Application* app ) createTool( 4061, addRemTb ); createTool( 4062, addRemTb ); createTool( 4063, addRemTb ); + createTool( 4068, addRemTb ); createTool( 4064, addRemTb ); createTool( 4065, addRemTb ); createTool( 4066, addRemTb ); + createTool( 4069, addRemTb ); createTool( separator(), addRemTb ); - createTool( 406, modifyTb ); createTool( 4067,modifyTb ); createTool( 407, modifyTb ); createTool( 408, modifyTb ); createTool( 409, modifyTb ); createTool( 410, modifyTb ); createTool( 411, modifyTb ); + createTool( 419, modifyTb ); createTool( 412, modifyTb ); createTool( 413, modifyTb ); createTool( 416, modifyTb ); @@ -3068,7 +3901,8 @@ void SMESHGUI::initialize( CAM_Application* app ) 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 @@ -3088,42 +3922,47 @@ void SMESHGUI::initialize( CAM_Application* app ) 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" ); // COMPUTE - 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( 712, OB, mesh, "&& isComputable" ); // EVALUATE + createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER + 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( 1101, OB, mesh_group + " " + hyp_alg ); // RENAME + 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/*, "&& " + hasElems*/); // 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 ); - - createPopupItem( 125, OB, mesh, only_one_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 + 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_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 + createPopupItem( 813, OB, group ); // DEL_GROUP with contents popupMgr()->insert( separator(), -1, 0 ); // popup for viewer @@ -3132,10 +3971,9 @@ void SMESHGUI::initialize( CAM_Application* app ) 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 ); createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR @@ -3145,7 +3983,7 @@ void SMESHGUI::initialize( CAM_Application* app ) 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'})"; @@ -3221,12 +4059,12 @@ void SMESHGUI::initialize( CAM_Application* app ) //------------------------------------------------- // Representation of the 2D Quadratic elements - //------------------------------------------------- + //------------------------------------------------- anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 ); popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule ); - + popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule ); @@ -3250,14 +4088,6 @@ void SMESHGUI::initialize( CAM_Application* app ) popupMgr()->insert( action( 1133 ), -1, -1 ); popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule ); - //------------------------------------------------- - // Clipping - //------------------------------------------------- - popupMgr()->insert( action( 1134 ), -1, -1 ); - popupMgr()->setRule( action( 1134 ), aMeshInVTK + "&& selcount=1 && isVisible", QtxPopupMgr::VisibleRule ); - - popupMgr()->insert( separator(), -1, -1 ); - //------------------------------------------------- // Controls //------------------------------------------------- @@ -3268,91 +4098,148 @@ void SMESHGUI::initialize( CAM_Application* app ) aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes; anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 ); - + popupMgr()->insert( action( 200 ), anId, -1 ); // RESET popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule ); popupMgr()->insert( separator(), anId, -1 ); - popupMgr()->insert( action( 6003 ), anId, -1 ); // FREE_BORDER + int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS + + popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE + popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE + popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule); + + aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS + + popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE + popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6001 ), anId, -1 ); // LENGTH + popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6004 ), anId, -1 ); // CONNECTION + popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule ); + popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE + popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule); - popupMgr()->insert( separator(), anId, -1 ); - - popupMgr()->insert( action( 6005 ), anId, -1 ); // FREE_NODE - popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule ); - popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule ); + aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS - popupMgr()->insert( action( 6002 ), anId, -1 ); // FREE_EDGE - popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule ); - popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule ); + popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE + popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/, + QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6018 ), anId, -1 ); // LENGTH_2D + popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6019 ), anId, -1 ); // CONNECTION_2D + popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6011 ), anId, -1 ); // AREA + popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6012 ), anId, -1 ); // TAPER + popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6013 ), anId, -1 ); // ASPECT + popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6014 ), anId, -1 ); // MIN_ANG + popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6015 ), anId, -1 ); // WARP + popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6016 ), anId, -1 ); // SKEW + popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( separator(), anId, -1 ); + popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D + popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE + popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE + popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule ); + popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE + popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule ); + + aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS - popupMgr()->insert( action( 6017 ), anId, -1 ); // ASPECT_3D + popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert ( action( 6009 ), anId, -1 ); // VOLUME_3D + popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule ); popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule ); - popupMgr()->insert( action( 6021 ), anId, -1 ); // FREE_FACE - popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/, - QtxPopupMgr::VisibleRule ); - popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule ); + popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D + popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME + popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME + popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule ); + + popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME + popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule ); popupMgr()->insert( separator(), anId, -1 ); popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule ); - popupMgr()->insert( separator(), -1, -1 ); - + popupMgr()->insert( separator(), anId, -1 ); + + aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS + + popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION + popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule ); + + popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION + popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule ); + popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule); + +#ifndef DISABLE_PLOT2DVIEWER + popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION + popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule ); +#endif + //------------------------------------------------- // Display / Erase //------------------------------------------------- + popupMgr()->insert( separator(), -1, -1 ); QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " + aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )"; popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY @@ -3366,8 +4253,19 @@ void SMESHGUI::initialize( CAM_Application* app ) popupMgr()->insert( separator(), -1, -1 ); + //------------------------------------------------- + // Clipping + //------------------------------------------------- + popupMgr()->insert( action( 1134 ), -1, -1 ); + popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule ); + + popupMgr()->insert( separator(), -1, -1 ); + connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ), this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) ); + + connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ), + this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) ); } //================================================================================ @@ -3394,6 +4292,13 @@ bool SMESHGUI::isSelectionCompatible() return isCompatible; } + +bool SMESHGUI::reusableOperation( const int id ) +{ + // compute, evaluate and precompute are not reusable operations + return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id ); +} + bool SMESHGUI::activateModule( SUIT_Study* study ) { bool res = SalomeApp_Module::activateModule( study ); @@ -3401,13 +4306,27 @@ bool SMESHGUI::activateModule( SUIT_Study* study ) setMenuShown( true ); setToolShown( true ); + // 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_ImportModuleNoBlock((char*)"salome_pluginsmanager"); + if(pluginsmanager==NULL) + PyErr_Print(); + else + { + PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str()); + if(result==NULL) + PyErr_Print(); + Py_XDECREF(result); + } + PyGILState_Release(gstate); + // end of GEOM plugins loading + // Reset actions accelerator keys action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED action( 33)->setEnabled(true); // Delete: Key_Delete - action(1101)->setEnabled(true); // Rename: Key_F2 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil()); @@ -3417,6 +4336,16 @@ bool SMESHGUI::activateModule( SUIT_Study* study ) updateObjBrowser(); // objects can be removed } + // get all view currently opened in the study and connect their signals to + // the corresponding slots of the class. + SUIT_Desktop* aDesk = study->application()->desktop(); + if ( aDesk ) { + QList wndList = aDesk->windows(); + SUIT_ViewWindow* wnd; + foreach ( wnd, wndList ) + connectView( wnd ); + } + return res; } @@ -3433,7 +4362,6 @@ bool SMESHGUI::deactivateModule( SUIT_Study* study ) action(113)->setShortcut(QKeySequence()); // Import MED action( 33)->setEnabled(false); // Delete: Key_Delete - action(1101)->setEnabled(false); // Rename: Key_F2 return SalomeApp_Module::deactivateModule( study ); } @@ -3513,8 +4441,58 @@ void SMESHGUI::viewManagers( QStringList& list ) const void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr ) { - if ( dynamic_cast( mgr ) ) + if ( dynamic_cast( mgr ) ) { SMESH::UpdateSelectionProp( this ); + + QVector aViews = mgr->getViews(); + for(int i = 0; i < aViews.count() ; i++){ + SUIT_ViewWindow *sf = aViews[i]; + connectView( sf ); + } + } +} + +void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager ) +{ + if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() ) + myClippingPlaneInfoMap.erase( theViewManager ); +} + +void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor ) +{ + theActor->AddObserver( SMESH::DeleteActorEvent, + myEventCallbackCommand.GetPointer(), + myPriority ); +} + +void SMESHGUI::ProcessEvents( vtkObject* theObject, + unsigned long theEvent, + void* theClientData, + void* theCallData ) +{ + if( SMESHGUI* aSMESHGUI = reinterpret_cast( theClientData ) ) { + if( theObject && theEvent == SMESH::DeleteActorEvent ) { + if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) { + SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap(); + SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin(); + for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) { + SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second; + SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin(); + for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) { + SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2; + std::list& anActorList = aClippingPlaneInfo.ActorList; + SMESH::TActorList::iterator anIter3 = anActorList.begin(); + for ( ; anIter3 != anActorList.end(); anIter3++ ) { + if( anActor == *anIter3 ) { + anActorList.erase( anIter3 ); + break; + } + } + } + } + } + } + } } void SMESHGUI::createPreferences() @@ -3522,8 +4500,12 @@ void SMESHGUI::createPreferences() // General tab ------------------------------------------------------------------------ int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) ); - int updateGroup = addPreference( tr( "PREF_GROUP_UPDATE" ), genTab ); - addPreference( tr( "PREF_AUTO_UPDATE" ), updateGroup, LightApp_Preferences::Bool, "SMESH", "auto_update" ); + int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" ); + int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" ); + setPreferenceProperty( lim, "min", 0 ); + setPreferenceProperty( lim, "max", 100000000 ); + setPreferenceProperty( lim, "step", 1000 ); + setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) ); int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab ); setPreferenceProperty( qaGroup, "columns", 2 ); @@ -3532,15 +4514,20 @@ void SMESHGUI::createPreferences() int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" ); setPreferenceProperty( prec, "min", 0 ); setPreferenceProperty( prec, "max", 16 ); + int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" ); + setPreferenceProperty( doubleNodesTol, "precision", 10 ); + setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 ); + setPreferenceProperty( doubleNodesTol, "max", 1000000.0 ); + setPreferenceProperty( doubleNodesTol, "step", 0.0000001 ); int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab ); 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 indices; indices.append( 0 ); indices.append( 1 ); @@ -3553,8 +4540,8 @@ void SMESHGUI::createPreferences() 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 ); @@ -3565,8 +4552,8 @@ void SMESHGUI::createPreferences() "SMESH", "max_angle" ); setPreferenceProperty( maxAngle, "min", 1 ); setPreferenceProperty( maxAngle, "max", 90 ); - - + + int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab ); setPreferenceProperty( exportgroup, "columns", 2 ); @@ -3577,9 +4564,9 @@ void SMESHGUI::createPreferences() setPreferenceProperty( computeGroup, "columns", 2 ); int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" ); modes.clear(); - modes.append( "Never" ); - modes.append( "Errors only" ); - modes.append( "Always" ); + modes.append( tr( "PREF_NOTIFY_NEVER" ) ); + modes.append( tr( "PREF_NOTIFY_ERROR" ) ); + modes.append( tr( "PREF_NOTIFY_ALWAYS" ) ); indices.clear(); indices.append( 0 ); indices.append( 1 ); @@ -3587,6 +4574,23 @@ void SMESHGUI::createPreferences() setPreferenceProperty( notifyMode, "strings", modes ); setPreferenceProperty( notifyMode, "indexes", indices ); + int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab ); + 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" ) ); + modes.append( tr( "PREF_ELEM_INFO_TREE" ) ); + indices.clear(); + indices.append( 0 ); + 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 ); int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin, @@ -3598,32 +4602,97 @@ void SMESHGUI::createPreferences() setPreferenceProperty( nbSeg, "min", 1 ); setPreferenceProperty( nbSeg, "max", 10000000 ); + int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab ); + addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool, + "SMESH", "forget_mesh_on_hyp_modif" ); + + + // Quantities with individual precision settings + int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab ); + setPreferenceProperty( precGroup, "columns", 2 ); + + const int nbQuantities = 6; + int precs[nbQuantities], ii = 0; + precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup, + LightApp_Preferences::IntSpin, "SMESH", "length_precision" ); + precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup, + LightApp_Preferences::IntSpin, "SMESH", "angle_precision" ); + precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup, + LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" ); + precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup, + LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" ); + precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup, + LightApp_Preferences::IntSpin, "SMESH", "area_precision" ); + precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup, + LightApp_Preferences::IntSpin, "SMESH", "vol_precision" ); + + // Set property for precision value for spinboxes + for ( ii = 0; ii < nbQuantities; ii++ ){ + setPreferenceProperty( precs[ii], "min", -14 ); + setPreferenceProperty( precs[ii], "max", 14 ); + 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 ); + + int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab ); + addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" ); + // Mesh tab ------------------------------------------------------------------------ int meshTab = addPreference( tr( "PREF_TAB_MESH" ) ); int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab ); - setPreferenceProperty( nodeGroup, "columns", 2 ); + setPreferenceProperty( nodeGroup, "columns", 3 ); addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" ); - int nodeSz = addPreference( tr( "PREF_SIZE" ), nodeGroup, LightApp_Preferences::IntSpin, "SMESH", "node_size" ); - setPreferenceProperty( nodeSz, "min", 1 ); - setPreferenceProperty( nodeSz, "max", 5 ); + int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" ); + + SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this); + QList aMarkerTypeIndicesList; + QList aMarkerTypeIconsList; + for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) { + QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i ); + QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) ); + aMarkerTypeIndicesList << i; + aMarkerTypeIconsList << pixmap; + } + setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList ); + setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList ); + + int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" ); + + QList aMarkerScaleIndicesList; + QStringList aMarkerScaleValuesList; + for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) { + aMarkerScaleIndicesList << i; + aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 ); + } + setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList ); + setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList ); 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" ); - //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space ); - //setPreferenceProperty( sp, "hstretch", 0 ); - //setPreferenceProperty( sp, "vstretch", 0 ); + 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 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, @@ -3632,9 +4701,6 @@ void SMESHGUI::createPreferences() setPreferenceProperty( size0d, "min", 1 ); setPreferenceProperty( size0d, "max", 10 ); - setPreferenceProperty( sp, "hstretch", 0 ); - setPreferenceProperty( sp, "vstretch", 0 ); - setPreferenceProperty( elemW, "min", 1 ); setPreferenceProperty( elemW, "max", 5 ); @@ -3661,19 +4727,11 @@ void SMESHGUI::createPreferences() addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" ); addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" ); - int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" ); - - setPreferenceProperty( selW, "min", 1 ); - setPreferenceProperty( selW, "max", 5 ); int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab ); setPreferenceProperty( preGroup, "columns", 2 ); addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" ); - int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" ); - - setPreferenceProperty( preW, "min", 1 ); - setPreferenceProperty( preW, "max", 5 ); int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab ); setPreferenceProperty( precSelGroup, "columns", 2 ); @@ -3754,6 +4812,18 @@ void SMESHGUI::createPreferences() setPreferenceProperty( hh, "min", 0.0 ); setPreferenceProperty( hh, "max", 1.0 ); setPreferenceProperty( hh, "step", 0.1 ); + + int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" ); + int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" ); + setPreferenceProperty( distributionGr, "columns", 3 ); + QStringList types; + types.append( tr( "SMESH_MONOCOLOR" ) ); + types.append( tr( "SMESH_MULTICOLOR" ) ); + indices.clear(); indices.append( 0 ); indices.append( 1 ); + setPreferenceProperty( coloringType, "strings", types ); + setPreferenceProperty( coloringType, "indexes", indices ); + addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" ); + } void SMESHGUI::preferencesChanged( const QString& sect, const QString& name ) @@ -3764,7 +4834,7 @@ void SMESHGUI::preferencesChanged( const QString& sect, const QString& name ) std::string aWarning; SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this); if( name=="selection_object_color" || name=="selection_element_color" || - name=="selection_width" || name=="highlight_color" || name=="highlight_width" || + name=="highlight_color" || name=="selection_precision_node" || name=="selection_precision_element" || name=="selection_precision_object") SMESH::UpdateSelectionProp( this ); @@ -3818,6 +4888,11 @@ void SMESHGUI::preferencesChanged( const QString& sect, const QString& name ) int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 ); myComponentSMESH->SetDefaultNbSegments( nbSeg ); } + else if ( name == "historical_python_dump" || + name == "forget_mesh_on_hyp_modif") { + QString val = aResourceMgr->stringValue( "SMESH", name ); + myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() ); + } if(aWarning.size() != 0){ aWarning += "The default values are applied instead."; @@ -3839,7 +4914,7 @@ void SMESHGUI::preferencesChanged( const QString& sect, const QString& name ) //================================================================================ void SMESHGUI::update( const int flags ) { - if ( flags & UF_Viewer | flags & UF_Forced ) + if ( (flags & UF_Viewer) | (flags & UF_Forced) ) SMESH::UpdateView(); else SalomeApp_Module::update( flags ); @@ -3891,6 +4966,12 @@ LightApp_Operation* SMESHGUI::createOperation( const int id ) const // to do : create operation here switch( id ) { + case 417: //convert to quadratic + op = new SMESHGUI_ConvToQuadOp(); + break; + case 418: // create 2D mesh as boundary on 3D + op = new SMESHGUI_Make2DFrom3DOp(); + break; case 701: // Compute mesh op = new SMESHGUI_ComputeOp(); break; @@ -3909,15 +4990,15 @@ LightApp_Operation* SMESHGUI::createOperation( const int id ) const case 712: // Evaluate mesh op = new SMESHGUI_EvaluateOp(); break; + case 713: // Evaluate mesh + op = new SMESHGUI_MeshOrderOp(); + break; case 806: // Create group on geom op = new SMESHGUI_GroupOnShapeOp(); break; - case 417: //convert to quadratic - op = new SMESHGUI_ConvToQuadOp(); - break; - case 418: // create 2D mesh as boundary on 3D - op = new SMESHGUI_Make2DFrom3DOp(); - break; + case 904: // Find element + op = new SMESHGUI_FindElemByPointOp(); + break; case 4067: // make mesh pass through point op = new SMESHGUI_MakeNodeAtPointOp(); break; @@ -3967,12 +5048,9 @@ SALOMEDS::Color SMESHGUI::getUniqueColor( const QList& theReser if( aTolerance < 1 ) break; } - //cout << "Iteration N" << anIterations << " (tolerance=" << aTolerance << ")"<< endl; aHue = (int)( 360.0 * rand() / RAND_MAX ); - //cout << "Hue = " << aHue << endl; - //cout << "Auto colors : "; bool ok = true; QList::const_iterator it = theReservedColors.constBegin(); QList::const_iterator itEnd = theReservedColors.constEnd(); @@ -3983,21 +5061,17 @@ SALOMEDS::Color SMESHGUI::getUniqueColor( const QList& theReser int h, s, v; aQColor.getHsv( &h, &s, &v ); - //cout << h << " "; if( abs( h - aHue ) < aTolerance ) { ok = false; - //cout << "break (diff = " << abs( h - aHue ) << ")"; break; } } - //cout << endl; if( ok ) break; } - //cout << "Hue of the returned color = " << aHue << endl; QColor aColor; aColor.setHsv( aHue, 255, 255 ); @@ -4011,6 +5085,7 @@ SALOMEDS::Color SMESHGUI::getUniqueColor( const QList& theReser const char gSeparator = '_'; // character used to separate parameter names const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b) +const char gPathSep = '|'; // character used to separate paths /*! * \brief Store visual parameters @@ -4036,6 +5111,39 @@ void SMESHGUI::storeVisualParameters (int savePoint) savePoint); _PTR(IParameters) ip = ClientFactory::getIParameters(ap); + // store map of custom markers + const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ]; + if( !aMarkerMap.empty() ) + { + VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin(); + for( ; anIter != aMarkerMap.end(); anIter++ ) + { + int anId = anIter->first; + VTK::MarkerData aMarkerData = anIter->second; + std::string aMarkerFileName = aMarkerData.first; + VTK::MarkerTexture aMarkerTexture = aMarkerData.second; + if( aMarkerTexture.size() < 3 ) + continue; // should contain at least width, height and the first value + + QString aPropertyName( "texture" ); + aPropertyName += gSeparator; + aPropertyName += QString::number( anId ); + + QString aPropertyValue = aMarkerFileName.c_str(); + aPropertyValue += gPathSep; + + VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin(); + ushort aWidth = *aTextureIter++; + ushort aHeight = *aTextureIter++; + aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep; + aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep; + for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ ) + aPropertyValue += QString::number( *aTextureIter ); + + ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() ); + } + } + // viewers counters are used for storing view_numbers in IParameters int vtkViewers = 0; @@ -4051,6 +5159,37 @@ void SMESHGUI::storeVisualParameters (int savePoint) // saving VTK actors properties if (vType == SVTK_Viewer::Type()) { + // store the clipping planes attached to the view manager + SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList; + SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman ); + if( anIter != myClippingPlaneInfoMap.end() ) + aClippingPlaneInfoList = anIter->second; + + if( !aClippingPlaneInfoList.empty() ) { + SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin(); + for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ ) + { + const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter; + SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane; + + QString aPropertyName( "ClippingPlane" ); + aPropertyName += gSeparator; + aPropertyName += QString::number( vtkViewers ); + aPropertyName += gSeparator; + aPropertyName += QString::number( anId ); + + QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData(); + aPropertyValue += gDigitsSep; + aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData(); + aPropertyValue += gDigitsSep; + aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData(); + aPropertyValue += gDigitsSep; + aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData(); + + ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() ); + } + } + QVector views = vman->getViews(); for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++) { @@ -4112,18 +5251,17 @@ void SMESHGUI::storeVisualParameters (int savePoint) // Colors (surface:edge:) vtkFloatingPointType r, g, b; + int delta; - aSmeshActor->GetSufaceColor(r, g, b); + 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"; @@ -4137,20 +5275,44 @@ void SMESHGUI::storeVisualParameters (int savePoint) 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()); // Sizes of lines and points QString sizeStr ("line"); sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth()); - sizeStr += gDigitsSep; sizeStr += "node"; - sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetNodeSize()); sizeStr += gDigitsSep; sizeStr += "shrink"; sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor()); param = vtkParam + "Sizes"; ip->setParameter(entry, param, sizeStr.toLatin1().data()); + // Point marker + QString markerStr; + + VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType(); + if( aMarkerType == VTK::MT_USER ) { + markerStr += "custom"; + markerStr += gDigitsSep; + markerStr += QString::number( aSmeshActor->GetMarkerTexture() ); + } + else { + markerStr += "std"; + markerStr += gDigitsSep; + markerStr += QString::number( (int)aMarkerType ); + markerStr += gDigitsSep; + markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() ); + } + + param = vtkParam + "PointMarker"; + ip->setParameter(entry, param, markerStr.toLatin1().data()); + // Opacity param = vtkParam + "Opacity"; ip->setParameter(entry, param, @@ -4158,22 +5320,25 @@ void SMESHGUI::storeVisualParameters (int savePoint) // Clipping param = vtkParam + "ClippingPlane"; - int nPlanes = aSmeshActor->GetNumberOfClippingPlanes(); - if (!nPlanes) - ip->setParameter(entry, param, "Off"); - for (int ipl = 0; ipl < nPlanes; ipl++) { - //vtkPlane* plane = aSmeshActor->GetClippingPlane(ipl); - SMESH::Orientation anOrientation; - double aDistance; - vtkFloatingPointType anAngle[2]; - SMESHGUI_ClippingDlg::GetPlaneParam(aSmeshActor, ipl, anOrientation, aDistance, anAngle); - std::string planeValue = QString::number((int)anOrientation).toLatin1().data(); - planeValue += gDigitsSep; planeValue += QString::number(aDistance).toLatin1().data(); - planeValue += gDigitsSep; planeValue += QString::number(anAngle[0]).toLatin1().data(); - planeValue += gDigitsSep; planeValue += QString::number(anAngle[1]).toLatin1().data(); - - ip->setParameter(entry, param + QString::number(ipl+1).toLatin1().data(), planeValue); + int aPlaneId = 0; + if( !aClippingPlaneInfoList.empty() ) { + SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin(); + for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ ) + { + const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1; + std::list anActorList = aClippingPlaneInfo.ActorList; + SMESH::TActorList::iterator anIter2 = anActorList.begin(); + for ( ; anIter2 != anActorList.end(); anIter2++ ) { + if( aSmeshActor == *anIter2 ) { + ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(), + QString::number( anId ).toLatin1().constData() ); + break; + } + } + } } + if( aPlaneId == 0 ) + ip->setParameter( entry, param, "Off" ); } // if (io->hasEntry()) } // SMESH_Actor && hasIO } // isVisible @@ -4185,6 +5350,25 @@ void SMESHGUI::storeVisualParameters (int savePoint) } // for (viewManagers) } +// data structures for clipping planes processing +typedef struct { + int Id; + vtkIdType Orientation; + vtkFloatingPointType Distance; + vtkFloatingPointType Angle[2]; +} TPlaneData; +typedef std::list TPlaneDataList; +typedef std::map TPlaneDataMap; + +typedef std::list TActorList; +typedef struct { + int PlaneId; + TActorList ActorList; + SUIT_ViewManager* ViewManager; +} TPlaneInfo; +typedef std::list TPlaneInfoList; +typedef std::map TPlaneInfoMap; + /*! * \brief Restore visual parameters * @@ -4209,6 +5393,115 @@ void SMESHGUI::restoreVisualParameters (int savePoint) savePoint); _PTR(IParameters) ip = ClientFactory::getIParameters(ap); + // restore map of custom markers and map of clipping planes + VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ]; + TPlaneDataMap aPlaneDataMap; + + std::vector properties = ip->getProperties(); + for (std::vector::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt) + { + std::string property = *propIt; + QString aPropertyName( property.c_str() ); + QString aPropertyValue( ip->getProperty( property ).c_str() ); + + QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts ); + if( aPropertyNameList.isEmpty() ) + continue; + + QString aPropertyType = aPropertyNameList[0]; + if( aPropertyType == "texture" ) + { + if( aPropertyNameList.size() != 2 ) + continue; + + bool ok = false; + int anId = aPropertyNameList[1].toInt( &ok ); + if( !ok || anId < 1 ) + continue; + + QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts ); + if( aPropertyValueList.size() != 2 ) + continue; + + std::string aMarkerFileName = aPropertyValueList[0].toStdString(); + QString aMarkerTextureString = aPropertyValueList[1]; + QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts ); + if( aMarkerTextureStringList.size() != 3 ) + continue; + + ok = false; + ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok ); + if( !ok ) + continue; + + ok = false; + ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok ); + if( !ok ) + continue; + + VTK::MarkerTexture aMarkerTexture; + aMarkerTexture.push_back( aWidth ); + aMarkerTexture.push_back( aHeight ); + + QString aMarkerTextureData = aMarkerTextureStringList[2]; + for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ ) + { + QChar aChar = aMarkerTextureData.at( i ); + if( aChar.isDigit() ) + aMarkerTexture.push_back( aChar.digitValue() ); + } + + aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture ); + } + else if( aPropertyType == "ClippingPlane" ) + { + if( aPropertyNameList.size() != 3 ) + continue; + + bool ok = false; + int aViewId = aPropertyNameList[1].toInt( &ok ); + if( !ok || aViewId < 0 ) + continue; + + ok = false; + int aClippingPlaneId = aPropertyNameList[2].toInt( &ok ); + if( !ok || aClippingPlaneId < 0 ) + continue; + + QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts ); + if( aPropertyValueList.size() != 4 ) + continue; + + TPlaneData aPlaneData; + aPlaneData.Id = aClippingPlaneId; + + ok = false; + aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok ); + if( !ok ) + continue; + + ok = false; + aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok ); + if( !ok ) + continue; + + ok = false; + aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok ); + if( !ok ) + continue; + + ok = false; + aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok ); + if( !ok ) + continue; + + TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ]; + aPlaneDataList.push_back( aPlaneData ); + } + } + + TPlaneInfoMap aPlaneInfoMap; + std::vector entries = ip->getEntries(); for (std::vector::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt) @@ -4255,39 +5548,40 @@ void SMESHGUI::restoreVisualParameters (int savePoint) if (vtkActors.IsBound(viewIndex)) aSmeshActor = vtkActors.Find(viewIndex); + QList lst; + getApp()->viewManagers(viewerTypStr, lst); + + // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager + SUIT_ViewManager* vman = NULL; + if (viewIndex >= 0 && viewIndex < lst.count()) + vman = lst.at(viewIndex); + if (paramNameStr == "Visibility") { - if (!aSmeshActor && displayer()) + if (!aSmeshActor && displayer() && vman) { - QList lst; - getApp()->viewManagers(viewerTypStr, lst); - - // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager - if (viewIndex >= 0 && viewIndex < lst.count()) { - SUIT_ViewManager* vman = lst.at(viewIndex); - SUIT_ViewModel* vmodel = vman->getViewModel(); - // SVTK view model can be casted to SALOME_View - displayer()->Display(entry, true, dynamic_cast(vmodel)); - - // store displayed actor in a temporary map for quicker - // access later when restoring other parameters - SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView(); - vtkRenderer* Renderer = vtkView->getRenderer(); - VTK::ActorCollectionCopy aCopy(Renderer->GetActors()); - vtkActorCollection* theActors = aCopy.GetActors(); - theActors->InitTraversal(); - bool isFound = false; - vtkActor *ac = theActors->GetNextActor(); - for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) { - if (ac->IsA("SMESH_Actor")) { - SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac); - if (aGeomAc->hasIO()) { - Handle(SALOME_InteractiveObject) io = - Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO()); - if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) { - isFound = true; - vtkActors.Bind(viewIndex, aGeomAc); - } + SUIT_ViewModel* vmodel = vman->getViewModel(); + // SVTK view model can be casted to SALOME_View + displayer()->Display(entry, true, dynamic_cast(vmodel)); + + // store displayed actor in a temporary map for quicker + // access later when restoring other parameters + SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView(); + vtkRenderer* Renderer = vtkView->getRenderer(); + VTK::ActorCollectionCopy aCopy(Renderer->GetActors()); + vtkActorCollection* theActors = aCopy.GetActors(); + theActors->InitTraversal(); + bool isFound = false; + vtkActor *ac = theActors->GetNextActor(); + for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) { + if (ac->IsA("SMESH_Actor")) { + SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac); + if (aGeomAc->hasIO()) { + Handle(SALOME_InteractiveObject) io = + Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO()); + if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) { + isFound = true; + vtkActors.Bind(viewIndex, aGeomAc); } } } @@ -4338,49 +5632,115 @@ void SMESHGUI::restoreVisualParameters (int savePoint) // 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); } } } // Sizes of lines and points else if (paramNameStr == "Sizes") { QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts); - if (sizes.count() == 6) { + if (sizes.count() == 4) { + if (sizes[0] != "line" || sizes[2] != "shrink") { + MESSAGE("Invalid order of data in Sizes, must be: " + "line:int:shrink:float"); + } + else { + aSmeshActor->SetLineWidth(sizes[1].toInt()); + aSmeshActor->SetShrinkFactor(sizes[3].toFloat()); + } + } + else if (sizes.count() == 6) { // just to support old format if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") { MESSAGE("Invalid order of data in Sizes, must be: " "line:int:node:int:shrink:float"); } else { aSmeshActor->SetLineWidth(sizes[1].toInt()); - aSmeshActor->SetNodeSize(sizes[3].toInt()); + //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete aSmeshActor->SetShrinkFactor(sizes[5].toFloat()); } } } + // Point marker + else if (paramNameStr == "PointMarker") { + QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts); + if( data.count() >= 2 ) { + bool ok = false; + int aParam1 = data[1].toInt( &ok ); + if( ok ) { + if( data[0] == "std" && data.count() == 3 ) { + int aParam2 = data[2].toInt( &ok ); + aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 ); + } + else if( data[0] == "custom" ) { + VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 ); + if( markerIt != aMarkerMap.end() ) { + VTK::MarkerData aMarkerData = markerIt->second; + aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second ); + } + } + } + } + } // Opacity else if (paramNameStr == "Opacity") { aSmeshActor->SetOpacity(val.toFloat()); } // Clipping else if (paramNameStr.startsWith("ClippingPlane")) { - cout << "$$$ ClippingPlane 1" << endl; - if (paramNameStr == "ClippingPlane1" || val == "Off") - aSmeshActor->RemoveAllClippingPlanes(); - if (val != "Off") { - cout << "$$$ ClippingPlane 2" << endl; - QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts); - if (vals.count() == 4) { // format check: 4 values - cout << "$$$ ClippingPlane 3" << endl; + QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts); + // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles) + // new format - val looks like "Off" or "0" (plane id) + // (note: in new format "Off" value is used only for consistency, + // so it is processed together with values in old format) + bool anIsOldFormat = ( vals.count() == 4 || val == "Off" ); + if( anIsOldFormat ) { + if (paramNameStr == "ClippingPlane1" || val == "Off") + aSmeshActor->RemoveAllClippingPlanes(); + if (val != "Off") { SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt(); double aDistance = vals[1].toFloat(); vtkFloatingPointType anAngle[2]; @@ -4393,8 +5753,51 @@ void SMESHGUI::restoreVisualParameters (int savePoint) if (viewIndex >= 0 && viewIndex < lst.count()) { SUIT_ViewManager* vman = lst.at(viewIndex); SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView(); - SMESHGUI_ClippingDlg::AddPlane(aSmeshActor, vtkView, - anOrientation, aDistance, anAngle); + + SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ]; + + SMESH::TActorList anActorList; + anActorList.push_back( aSmeshActor ); + SMESH::OrientedPlane* aPlane = + SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle); + if( aPlane ) { + SMESH::ClippingPlaneInfo aClippingPlaneInfo; + aClippingPlaneInfo.Plane = aPlane; + aClippingPlaneInfo.ActorList = anActorList; + aClippingPlaneInfoList.push_back( aClippingPlaneInfo ); + } + } + } + } + else { + bool ok = false; + int aPlaneId = val.toInt( &ok ); + if( ok && aPlaneId >= 0 ) { + bool anIsDefinedPlane = false; + TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ]; + TPlaneInfoList::iterator anIter = aPlaneInfoList.begin(); + for( ; anIter != aPlaneInfoList.end(); anIter++ ) { + TPlaneInfo& aPlaneInfo = *anIter; + if( aPlaneInfo.PlaneId == aPlaneId ) { + aPlaneInfo.ActorList.push_back( aSmeshActor ); + anIsDefinedPlane = true; + break; + } + } + if( !anIsDefinedPlane ) { + TPlaneInfo aPlaneInfo; + aPlaneInfo.PlaneId = aPlaneId; + aPlaneInfo.ActorList.push_back( aSmeshActor ); + aPlaneInfo.ViewManager = vman; + + // to make the list sorted by plane id + anIter = aPlaneInfoList.begin(); + for( ; anIter != aPlaneInfoList.end(); anIter++ ) { + const TPlaneInfo& aPlaneInfoRef = *anIter; + if( aPlaneInfoRef.PlaneId > aPlaneId ) + break; + } + aPlaneInfoList.insert( anIter, aPlaneInfo ); } } } @@ -4405,6 +5808,101 @@ void SMESHGUI::restoreVisualParameters (int savePoint) } // for names/parameters iterator } // for entries iterator + // take into account planes with empty list of actors referred to them + QList aVMList; + getApp()->viewManagers(SVTK_Viewer::Type(), aVMList); + + TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin(); + for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) { + int aViewId = aPlaneDataIter->first; + if( aViewId >= 0 && aViewId < aVMList.count() ) { + SUIT_ViewManager* aViewManager = aVMList.at( aViewId ); + + const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second; + + TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ]; + TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin(); + for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) { + const TPlaneData& aPlaneData = *anIter2; + int aPlaneId = aPlaneData.Id; + + bool anIsFound = false; + TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin(); + for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) { + const TPlaneInfo& aPlaneInfo = *anIter3; + if( aPlaneInfo.PlaneId == aPlaneId ) { + anIsFound = true; + break; + } + } + + if( !anIsFound ) { + TPlaneInfo aPlaneInfo; // ActorList field is empty + aPlaneInfo.PlaneId = aPlaneId; + aPlaneInfo.ViewManager = aViewManager; + + // to make the list sorted by plane id + TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin(); + for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) { + const TPlaneInfo& aPlaneInfoRef = *anIter4; + if( aPlaneInfoRef.PlaneId > aPlaneId ) + break; + } + aPlaneInfoList.insert( anIter4, aPlaneInfo ); + } + } + } + } + + // add clipping planes to actors according to the restored parameters + // and update the clipping plane map + TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin(); + for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) { + int aViewId = anIter1->first; + const TPlaneInfoList& aPlaneInfoList = anIter1->second; + + TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId ); + if( anIter2 == aPlaneDataMap.end() ) + continue; + const TPlaneDataList& aPlaneDataList = anIter2->second; + + TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin(); + for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) { + const TPlaneInfo& aPlaneInfo = *anIter3; + int aPlaneId = aPlaneInfo.PlaneId; + const TActorList& anActorList = aPlaneInfo.ActorList; + SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager; + if( !aViewManager ) + continue; + + SVTK_ViewWindow* aViewWindow = dynamic_cast( aViewManager->getActiveView() ); + if( !aViewWindow ) + continue; + + SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ]; + + TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin(); + for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) { + const TPlaneData& aPlaneData = *anIter4; + if( aPlaneData.Id == aPlaneId ) { + SMESH::OrientedPlane* aPlane = + SMESHGUI_ClippingDlg::AddPlane( anActorList, + aViewWindow, + (SMESH::Orientation)aPlaneData.Orientation, + aPlaneData.Distance, + aPlaneData.Angle ); + if( aPlane ) { + SMESH::ClippingPlaneInfo aClippingPlaneInfo; + aClippingPlaneInfo.Plane = aPlane; + aClippingPlaneInfo.ActorList = anActorList; + aClippingPlaneInfoList.push_back( aClippingPlaneInfo ); + } + break; + } + } + } + } + // update all VTK views QList lst; getApp()->viewManagers(lst); @@ -4427,8 +5925,8 @@ void SMESHGUI::restoreVisualParameters (int savePoint) */ 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 ); QStringList fam; @@ -4450,5 +5948,161 @@ int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString */ void SMESHGUI::onHypothesisEdit( int result ) { + if( result == 1 ) + SMESHGUI::Modified(); updateObjBrowser( true ); } + + +/*! + \brief Signal handler closing(SUIT_ViewWindow*) of a view + \param pview view being closed +*/ +void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) { +#ifndef DISABLE_PLOT2DVIEWER + //Crear all Plot2d Viewers if need. + SMESH::ClearPlot2Viewers(pview); +#endif +} + +void SMESHGUI::message( const QString& msg ) +{ + // dispatch message + QStringList data = msg.split("/"); + if ( data.count() > 0 ) { + if ( data.first() == "mesh_loading" ) { + // get mesh entry + QString entry = data.count() > 1 ? data[1] : QString(); + if ( entry.isEmpty() ) + return; + // get study + _PTR(Study) study = dynamic_cast( application()->activeStudy() )->studyDS(); + // get mesh name + _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() ); + QString name; + if ( obj ) + name = obj->GetName().c_str(); + if ( name.isEmpty() ) + return; + + if ( data.last() == "stop" ) + application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) ); + else + application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) ); + QApplication::processEvents(); + } + } +} + +/*! + \brief Connects or disconnects signals about activating and cloning view on the module slots + \param pview view which is connected/disconnected +*/ +void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) { + if(!pview) + return; + + SUIT_ViewManager* viewMgr = pview->getViewManager(); + if ( viewMgr ) { + disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ), + this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) ); + + connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ), + this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) ); + } +} + +/*! + \brief Return \c true if object can be renamed +*/ +bool SMESHGUI::renameAllowed( const QString& entry) const { + SalomeApp_Application* anApp = dynamic_cast( application() ); + if( !anApp ) + return false; + + SalomeApp_Study* appStudy = dynamic_cast( anApp->activeStudy() ); + if( !appStudy ) + return false; + + SalomeApp_DataObject* obj = dynamic_cast(appStudy->findObjectByEntry(entry)); + + if(!obj) + return false; + + if(appStudy->isComponent(entry) || obj->isReference()) + return false; + + // check type to prevent renaming of inappropriate objects + int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument()); + 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) + return true; + + return false; +} + +/*! + Rename object by entry. + \param entry entry of the object + \param name new name of the object + \brief Return \c true if rename operation finished successfully, \c false otherwise. +*/ +bool SMESHGUI::renameObject( const QString& entry, const QString& name) { + + SalomeApp_Application* anApp = dynamic_cast( application() ); + if( !anApp ) + return false; + + SalomeApp_Study* appStudy = dynamic_cast( anApp->activeStudy() ); + + if(!appStudy) + return false; + + _PTR(Study) aStudy = appStudy->studyDS(); + + if(!aStudy) + return false; + + bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked(); + if ( aLocked ) { + SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") ); + return false; + } + + + _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) ); + _PTR(GenericAttribute) anAttr; + _PTR(AttributeName) aName; + if ( obj ) { + if ( obj->FindAttribute(anAttr, "AttributeName") ) { + aName = anAttr; + // check type to prevent renaming of inappropriate objects + int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() ); + 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(IObject); + if( !aGroupObject->_is_nil() ) { + aGroupObject->SetName( qPrintable(name) ); + if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) ) + anActor->setName( qPrintable(name) ); + } + return true; + } + } + } + } + return false; +}