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