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