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