src/SMESHGUI/SMESHGUI_Swig.cxx

   1 //  SMESH SMESHGUI : GUI for SMESH component
   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_Swig.cxx
  25 //  Author : Nicolas REJNERI
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 using namespace std;
  30 #include "SMESHGUI_Swig.hxx"
  31
  32 #include "Utils_ORB_INIT.hxx"
  33 #include "Utils_SINGLETON.hxx"
  34
  35 // SALOME Includes
  36 #include "QAD_Application.h"
  37 #include "QAD_Desktop.h"
  38 #include "QAD_ResourceMgr.h"
  39
  40 #include "utilities.h"
  41
  42 // Open CASCADE Includes
  43 #include <TopoDS.hxx>
  44
  45 // IDL Headers
  46 #include <SALOMEconfig.h>
  47 #include CORBA_SERVER_HEADER(SMESH_Gen)
  48 #include CORBA_SERVER_HEADER(SMESH_Mesh)
  49 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
  50
  51 static CORBA::ORB_var _orb;
  52
  53 static char* ObjectToString (CORBA::Object_ptr obj)
  54 {
  55   return _orb->object_to_string(obj);
  56 }
  57
  58 static CORBA::Object_ptr StringToObject (const char* ior)
  59 {
  60   return _orb->string_to_object(ior);
  61 }
  62
  63 SMESH_Swig::SMESH_Swig()
  64 {
  65   MESSAGE("Constructeur");
  66   setOrb();
  67 }
  68
  69 void SMESH_Swig::Init(int studyID)
  70 {
  71   MESSAGE("Init");
  72   Engines::Component_var comp = QAD_Application::getDesktop()->getEngine("FactoryServer", "SMESH");
  73   SMESH::SMESH_Gen_var CompMesh = SMESH::SMESH_Gen::_narrow(comp);
  74
  75   Engines::Component_var comp1 = QAD_Application::getDesktop()->getEngine("FactoryServer", "GEOM");
  76   GEOM::GEOM_Gen_var CompGeom = GEOM::GEOM_Gen::_narrow(comp1);
  77
  78   QAD_ResourceMgr* resMgr = QAD_Desktop::createResourceManager();
  79   if ( resMgr ) {
  80     QString msg;
  81     if (!resMgr->loadResources( "SMESH", msg ))
  82       MESSAGE ( msg )
  83   }
  84
  85   CORBA::Object_var obj = QAD_Application::getDesktop()->getNameService()->Resolve("/myStudyManager");
  86   SALOMEDS::StudyManager_var myStudyMgr = SALOMEDS::StudyManager::_narrow(obj);
  87   myStudy = myStudyMgr->GetStudyByID(studyID);
  88
  89   CompMesh->SetCurrentStudy( myStudy.in() );
  90
  91   myStudyBuilder = myStudy->NewBuilder();
  92   SALOMEDS::GenericAttribute_var anAttr;
  93   SALOMEDS::AttributeName_var    aName;
  94   SALOMEDS::AttributePixMap_var  aPixmap;
  95
  96   // See return value of SMESH::SMESH_Gen::ComponentDataType()
  97   SALOMEDS::SComponent_var father = myStudy->FindComponent("SMESH");
  98
  99   if (father->_is_nil()) {
 100     bool aLocked = myStudy->GetProperties()->IsLocked();
 101     if (aLocked) myStudy->GetProperties()->SetLocked(false);
 102     father = myStudyBuilder->NewComponent("SMESH");
 103     anAttr = myStudyBuilder->FindOrCreateAttribute(father, "AttributeName");
 104     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 105     //NRI    aName->SetValue(QObject::tr("SMESH_MEN_COMPONENT"));
 106     aName->SetValue( QAD_Application::getDesktop()->getComponentUserName( "SMESH" ) );
 107     anAttr = myStudyBuilder->FindOrCreateAttribute(father, "AttributePixMap");
 108     aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 109     aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
 110     myStudyBuilder->DefineComponentInstance(father, CompMesh );
 111     if (aLocked) myStudy->GetProperties()->SetLocked(true);
 112   }
 113   mySComponentMesh = SALOMEDS::SComponent::_narrow( father );
 114
 115   // Tags definition
 116   Tag_HypothesisRoot  = 1;
 117   Tag_AlgorithmsRoot  = 2;
 118
 119   Tag_RefOnShape      = 1;
 120   Tag_RefOnAppliedHypothesis = 2;
 121   Tag_RefOnAppliedAlgorithms = 3;
 122
 123   Tag_SubMeshOnVertex = 4;
 124   Tag_SubMeshOnEdge = 5;
 125   Tag_SubMeshOnFace = 6;
 126   Tag_SubMeshOnSolid = 7;
 127   Tag_SubMeshOnCompound = 8;
 128 }
 129
 130 SMESH_Swig::~SMESH_Swig()
 131 {
 132   MESSAGE("Destructeur");
 133 }
 134
 135
 136 const char* SMESH_Swig::AddNewMesh(const char* IOR)
 137 {
 138   MESSAGE("AddNewMesh");
 139
 140   // VSR: added temporarily - to be removed - objects are published automatically by engine
 141   SALOMEDS::SObject_var SO = myStudy->FindObjectIOR( IOR );
 142   if ( !SO->_is_nil() )
 143     return SO->GetID();
 144
 145   //Find or Create Hypothesis root
 146   SALOMEDS::GenericAttribute_var    anAttr;
 147   SALOMEDS::AttributeName_var       aName;
 148   SALOMEDS::AttributeIOR_var        anIOR;
 149   SALOMEDS::AttributeSelectable_var aSelAttr;
 150   SALOMEDS::AttributePixMap_var     aPixmap;
 151
 152   SALOMEDS::SObject_var HypothesisRoot;
 153   if (!mySComponentMesh->FindSubObject (Tag_HypothesisRoot, HypothesisRoot)) {
 154     HypothesisRoot = myStudyBuilder->NewObjectToTag (mySComponentMesh, Tag_HypothesisRoot);
 155     anAttr = myStudyBuilder->FindOrCreateAttribute(HypothesisRoot, "AttributeName");
 156     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 157     aName->SetValue(QObject::tr("SMESH_MEN_HYPOTHESIS"));
 158     anAttr = myStudyBuilder->FindOrCreateAttribute(HypothesisRoot, "AttributePixMap");
 159     aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 160     aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO" );
 161     anAttr = myStudyBuilder->FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable");
 162     aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 163     aSelAttr->SetSelectable(false);
 164   }
 165
 166   SALOMEDS::SObject_var AlgorithmsRoot;
 167   if (!mySComponentMesh->FindSubObject (Tag_AlgorithmsRoot, AlgorithmsRoot)) {
 168     AlgorithmsRoot = myStudyBuilder->NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot);
 169     anAttr = myStudyBuilder->FindOrCreateAttribute(AlgorithmsRoot, "AttributeName");
 170     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 171     aName->SetValue(QObject::tr("SMESH_MEN_ALGORITHMS"));
 172     anAttr = myStudyBuilder->FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap");
 173     aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 174     aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO" );
 175     anAttr = myStudyBuilder->FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable");
 176     aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 177     aSelAttr->SetSelectable(false);
 178   }
 179
 180   // Add New Mesh
 181   SALOMEDS::SObject_var newMesh = myStudyBuilder->NewObject(mySComponentMesh);
 182   anAttr = myStudyBuilder->FindOrCreateAttribute(newMesh, "AttributePixMap");
 183   aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 184   aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH" );
 185   anAttr = myStudyBuilder->FindOrCreateAttribute(newMesh, "AttributeIOR");
 186   anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 187   anIOR->SetValue(IOR);
 188   return SALOMEDS::SObject::_narrow( newMesh )->GetID();
 189 }
 190
 191 const char* SMESH_Swig::AddNewHypothesis(const char* IOR)
 192 {
 193   MESSAGE("AddNewHypothesis");
 194
 195   // VSR: added temporarily - to be removed - objects are published automatically by engine
 196   SALOMEDS::SObject_var SO = myStudy->FindObjectIOR( IOR );
 197   if ( !SO->_is_nil() )
 198     return SO->GetID();
 199
 200   //Find or Create Hypothesis root
 201   SALOMEDS::SObject_var             HypothesisRoot;
 202   SALOMEDS::GenericAttribute_var    anAttr;
 203   SALOMEDS::AttributeName_var       aName;
 204   SALOMEDS::AttributeIOR_var        anIOR;
 205   SALOMEDS::AttributeSelectable_var aSelAttr;
 206   SALOMEDS::AttributePixMap_var     aPixmap;
 207
 208   if (!mySComponentMesh->FindSubObject (Tag_HypothesisRoot, HypothesisRoot)) {
 209     HypothesisRoot = myStudyBuilder->NewObjectToTag (mySComponentMesh, Tag_HypothesisRoot);
 210     anAttr = myStudyBuilder->FindOrCreateAttribute(HypothesisRoot, "AttributeName");
 211     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 212     aName->SetValue(QObject::tr("SMESH_MEN_HYPOTHESIS"));
 213     anAttr = myStudyBuilder->FindOrCreateAttribute(HypothesisRoot, "AttributeSelectable");
 214     aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 215     aSelAttr->SetSelectable(false);
 216     anAttr = myStudyBuilder->FindOrCreateAttribute(HypothesisRoot, "AttributePixMap");
 217     aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 218     aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO" );
 219   }
 220   // Add New Hypothesis
 221   SALOMEDS::SObject_var newHypo = myStudyBuilder->NewObject(HypothesisRoot);
 222   anAttr = myStudyBuilder->FindOrCreateAttribute(newHypo, "AttributePixMap");
 223   aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 224   SMESH::SMESH_Hypothesis_var H = SMESH::SMESH_Hypothesis::_narrow( StringToObject(IOR) );
 225   QString aType = H->GetName();
 226   aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO_" + aType );
 227 //    if ( aType.compare("LocalLength") == 0 )
 228 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO_LENGTH" );
 229 //    else if ( aType.compare("NumberOfSegments") == 0 )
 230 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO_SEGMENT" );
 231 //    else if ( aType.compare("MaxElementArea") == 0 )
 232 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO_AREA" );
 233 //    else if ( aType.compare("MaxElementVolume") == 0 )
 234 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO_VOLUME" );
 235   anAttr = myStudyBuilder->FindOrCreateAttribute(newHypo, "AttributeIOR");
 236   anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 237   anIOR->SetValue(IOR);
 238   return SALOMEDS::SObject::_narrow(newHypo)->GetID();
 239 }
 240
 241 const char* SMESH_Swig::AddNewAlgorithms(const char* IOR)
 242 {
 243   MESSAGE("AddNewAlgorithms");
 244
 245   // VSR: added temporarily - to be removed - objects are published automatically by engine
 246   SALOMEDS::SObject_var SO = myStudy->FindObjectIOR( IOR );
 247   if ( !SO->_is_nil() )
 248     return SO->GetID();
 249
 250   //Find or Create Algorithms root
 251   SALOMEDS::SObject_var             AlgorithmsRoot;
 252   SALOMEDS::GenericAttribute_var    anAttr;
 253   SALOMEDS::AttributeName_var       aName;
 254   SALOMEDS::AttributeIOR_var        anIOR;
 255   SALOMEDS::AttributeSelectable_var aSelAttr;
 256   SALOMEDS::AttributePixMap_var     aPixmap;
 257
 258   if (!mySComponentMesh->FindSubObject (Tag_AlgorithmsRoot, AlgorithmsRoot)) {
 259     AlgorithmsRoot = myStudyBuilder->NewObjectToTag (mySComponentMesh, Tag_AlgorithmsRoot);
 260     anAttr = myStudyBuilder->FindOrCreateAttribute(AlgorithmsRoot, "AttributeName");
 261     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 262     aName->SetValue(QObject::tr("SMESH_MEN_ALGORITHMS"));
 263     anAttr = myStudyBuilder->FindOrCreateAttribute(AlgorithmsRoot, "AttributeSelectable");
 264     aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 265     aSelAttr->SetSelectable(false);
 266     anAttr = myStudyBuilder->FindOrCreateAttribute(AlgorithmsRoot, "AttributePixMap");
 267     aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 268     aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO" );
 269   }
 270   // Add New Algorithms
 271   SALOMEDS::SObject_var newHypo = myStudyBuilder->NewObject(AlgorithmsRoot);
 272   anAttr = myStudyBuilder->FindOrCreateAttribute(newHypo, "AttributePixMap");
 273   aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 274   SMESH::SMESH_Hypothesis_var H = SMESH::SMESH_Hypothesis::_narrow( StringToObject(IOR) );
 275   QString aType = H->GetName();
 276   aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO_" + aType );
 277 //    if ( aType.compare("Regular_1D") == 0 )
 278 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO_REGULAR" );
 279 //    else if ( aType.compare("MEFISTO_2D") == 0 )
 280 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO_MEFISTO" );
 281 //    else if ( aType.compare("Quadrangle_2D") == 0 )
 282 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO_QUAD" );
 283 //    else if ( aType.compare("Hexa_3D") == 0 )
 284 //      aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO_HEXA" );
 285   anAttr = myStudyBuilder->FindOrCreateAttribute(newHypo, "AttributeIOR");
 286   anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 287   anIOR->SetValue(IOR);
 288   return SALOMEDS::SObject::_narrow(newHypo)->GetID();
 289 }
 290
 291 void SMESH_Swig::SetShape(const char* ShapeEntry, const char* MeshEntry)
 292 {
 293   SALOMEDS::SObject_var SO_MorSM = myStudy->FindObjectID( MeshEntry );
 294   SALOMEDS::SObject_var SO_GeomShape = myStudy->FindObjectID( ShapeEntry );
 295
 296   if ( !SO_MorSM->_is_nil() && !SO_GeomShape->_is_nil() ) {
 297     SALOMEDS::SObject_var SO = myStudyBuilder->NewObjectToTag (SO_MorSM, Tag_RefOnShape);
 298     myStudyBuilder->Addreference (SO,SO_GeomShape);
 299   }
 300 }
 301
 302 void SMESH_Swig::SetHypothesis(const char* Mesh_Or_SubMesh_Entry, const char* Hypothesis_Entry)
 303 {
 304   SALOMEDS::SObject_var SO_MorSM = myStudy->FindObjectID( Mesh_Or_SubMesh_Entry );
 305   SALOMEDS::SObject_var SO_Hypothesis = myStudy->FindObjectID( Hypothesis_Entry );
 306   SALOMEDS::GenericAttribute_var    anAttr;
 307   SALOMEDS::AttributeName_var       aName;
 308   SALOMEDS::AttributeSelectable_var aSelAttr;
 309   SALOMEDS::AttributePixMap_var     aPixmap;
 310
 311   if ( !SO_MorSM->_is_nil() && !SO_Hypothesis->_is_nil() ) {
 312
 313     //Find or Create Applied Hypothesis root
 314     SALOMEDS::SObject_var AHR;
 315     if (!SO_MorSM->FindSubObject (Tag_RefOnAppliedHypothesis, AHR)) {
 316       AHR = myStudyBuilder->NewObjectToTag (SO_MorSM, Tag_RefOnAppliedHypothesis);
 317       anAttr = myStudyBuilder->FindOrCreateAttribute(AHR, "AttributeName");
 318       aName = SALOMEDS::AttributeName::_narrow(anAttr);
 319       aName->SetValue(QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"));
 320       anAttr = myStudyBuilder->FindOrCreateAttribute(AHR, "AttributeSelectable");
 321       aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 322       aSelAttr->SetSelectable(false);
 323       anAttr = myStudyBuilder->FindOrCreateAttribute(AHR, "AttributePixMap");
 324       aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 325       aPixmap->SetPixMap( "ICON_SMESH_TREE_HYPO" );
 326     }
 327     SALOMEDS::SObject_var SO = myStudyBuilder->NewObject(AHR);
 328     myStudyBuilder->Addreference (SO,SO_Hypothesis);
 329   }
 330 }
 331 void SMESH_Swig::SetAlgorithms(const char* Mesh_Or_SubMesh_Entry, const char* Algorithms_Entry)
 332 {
 333   SALOMEDS::SObject_var SO_MorSM = myStudy->FindObjectID( Mesh_Or_SubMesh_Entry );
 334   SALOMEDS::SObject_var SO_Algorithms = myStudy->FindObjectID( Algorithms_Entry );
 335   SALOMEDS::GenericAttribute_var    anAttr;
 336   SALOMEDS::AttributeName_var       aName;
 337   SALOMEDS::AttributeSelectable_var aSelAttr;
 338   SALOMEDS::AttributePixMap_var     aPixmap;
 339
 340   if ( !SO_MorSM->_is_nil() && !SO_Algorithms->_is_nil() ) {
 341     //Find or Create Applied Algorithms root
 342     SALOMEDS::SObject_var AHR;
 343     if (!SO_MorSM->FindSubObject (Tag_RefOnAppliedAlgorithms, AHR)) {
 344       AHR = myStudyBuilder->NewObjectToTag (SO_MorSM, Tag_RefOnAppliedAlgorithms);
 345       anAttr = myStudyBuilder->FindOrCreateAttribute(AHR, "AttributeName");
 346       aName = SALOMEDS::AttributeName::_narrow(anAttr);
 347       aName->SetValue(QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"));
 348       anAttr = myStudyBuilder->FindOrCreateAttribute(AHR, "AttributeSelectable");
 349       aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 350       aSelAttr->SetSelectable(false);
 351       anAttr = myStudyBuilder->FindOrCreateAttribute(AHR, "AttributePixMap");
 352       aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 353       aPixmap->SetPixMap( "ICON_SMESH_TREE_ALGO" );
 354     }
 355     SALOMEDS::SObject_var SO = myStudyBuilder->NewObject(AHR);
 356     myStudyBuilder->Addreference (SO,SO_Algorithms);
 357   }
 358 }
 359
 360 void SMESH_Swig::UnSetHypothesis(const char* Applied_Hypothesis_Entry )
 361 {
 362   SALOMEDS::SObject_var SO_Applied_Hypothesis = myStudy->FindObjectID( Applied_Hypothesis_Entry );
 363   if ( !SO_Applied_Hypothesis->_is_nil() )
 364     myStudyBuilder->RemoveObject(SO_Applied_Hypothesis);
 365 }
 366
 367
 368 const char* SMESH_Swig::AddSubMesh(const char* SO_Mesh_Entry, const char* SM_IOR, int ST)
 369 {
 370   SALOMEDS::SObject_var SO_Mesh = myStudy->FindObjectID( SO_Mesh_Entry );
 371   if ( !SO_Mesh->_is_nil() ) {
 372
 373     long Tag_Shape ;
 374     Standard_CString Name;
 375
 376     if      (ST == TopAbs_SOLID) {Tag_Shape = Tag_SubMeshOnSolid;    Name = strdup(QObject::tr("SMESH_MEN_SubMeshesOnSolid"));}
 377     else if (ST == TopAbs_FACE)  {Tag_Shape = Tag_SubMeshOnFace;     Name = strdup(QObject::tr("SMESH_MEN_SubMeshesOnFace"));}
 378     else if (ST == TopAbs_EDGE)  {Tag_Shape = Tag_SubMeshOnEdge;     Name = strdup(QObject::tr("SMESH_MEN_SubMeshesOnEdge"));}
 379     else if (ST == TopAbs_VERTEX){Tag_Shape = Tag_SubMeshOnVertex;   Name = strdup(QObject::tr("SMESH_MEN_SubMeshesOnVertex"));}
 380     else {
 381       Tag_Shape = Tag_SubMeshOnCompound; Name = strdup(QObject::tr("SMESH_MEN_SubMeshesOnCompound"));
 382     }
 383     SALOMEDS::SObject_var SubmeshesRoot;
 384     SALOMEDS::GenericAttribute_var        anAttr;
 385     SALOMEDS::AttributeName_var           aName;
 386     SALOMEDS::AttributeIOR_var            anIOR;
 387     SALOMEDS::AttributeSelectable_var     aSelAttr;
 388     if (!SO_Mesh->FindSubObject (Tag_Shape,SubmeshesRoot )) {
 389       SubmeshesRoot = myStudyBuilder->NewObjectToTag (SO_Mesh, Tag_Shape);
 390       anAttr = myStudyBuilder->FindOrCreateAttribute(SubmeshesRoot, "AttributeName");
 391       aName = SALOMEDS::AttributeName::_narrow(anAttr);
 392       aName->SetValue(Name);
 393       anAttr = myStudyBuilder->FindOrCreateAttribute(SubmeshesRoot, "AttributeSelectable");
 394       aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 395       aSelAttr->SetSelectable(false);
 396     }
 397
 398     free(Name);
 399
 400     SALOMEDS::SObject_var SO = myStudyBuilder->NewObject (SubmeshesRoot);
 401     anAttr = myStudyBuilder->FindOrCreateAttribute(SO, "AttributeIOR");
 402     anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 403     anIOR->SetValue(SM_IOR);
 404     return SALOMEDS::SObject::_narrow( SO )->GetID();
 405   }
 406   return "";
 407 }
 408
 409 const char* SMESH_Swig::AddSubMeshOnShape(const char* Mesh_Entry, const char* GeomShape_Entry,
 410                                              const char* SM_IOR, int ST)
 411 {
 412   SALOMEDS::SObject_var SO_GeomShape = myStudy->FindObjectID( GeomShape_Entry );
 413   if ( !SO_GeomShape->_is_nil() ) {
 414     const char * SM_Entry = AddSubMesh (Mesh_Entry,SM_IOR,ST);
 415     SALOMEDS::SObject_var SO_SM = myStudy->FindObjectID( SM_Entry );
 416     if ( !SO_SM->_is_nil() ) {
 417       SetShape (GeomShape_Entry, SM_Entry);
 418       return SALOMEDS::SObject::_narrow( SO_SM )->GetID();
 419     }
 420   }
 421   return "";
 422 }
 423
 424 void SMESH_Swig::CreateAndDisplayActor( const char* Mesh_Entry )
 425 {
 426   //  SMESH_Actor* Mesh = smeshGUI->ReadScript(aM);
 427 }
 428
 429 void SMESH_Swig::SetName(const char* Entry, const char* Name)
 430 {
 431   SALOMEDS::SObject_var SO = myStudy->FindObjectID( Entry );
 432   SALOMEDS::GenericAttribute_var anAttr;
 433   SALOMEDS::AttributeName_var    aName;
 434   if ( !SO->_is_nil() )  {
 435     anAttr = myStudyBuilder->FindOrCreateAttribute(SO, "AttributeName");
 436     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 437     aName->SetValue(Name);
 438   }
 439 }
 440
 441
 442 void SMESH_Swig::setOrb()
 443 {
 444   try {
 445     ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
 446     ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 447     _orb = init( 0 , 0 );
 448   } catch (...) {
 449     INFOS("internal error : orb not found");
 450     _orb = 0;
 451   }
 452   ASSERT(! CORBA::is_nil(_orb));
 453 }