* they not assigned to elements
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
- */
+ */
boolean DoubleNodes( in long_array theNodes, in long_array theModifiedElems );
/*!
- * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
- * This method provided for convenience works as DoubleNodes() described above.
- * \param theNodeId - identifier of node to be doubled.
- * \param theModifiedElems - identifiers of elements to be updated.
- * \return TRUE if operation has been completed successfully, FALSE otherwise
- * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
- */
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * This method provided for convenience works as DoubleNodes() described above.
+ * \param theNodeId - identifier of node to be doubled.
+ * \param theModifiedElems - identifiers of elements to be updated.
+ * \return TRUE if operation has been completed successfully, FALSE otherwise
+ * \sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
+ */
boolean DoubleNode( in long theNodeId, in long_array theModifiedElems );
/*!
- * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
- * This method provided for convenience works as DoubleNodes() described above.
- * \param theNodes - group of nodes to be doubled.
- * \param theModifiedElems - group of elements to be updated.
- * \return TRUE if operation has been completed successfully, FALSE otherwise
- * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
- */
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * This method provided for convenience works as DoubleNodes() described above.
+ * \param theNodes - group of nodes to be doubled.
+ * \param theModifiedElems - group of elements to be updated.
+ * \return TRUE if operation has been completed successfully, FALSE otherwise
+ * \sa DoubleNode(), DoubleNodes(), DoubleNodeGroups(), DoubleNodeGroupNew()
+ */
boolean DoubleNodeGroup( in SMESH_GroupBase theNodes,
in SMESH_GroupBase theModifiedElems );
in SMESH_GroupBase theModifiedElems );
/*!
- \brief Creates a hole in a mesh by doubling the nodes of some particular elements
- This method provided for convenience works as DoubleNodes() described above.
- \param theNodes - list of groups of nodes to be doubled
- \param theModifiedElems - list of groups of elements to be updated.
- \return TRUE if operation has been completed successfully, FALSE otherwise
- \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
- */
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * This method provided for convenience works as DoubleNodes() described above.
+ * \param theNodes - list of groups of nodes to be doubled
+ * \param theModifiedElems - list of groups of elements to be updated.
+ * \return TRUE if operation has been completed successfully, FALSE otherwise
+ * \sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
+ */
boolean DoubleNodeGroups( in ListOfGroups theNodes,
in ListOfGroups theModifiedElems );
+ /*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
+ * Works as DoubleNodeGroups() described above, but returns a new group with
+ * newly created nodes.
+ * \param theNodes - list of groups of nodes to be doubled
+ * \param theModifiedElems - list of groups of elements to be updated.
+ * \return a new group with newly created nodes
+ * \sa DoubleNodeGroups()
+ */
+ SMESH_Group DoubleNodeGroupsNew( in ListOfGroups theNodes,
+ in ListOfGroups theModifiedElems );
+
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
* \param theElems - the list of elements (edges or faces) to be replicated
* replicated nodes should be associated to.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodeGroups()
- */
+ */
boolean DoubleNodeElem( in long_array theElems,
in long_array theNodesNot,
in long_array theAffectedElems );
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
- */
+ */
boolean DoubleNodeElemInRegion( in long_array theElems,
in long_array theNodesNot,
in GEOM::GEOM_Object theShape );
* should be associated to.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodes(), DoubleNodeGroups(), DoubleNodeElemGroupNew()
- */
+ */
boolean DoubleNodeElemGroup( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems );
* should be associated to.
* \return a new group with newly created elements
* \sa DoubleNodeElemGroup()
- */
+ */
SMESH_Group DoubleNodeElemGroupNew( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot,
in SMESH_GroupBase theAffectedElems );
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
- */
+ */
boolean DoubleNodeElemGroupInRegion( in SMESH_GroupBase theElems,
in SMESH_GroupBase theNodesNot,
in GEOM::GEOM_Object theShape );
* should be associated to.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
- */
+ */
boolean DoubleNodeElemGroups( in ListOfGroups theElems,
in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems );
* should be associated to.
* \return a new group with newly created elements
* \sa DoubleNodeElemGroups()
- */
+ */
SMESH_Group DoubleNodeElemGroupsNew( in ListOfGroups theElems,
in ListOfGroups theNodesNot,
in ListOfGroups theAffectedElems );
* The replicated nodes should be associated to affected elements.
* \return TRUE if operation has been completed successfully, FALSE otherwise
* \sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
- */
+ */
boolean DoubleNodeElemGroupsInRegion( in ListOfGroups theElems,
in ListOfGroups theNodesNot,
in GEOM::GEOM_Object theShape );
#include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx>
+#include <SALOME_ListIteratorOfListIO.hxx>
// Qt includes
#include <QApplication>
#define SPACING 6
#define MARGIN 11
+/*!
+ \class BusyLocker
+ \brief Simple 'busy state' flag locker.
+ \internal
+*/
+
+class BusyLocker
+{
+public:
+ //! Constructor. Sets passed boolean flag to \c true.
+ BusyLocker( bool& busy ) : myBusy( busy ) { myBusy = true; }
+ //! Destructor. Clear external boolean flag passed as parameter to the constructor to \c false.
+ ~BusyLocker() { myBusy = false; }
+private:
+ bool& myBusy; //! External 'busy state' boolean flag
+};
/*!
\brief Constructor
void SMESHGUI_DuplicateNodesDlg::Init()
{
mySMESHGUI->SetActiveDialogBox((QDialog*)this);
+ myCheckBoxNewGroup->setChecked(true);
// Set initial parameters
myBusy = false;
myCurrentLineEdit = myLineEdit1;
- myGroup1 = SMESH::SMESH_GroupBase::_nil();
- myGroup2 = SMESH::SMESH_GroupBase::_nil();
- myGroup3 = SMESH::SMESH_GroupBase::_nil();
+ myGroups1.clear();
+ myGroups2.clear();
+ myGroups3.clear();
// Set selection mode
mySelectionMgr->installFilter(new SMESH_TypeFilter(GROUP));
myLineEdit2->clear();
myLineEdit3->clear();
- // Checkbox should be checked by default
- myCheckBoxNewGroup->setChecked(true);
+ myGroups1.clear();
+ myGroups2.clear();
+ myGroups3.clear();
// Set the first field as current
myCurrentLineEdit = myLineEdit1;
*/
bool SMESHGUI_DuplicateNodesDlg::onApply()
{
- if (mySMESHGUI->isActiveStudyLocked() || !isValid())
+ if ( mySMESHGUI->isActiveStudyLocked() || !isValid() )
return false;
- myBusy = true;
+ BusyLocker lock( myBusy );
bool toCreateGroup = myCheckBoxNewGroup->isChecked();
int operationMode = myGroupConstructors->checkedId();
SUIT_OverrideCursor aWaitCursor;
try {
- SMESH::SMESH_Mesh_ptr aMesh = myGroup1->GetMesh();
+ SMESH::SMESH_Mesh_var aMesh = myGroups1[0]->GetMesh();
SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
- if (operationMode == 0) {
- if (toCreateGroup) {
- SMESH::SMESH_GroupBase_ptr aNewGroup =
- aMeshEditor->DoubleNodeGroupNew(myGroup1, myGroup2);
- if (!CORBA::is_nil(aNewGroup))
- result = true;
+ if ( operationMode == 0 ) {
+ SMESH::ListOfGroups_var g1 = new SMESH::ListOfGroups();
+ g1->length( myGroups1.count() );
+ for ( int i = 0; i < myGroups1.count(); i++ )
+ g1[i] = myGroups1[i];
+ SMESH::ListOfGroups_var g2 = new SMESH::ListOfGroups();
+ g2->length( myGroups2.count() );
+ for ( int i = 0; i < myGroups2.count(); i++ )
+ g2[i] = myGroups2[i];
+
+ if ( toCreateGroup ) {
+ SMESH::SMESH_GroupBase_var aNewGroup =
+ aMeshEditor->DoubleNodeGroupsNew( g1.in(), g2.in() );
+ result = !CORBA::is_nil( aNewGroup );
+ }
+ else {
+ result = aMeshEditor->DoubleNodeGroups( g1.in(), g2.in() );
}
- else
- result = aMeshEditor->DoubleNodeGroup(myGroup1, myGroup2);
}
else {
- if (toCreateGroup) {
+ SMESH::ListOfGroups_var g1 = new SMESH::ListOfGroups();
+ g1->length( myGroups1.count() );
+ for ( int i = 0; i < myGroups1.count(); i++ )
+ g1[i] = myGroups1[i];
+ SMESH::ListOfGroups_var g2 = new SMESH::ListOfGroups();
+ g2->length( myGroups2.count() );
+ for ( int i = 0; i < myGroups2.count(); i++ )
+ g2[i] = myGroups2[i];
+ SMESH::ListOfGroups_var g3 = new SMESH::ListOfGroups();
+ g3->length( myGroups3.count() );
+
+ for ( int i = 0; i < myGroups3.count(); i++ )
+ g3[i] = myGroups3[i];
+ if ( toCreateGroup ) {
SMESH::SMESH_GroupBase_ptr aNewGroup =
- aMeshEditor->DoubleNodeElemGroupNew(myGroup1, myGroup2, myGroup3);
- if (!CORBA::is_nil(aNewGroup))
- result = true;
+ aMeshEditor->DoubleNodeElemGroupsNew( g1.in(), g2.in(), g3.in() );
+ result = !CORBA::is_nil( aNewGroup );
+ }
+ else {
+ result = aMeshEditor->DoubleNodeElemGroups( g1.in(), g2.in(), g3.in() );
}
- else
- result = aMeshEditor->DoubleNodeElemGroup(myGroup1, myGroup2, myGroup3);
}
}
catch (const SALOME::SALOME_Exception& S_ex) {
SUIT_MessageBox::warning(this,
tr("SMESH_WRN_WARNING"),
tr("SMESH_OPERATION_FAILED"));
- myBusy = false;
return false;
}
*/
void SMESHGUI_DuplicateNodesDlg::onSelectionChanged()
{
- if (myBusy || !isEnabled()) return;
+ if ( myBusy || !isEnabled() ) return;
- // Try to get selected group
+ int operationMode = myGroupConstructors->checkedId();
+
SALOME_ListIO aList;
mySelectionMgr->selectedObjects( aList );
int aNbSel = aList.Extent();
- SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_nil();
- if (aNbSel == 1) {
- Handle(SALOME_InteractiveObject) IO = aList.First();
- aGroup = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IO);
-
- // Check group type
- if (!CORBA::is_nil(aGroup)) {
- int operationMode = myGroupConstructors->checkedId();
+ QList<SMESH::SMESH_GroupBase_var> aGroups;
+
+ SALOME_ListIteratorOfListIO anIter ( aList );
+ bool ok = true;
+ for ( ; anIter.More() && ok; anIter.Next()) {
+ SMESH::SMESH_GroupBase_var aGroup = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>( anIter.Value() );
+ // check group is selected
+ ok = !CORBA::is_nil( aGroup );
+ // check groups of the same mesh are selected
+ if ( ok ) {
+ SMESH::SMESH_Mesh_var aMesh1;
+ if ( !aGroups.isEmpty() ) aMesh1 = aGroups[0]->GetMesh();
+ SMESH::SMESH_Mesh_var aMesh2 = aGroup->GetMesh();
+ ok = CORBA::is_nil( aMesh1 ) || aMesh1->_is_equivalent( aMesh2 );
+ }
+ // check group of proper type is selected
+ if ( ok ) {
SMESH::ElementType aGroupType = aGroup->GetType();
- bool isTypeValid = true;
-
- if (operationMode == 0) {
- if ( (myCurrentLineEdit == myLineEdit1 && aGroupType != SMESH::NODE) ||
- (myCurrentLineEdit == myLineEdit2 && aGroupType == SMESH::NODE) )
- isTypeValid = false;
+ if ( operationMode == 0 ) {
+ ok = ( myCurrentLineEdit == myLineEdit1 && aGroupType == SMESH::NODE ) ||
+ ( myCurrentLineEdit == myLineEdit2 && aGroupType != SMESH::NODE );
}
- else if (operationMode == 1) {
- if ( (myCurrentLineEdit == myLineEdit1 && aGroupType != SMESH::EDGE &&
- aGroupType != SMESH::FACE) ||
- (myCurrentLineEdit == myLineEdit2 && aGroupType != SMESH::NODE) ||
- (myCurrentLineEdit == myLineEdit3 && aGroupType == SMESH::NODE) )
- isTypeValid = false;
+ else {
+ ok = ( myCurrentLineEdit == myLineEdit1 && ( aGroupType == SMESH::EDGE ||
+ aGroupType == SMESH::FACE ) ) ||
+ ( myCurrentLineEdit == myLineEdit2 && aGroupType == SMESH::NODE ) ||
+ ( myCurrentLineEdit == myLineEdit3 && aGroupType != SMESH::NODE );
}
-
- if (!isTypeValid)
- aGroup = SMESH::SMESH_GroupBase::_nil();
}
+ if ( ok ) aGroups << aGroup;
}
// Clear current field
myCurrentLineEdit->clear();
- // Set corresponding SMESH group
- if (myCurrentLineEdit == myLineEdit1) {
- myGroup1 = SMESH::SMESH_Group::_narrow(aGroup);
+ if ( ok && !aGroups.isEmpty() ) {
+ if ( myCurrentLineEdit == myLineEdit1 ) myGroups1 = aGroups;
+ else if ( myCurrentLineEdit == myLineEdit2 ) myGroups2 = aGroups;
+ else if ( myCurrentLineEdit == myLineEdit3 ) myGroups3 = aGroups;
+ myCurrentLineEdit->setText( aGroups.count() == 1 ? aGroups[0]->GetName() :
+ QObject::tr( "SMESH_OBJECTS_SELECTED" ).arg( aGroups.count() ) );
}
- else if (myCurrentLineEdit == myLineEdit2) {
- myGroup2 = SMESH::SMESH_Group::_narrow(aGroup);
- }
- else if (myCurrentLineEdit == myLineEdit3) {
- myGroup3 = SMESH::SMESH_Group::_narrow(aGroup);
+ else {
+ if ( myCurrentLineEdit == myLineEdit1 ) myGroups1.clear();
+ else if ( myCurrentLineEdit == myLineEdit2 ) myGroups2.clear();
+ else if ( myCurrentLineEdit == myLineEdit3 ) myGroups3.clear();
+ myCurrentLineEdit->clear();
}
-
- // Set group name
- if (!CORBA::is_nil(aGroup))
- myCurrentLineEdit->setText(aGroup->GetName());
// Enable/disable "Apply and Close" and "Apply" buttons
bool isDataValid = isValid();
- myButtonOk->setEnabled(isDataValid);
- myButtonApply->setEnabled(isDataValid);
+ myButtonOk->setEnabled( isDataValid );
+ myButtonApply->setEnabled( isDataValid );
}
/*!
*/
bool SMESHGUI_DuplicateNodesDlg::isValid()
{
- // Only first group (nodes/elemets to duplicate) is mandatory
- bool isValid = !CORBA::is_nil(myGroup1);
-
- // First (elements to duplicate) and last groups should be defined in the second operation mode
- if (isValid && myGroupConstructors->checkedId() == 1)
- isValid = !CORBA::is_nil(myGroup3);
-
- return isValid;
+ return myGroupConstructors->checkedId() == 1 ?
+ ( !myGroups1.isEmpty() && !myGroups3.isEmpty() ) :
+ ( !myGroups1.isEmpty() );
}
SMESHGUI* mySMESHGUI;
LightApp_SelectionMgr* mySelectionMgr;
- SMESH::SMESH_GroupBase_var myGroup1;
- SMESH::SMESH_GroupBase_var myGroup2;
- SMESH::SMESH_GroupBase_var myGroup3;
+ QList<SMESH::SMESH_GroupBase_var> myGroups1;
+ QList<SMESH::SMESH_GroupBase_var> myGroups2;
+ QList<SMESH::SMESH_GroupBase_var> myGroups3;
bool myBusy;
}
// DoubleNodeElemGroupNew() -> DoubleNodeElemGroup()
// DoubleNodeGroupNew() -> DoubleNodeGroup()
+ // DoubleNodeGroupsNew() -> DoubleNodeGroups()
// DoubleNodeElemGroupsNew() -> DoubleNodeElemGroups()
- if ( !isPyMeshMethod && ( method == "DoubleNodeElemGroupNew" || method == "DoubleNodeGroupNew" || method == "DoubleNodeElemGroupsNew"))
+ if ( !isPyMeshMethod && ( method == "DoubleNodeElemGroupNew" || method == "DoubleNodeElemGroupsNew" ||
+ method == "DoubleNodeGroupNew" || method == "DoubleNodeGroupsNew"))
{
isPyMeshMethod=true;
theCommand->SetMethod( method.SubString( 1, method.Length()-3));
return aResult;
}
+//================================================================================
+/*!
+ * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
+ * Works as DoubleNodeGroups(), but returns a new group with newly created nodes.
+ * \param theNodes - group of nodes to be doubled.
+ * \param theModifiedElems - group of elements to be updated.
+ * \return a new group with newly created nodes
+ * \sa DoubleNodeGroups()
+ */
+//================================================================================
+
+SMESH::SMESH_Group_ptr SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
+ const SMESH::ListOfGroups& theModifiedElems )
+{
+ SMESH::SMESH_Group_var aNewGroup;
+
+ TPythonDump pyDump; // suppress dump by the next line
+
+ bool aResult = DoubleNodeGroups( theNodes, theModifiedElems );
+
+ if ( aResult )
+ {
+ // Create group with newly created nodes
+ SMESH::long_array_var anIds = GetLastCreatedNodes();
+ if (anIds->length() > 0) {
+ string anUnindexedName (theNodes[0]->GetName());
+ string aNewName = generateGroupName(anUnindexedName + "_double");
+ aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
+ aNewGroup->Add(anIds);
+ }
+ }
+
+ pyDump << "createdNodes = " << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
+ << theModifiedElems << " )";
+
+ return aNewGroup._retn();
+}
+
+
//================================================================================
/*!
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
SMESH::SMESH_GroupBase_ptr theModifiedElems );
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
- const SMESH::ListOfGroups& theModifiedElems);
+ const SMESH::ListOfGroups& theModifiedElems );
+
+ SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
+ const SMESH::ListOfGroups& theModifiedElems );
/*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
# @param theModifiedElems list of groups of elements to be updated.
# @return TRUE if operation has been completed successfully, FALSE otherwise
# @ingroup l2_modif_edit
- def DoubleNodeGroups(self, theNodes, theModifiedElems):
+ def DoubleNodeGroups(self, theNodes, theModifiedElems, theMakeGroup=False):
+ if theMakeGroup:
+ return self.editor.DoubleNodeGroupsNew(theNodes, theModifiedElems)
return self.editor.DoubleNodeGroups(theNodes, theModifiedElems)
## Creates a hole in a mesh by doubling the nodes of some particular elements
