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