src/SMESH_I/SMESH_Mesh_i.cxx

   1 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Mesh_i.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "SMESH_Mesh_i.hxx"
  30 #include "SMESH_subMesh_i.hxx"
  31 #include "SMESH_MEDMesh_i.hxx"
  32 #include "SMESH_Group_i.hxx"
  33 #include "SMESH_Filter_i.hxx"
  34 #include "SMESH_PythonDump.hxx"
  35
  36 #include "Utils_CorbaException.hxx"
  37 #include "Utils_ExceptHandlers.hxx"
  38 #include "utilities.h"
  39
  40 #include "SALOME_NamingService.hxx"
  41 #include "Utils_SINGLETON.hxx"
  42 #include "OpUtil.hxx"
  43
  44 #include "SMESHDS_Command.hxx"
  45 #include "SMESHDS_CommandType.hxx"
  46 #include "SMESH_MeshEditor_i.hxx"
  47 #include "SMESH_Gen_i.hxx"
  48 #include "DriverMED_R_SMESHDS_Mesh.h"
  49
  50 // OCCT Includes
  51 #include <OSD_Path.hxx>
  52 #include <OSD_File.hxx>
  53 #include <OSD_Directory.hxx>
  54 #include <OSD_Protection.hxx>
  55 #include <TColStd_MapOfInteger.hxx>
  56 #include <TColStd_MapIteratorOfMapOfInteger.hxx>
  57 #include <TColStd_SequenceOfInteger.hxx>
  58 #include "TCollection_AsciiString.hxx"
  59
  60 // STL Includes
  61 #include <string>
  62 #include <iostream>
  63 #include <sstream>
  64
  65 #ifdef _DEBUG_
  66 static int MYDEBUG = 0;
  67 #else
  68 static int MYDEBUG = 0;
  69 #endif
  70
  71 using namespace std;
  72 using SMESH::TPythonDump;
  73
  74 int SMESH_Mesh_i::myIdGenerator = 0;
  75
  76 //=============================================================================
  77 /*!
  78  *  Constructor
  79  */
  80 //=============================================================================
  81
  82 SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
  83                             SMESH_Gen_i*            gen_i,
  84                             CORBA::Long studyId )
  85 : SALOME::GenericObj_i( thePOA )
  86 {
  87   INFOS("SMESH_Mesh_i");
  88   _impl = NULL;
  89   _gen_i = gen_i;
  90   _id = myIdGenerator++;
  91   _studyId = studyId;
  92   thePOA->activate_object( this );
  93 }
  94
  95 //=============================================================================
  96 /*!
  97  *  Destructor
  98  */
  99 //=============================================================================
 100
 101 SMESH_Mesh_i::~SMESH_Mesh_i()
 102 {
 103   INFOS("~SMESH_Mesh_i");
 104   map<int, SMESH::SMESH_GroupBase_ptr>::iterator it;
 105   for ( it = _mapGroups.begin(); it != _mapGroups.end(); it++ ) {
 106     SMESH_GroupBase_i* aGroup = dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( it->second ).in() );
 107     if ( aGroup ) {
 108
 109       // this method is colled from destructor of group (PAL6331)
 110       //_impl->RemoveGroup( aGroup->GetLocalID() );
 111
 112       aGroup->Destroy();
 113     }
 114   }
 115   _mapGroups.clear();
 116 }
 117
 118 //=============================================================================
 119 /*!
 120  *  SetShape
 121  *
 122  *  Associates <this> mesh with <theShape> and puts a reference
 123  *  to <theShape> into the current study;
 124  *  the previous shape is substituted by the new one.
 125  */
 126 //=============================================================================
 127
 128 void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
 129     throw (SALOME::SALOME_Exception)
 130 {
 131   Unexpect aCatch(SALOME_SalomeException);
 132   try {
 133     _impl->ShapeToMesh( _gen_i->GeomObjectToShape( theShapeObject ));
 134   }
 135   catch(SALOME_Exception & S_ex) {
 136     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 137   }
 138 }
 139
 140 //=======================================================================
 141 //function : GetShapeToMesh
 142 //purpose  :
 143 //=======================================================================
 144
 145 GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
 146     throw (SALOME::SALOME_Exception)
 147 {
 148   Unexpect aCatch(SALOME_SalomeException);
 149   GEOM::GEOM_Object_var aShapeObj;
 150   try {
 151     TopoDS_Shape S = _impl->GetMeshDS()->ShapeToMesh();
 152     if ( !S.IsNull() )
 153       aShapeObj = _gen_i->ShapeToGeomObject( S );
 154   }
 155   catch(SALOME_Exception & S_ex) {
 156     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 157   }
 158   return aShapeObj._retn();
 159 }
 160
 161 //=============================================================================
 162 /*!
 163  *
 164  */
 165 //=============================================================================
 166
 167 static SMESH::DriverMED_ReadStatus ConvertDriverMEDReadStatus (int theStatus)
 168 {
 169   SMESH::DriverMED_ReadStatus res;
 170   switch (theStatus)
 171   {
 172   case DriverMED_R_SMESHDS_Mesh::DRS_OK:
 173     res = SMESH::DRS_OK; break;
 174   case DriverMED_R_SMESHDS_Mesh::DRS_EMPTY:
 175     res = SMESH::DRS_EMPTY; break;
 176   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_RENUMBER:
 177     res = SMESH::DRS_WARN_RENUMBER; break;
 178   case DriverMED_R_SMESHDS_Mesh::DRS_WARN_SKIP_ELEM:
 179     res = SMESH::DRS_WARN_SKIP_ELEM; break;
 180   case DriverMED_R_SMESHDS_Mesh::DRS_FAIL:
 181   default:
 182     res = SMESH::DRS_FAIL; break;
 183   }
 184   return res;
 185 }
 186
 187 //=============================================================================
 188 /*!
 189  *  ImportMEDFile
 190  *
 191  *  Imports mesh data from MED file
 192  */
 193 //=============================================================================
 194
 195 SMESH::DriverMED_ReadStatus
 196 SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
 197   throw ( SALOME::SALOME_Exception )
 198 {
 199   Unexpect aCatch(SALOME_SalomeException);
 200   int status;
 201   try {
 202     status = importMEDFile( theFileName, theMeshName );
 203   }
 204   catch( SALOME_Exception& S_ex ) {
 205     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 206   }
 207   catch ( ... ) {
 208     THROW_SALOME_CORBA_EXCEPTION("ImportMEDFile(): unknown exception", SALOME::BAD_PARAM);
 209   }
 210
 211   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
 212   if ( !aStudy->_is_nil() ) {
 213     // publishing of the groups in the study (sub-meshes are out of scope of MED import)
 214     map<int, SMESH::SMESH_GroupBase_ptr>::iterator it = _mapGroups.begin();
 215     for (; it != _mapGroups.end(); it++ ) {
 216       SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_duplicate( it->second );
 217       _gen_i->PublishGroup( aStudy, _this(), aGroup,
 218                            GEOM::GEOM_Object::_nil(), aGroup->GetName());
 219     }
 220   }
 221   return ConvertDriverMEDReadStatus(status);
 222 }
 223
 224 //=============================================================================
 225 /*!
 226  *  ImportUNVFile
 227  *
 228  *  Imports mesh data from MED file
 229  */
 230 //=============================================================================
 231
 232 int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
 233   throw ( SALOME::SALOME_Exception )
 234 {
 235   // Read mesh with name = <theMeshName> into SMESH_Mesh
 236   _impl->UNVToMesh( theFileName );
 237
 238   return 1;
 239 }
 240
 241 //=============================================================================
 242 /*!
 243  *  ImportSTLFile
 244  *
 245  *  Imports mesh data from STL file
 246  */
 247 //=============================================================================
 248 int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
 249   throw ( SALOME::SALOME_Exception )
 250 {
 251   // Read mesh with name = <theMeshName> into SMESH_Mesh
 252   _impl->STLToMesh( theFileName );
 253
 254   return 1;
 255 }
 256
 257 //=============================================================================
 258 /*!
 259  *  importMEDFile
 260  *
 261  *  Imports mesh data from MED file
 262  */
 263 //=============================================================================
 264
 265 int SMESH_Mesh_i::importMEDFile( const char* theFileName, const char* theMeshName )
 266 {
 267   // Read mesh with name = <theMeshName> and all its groups into SMESH_Mesh
 268   int status = _impl->MEDToMesh( theFileName, theMeshName );
 269
 270   // Create group servants, if any groups were imported
 271   list<int> aGroupIds = _impl->GetGroupIds();
 272   for ( list<int>::iterator it = aGroupIds.begin(); it != aGroupIds.end(); it++ ) {
 273     SMESH_Group_i* aGroupImpl     = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, *it );
 274
 275     // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
 276     SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
 277     aGroupImpl->Register();
 278     // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
 279
 280     SMESH::SMESH_Group_var aGroup = SMESH::SMESH_Group::_narrow( aGroupImpl->_this() );
 281     _mapGroups[*it]               = SMESH::SMESH_Group::_duplicate( aGroup );
 282
 283     // register CORBA object for persistence
 284     int nextId = _gen_i->RegisterObject( aGroup );
 285     if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId);
 286   }
 287
 288   return status;
 289 }
 290
 291 //=============================================================================
 292 /*!
 293  *
 294  */
 295 //=============================================================================
 296
 297 static SMESH::Hypothesis_Status ConvertHypothesisStatus
 298                          (SMESH_Hypothesis::Hypothesis_Status theStatus)
 299 {
 300   SMESH::Hypothesis_Status res;
 301   switch (theStatus)
 302   {
 303   case SMESH_Hypothesis::HYP_OK:
 304     res = SMESH::HYP_OK; break;
 305   case SMESH_Hypothesis::HYP_MISSING:
 306     res = SMESH::HYP_MISSING; break;
 307   case SMESH_Hypothesis::HYP_CONCURENT:
 308     res = SMESH::HYP_CONCURENT; break;
 309   case SMESH_Hypothesis::HYP_BAD_PARAMETER:
 310     res = SMESH::HYP_BAD_PARAMETER; break;
 311   case SMESH_Hypothesis::HYP_INCOMPATIBLE:
 312     res = SMESH::HYP_INCOMPATIBLE; break;
 313   case SMESH_Hypothesis::HYP_NOTCONFORM:
 314     res = SMESH::HYP_NOTCONFORM; break;
 315   case SMESH_Hypothesis::HYP_ALREADY_EXIST:
 316     res = SMESH::HYP_ALREADY_EXIST; break;
 317   case SMESH_Hypothesis::HYP_BAD_DIM:
 318     res = SMESH::HYP_BAD_DIM; break;
 319   case SMESH_Hypothesis::HYP_BAD_SUBSHAPE:
 320     res = SMESH::HYP_BAD_SUBSHAPE; break;
 321   default:
 322     res = SMESH::HYP_UNKNOWN_FATAL;
 323   }
 324   return res;
 325 }
 326
 327 //=============================================================================
 328 /*!
 329  *  AddHypothesis
 330  *
 331  *  calls internal addHypothesis() and then adds a reference to <anHyp> under
 332  *  the SObject actually having a reference to <aSubShape>.
 333  *  NB: For this method to work, it is necessary to add a reference to sub-shape first.
 334  */
 335 //=============================================================================
 336
 337 SMESH::Hypothesis_Status SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
 338                                                      SMESH::SMESH_Hypothesis_ptr anHyp)
 339   throw(SALOME::SALOME_Exception)
 340 {
 341   Unexpect aCatch(SALOME_SalomeException);
 342   SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShapeObject, anHyp );
 343
 344   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
 345     _gen_i->AddHypothesisToShape(_gen_i->GetCurrentStudy(), _this(),
 346                                  aSubShapeObject, anHyp );
 347
 348   if(MYDEBUG) MESSAGE( " AddHypothesis(): status = " << status );
 349
 350   // Update Python script
 351   TPythonDump() << "status = " << _this() << ".AddHypothesis( "
 352                 << aSubShapeObject << ", " << anHyp << " )";
 353
 354   return ConvertHypothesisStatus(status);
 355 }
 356
 357 //=============================================================================
 358 /*!
 359  *
 360  */
 361 //=============================================================================
 362
 363 SMESH_Hypothesis::Hypothesis_Status
 364   SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr       aSubShapeObject,
 365                               SMESH::SMESH_Hypothesis_ptr anHyp)
 366 {
 367   if(MYDEBUG) MESSAGE("addHypothesis");
 368
 369   if (CORBA::is_nil(aSubShapeObject))
 370     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
 371                                  SALOME::BAD_PARAM);
 372
 373   SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
 374   if (CORBA::is_nil(myHyp))
 375     THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference",
 376                                  SALOME::BAD_PARAM);
 377
 378   SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
 379   try
 380   {
 381     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape( aSubShapeObject);
 382     int hypId = myHyp->GetId();
 383     status = _impl->AddHypothesis(myLocSubShape, hypId);
 384     if ( !SMESH_Hypothesis::IsStatusFatal(status) ) {
 385       _mapHypo[hypId] = SMESH::SMESH_Hypothesis::_duplicate( myHyp );
 386       // assure there is a corresponding submesh
 387       if ( !_impl->IsMainShape( myLocSubShape )) {
 388         int shapeId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
 389         if ( _mapSubMesh_i.find( shapeId ) == _mapSubMesh_i.end() )
 390           createSubMesh( aSubShapeObject );
 391       }
 392     }
 393   }
 394   catch(SALOME_Exception & S_ex)
 395   {
 396     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 397   }
 398   return status;
 399 }
 400
 401 //=============================================================================
 402 /*!
 403  *
 404  */
 405 //=============================================================================
 406
 407 SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
 408                                                         SMESH::SMESH_Hypothesis_ptr anHyp)
 409      throw(SALOME::SALOME_Exception)
 410 {
 411   Unexpect aCatch(SALOME_SalomeException);
 412   SMESH_Hypothesis::Hypothesis_Status status = removeHypothesis( aSubShapeObject, anHyp );
 413
 414   if ( !SMESH_Hypothesis::IsStatusFatal(status) )
 415     _gen_i->RemoveHypothesisFromShape(_gen_i->GetCurrentStudy(), _this(),
 416                                       aSubShapeObject, anHyp );
 417
 418   // Update Python script
 419   TPythonDump() << "status = " << _this() << ".RemoveHypothesis( "
 420                 << aSubShapeObject << ", " << anHyp << " )";
 421
 422   return ConvertHypothesisStatus(status);
 423 }
 424
 425 //=============================================================================
 426 /*!
 427  *
 428  */
 429 //=============================================================================
 430
 431 SMESH_Hypothesis::Hypothesis_Status SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShapeObject,
 432                                  SMESH::SMESH_Hypothesis_ptr anHyp)
 433 {
 434         if(MYDEBUG) MESSAGE("removeHypothesis()");
 435         // **** proposer liste de subShape (selection multiple)
 436
 437         if (CORBA::is_nil(aSubShapeObject))
 438                 THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
 439                         SALOME::BAD_PARAM);
 440
 441         SMESH::SMESH_Hypothesis_var myHyp = SMESH::SMESH_Hypothesis::_narrow(anHyp);
 442         if (CORBA::is_nil(myHyp))
 443           THROW_SALOME_CORBA_EXCEPTION("bad hypothesis reference",
 444                         SALOME::BAD_PARAM);
 445
 446         SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_OK;
 447         try
 448         {
 449                 TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
 450                 int hypId = myHyp->GetId();
 451                 status = _impl->RemoveHypothesis(myLocSubShape, hypId);
 452                 if ( !SMESH_Hypothesis::IsStatusFatal(status) )
 453                   _mapHypo.erase( hypId );
 454         }
 455         catch(SALOME_Exception & S_ex)
 456         {
 457                 THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 458         }
 459         return status;
 460 }
 461
 462 //=============================================================================
 463 /*!
 464  *
 465  */
 466 //=============================================================================
 467
 468 SMESH::ListOfHypothesis *
 469         SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShapeObject)
 470 throw(SALOME::SALOME_Exception)
 471 {
 472   Unexpect aCatch(SALOME_SalomeException);
 473   if (MYDEBUG) MESSAGE("GetHypothesisList");
 474   if (CORBA::is_nil(aSubShapeObject))
 475     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
 476                                  SALOME::BAD_PARAM);
 477
 478   SMESH::ListOfHypothesis_var aList = new SMESH::ListOfHypothesis();
 479
 480   try {
 481     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
 482     const list<const SMESHDS_Hypothesis*>& aLocalList = _impl->GetHypothesisList( myLocSubShape );
 483     int i = 0, n = aLocalList.size();
 484     aList->length( n );
 485
 486     for ( list<const SMESHDS_Hypothesis*>::const_iterator anIt = aLocalList.begin(); i < n && anIt != aLocalList.end(); anIt++ ) {
 487       SMESHDS_Hypothesis* aHyp = (SMESHDS_Hypothesis*)(*anIt);
 488       if ( _mapHypo.find( aHyp->GetID() ) != _mapHypo.end() )
 489         aList[i++] = SMESH::SMESH_Hypothesis::_narrow( _mapHypo[aHyp->GetID()] );
 490     }
 491
 492     aList->length( i );
 493   }
 494   catch(SALOME_Exception & S_ex) {
 495     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 496   }
 497
 498   return aList._retn();
 499 }
 500
 501 //=============================================================================
 502 /*!
 503  *
 504  */
 505 //=============================================================================
 506 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShapeObject,
 507                                                   const char*           theName )
 508      throw(SALOME::SALOME_Exception)
 509 {
 510   Unexpect aCatch(SALOME_SalomeException);
 511   MESSAGE("SMESH_Mesh_i::GetSubMesh");
 512   if (CORBA::is_nil(aSubShapeObject))
 513     THROW_SALOME_CORBA_EXCEPTION("bad subShape reference",
 514                                  SALOME::BAD_PARAM);
 515
 516   SMESH::SMESH_subMesh_var subMesh;
 517   SMESH::SMESH_Mesh_var    aMesh = SMESH::SMESH_Mesh::_narrow(_this());
 518   try {
 519     TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(aSubShapeObject);
 520
 521     //Get or Create the SMESH_subMesh object implementation
 522
 523     int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
 524     subMesh = getSubMesh( subMeshId );
 525
 526     // create a new subMesh object servant if there is none for the shape
 527     if ( subMesh->_is_nil() )
 528       subMesh = createSubMesh( aSubShapeObject );
 529
 530     if ( _gen_i->CanPublishInStudy( subMesh )) {
 531       SALOMEDS::SObject_var aSO =
 532         _gen_i->PublishSubMesh(_gen_i->GetCurrentStudy(), aMesh,
 533                                subMesh, aSubShapeObject, theName );
 534       if ( !aSO->_is_nil()) {
 535         // Update Python script
 536         TPythonDump() << aSO << " = " << _this() << ".GetSubMesh( "
 537                       << aSubShapeObject << ", '" << theName << "' )";
 538       }
 539     }
 540   }
 541   catch(SALOME_Exception & S_ex) {
 542     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
 543   }
 544   return subMesh._retn();
 545 }
 546
 547 //=============================================================================
 548 /*!
 549  *
 550  */
 551 //=============================================================================
 552
 553 void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
 554      throw (SALOME::SALOME_Exception)
 555 {
 556   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::RemoveSubMesh");
 557   if ( theSubMesh->_is_nil() )
 558     return;
 559
 560   GEOM::GEOM_Object_var aSubShapeObject;
 561   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
 562   if ( !aStudy->_is_nil() )  {
 563     // Remove submesh's SObject
 564     SALOMEDS::SObject_var anSO = _gen_i->ObjectToSObject( aStudy, theSubMesh );
 565     if ( !anSO->_is_nil() ) {
 566       long aTag = SMESH_Gen_i::GetRefOnShapeTag();
 567       SALOMEDS::SObject_var anObj, aRef;
 568       if ( anSO->FindSubObject( aTag, anObj ) && anObj->ReferencedObject( aRef ) )
 569         aSubShapeObject = GEOM::GEOM_Object::_narrow( aRef->GetObject() );
 570
 571       aStudy->NewBuilder()->RemoveObjectWithChildren( anSO );
 572
 573       // Update Python script
 574       TPythonDump() << _this() << ".RemoveSubMesh( " << anSO << " )";
 575     }
 576   }
 577
 578   removeSubMesh( theSubMesh, aSubShapeObject.in() );
 579 }
 580
 581 //=============================================================================
 582 /*!
 583  *  ElementTypeString
 584  */
 585 //=============================================================================
 586 #define CASE2STRING(enum) case SMESH::enum: return "SMESH."#enum;
 587 inline TCollection_AsciiString ElementTypeString (SMESH::ElementType theElemType)
 588 {
 589   switch (theElemType) {
 590     CASE2STRING( ALL );
 591     CASE2STRING( NODE );
 592     CASE2STRING( EDGE );
 593     CASE2STRING( FACE );
 594     CASE2STRING( VOLUME );
 595   default:;
 596   }
 597   return "";
 598 }
 599
 600 //=============================================================================
 601 /*!
 602  *
 603  */
 604 //=============================================================================
 605
 606 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
 607                                                  const char*         theName )
 608      throw(SALOME::SALOME_Exception)
 609 {
 610   Unexpect aCatch(SALOME_SalomeException);
 611   SMESH::SMESH_Group_var aNewGroup =
 612     SMESH::SMESH_Group::_narrow( createGroup( theElemType, theName ));
 613
 614   if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
 615     SALOMEDS::SObject_var aSO =
 616       _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
 617                            aNewGroup, GEOM::GEOM_Object::_nil(), theName);
 618     if ( !aSO->_is_nil()) {
 619       // Update Python script
 620       TPythonDump() << aSO << " = " << _this() << ".CreateGroup( "
 621                     << ElementTypeString(theElemType) << ", '" << theName << "' )";
 622     }
 623   }
 624   return aNewGroup._retn();
 625 }
 626
 627
 628 //=============================================================================
 629 /*!
 630  *
 631  */
 632 //=============================================================================
 633 SMESH::SMESH_GroupOnGeom_ptr SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType    theElemType,
 634                                                                 const char*           theName,
 635                                                                 GEOM::GEOM_Object_ptr theGeomObj)
 636      throw(SALOME::SALOME_Exception)
 637 {
 638   Unexpect aCatch(SALOME_SalomeException);
 639   SMESH::SMESH_GroupOnGeom_var aNewGroup;
 640
 641   TopoDS_Shape aShape = _gen_i->GeomObjectToShape( theGeomObj );
 642   if ( !aShape.IsNull() ) {
 643     aNewGroup = SMESH::SMESH_GroupOnGeom::_narrow
 644       ( createGroup( theElemType, theName, aShape ));
 645     if ( _gen_i->CanPublishInStudy( aNewGroup ) ) {
 646       SALOMEDS::SObject_var aSO =
 647         _gen_i->PublishGroup(_gen_i->GetCurrentStudy(), _this(),
 648                              aNewGroup, theGeomObj, theName);
 649       if ( !aSO->_is_nil()) {
 650         // Update Python script
 651         TPythonDump() << aSO << " = " << _this() << ".CreateGroupFromGEOM("
 652                       << ElementTypeString(theElemType) << ", '" << theName << "', "
 653                       << theGeomObj << " )";
 654       }
 655     }
 656   }
 657
 658   return aNewGroup._retn();
 659 }
 660
 661 //=============================================================================
 662 /*!
 663  *
 664  */
 665 //=============================================================================
 666
 667 void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
 668      throw (SALOME::SALOME_Exception)
 669 {
 670   if ( theGroup->_is_nil() )
 671     return;
 672
 673   SMESH_GroupBase_i* aGroup =
 674     dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
 675   if ( !aGroup )
 676     return;
 677
 678   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
 679   if ( !aStudy->_is_nil() )  {
 680     SALOMEDS::SObject_var aGroupSO = _gen_i->ObjectToSObject( aStudy, theGroup );
 681
 682     if ( !aGroupSO->_is_nil() ) {
 683       // Update Python script
 684       TPythonDump() << _this() << ".RemoveGroup( " << aGroupSO << " )";
 685
 686       // Remove group's SObject
 687       aStudy->NewBuilder()->RemoveObject( aGroupSO );
 688     }
 689   }
 690
 691   // Remove the group from SMESH data structures
 692   removeGroup( aGroup->GetLocalID() );
 693 }
 694
 695 //=============================================================================
 696 /*! RemoveGroupWithContents
 697  *  Remove group with its contents
 698  */
 699 //=============================================================================
 700 void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
 701   throw (SALOME::SALOME_Exception)
 702 {
 703   if ( theGroup->_is_nil() )
 704     return;
 705
 706   SMESH_GroupBase_i* aGroup =
 707     dynamic_cast<SMESH_GroupBase_i*>( SMESH_Gen_i::GetServant( theGroup ).in() );
 708   if ( !aGroup )
 709     return;
 710
 711   SMESH::long_array_var anIds = aGroup->GetListOfID();
 712   SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
 713
 714   // Update Python script
 715   TPythonDump() << _this() << ".RemoveGroupWithContents( " << theGroup << " )";
 716
 717   // Remove contents
 718   if ( aGroup->GetType() == SMESH::NODE )
 719     aMeshEditor->RemoveNodes( anIds );
 720   else
 721     aMeshEditor->RemoveElements( anIds );
 722
 723   // Remove group
 724   RemoveGroup( theGroup );
 725
 726   // Clear python lines, created by RemoveNodes/Elements() and RemoveGroup()
 727   _gen_i->RemoveLastFromPythonScript(_gen_i->GetCurrentStudy()->StudyId());
 728   _gen_i->RemoveLastFromPythonScript(_gen_i->GetCurrentStudy()->StudyId());
 729 }
 730
 731 //=============================================================================
 732 /*! UnionGroups
 733  *  New group is created. All mesh elements that are
 734  *  present in initial groups are added to the new one
 735  */
 736 //=============================================================================
 737 SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
 738                                                   SMESH::SMESH_GroupBase_ptr theGroup2,
 739                                                   const char* theName )
 740   throw (SALOME::SALOME_Exception)
 741 {
 742   try
 743   {
 744     if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
 745          theGroup1->GetType() != theGroup2->GetType() )
 746       return SMESH::SMESH_Group::_nil();
 747
 748     // Create Union
 749     SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
 750     if ( aResGrp->_is_nil() )
 751       return SMESH::SMESH_Group::_nil();
 752
 753     SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
 754     SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
 755
 756     TColStd_MapOfInteger aResMap;
 757
 758     for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
 759       aResMap.Add( anIds1[ i1 ] );
 760
 761     for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
 762       aResMap.Add( anIds2[ i2 ] );
 763
 764     SMESH::long_array_var aResIds = new SMESH::long_array;
 765     aResIds->length( aResMap.Extent() );
 766
 767     int resI = 0;
 768     TColStd_MapIteratorOfMapOfInteger anIter( aResMap );
 769     for( ; anIter.More(); anIter.Next() )
 770       aResIds[ resI++ ] = anIter.Key();
 771
 772     aResGrp->Add( aResIds );
 773
 774     // Clear python lines, created by CreateGroup() and Add()
 775     SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
 776     _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
 777     _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
 778
 779     // Update Python script
 780     TPythonDump() << aResGrp << " = " << _this() << ".UnionGroups( "
 781                   << theGroup1 << ", " << theGroup2 << ", '"
 782                   << theName << "' )";
 783
 784     return aResGrp._retn();
 785   }
 786   catch( ... )
 787   {
 788     return SMESH::SMESH_Group::_nil();
 789   }
 790 }
 791
 792 //=============================================================================
 793 /*! IntersectGroups
 794  *  New group is created. All mesh elements that are
 795  *  present in both initial groups are added to the new one.
 796  */
 797 //=============================================================================
 798 SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
 799                                                       SMESH::SMESH_GroupBase_ptr theGroup2,
 800                                                       const char* theName )
 801   throw (SALOME::SALOME_Exception)
 802 {
 803   if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
 804        theGroup1->GetType() != theGroup2->GetType() )
 805     return SMESH::SMESH_Group::_nil();
 806
 807   // Create Intersection
 808   SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
 809   if ( aResGrp->_is_nil() )
 810     return aResGrp;
 811
 812   SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
 813   SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
 814
 815   TColStd_MapOfInteger aMap1;
 816
 817   for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
 818     aMap1.Add( anIds1[ i1 ] );
 819
 820   TColStd_SequenceOfInteger aSeq;
 821
 822   for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
 823     if ( aMap1.Contains( anIds2[ i2 ] ) )
 824       aSeq.Append( anIds2[ i2 ] );
 825
 826   SMESH::long_array_var aResIds = new SMESH::long_array;
 827   aResIds->length( aSeq.Length() );
 828
 829   for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
 830     aResIds[ resI ] = aSeq( resI + 1 );
 831
 832   aResGrp->Add( aResIds );
 833
 834   // Clear python lines, created by CreateGroup() and Add()
 835   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
 836   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
 837   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
 838
 839   // Update Python script
 840   TPythonDump() << aResGrp << " = " << _this() << ".IntersectGroups( "
 841                 << theGroup1 << ", " << theGroup2 << ", '" << theName << "')";
 842
 843   return aResGrp._retn();
 844 }
 845
 846 //=============================================================================
 847 /*! CutGroups
 848  *  New group is created. All mesh elements that are present in
 849  *  main group but do not present in tool group are added to the new one
 850  */
 851 //=============================================================================
 852 SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
 853                                                 SMESH::SMESH_GroupBase_ptr theGroup2,
 854                                                 const char* theName )
 855   throw (SALOME::SALOME_Exception)
 856 {
 857   if ( theGroup1->_is_nil() || theGroup2->_is_nil() ||
 858        theGroup1->GetType() != theGroup2->GetType() )
 859     return SMESH::SMESH_Group::_nil();
 860
 861   // Perform Cutting
 862   SMESH::SMESH_Group_var aResGrp = CreateGroup( theGroup1->GetType(), theName );
 863   if ( aResGrp->_is_nil() )
 864     return aResGrp;
 865
 866   SMESH::long_array_var anIds1 = theGroup1->GetListOfID();
 867   SMESH::long_array_var anIds2 = theGroup2->GetListOfID();
 868
 869   TColStd_MapOfInteger aMap2;
 870
 871   for ( int i2 = 0, n2 = anIds2->length(); i2 < n2; i2++ )
 872     aMap2.Add( anIds2[ i2 ] );
 873
 874
 875   TColStd_SequenceOfInteger aSeq;
 876   for ( int i1 = 0, n1 = anIds1->length(); i1 < n1; i1++ )
 877     if ( !aMap2.Contains( anIds1[ i1 ] ) )
 878       aSeq.Append( anIds1[ i1 ] );
 879
 880   SMESH::long_array_var aResIds = new SMESH::long_array;
 881   aResIds->length( aSeq.Length() );
 882
 883   for ( int resI = 0, resN = aSeq.Length(); resI < resN; resI++ )
 884     aResIds[ resI ] = aSeq( resI + 1 );
 885
 886   aResGrp->Add( aResIds );
 887
 888   // Clear python lines, created by CreateGroup() and Add()
 889   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
 890   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
 891   _gen_i->RemoveLastFromPythonScript(aStudy->StudyId());
 892
 893   // Update Python script
 894   TPythonDump() << aResGrp << " = " << _this() << ".CutGroups( "
 895                 << theGroup1 << ", " << theGroup2 << ", '"
 896                 << theName << "' )";
 897
 898   return aResGrp._retn();
 899 }
 900
 901 //=============================================================================
 902 /*!
 903  *
 904  */
 905 //=============================================================================
 906
 907 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theSubShapeObject )
 908 {
 909   if(MYDEBUG) MESSAGE( "createSubMesh" );
 910   TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
 911
 912   ::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
 913   int subMeshId = _impl->GetMeshDS()->ShapeToIndex( myLocSubShape );
 914   SMESH_subMesh_i *subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
 915   SMESH::SMESH_subMesh_var subMesh
 916     = SMESH::SMESH_subMesh::_narrow(subMeshServant->_this());
 917
 918   _mapSubMesh[subMeshId] = mySubMesh;
 919   _mapSubMesh_i[subMeshId] = subMeshServant;
 920   _mapSubMeshIor[subMeshId] = SMESH::SMESH_subMesh::_duplicate(subMesh);
 921
 922   // register CORBA object for persistence
 923   int nextId = _gen_i->RegisterObject( subMesh );
 924   if(MYDEBUG) MESSAGE( "Add submesh to map with id = "<< nextId);
 925
 926   return subMesh._retn();
 927 }
 928
 929 //=======================================================================
 930 //function : getSubMesh
 931 //purpose  :
 932 //=======================================================================
 933
 934 SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::getSubMesh(int shapeID)
 935 {
 936   map<int, SMESH::SMESH_subMesh_ptr>::iterator it = _mapSubMeshIor.find( shapeID );
 937   if ( it == _mapSubMeshIor.end() )
 938     return SMESH::SMESH_subMesh::_nil();
 939
 940   return SMESH::SMESH_subMesh::_duplicate( (*it).second );
 941 }
 942
 943
 944 //=============================================================================
 945 /*!
 946  *
 947  */
 948 //=============================================================================
 949
 950 void SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh,
 951                                   GEOM::GEOM_Object_ptr    theSubShapeObject )
 952 {
 953   MESSAGE("SMESH_Mesh_i::removeSubMesh()");
 954   if ( theSubMesh->_is_nil() || theSubShapeObject->_is_nil() )
 955     return;
 956
 957   try {
 958     SMESH::ListOfHypothesis_var aHypList = GetHypothesisList( theSubShapeObject );
 959     for ( int i = 0, n = aHypList->length(); i < n; i++ ) {
 960       removeHypothesis( theSubShapeObject, aHypList[i] );
 961     }
 962   }
 963   catch( const SALOME::SALOME_Exception& ) {
 964     INFOS("SMESH_Mesh_i::removeSubMesh(): exception caught!");
 965   }
 966
 967   int subMeshId = theSubMesh->GetId();
 968
 969   _mapSubMesh.erase(subMeshId);
 970   _mapSubMesh_i.erase(subMeshId);
 971   _mapSubMeshIor.erase(subMeshId);
 972   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeSubMesh() completed");
 973 }
 974
 975 //=============================================================================
 976 /*!
 977  *
 978  */
 979 //=============================================================================
 980
 981 SMESH::SMESH_GroupBase_ptr SMESH_Mesh_i::createGroup (SMESH::ElementType theElemType,
 982                                                       const char*         theName,
 983                                                       const TopoDS_Shape& theShape )
 984 {
 985   int anId;
 986   SMESH::SMESH_GroupBase_var aGroup;
 987   if ( _impl->AddGroup( (SMDSAbs_ElementType)theElemType, theName, anId, theShape )) {
 988     SMESH_GroupBase_i* aGroupImpl;
 989     if ( !theShape.IsNull() )
 990       aGroupImpl = new SMESH_GroupOnGeom_i( SMESH_Gen_i::GetPOA(), this, anId );
 991     else
 992       aGroupImpl = new SMESH_Group_i( SMESH_Gen_i::GetPOA(), this, anId );
 993
 994     // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
 995     SMESH_Gen_i::GetPOA()->activate_object( aGroupImpl );
 996     aGroupImpl->Register();
 997     // PAL7962: san -- To ensure correct mapping of servant and correct reference counting in GenericObj_i
 998
 999     aGroup = SMESH::SMESH_GroupBase::_narrow( aGroupImpl->_this() );
1000     _mapGroups[anId] = SMESH::SMESH_GroupBase::_duplicate( aGroup );
1001
1002     // register CORBA object for persistence
1003     int nextId = _gen_i->RegisterObject( aGroup );
1004     if(MYDEBUG) MESSAGE( "Add group to map with id = "<< nextId);
1005   }
1006   return aGroup._retn();
1007 }
1008
1009 //=============================================================================
1010 /*!
1011  * SMESH_Mesh_i::removeGroup
1012  *
1013  * Should be called by ~SMESH_Group_i()
1014  */
1015 //=============================================================================
1016
1017 void SMESH_Mesh_i::removeGroup( const int theId )
1018 {
1019   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::removeGroup()" );
1020   if ( _mapGroups.find( theId ) != _mapGroups.end() ) {
1021     _mapGroups.erase( theId );
1022     _impl->RemoveGroup( theId );
1023   }
1024 }
1025
1026
1027 //=============================================================================
1028 /*!
1029  *
1030  */
1031 //=============================================================================
1032
1033 SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
1034 throw(SALOME::SALOME_Exception)
1035 {
1036   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetLog");
1037
1038   SMESH::log_array_var aLog;
1039   try{
1040     list < SMESHDS_Command * >logDS = _impl->GetLog();
1041     aLog = new SMESH::log_array;
1042     int indexLog = 0;
1043     int lg = logDS.size();
1044     SCRUTE(lg);
1045     aLog->length(lg);
1046     list < SMESHDS_Command * >::iterator its = logDS.begin();
1047     while(its != logDS.end()){
1048       SMESHDS_Command *com = *its;
1049       int comType = com->GetType();
1050       //SCRUTE(comType);
1051       int lgcom = com->GetNumber();
1052       //SCRUTE(lgcom);
1053       const list < int >&intList = com->GetIndexes();
1054       int inum = intList.size();
1055       //SCRUTE(inum);
1056       list < int >::const_iterator ii = intList.begin();
1057       const list < double >&coordList = com->GetCoords();
1058       int rnum = coordList.size();
1059       //SCRUTE(rnum);
1060       list < double >::const_iterator ir = coordList.begin();
1061       aLog[indexLog].commandType = comType;
1062       aLog[indexLog].number = lgcom;
1063       aLog[indexLog].coords.length(rnum);
1064       aLog[indexLog].indexes.length(inum);
1065       for(int i = 0; i < rnum; i++){
1066         aLog[indexLog].coords[i] = *ir;
1067         //MESSAGE(" "<<i<<" "<<ir.Value());
1068         ir++;
1069       }
1070       for(int i = 0; i < inum; i++){
1071         aLog[indexLog].indexes[i] = *ii;
1072         //MESSAGE(" "<<i<<" "<<ii.Value());
1073         ii++;
1074       }
1075       indexLog++;
1076       its++;
1077     }
1078     if(clearAfterGet)
1079       _impl->ClearLog();
1080   }
1081   catch(SALOME_Exception & S_ex){
1082     THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
1083   }
1084   return aLog._retn();
1085 }
1086
1087
1088 //=============================================================================
1089 /*!
1090  *
1091  */
1092 //=============================================================================
1093
1094 void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
1095 {
1096   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::ClearLog");
1097   // ****
1098 }
1099
1100 //=============================================================================
1101 /*!
1102  *
1103  */
1104 //=============================================================================
1105
1106 CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
1107 {
1108   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetId");
1109   return _id;
1110 }
1111
1112 //=============================================================================
1113 /*!
1114  *
1115  */
1116 //=============================================================================
1117
1118 CORBA::Long SMESH_Mesh_i::GetStudyId()throw(SALOME::SALOME_Exception)
1119 {
1120   return _studyId;
1121 }
1122
1123 //=============================================================================
1124 /*!
1125  *
1126  */
1127 //=============================================================================
1128
1129 void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
1130 {
1131   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::SetImpl");
1132   _impl = impl;
1133 }
1134
1135 //=============================================================================
1136 /*!
1137  *
1138  */
1139 //=============================================================================
1140
1141 ::SMESH_Mesh & SMESH_Mesh_i::GetImpl()
1142 {
1143   if(MYDEBUG) MESSAGE("SMESH_Mesh_i::GetImpl()");
1144   return *_impl;
1145 }
1146
1147
1148 //=============================================================================
1149 /*!
1150  *
1151  */
1152 //=============================================================================
1153
1154 SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
1155 {
1156   // Create MeshEditor
1157   SMESH_MeshEditor_i *aMeshEditor = new SMESH_MeshEditor_i( _impl );
1158   SMESH::SMESH_MeshEditor_var aMesh = aMeshEditor->_this();
1159
1160   // Update Python script
1161   TPythonDump() << aMeshEditor << " = " << _this() << ".GetMeshEditor()";
1162
1163   return aMesh._retn();
1164 }
1165
1166 //=============================================================================
1167 /*!
1168  *  Export in different formats
1169  */
1170 //=============================================================================
1171
1172 CORBA::Boolean SMESH_Mesh_i::HasDuplicatedGroupNamesMED()
1173 {
1174   return _impl->HasDuplicatedGroupNamesMED();
1175 }
1176
1177 static void PrepareForWriting (const char* file)
1178 {
1179   TCollection_AsciiString aFullName ((char*)file);
1180   OSD_Path aPath (aFullName);
1181   OSD_File aFile (aPath);
1182   if (aFile.Exists()) {
1183     // existing filesystem node
1184     if (aFile.KindOfFile() == OSD_FILE) {
1185       if (aFile.IsWriteable()) {
1186         aFile.Reset();
1187         aFile.Remove();
1188         if (aFile.Failed()) {
1189           TCollection_AsciiString msg ("File ");
1190           msg += aFullName + " cannot be replaced.";
1191           THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
1192         }
1193       } else {
1194         TCollection_AsciiString msg ("File ");
1195         msg += aFullName + " cannot be overwritten.";
1196         THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
1197       }
1198     } else {
1199       TCollection_AsciiString msg ("Location ");
1200       msg += aFullName + " is not a file.";
1201       THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
1202     }
1203   } else {
1204     // nonexisting file; check if it can be created
1205     aFile.Reset();
1206     aFile.Build(OSD_WriteOnly, OSD_Protection());
1207     if (aFile.Failed()) {
1208       TCollection_AsciiString msg ("You cannot create the file ");
1209       msg += aFullName + ". Check the directory existance and access rights.";
1210       THROW_SALOME_CORBA_EXCEPTION(msg.ToCString(), SALOME::BAD_PARAM);
1211     } else {
1212       aFile.Close();
1213       aFile.Remove();
1214     }
1215   }
1216 }
1217
1218 void SMESH_Mesh_i::ExportToMED (const char* file,
1219                                 CORBA::Boolean auto_groups,
1220                                 SMESH::MED_VERSION theVersion)
1221   throw(SALOME::SALOME_Exception)
1222 {
1223   Unexpect aCatch(SALOME_SalomeException);
1224
1225   // Update Python script
1226   TPythonDump() << _this() << ".ExportToMED( '"
1227                 << file << "', " << auto_groups << ", " << theVersion << " )";
1228
1229   // Perform Export
1230   PrepareForWriting(file);
1231   char* aMeshName = "Mesh";
1232   SALOMEDS::Study_ptr aStudy = _gen_i->GetCurrentStudy();
1233   if ( !aStudy->_is_nil() ) {
1234     SALOMEDS::SObject_var aMeshSO = _gen_i->ObjectToSObject( aStudy, _this() );
1235     if ( !aMeshSO->_is_nil() ) {
1236       aMeshName = aMeshSO->GetName();
1237       //SCRUTE(file);
1238       //SCRUTE(aMeshName);
1239       //SCRUTE(aMeshSO->GetID());
1240
1241       // asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes
1242       if ( !aStudy->GetProperties()->IsLocked() )
1243         {
1244         SALOMEDS::GenericAttribute_var anAttr;
1245         SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
1246         SALOMEDS::AttributeExternalFileDef_var aFileName;
1247         anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeExternalFileDef");
1248         aFileName = SALOMEDS::AttributeExternalFileDef::_narrow(anAttr);
1249         ASSERT(!aFileName->_is_nil());
1250         aFileName->SetValue(file);
1251         SALOMEDS::AttributeFileType_var aFileType;
1252         anAttr=aStudyBuilder->FindOrCreateAttribute(aMeshSO, "AttributeFileType");
1253         aFileType = SALOMEDS::AttributeFileType::_narrow(anAttr);
1254         ASSERT(!aFileType->_is_nil());
1255         aFileType->SetValue("FICHIERMED");
1256         }
1257     }
1258   }
1259   _impl->ExportMED( file, aMeshName, auto_groups, theVersion );
1260 }
1261
1262 void SMESH_Mesh_i::ExportMED (const char* file,
1263                               CORBA::Boolean auto_groups)
1264   throw(SALOME::SALOME_Exception)
1265 {
1266   ExportToMED(file,auto_groups,SMESH::MED_V2_1);
1267 }
1268
1269 void SMESH_Mesh_i::ExportDAT (const char *file)
1270   throw(SALOME::SALOME_Exception)
1271 {
1272   Unexpect aCatch(SALOME_SalomeException);
1273
1274   // Update Python script
1275   TPythonDump() << _this() << ".ExportDAT( '" << file << "' )";
1276
1277   // Perform Export
1278   PrepareForWriting(file);
1279   _impl->ExportDAT(file);
1280 }
1281
1282 void SMESH_Mesh_i::ExportUNV (const char *file)
1283   throw(SALOME::SALOME_Exception)
1284 {
1285   Unexpect aCatch(SALOME_SalomeException);
1286
1287   // Update Python script
1288   TPythonDump() << _this() << ".ExportUNV( '" << file << "' )";
1289
1290   // Perform Export
1291   PrepareForWriting(file);
1292   _impl->ExportUNV(file);
1293 }
1294
1295 void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
1296   throw(SALOME::SALOME_Exception)
1297 {
1298   Unexpect aCatch(SALOME_SalomeException);
1299
1300   // Update Python script
1301   TPythonDump() << _this() << ".ExportSTL( '" << file << "', " << isascii << " )";
1302
1303   // Perform Export
1304   PrepareForWriting(file);
1305   _impl->ExportSTL(file, isascii);
1306 }
1307
1308 //=============================================================================
1309 /*!
1310  *
1311  */
1312 //=============================================================================
1313
1314 SALOME_MED::MESH_ptr SMESH_Mesh_i::GetMEDMesh()throw(SALOME::SALOME_Exception)
1315 {
1316   Unexpect aCatch(SALOME_SalomeException);
1317   SMESH_MEDMesh_i *aMedMesh = new SMESH_MEDMesh_i(this);
1318   SALOME_MED::MESH_var aMesh = aMedMesh->_this();
1319   return aMesh._retn();
1320 }
1321
1322 //=============================================================================
1323 /*!
1324  *
1325  */
1326 //=============================================================================
1327 CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
1328 {
1329   Unexpect aCatch(SALOME_SalomeException);
1330   return _impl->NbNodes();
1331 }
1332
1333 //=============================================================================
1334 /*!
1335  *
1336  */
1337 //=============================================================================
1338 CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception)
1339 {
1340   Unexpect aCatch(SALOME_SalomeException);
1341   return NbEdges() + NbFaces() + NbVolumes();
1342 }
1343
1344 //=============================================================================
1345 /*!
1346  *
1347  */
1348 //=============================================================================
1349 CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception)
1350 {
1351   Unexpect aCatch(SALOME_SalomeException);
1352   return _impl->NbEdges();
1353 }
1354
1355 //=============================================================================
1356 /*!
1357  *
1358  */
1359 //=============================================================================
1360 CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception)
1361 {
1362   Unexpect aCatch(SALOME_SalomeException);
1363   return _impl->NbFaces();
1364 }
1365
1366 CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception)
1367 {
1368   Unexpect aCatch(SALOME_SalomeException);
1369   return _impl->NbTriangles();
1370 }
1371
1372 CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
1373 {
1374   Unexpect aCatch(SALOME_SalomeException);
1375   return _impl->NbQuadrangles();
1376 }
1377
1378 CORBA::Long SMESH_Mesh_i::NbPolygons()throw(SALOME::SALOME_Exception)
1379 {
1380   Unexpect aCatch(SALOME_SalomeException);
1381   return _impl->NbPolygons();
1382 }
1383
1384 //=============================================================================
1385 /*!
1386  *
1387  */
1388 //=============================================================================
1389 CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception)
1390 {
1391   Unexpect aCatch(SALOME_SalomeException);
1392   return _impl->NbVolumes();
1393 }
1394
1395 CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception)
1396 {
1397   Unexpect aCatch(SALOME_SalomeException);
1398   return _impl->NbTetras();
1399 }
1400
1401 CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception)
1402 {
1403   Unexpect aCatch(SALOME_SalomeException);
1404   return _impl->NbHexas();
1405 }
1406
1407 CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception)
1408 {
1409   Unexpect aCatch(SALOME_SalomeException);
1410   return _impl->NbPyramids();
1411 }
1412
1413 CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception)
1414 {
1415   Unexpect aCatch(SALOME_SalomeException);
1416   return _impl->NbPrisms();
1417 }
1418
1419 CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception)
1420 {
1421   Unexpect aCatch(SALOME_SalomeException);
1422   return _impl->NbPolyhedrons();
1423 }
1424
1425 //=============================================================================
1426 /*!
1427  *
1428  */
1429 //=============================================================================
1430 CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
1431 {
1432   Unexpect aCatch(SALOME_SalomeException);
1433   return _impl->NbSubMesh();
1434 }
1435
1436 //=============================================================================
1437 /*!
1438  *
1439  */
1440 //=============================================================================
1441 char* SMESH_Mesh_i::Dump()
1442 {
1443   std::ostringstream os;
1444   _impl->Dump( os );
1445   return CORBA::string_dup( os.str().c_str() );
1446 }
1447
1448 //=============================================================================
1449 /*!
1450  *
1451  */
1452 //=============================================================================
1453 SMESH::long_array* SMESH_Mesh_i::GetIDs()
1454 {
1455   SMESH::long_array_var aResult = new SMESH::long_array();
1456   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
1457   int aMinId = aSMESHDS_Mesh->MinElementID();
1458   int aMaxId =  aSMESHDS_Mesh->MaxElementID();
1459
1460   aResult->length(aMaxId - aMinId + 1);
1461
1462   for (int i = 0, id = aMinId; id <= aMaxId; id++  )
1463     aResult[i++] = id;
1464
1465   return aResult._retn();
1466 }
1467
1468 //=============================================================================
1469 /*!
1470  *
1471  */
1472 //=============================================================================
1473
1474 SMESH::long_array* SMESH_Mesh_i::GetElementsId()
1475      throw (SALOME::SALOME_Exception)
1476 {
1477   Unexpect aCatch(SALOME_SalomeException);
1478   MESSAGE("SMESH_Mesh_i::GetElementsId");
1479   SMESH::long_array_var aResult = new SMESH::long_array();
1480   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
1481
1482   if ( aSMESHDS_Mesh == NULL )
1483     return aResult._retn();
1484
1485   long nbElements = NbElements();
1486   aResult->length( nbElements );
1487   SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator();
1488   for ( int i = 0, n = nbElements; i < n && anIt->more(); i++ )
1489     aResult[i] = anIt->next()->GetID();
1490
1491   return aResult._retn();
1492 }
1493
1494
1495 //=============================================================================
1496 /*!
1497  *
1498  */
1499 //=============================================================================
1500
1501 SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
1502     throw (SALOME::SALOME_Exception)
1503 {
1504   Unexpect aCatch(SALOME_SalomeException);
1505   MESSAGE("SMESH_subMesh_i::GetElementsByType");
1506   SMESH::long_array_var aResult = new SMESH::long_array();
1507   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
1508
1509   if ( aSMESHDS_Mesh == NULL )
1510     return aResult._retn();
1511
1512   long nbElements = NbElements();
1513
1514   // No sense in returning ids of elements along with ids of nodes:
1515   // when theElemType == SMESH::ALL, return node ids only if
1516   // there are no elements
1517   if ( theElemType == SMESH::NODE || theElemType == SMESH::ALL && nbElements == 0 )
1518     return GetNodesId();
1519
1520   aResult->length( nbElements );
1521
1522   int i = 0;
1523
1524   SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator();
1525   while ( i < nbElements && anIt->more() ) {
1526     const SMDS_MeshElement* anElem = anIt->next();
1527     if ( theElemType == SMESH::ALL || anElem->GetType() == (SMDSAbs_ElementType)theElemType )
1528       aResult[i++] = anElem->GetID();
1529   }
1530
1531   aResult->length( i );
1532
1533   return aResult._retn();
1534 }
1535
1536 //=============================================================================
1537 /*!
1538  *
1539  */
1540 //=============================================================================
1541
1542 SMESH::long_array* SMESH_Mesh_i::GetNodesId()
1543   throw (SALOME::SALOME_Exception)
1544 {
1545   Unexpect aCatch(SALOME_SalomeException);
1546   MESSAGE("SMESH_subMesh_i::GetNodesId");
1547   SMESH::long_array_var aResult = new SMESH::long_array();
1548   SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
1549
1550   if ( aSMESHDS_Mesh == NULL )
1551     return aResult._retn();
1552
1553   long nbNodes = NbNodes();
1554   aResult->length( nbNodes );
1555   SMDS_NodeIteratorPtr anIt = aSMESHDS_Mesh->nodesIterator();
1556   for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ )
1557     aResult[i] = anIt->next()->GetID();
1558
1559   return aResult._retn();
1560 }
1561
1562 //=============================================================================
1563 /*!
1564  *
1565  */
1566 //=============================================================================
1567
1568 SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
1569   throw (SALOME::SALOME_Exception)
1570 {
1571   return ( SMESH::ElementType )_impl->GetElementType( id, iselem );
1572 }
1573
1574 //=============================================================================
1575 /*!
1576  *
1577  */
1578 //=============================================================================
1579
1580 CORBA::Long SMESH_Mesh_i::GetMeshPtr()
1581 {
1582   return (CORBA::Long)_impl;
1583 }