geom/src/GEOM_I/GEOM_Gen_i.cc

// Copyright (C) 2007-2019  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

#ifdef WIN32
#pragma warning( disable:4786 )
#endif

#include <Standard_Stream.hxx>

#include "GEOM_Gen_i.hh"
#include "GEOM_Object_i.hh"
#include "GEOM_Field_i.hh"
#include "GEOM_version.h"

#include "Utils_CorbaException.hxx"
#include "OpUtil.hxx"
#include "Utils_ExceptHandlers.hxx"
#include "utilities.h"

#include "GEOM_Object.hxx"
#include "GEOM_Function.hxx"
#include "GEOM_ISubShape.hxx"
#include "GEOM_PythonDump.hxx"
#include "GEOMImpl_Types.hxx"
#include "GEOMImpl_CopyDriver.hxx"
#include "GEOMImpl_IInsertOperations.hxx"
#include "GEOM_wrap.hxx"
#include "GEOMUtils_XmlHandler.hxx"

// Cascade headers
#include <BRep_Builder.hxx>
#include <BRepTools.hxx>
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>
#include <TDF_ChildIDIterator.hxx>
#include <TNaming_NamedShape.hxx>
#include <TDataStd_Name.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopExp.hxx>
#include <OSD.hxx>
#include <TDataStd_ChildNodeIterator.hxx>
#include <TDocStd_Owner.hxx>
#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>

#include <SALOMEDS_Tool.hxx>
#include <SALOMEDS_wrap.hxx>
#include <Basics_DirUtils.hxx>
#include <Basics_Utils.hxx>

#include <set>
#include <sstream>

#ifdef WIN32
 #include <windows.h>
 #include <process.h>
#else
 #include <dlfcn.h>
#endif

#ifdef WIN32
 #define LibHandle HMODULE
 #define LoadLib( name ) LoadLibrary( name )
 #define GetProc GetProcAddress
 #define UnLoadLib( handle ) FreeLibrary( handle );
#else
 #define LibHandle void*
 #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_GLOBAL )
 #define GetProc dlsym
 #define UnLoadLib( handle ) dlclose( handle );
#endif

//============================================================================
// function : GEOM_Gen_i()
// purpose  : constructor to be called for servant creation.
//============================================================================
GEOM_Gen_i::GEOM_Gen_i(CORBA::ORB_ptr            orb,
                       PortableServer::POA_ptr   poa,
                       PortableServer::ObjectId* contId,
                       const char*               instanceName,
                       const char*               interfaceName) :
  Engines_Component_i(orb, poa, contId, instanceName, interfaceName)
{
  _thisObj = this;
  _id = _poa->activate_object(_thisObj);
  name_service = new SALOME_NamingService(_orb);

  _impl = new ::GEOMImpl_Gen;

  //PAL10867: disable signals catching with "noexcepthandler" option
  char* envNoCatchSignals = getenv("NOT_INTERCEPT_SIGNALS");
  if (!envNoCatchSignals || !atoi(envNoCatchSignals))
  {
    //work around PAL12004, PAL12628
    //OSD::SetSignal( true );
    bool raiseFPE = false;
#if defined(_DEBUG_) | defined(_DEBUG) //the Last for WIN32 default settings
    char* envEnableFPE = getenv("ENABLE_FPE");
    if (envEnableFPE && atoi(envEnableFPE))
      raiseFPE = true;
#endif
    OSD::SetSignal( raiseFPE );
  }

  GEOMUtils::PluginInfo plugins = GEOMUtils::ReadPluginInfo();
  GEOMUtils::PluginInfo::const_iterator it;
  for (it = plugins.begin(); it != plugins.end(); ++it)
  {
    try {
      LoadPlugin((*it).serverLib);
    }
    catch (...)  {
      MESSAGE("Warning: can't load plugin library " << (*it).serverLib);
    }
  }
}

//============================================================================
// function : ~GEOM_Gen_i()
// purpose  : destructor
//============================================================================
GEOM_Gen_i::~GEOM_Gen_i() {
  delete name_service;
  delete _impl;
  std::map<std::string, GEOM_GenericOperationsCreator*>::const_iterator it;
  for ( it = myOpCreatorMap.begin(); it != myOpCreatorMap.end(); ++it)
    delete (*it).second;
}


//============================================================================
// function : IORToLocalPersistentID()
// purpose  :
//============================================================================
char* GEOM_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
                                         const char* IORString,
                                         CORBA::Boolean isMultiFile,
                                         CORBA::Boolean isASCII)
{
  GEOM::GEOM_BaseObject_var anObject =
    GEOM::GEOM_BaseObject::_narrow(_orb->string_to_object(IORString));
  if (!CORBA::is_nil(anObject)) {
    return anObject->GetEntry();
  }
  return 0;
}


//============================================================================
// function : LocalPersistentIDToIOR()
// purpose  : Create/Load CORBA object from a persistent ref (an entry)
//          : Used when a study is loaded
//          : The IOR (IORName) of object created is returned
//============================================================================
char* GEOM_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
                                         const char* aLocalPersistentID,
                                         CORBA::Boolean isMultiFile,
                                         CORBA::Boolean isASCII)
{
  Handle(::GEOM_BaseObject) anObject =
    _impl->GetObject(aLocalPersistentID);
  if ( !anObject.IsNull() )
  {
    TCollection_AsciiString anEntry;
    TDF_Tool::Entry(anObject->GetEntry(), anEntry);
    GEOM::GEOM_BaseObject_var obj = GetObject(anEntry.ToCString());

    CORBA::String_var aPersRefString = _orb->object_to_string(obj);
    return CORBA::string_dup(aPersRefString);
  }
  else
  {
    return CORBA::string_dup("");
  }
}

//============================================================================
// function : CanPublishInStudy
// purpose  :
//============================================================================
bool GEOM_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR)
{
  GEOM::GEOM_Object_var anObject = GEOM::GEOM_Object::_narrow(theIOR);
  return !(anObject->_is_nil());
}


//============================================================================
// function : PublishInStudy
// purpose  :
//============================================================================
SALOMEDS::SObject_ptr GEOM_Gen_i::PublishInStudy(SALOMEDS::SObject_ptr theSObject,
                                                 CORBA::Object_ptr     theObject,
                                                 const char*           theName)
  throw (SALOME::SALOME_Exception)
{
  Unexpect aCatch(SALOME_SalomeException);
  SALOMEDS::SObject_var aResultSO;
  SALOMEDS::Study_var aStudy = getStudyServant();
  if(CORBA::is_nil(theObject) || aStudy->_is_nil()) return aResultSO;
  GEOM::GEOM_BaseObject_var aBaseObj = GEOM::GEOM_BaseObject::_narrow(theObject);
  GEOM::GEOM_Object_var       aShape = GEOM::GEOM_Object::_narrow(theObject);
  if(aBaseObj->_is_nil()) return aResultSO;

  SALOMEDS::GenericAttribute_var anAttr;
  SALOMEDS::StudyBuilder_var     aStudyBuilder = aStudy->NewBuilder();
  SALOMEDS::UseCaseBuilder_wrap  useCaseBuilder = aStudy->GetUseCaseBuilder();

  SALOMEDS::SComponent_var       aFather = aStudy->FindComponent("GEOM");
  if (aFather->_is_nil()) {
    aFather = aStudyBuilder->NewComponent("GEOM");
    anAttr = aStudyBuilder->FindOrCreateAttribute(aFather, "AttributeName");
    SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
    aName->SetValue("Geometry");
    aName->UnRegister();
    anAttr = aStudyBuilder->FindOrCreateAttribute(aFather, "AttributePixMap");
    SALOMEDS::AttributePixMap_var aPixMap=SALOMEDS::AttributePixMap::_narrow(anAttr);
    aPixMap->SetPixMap("ICON_OBJBROWSER_Geometry");
    aPixMap->UnRegister();
    aStudyBuilder->DefineComponentInstance(aFather, (GEOM::GEOM_Gen_var)GEOM_Gen::_this());
    // add component to the use case tree
    // (to support tree representation customization and drag-n-drop)
    useCaseBuilder->SetRootCurrent();
    useCaseBuilder->Append( aFather ); // component object is added as the top level item
  }
  if (aFather->_is_nil()) return aResultSO;

  if (CORBA::is_nil(theSObject)) {
    aResultSO = aStudyBuilder->NewObject(aFather);
  } else {
    if (!theSObject->ReferencedObject(aResultSO))
      aResultSO = SALOMEDS::SObject::_duplicate(theSObject); //SRN: Added Aug 24,2004 : for  the method AddInStudy with theFather argumenet != NULL
    //THROW_SALOME_CORBA_EXCEPTION("Publish in study supervision graph error",SALOME::BAD_PARAM);
  }
  CORBA::String_var aGeomObjIOR = _orb->object_to_string(theObject);
  aResultSO->SetAttrString("AttributeIOR",aGeomObjIOR);

  TCollection_AsciiString anObjectName, aNamePrefix("Shape_");
  CORBA::Long mytype=aBaseObj->GetType();

  // BEGIN: try to find existed name for current shape
  if ( !aShape->_is_nil() && mytype != GEOM_GROUP)
  {
    // receive current TopoDS shape
    CORBA::String_var entry = aShape->GetEntry();
    Handle(::GEOM_Object) aGShape = Handle(::GEOM_Object)::DownCast
      ( _impl->GetObject( entry ));
    TopoDS_Shape TopoSh = aGShape->GetValue();
    // find label of main shape
    GEOM::GEOM_Object_var aMainSh = aShape;
    while( !aMainSh->IsMainShape() ) {
      aMainSh = aMainSh->GetMainShape();
    }
    entry = aMainSh->GetEntry();
    Handle(::GEOM_BaseObject) anObj = _impl->GetObject( entry );
    TDF_Label aMainLbl = anObj->GetFunction(1)->GetNamingEntry();

    // check all named shapes using iterator
    TDF_ChildIDIterator anIt (aMainLbl, TNaming_NamedShape::GetID(), Standard_True);

    for (; anIt.More() && anObjectName.IsEmpty(); anIt.Next()) {
      Handle(TNaming_NamedShape) anAttr =
        Handle(TNaming_NamedShape)::DownCast(anIt.Value());
      if (anAttr.IsNull()) continue;
      TopoDS_Shape S = anAttr->Get();
      if (S.IsEqual(TopoSh)) {
        TDF_Label L = anAttr->Label();
        Handle(TDataStd_Name) aName;
        if (L.FindAttribute(TDataStd_Name::GetID(), aName))
          anObjectName = aName->Get();
      }
    }
  }
  // END: try to find existed name for current shape

  if ( mytype == GEOM_GROUP ) {
    GEOM::GEOM_IGroupOperations_var anOp = GetIGroupOperations();
    switch ( (TopAbs_ShapeEnum)anOp->GetType( aShape )) {
    case TopAbs_VERTEX:
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_GROUP_PNT" );
      aNamePrefix = "Group_Of_Vertices_";
      break;
    case TopAbs_EDGE:
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_GROUP_EDGE");
      aNamePrefix = "Group_Of_Edges_";
      break;
    case TopAbs_FACE:
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_GROUP_FACE");
      aNamePrefix = "Group_Of_Faces_";
      break;
    case TopAbs_SOLID:
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_GROUP_SOLID");
      aNamePrefix = "Group_Of_Solids_";
      break;
    default:
      aNamePrefix = "Group_";
    }
  } else if ( mytype == GEOM_MARKER ) {
    aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_LCS");
    aNamePrefix = "LocalCS_";
  }  else if ( mytype >= USER_TYPE_EX ) {
    char buf[20];
    sprintf( buf, "%d", aBaseObj->GetType() );
    GEOM::CreationInformationSeq_var infoSeq = aBaseObj->GetCreationInformation();
    std::string plgId;
    for ( size_t j = 0; j < infoSeq->length(); ++j )
      for ( size_t i = 0; i < infoSeq[j].params.length(); ++i ) {
        std::string param_name  = infoSeq[j].params[i].name.in();
        std::string param_value = infoSeq[j].params[i].value.in();
        if( param_name == PLUGIN_NAME) {
          plgId = param_value;
          break;
        }
      }
    if(plgId.length() > 0 ) {
      plgId += "::";
    }
    plgId +="ICON_OBJBROWSER_";
    plgId += buf;
    aResultSO->SetAttrString("AttributePixMap",plgId.c_str());
  } else if ( mytype > USER_TYPE ) {
    char buf[20];
    sprintf( buf, "%d", aBaseObj->GetType() );
    std::string advId = "ICON_OBJBROWSER_ADVANCED_"; advId += buf;
    aResultSO->SetAttrString("AttributePixMap",advId.c_str());
    aNamePrefix = "Advanced_";
  } else if ( mytype == GEOM_FIELD ) {
    aNamePrefix = "Field_";
    GEOM::GEOM_Field_var aField = GEOM::GEOM_Field::_narrow(theObject);
    if ( !aField->_is_nil() )
      switch( aField->GetDimension() ) {
      case 0:
        aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_FIELD_PNT" ); break;
      case 1:
        aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_FIELD_EDGE"); break;
      case 2:
        aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_FIELD_FACE"); break;
      case 3:
        aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_FIELD_SOLID"); break;
      default:
        aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_FIELD_SOLID");
      }
  } else if ( mytype == GEOM_FIELD_STEP ) {
    aNamePrefix = "Step_";
  } else if ( !aShape->_is_nil() ) {
    GEOM::shape_type myshapetype=aShape->GetShapeType();
    if ( myshapetype == GEOM::COMPOUND ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_COMPOUND" );
      aNamePrefix = "Compound_";
    } else if ( myshapetype == GEOM::COMPSOLID ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_COMPSOLID");
      aNamePrefix = "Compsolid_";
    } else if ( myshapetype == GEOM::SOLID ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_SOLID");
      aNamePrefix = "Solid_";
    } else if ( myshapetype == GEOM::SHELL ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_SHELL");
      aNamePrefix = "Shell_";
    } else if ( myshapetype == GEOM::FACE ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_FACE");
      aNamePrefix = "Face_";
    } else if ( myshapetype == GEOM::WIRE ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_WIRE");
      aNamePrefix = "Wire_";
    } else if ( myshapetype == GEOM::EDGE ) {
      aResultSO->SetAttrString("AttributePixMap", "ICON_OBJBROWSER_EDGE");
      aNamePrefix = "Edge_";
    } else if ( myshapetype == GEOM::VERTEX ) {
      aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_VERTEX" );
      aNamePrefix = "Vertex_";
    }
  }
  if ( anObjectName.IsEmpty() )
  {
    //if (strlen(theName) == 0) aNamePrefix += TCollection_AsciiString(aResultSO->Tag());
    //else anObjectName = TCollection_AsciiString(CORBA::string_dup(theName));

    // asv : 11.11.04 Introducing a more sofisticated method of name creation, just as
    //       it is done in GUI in GEOMBase::GetDefaultName() - not just add a Tag() == number
    //       of objects in the study, but compute a number of objects with the same prefix
    //       and build a new name as Prefix_N+1
    if ( strlen( theName ) == 0 ) { // MOST PROBABLY CALLED FROM BATCHMODE OR SUPERVISOR
      int i = 0;                    // (WITH EMPTY NEW NAME)
      SALOMEDS::SObject_var obj;
      do {
        anObjectName = aNamePrefix + TCollection_AsciiString(++i);
        obj = aStudy->FindObject( anObjectName.ToCString() );
      }
      while ( !obj->_is_nil() );
    }
    else { // MOST PROBABLY CALLED FROM GEOM GUI (ALREADY WITH VALID NAME)
      anObjectName = theName;
    }
  }

  //Set the study entry as a name of  the published GEOM_Object
  CORBA::String_var anID = aResultSO->GetID();
  aBaseObj->SetStudyEntry(anID.in());

  //Set a name of the added shape
  aResultSO->SetAttrString("AttributeName",anObjectName.ToCString());

  //Set NoteBook variables used in the object creation
  TCollection_AsciiString aVars;
  CORBA::String_var aString=aBaseObj->GetParameters();
  SALOMEDS::ListOfListOfStrings_var aSections = aStudy->ParseVariables(aString);
  for(int i = 0, n = aSections->length(); i < n; i++) {
    SALOMEDS::ListOfStrings aListOfVars = aSections[i];
    for(int j = 0, m = aListOfVars.length(); j < m; j++) {
      if(aStudy->IsVariable(aListOfVars[j].in()))
        aVars += aListOfVars[j].in();
      if(j != m-1)
        aVars += ":";
    }
    if(i != n-1)
      aVars += "|";
  }
  aResultSO->SetAttrString("AttributeString",aVars.ToCString());

  aFather->UnRegister();

  //Set a name of the GEOM object
  aBaseObj->SetName(anObjectName.ToCString());

  // add object to the use case tree
  // (to support tree representation customization and drag-n-drop)
  useCaseBuilder->AppendTo( aResultSO->GetFather(), aResultSO );

  return aResultSO._retn();
}

//============================================================================
// function : CreateAndPublishGroup
// purpose  : auxiliary for PublishNamedShapesInStudy
//============================================================================
void GEOM_Gen_i::CreateAndPublishGroup(GEOM::GEOM_Object_var theMainShape,
                                       const TopTools_IndexedMapOfShape& anIndices,
                                       const TopTools_SequenceOfShape& SeqS,
                                       const TColStd_SequenceOfAsciiString& SeqN,
                                       const Standard_CString& GrName,
                                       GEOM::ListOfGO_var aResList)
{
  CORBA::String_var entry = theMainShape->GetEntry();
  //Handle(::GEOM_Object) aMainShape = _impl->GetObject(entry);
  Handle(TColStd_HArray1OfInteger) anArray;
  if(SeqS.Length()>0) {
    // create a group
    GEOM::GEOM_IGroupOperations_var GOp = GetIGroupOperations();
    GEOM::GEOM_Object_wrap GrObj = GOp->CreateGroup( theMainShape, SeqS(1).ShapeType() );
    AddInStudy(GrObj, GrName, theMainShape._retn());
    //CORBA::String_var GrEntry = GrObj->GetEntry();
    //Handle(::GEOM_Object) HGrObj = _impl->GetObject(GrEntry);
    // add named objects
    //Handle(::GEOM_Object) anObj;
    for(int i=1; i<=SeqS.Length(); i++) {
      TopoDS_Shape aValue = SeqS.Value(i);
      //anArray = new TColStd_HArray1OfInteger(1,1);
      Standard_Integer anIndex = anIndices.FindIndex(aValue);
      //anArray->SetValue(1, anIndex);
      GOp->AddObject(GrObj,anIndex);
      //anObj = GEOM_Engine::GetEngine()->AddObject(GEOM_SUBSHAPE);
      //if (anObj.IsNull()) continue;
      //Handle(::GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
      //if (aFunction.IsNull()) continue;
      //GEOM_ISubShape aSSI(aFunction);
      //aSSI.SetMainShape(aMainShape->GetLastFunction());
      //aSSI.SetIndices(anArray);
      //aFunction->SetValue(aValue);
      //GOp->UnionIDs(GrObj, anIndex);
      //SALOMEDS::SObject_var aResultSO;
      //TCollection_AsciiString anEntry;
      //TDF_Tool::Entry(anObj->GetEntry(),anEntry);
      //GEOM::GEOM_Object_var aGObj = GetObject(anEntry.ToCString());
      //AddInStudy(aGObj._retn(), SeqN.Value(i).ToCString(), GrObj);
    }
  }
}


//============================================================================
// function : PublishNamedShapesInStudy
// purpose  :
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::
            PublishNamedShapesInStudy(//SALOMEDS::SObject_ptr theSObject,
                                      CORBA::Object_ptr theObject)
{
  //Unexpect aCatch(SALOME_SalomeException);
  GEOM::ListOfGO_var aResList = new GEOM::ListOfGO;

  //CORBA::Object_var theObject = theSObject->GetObject();
  GEOM::GEOM_Object_var theMainShape = GEOM::GEOM_Object::_narrow(theObject);
  if(theMainShape->_is_nil()) return aResList._retn();

  CORBA::String_var entry = theMainShape->GetEntry();
  Handle(::GEOM_Object) aMainShape = Handle(::GEOM_Object)::DownCast
    ( _impl->GetObject( entry ));
  if (aMainShape.IsNull()) return aResList._retn();
  TopoDS_Shape MainSh = aMainShape->GetValue();

  TDF_Label aMainLbl = aMainShape->GetEntry();
  TopTools_SequenceOfShape SolidSeqS, FaceSeqS, EdgeSeqS, VertSeqS;
  TColStd_SequenceOfAsciiString SolidSeqN, FaceSeqN, EdgeSeqN, VertSeqN;
  TDF_ChildIDIterator anIt(aMainLbl, TNaming_NamedShape::GetID(), Standard_True);
  for(; anIt.More(); anIt.Next()) {
    Handle(TNaming_NamedShape) anAttr =
      Handle(TNaming_NamedShape)::DownCast(anIt.Value());
    if(anAttr.IsNull()) continue;
    TopoDS_Shape S = anAttr->Get();
    TDF_Label L = anAttr->Label();
    //if(S.IsEqual(MainSh)) continue;
    Handle(TDataStd_Name) aName;
    if(L.FindAttribute(TDataStd_Name::GetID(),aName)) {
      TCollection_ExtendedString EName = aName->Get();
      if(S.ShapeType()==TopAbs_SOLID) {
        SolidSeqS.Append(S);
        SolidSeqN.Append(aName->Get());
      }
      else if(S.ShapeType()==TopAbs_FACE) {
        FaceSeqS.Append(S);
        FaceSeqN.Append(aName->Get());
      }
      else if(S.ShapeType()==TopAbs_EDGE) {
        EdgeSeqS.Append(S);
        EdgeSeqN.Append(aName->Get());
      }
      else if(S.ShapeType()==TopAbs_VERTEX) {
        VertSeqS.Append(S);
        VertSeqN.Append(aName->Get());
      }
    }
  }

  TopTools_IndexedMapOfShape anIndices;
  TopExp::MapShapes(MainSh, anIndices);

  CreateAndPublishGroup(theMainShape, anIndices, SolidSeqS, SolidSeqN,
                        "Group_Of_Named_Solids", aResList);

  CreateAndPublishGroup(theMainShape, anIndices, FaceSeqS, FaceSeqN,
                        "Group_Of_Named_Faces", aResList);

  CreateAndPublishGroup(theMainShape, anIndices, EdgeSeqS, EdgeSeqN,
                        "Group_Of_Named_Edges", aResList);

  CreateAndPublishGroup(theMainShape, anIndices, VertSeqS, VertSeqN,
                        "Group_Of_Named_Vertices", aResList);

  return aResList._retn();
}


//============================================================================
// function : Save()
// purpose  : save OCAF/Geom document
//============================================================================
SALOMEDS::TMPFile* GEOM_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
                                    const char* theURL,
                                    bool isMultiFile) {
  SALOMEDS::TMPFile_var aStreamFile;
  // Get a temporary directory to store a file
  std::string aTmpDir = (isMultiFile)?theURL:SALOMEDS_Tool::GetTmpDir();

  // OCCT BUG: cannot save a document (in current folder)
  // if directory name is empty
  if (aTmpDir.size() == 0) {
#ifdef WIN32
    aTmpDir = ".\\";
#else
    aTmpDir = "./";
#endif
  }

  // Create a list to store names of created files
  SALOMEDS_Tool::ListOfFiles aSeq;
  aSeq.reserve(1);
  // Prepare a file name to open
  TCollection_AsciiString aNameWithExt("");
  if (isMultiFile) 
    aNameWithExt = TCollection_AsciiString((char*)(SALOMEDS_Tool::GetNameFromPath(
			  Kernel_Utils::encode(getStudyServant()->URL())).c_str()));
  aNameWithExt += TCollection_AsciiString("_GEOM.cbf");
  aSeq.push_back(CORBA::string_dup(aNameWithExt.ToCString()));
  // Build a full file name of temporary file
  TCollection_AsciiString aFullName = TCollection_AsciiString((char*)aTmpDir.c_str()) + aNameWithExt;
  // Save GEOM component in this file
  _impl->Save((char*) aFullName.ToCString());
  // Conver a file to the byte stream
  aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.c_str(), aSeq, isMultiFile);
  // Remove the created file and tmp directory
  if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq, true);

  // Return the created byte stream
  return aStreamFile._retn();
}


//============================================================================
// function : SaveASCII()
// purpose  :
//============================================================================
SALOMEDS::TMPFile* GEOM_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
                                         const char* theURL,
                                         bool isMultiFile) {
  SALOMEDS::TMPFile_var aStreamFile = Save(theComponent, theURL, isMultiFile);
  return aStreamFile._retn();
}


//============================================================================
// function : Load()
// purpose  :
//============================================================================
CORBA::Boolean GEOM_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
                                const SALOMEDS::TMPFile& theStream,
                                const char* theURL,
                                bool isMultiFile) {

  if (theStream.length() <= 9) {
    MESSAGE("The TMPFile is too short : " << theStream.length() << " bytes ");
    return false;
  }

  // Get a temporary directory for a file
  std::string aTmpDir = isMultiFile?theURL:SALOMEDS_Tool::GetTmpDir();

  // OCCT BUG: cannot load a document (from current folder)
  // if directory name is empty
  if (aTmpDir.size() == 0) {
#ifdef WIN32
    aTmpDir = ".\\";
#else
    aTmpDir = "./";
#endif
  }

  // Conver the byte stream theStream to a file and place it in tmp directory
  SALOMEDS_Tool::ListOfFiles aSeq =
    SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.c_str(), isMultiFile);

  // Prepare a file name to open
  TCollection_AsciiString aNameWithExt("");
  SALOMEDS::Study_var study = getStudyServant();

  // Get the file name.
  int         i;
  int         aLength  = aSeq.size();
  const char *aGeomSgd = "_GEOM.sgd";
  const char *aGeomcbf = "_GEOM.cbf";

  for(i = 0; i < aLength; i++) {
    std::string aName(aSeq[i]);

    if (aName.rfind(aGeomSgd) != std::string::npos ||
        aName.rfind(aGeomcbf) != std::string::npos) {
      aNameWithExt = aName.c_str();
      break;
    }
  }

  TCollection_AsciiString aFullName = (TCollection_AsciiString((char*)aTmpDir.c_str()) + aNameWithExt);

  // Open document
  if (!_impl->Load((char*) aFullName.ToCString())) return false;

  // Remove the created file and tmp directory
  if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq, true);

  // creation of tree nodes for all data objects in the study
  // to support tree representation customization and drag-n-drop:
  SALOMEDS::UseCaseBuilder_wrap useCaseBuilder = study->GetUseCaseBuilder();
  if ( !useCaseBuilder->IsUseCaseNode( theComponent ) ) {
    useCaseBuilder->SetRootCurrent();
    useCaseBuilder->Append( theComponent ); // component object is added as the top level item
  }

  SALOMEDS::ChildIterator_wrap it = study->NewChildIterator( theComponent );
  for ( it->InitEx(true); it->More(); it->Next() ) {
    if ( !useCaseBuilder->IsUseCaseNode( it->Value() ) ) {
      useCaseBuilder->AppendTo( it->Value()->GetFather(), it->Value() );
    }
  }

  return true;
}


//============================================================================
// function : LoadASCII()
// purpose  :
//============================================================================
CORBA::Boolean GEOM_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
                                     const SALOMEDS::TMPFile& theStream,
                                     const char* theURL,
                                     bool isMultiFile) {
  return Load(theComponent, theStream, theURL, isMultiFile);
}


//============================================================================
// function : Close()
// purpose  :
//============================================================================
void GEOM_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
{
  _impl->Close();
}

//============================================================================
// function : CanCopy()
// purpose  :
//============================================================================
CORBA::Boolean GEOM_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) {
  // Try to retrieve known by Geometry component GEOM_Object by given IOR
  SALOMEDS::GenericAttribute_var anAttr;
  if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return false;

  SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);

  CORBA::String_var aString=anIOR->Value();
  anIOR->UnRegister();
  CORBA::Object_var anObj = _orb->string_to_object(aString);
  GEOM::GEOM_Object_var anObject = GEOM::GEOM_Object::_narrow(anObj);
  // If the object is null one it can't be copied: return false
  if (anObject->_is_nil()) return false;
  return true;
}

//============================================================================
// function : CopyFrom()
// purpose  :
//============================================================================
SALOMEDS::TMPFile* GEOM_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID)
{
  // Declare a sequence of the byte to store the copied object
  SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile;

  // Try to get GEOM_Object object by given SObject
  SALOMEDS::GenericAttribute_var anAttr;
  if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return aStreamFile._retn();
  GEOM::GEOM_Object_var anObject = GEOM::GEOM_Object::_narrow
    (_orb->string_to_object(SALOMEDS::AttributeIOR::_narrow(anAttr)->Value()));
  if (anObject->_is_nil()) return aStreamFile._retn();

  aStreamFile = anObject->GetShapeStream();

  // Assign an ID  the type of  GEOM_Object
  theObjectID = anObject->GetType();

  // Return created TMPFile
  return aStreamFile._retn();
}

//============================================================================
// function : CanPaste()
// purpose  :
//============================================================================
CORBA::Boolean GEOM_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) {
  // The Geometry component can paste only objects copied by Geometry component
  // and with the object type = 1
  if (strcmp(theComponentName, ComponentDataType()) != 0) return false;
  return true;
}

//============================================================================
// function : PasteInto()
// purpose  :
//============================================================================
SALOMEDS::SObject_ptr GEOM_Gen_i::PasteInto(const SALOMEDS::TMPFile& theStream,
                                            CORBA::Long theObjectID,
                                            SALOMEDS::SObject_ptr theObject) {
  // Find the current Study and StudyBuilder
  SALOMEDS::Study_var aStudy = getStudyServant();
  SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
  SALOMEDS::UseCaseBuilder_var anUseCaseBuilder = aStudy->GetUseCaseBuilder();
  SALOMEDS::SObject_var aNewSO;
  // Retrieve a TopoDS_Shape from byte stream
  TopoDS_Shape aTopology;
  std::istringstream aStreamedBrep((char*) &theStream[0]);
  BRep_Builder aBuilder;
  try {
    BRepTools::Read(aTopology, aStreamedBrep, aBuilder);
  } catch (Standard_Failure) {
    return aNewSO._retn();
  }

  // SObject of the created shape is theObject or new Child of Component if theObject == geom component
  if (strcmp(theObject->GetFatherComponent()->GetID(),theObject->GetID()) == 0) {
    aNewSO = aStudyBuilder->NewObject(theObject);
  } else aNewSO = SALOMEDS::SObject::_duplicate(theObject);


  //Create a new GEOM_Object
  Handle(::GEOM_Object) anObj = _impl->AddObject(theObjectID);
  Handle(::GEOM_Function) aFunction = anObj->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF);
  aFunction->SetValue(aTopology);

  TCollection_AsciiString anEntry;
  TDF_Tool::Entry(anObj->GetEntry(), anEntry);
  GEOM::GEOM_BaseObject_var obj = GetObject(anEntry.ToCString());

  //Set the study entry of the published GEOM_Object
  obj->SetStudyEntry(aNewSO->GetID());

  // Add IORAttribute to the Study and set IOR of the created GEOM_Object to it
  SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aNewSO, "AttributeIOR");
  SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
  CORBA::String_var objStr = _orb->object_to_string(obj);
  anIOR->SetValue(objStr.in());
  anIOR->UnRegister();

  // add object to the use case tree
  // (to support tree representation customization and drag-n-drop)
  anUseCaseBuilder->AppendTo( aNewSO->GetFather(), aNewSO );

  // Return the created in the Study SObject
  return aNewSO._retn();
}

//============================================================================
// function : ComponentDataType()
// purpose  :
//============================================================================
char* GEOM_Gen_i::ComponentDataType()
{
  return CORBA::string_dup("GEOM");
}

//============================================================================
// function : AddInStudy
// purpose  :
//============================================================================
SALOMEDS::SObject_ptr GEOM_Gen_i::AddInStudy (GEOM::GEOM_BaseObject_ptr theObject,
                                              const char*               theName,
                                              GEOM::GEOM_BaseObject_ptr theFather)
{
  SALOMEDS::SObject_var aResultSO;
  SALOMEDS::Study_var aStudy = getStudyServant();
  if(theObject->_is_nil() || aStudy->_is_nil()) return aResultSO;

  SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
  CORBA::String_var IOR;

  if(!theFather->_is_nil()) {
    IOR = _orb->object_to_string(theFather);
    SALOMEDS::SObject_wrap aFatherSO = aStudy->FindObjectIOR(IOR.in());
    if(aFatherSO->_is_nil()) return aResultSO._retn();
    aResultSO = aStudyBuilder->NewObject(aFatherSO);
    //aStudyBuilder->Addreference(aResultSO, aResultSO);
  }

  aResultSO = PublishInStudy(aResultSO, theObject, theName);
  if(aResultSO->_is_nil()) return aResultSO._retn();

  GEOM::ListOfGBO_var aList = theObject->GetDependency();
  Standard_Integer aLength = aList->length();
  if(aLength < 1) return aResultSO._retn();

  //Publish the arguments
  TCollection_AsciiString aPrevID; // to avoid multiple references to same object
  for(Standard_Integer i = 0; i< aLength; i++) {
    GEOM::GEOM_BaseObject_var anObject = aList[i];
    if(anObject->_is_nil()) continue;
    IOR = _orb->object_to_string(anObject);
    SALOMEDS::SObject_wrap aSO =  aStudy->FindObjectIOR(IOR.in());
    if(aSO->_is_nil()) continue;
    CORBA::String_var anID = aSO->GetID();
    if ( aPrevID == anID.in() ) continue;
    aPrevID = anID.in();
    SALOMEDS::SObject_wrap aSubSO = aStudyBuilder->NewObject(aResultSO);
    aStudyBuilder->Addreference(aSubSO, aSO);
    aStudy->GetUseCaseBuilder()->AppendTo( aResultSO, aSubSO );
  }

  return aResultSO._retn();
}

//============================================================================
// function : RestoreSubShapesO
// purpose  : Publish sub-shapes, standing for arguments and sub-shapes of arguments.
//            To be used from python scripts out of geompy.addToStudy (non-default usage)
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreSubShapesO (GEOM::GEOM_Object_ptr   theObject,
                                               const GEOM::ListOfGO&   theArgs,
                                               GEOM::find_shape_method theFindMethod,
                                               CORBA::Boolean          theInheritFirstArg,
                                               CORBA::Boolean          theAddPrefix)
{
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  SALOMEDS::Study_var aStudy = getStudyServant();
  if (CORBA::is_nil(aStudy) || CORBA::is_nil(theObject))
    return aParts._retn();

  // find SObject in the study if it is already published
  CORBA::String_var anIORo = _orb->object_to_string(theObject);
  SALOMEDS::SObject_var aSO = aStudy->FindObjectIOR(anIORo.in());
  //PTv, IMP 0020001, The salome object <aSO>
  // is not obligatory in case of invocation from script
  // if (CORBA::is_nil(aSO))
  //  return aParts._retn();

  aParts = RestoreSubShapes(theObject, aSO, theArgs,
                            theFindMethod, theInheritFirstArg, theAddPrefix);
  if (!CORBA::is_nil(aSO)) aSO->UnRegister();
  return aParts._retn();
}

//============================================================================
// function : RestoreGivenSubShapesO
// purpose  : Publish sub-shapes, standing for arguments and sub-shapes of arguments.
//            To be used from python scripts, generated by Dump Python.
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreGivenSubShapesO (GEOM::GEOM_Object_ptr   theObject,
                                                    const GEOM::ListOfGO&   theArgs,
                                                    GEOM::find_shape_method theFindMethod,
                                                    CORBA::Boolean          theInheritFirstArg,
                                                    CORBA::Boolean          theAddPrefix)
{
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  if (CORBA::is_nil(getStudyServant()) || CORBA::is_nil(theObject))
    return aParts._retn();

  // find SObject in the study if it is already published
  CORBA::String_var anIORo = _orb->object_to_string(theObject);
  SALOMEDS::SObject_var aSO = getStudyServant()->FindObjectIOR(anIORo.in());
  //PTv, IMP 0020001, The salome object <aSO>
  // is not obligatory in case of invocation from script
  // if (CORBA::is_nil(aSO))
  //  return aParts._retn();

  aParts = RestoreGivenSubShapes(theObject, aSO, theArgs,
                                 theFindMethod, theInheritFirstArg, theAddPrefix);
  if (!CORBA::is_nil(aSO)) aSO->UnRegister();
  return aParts._retn();
}

//============================================================================
// function : RestoreSubShapesSO
// purpose  : Publish sub-shapes, standing for arguments and sub-shapes of arguments.
//            To be used from GUI and from geompy.addToStudy
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreSubShapesSO (SALOMEDS::SObject_ptr   theSObject,
                                                const GEOM::ListOfGO&   theArgs,
                                                GEOM::find_shape_method theFindMethod,
                                                CORBA::Boolean          theInheritFirstArg,
                                                CORBA::Boolean          theAddPrefix)
{
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  if (CORBA::is_nil(getStudyServant()) || CORBA::is_nil(theSObject))
    return aParts._retn();

  SALOMEDS::GenericAttribute_var anAttr;
  if (!theSObject->FindAttribute(anAttr, "AttributeIOR"))
    return aParts._retn();

  SALOMEDS::AttributeIOR_var anAttrIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
  CORBA::String_var anIORso = anAttrIOR->Value();

  // get Object from SObject
  GEOM::GEOM_Object_var anO = GEOM::GEOM_Object::_narrow(_orb->string_to_object(anIORso));
  if (CORBA::is_nil(anO))
    return aParts._retn();

  aParts = RestoreSubShapes(anO, theSObject, theArgs,
                            theFindMethod, theInheritFirstArg, theAddPrefix);
  return aParts._retn();
}

//============================================================================
// function : addToListOfGO
// purpose  : static local function
//============================================================================
static void addToListOfGO( GEOM::GEOM_Object_ptr theObject,
                           GEOM::ListOfGO& theList )
{
  const int oldLen = theList.length();
  theList.length(oldLen + 1);
  theList[ oldLen ] = GEOM::GEOM_Object::_duplicate( theObject );
}

//============================================================================
// function : addToListOfGO
// purpose  : static local function
//============================================================================
static void addToListOfGO( const GEOM::ListOfGO& theSrcList,
                           GEOM::ListOfGO& theTrgList )
{
  const int oldLen = theTrgList.length();
  const int srcLen = theSrcList.length();
  theTrgList.length(oldLen + srcLen);
  for( int i = 0; i < srcLen; i++ )
    theTrgList[ oldLen + i ] = GEOM::GEOM_Object::_duplicate( theSrcList[ i ] );
}

//============================================================================
// function : RestoreSubShapes
// purpose  : Private method. Works only if both theObject and theSObject
//            are defined, and does not check, if they correspond to each other.
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreSubShapes(GEOM::GEOM_Object_ptr   theObject,
                                             SALOMEDS::SObject_ptr   theSObject,
                                             const GEOM::ListOfGO&   theArgs,
                                             GEOM::find_shape_method theFindMethod,
                                             CORBA::Boolean          theInheritFirstArg,
                                             CORBA::Boolean          theAddPrefix)
{
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  SALOMEDS::Study_var aStudy = getStudyServant();
  //PTv, IMP 0020001, The salome object <theSObject>
  //     is not obligatory in case of invocation from script
  if (CORBA::is_nil(aStudy) || CORBA::is_nil(theObject) /*|| CORBA::is_nil(theSObject)*/)
    return aParts._retn();

  // For Dump Python (mantis issue 0020768)
  GEOM::ListOfGO_var anOutArgs = new GEOM::ListOfGO;

  // Arguments to be published
  GEOM::ListOfGO_var aList;

  // If theArgs list is empty, we try to publish all arguments,
  // otherwise publish only passed args
  Standard_Integer nbArgsActual = -1; // -1 means unknown
  Standard_Integer aLength = theArgs.length();
  if (aLength > 0) {
    aList = new GEOM::ListOfGO;
    aList->length(aLength);
    for (int i = 0; i < aLength; i++) {
      aList[i] = GEOM::GEOM_Object::_duplicate( theArgs[i] );
    }
  }
  else {
    // Get all arguments
    GEOM::ListOfGBO_var boList = theObject->GetDependency();
    aLength = boList->length();
    aList = new GEOM::ListOfGO;
    aList->length(aLength);
    for (int i = 0; i < aLength; i++)
      aList[i] = GEOM::GEOM_Object::_narrow( boList[i] );
    nbArgsActual = aLength;
  }

  if (aLength < 1)
    return aParts._retn();

  if (theInheritFirstArg || (nbArgsActual == 1)) {
    // Do not publish argument's reflection,
    // but only reconstruct its published sub-shapes

    CORBA::String_var anIOR = _orb->object_to_string(aList[0]);
    SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());

    // remember restored objects for Python Dump
    addToListOfGO(aList[0], anOutArgs);

    aParts = RestoreSubShapesOneLevel(anArgSO, theSObject, theObject,
                                      anOutArgs, theFindMethod, theAddPrefix);

    // set the color of the transformed shape to the color of initial shape
    theObject->SetColor(aList[0]->GetColor());
    // set the texture
    if (theObject->GetShapeType() == GEOM::VERTEX) {
      theObject->SetMarkerStd(aList[0]->GetMarkerType(), aList[0]->GetMarkerSize());
      if (aList[0]->GetMarkerType() == GEOM::MT_USER)
        theObject->SetMarkerTexture(aList[0]->GetMarkerTexture());
    }
    if (!CORBA::is_nil(anArgSO))
      anArgSO->UnRegister();
  }
  else {
    // Get interface, containing method, which we will use to reconstruct sub-shapes
    GEOM::GEOM_IShapesOperations_var  aShapesOp = GetIShapesOperations();
    GEOM::GEOM_IGroupOperations_var    aGroupOp = GetIGroupOperations();
    GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations();

    PortableServer::Servant aServant = _poa->reference_to_servant(aTrsfOp.in());
    GEOM_ITransformOperations_i*      aTrsfOpSv = dynamic_cast<GEOM_ITransformOperations_i*>(aServant);

    // Reconstruct arguments and tree of sub-shapes of the arguments
    CORBA::String_var anIOR;
    SALOMEDS::StudyBuilder_var      aStudyBuilder = aStudy->NewBuilder();
    SALOMEDS::UseCaseBuilder_wrap  useCaseBuilder = aStudy->GetUseCaseBuilder();
    for (Standard_Integer i = 0; i < aLength; i++)
    {
      GEOM::GEOM_Object_var anArgO = aList[i];
      if (!CORBA::is_nil(anArgO)) {
        anIOR = _orb->object_to_string(anArgO);
        SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());
        TCollection_AsciiString anArgName;
        if (CORBA::is_nil(anArgSO)) {
          anArgName = "arg_";
          anArgName += TCollection_AsciiString(i);
        }
        else {
          anArgName = anArgSO->GetName();
        }

        // Find a sub-shape of theObject in place of the argument
        GEOM::GEOM_Object_var aSubO;
        switch (theFindMethod) {
        case GEOM::FSM_GetInPlace:
          {
            // Use GetInPlace
            aSubO = aShapesOp->GetInPlace(theObject, anArgO);
          }
          break;
        case GEOM::FSM_MultiTransformed:
          {
            // Only for Multi-transformations
            GEOM::GEOM_Object_var anArgOTrsf = aTrsfOpSv->TransformLikeOtherCopy(anArgO, theObject);
            if (!CORBA::is_nil(anArgOTrsf)) {
              CORBA::String_var anArgOTrsfEntry = anArgOTrsf->GetEntry();
              Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
              Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
              anArgOTrsfFun->SetDescription("");
              aSubO = aShapesOp->GetInPlace(theObject, anArgOTrsf);
            }
            /*
            Handle(::GEOM_Function) anOFun = theObject->GetLastFunction();
            if (!anOFun.IsNull()) {
              CORBA::String_var entryArg = anArgO->GetEntry();
              Handle(::GEOM_Object) anArgOImpl = _impl->GetObject(entryArg);
              if (!anArgOImpl.IsNull()) {
                TopoDS_Shape anArgOShape = anArgOImpl->GetValue();
                TopoDS_Shape aMultiArgShape;
                //GEOM::GEOM_Object_var anArgOMulti; // ???
                switch (anOFun->GetType()) {
                case TRANSLATE_1D:
                  {
                    GEOMImpl_ITranslate aTI (anOFun);
                    aMultiArgShape = GEOMImpl_ITransformOperations::TranslateShape1D(anArgOShape, &aTI);
                    //anArgOMulti = aTrsfOpSv->Translate1D(anArgO, , , );
                  }
                  break;
                case TRANSLATE_2D:
                  {
                    GEOMImpl_ITranslate aTI (anOFun);
                    aMultiArgShape = GEOMImpl_ITransformOperations::TranslateShape2D(anArgOShape, &aTI);
                  }
                  break;
                case ROTATE_1D:
                  {
                    GEOMImpl_IRotate aTI (anOFun);
                    //aMultiArgShape = GEOMImpl_ITransformOperations::TranslateShape2D(anArgOShape, &aTI);
                  }
                  break;
                case ROTATE_2D:
                  {
                    GEOMImpl_IRotate aTI (anOFun);
                    //aMultiArgShape = GEOMImpl_ITransformOperations::TranslateShape2D(anArgOShape, &aTI);
                  }
                  break;
                default:
                  {}
                }
                GEOM::GEOM_Object_var anArgOMulti = (aMultiArgShape); // TODO
                Handle(::GEOM_Function) anArgOMultiFun = anArgOMulti->GetLastFunction();
                anArgOMultiFun->SetDescription("");
                aSubO = aShapesOp->GetInPlace(theObject, anArgOMulti);
              }
            }
            */
          }
          break;
        case GEOM::FSM_Transformed:
          {
            // transformation, cannot use GetInPlace, operate with indices
            GEOM::ListOfLong_var anIDs = anArgO->GetSubShapeIndices();
            if (anIDs->length() > 1) {
              // group
              aSubO = aGroupOp->CreateGroup(theObject, aGroupOp->GetType(anArgO));
              if (!CORBA::is_nil(aSubO))
                aGroupOp->UnionIDs(aSubO, anIDs);
            }
            else if (anIDs->length() > 0) {
              // single sub-shape
              aSubO = aShapesOp->GetSubShape(theObject, anIDs[0]);
            }
          }
          break;
        case GEOM::FSM_GetSame:
          {
            // Use GetSame
            aSubO = aShapesOp->GetSame(theObject, anArgO);
          }
          break;
        case GEOM::FSM_GetShapesOnShape:
          {
            // Use GetShapesOnShape. Can work only on solids, so it has sense to search only solids
            aSubO = aShapesOp->GetShapesOnShapeAsCompound(anArgO, theObject,
              (short)GEOM::SOLID, GEOM::ST_ONIN);
          }
          break;
        case GEOM::FSM_GetInPlaceByHistory:
          {
            // Use GetInPlaceByHistory
            aSubO = aShapesOp->GetInPlaceByHistory(theObject, anArgO);
          }
          break;
        default:
          {}
        }

        if (!CORBA::is_nil(aSubO)) {
          // remember restored objects for Python Dump
          addToListOfGO(anArgO, anOutArgs);

          // add to parts list
          addToListOfGO( aSubO, aParts );

          // Publish the sub-shape
          SALOMEDS::SObject_var aSubSO;
          if (!CORBA::is_nil(theSObject)) {
            TCollection_AsciiString aSubName;
            if (theAddPrefix) {
              aSubName = "from_";
            }
            aSubName += anArgName;
            aSubSO = aStudyBuilder->NewObject(theSObject);
            aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
            // Restore color
            aSubO->SetColor(anArgO->GetColor());
            // set the texture
            if (aSubO->GetShapeType() == GEOM::VERTEX) {
              aSubO->SetMarkerStd(anArgO->GetMarkerType(), anArgO->GetMarkerSize());
              if (anArgO->GetMarkerType() == GEOM::MT_USER)
                aSubO->SetMarkerTexture(anArgO->GetMarkerTexture());
            }
          }

          if (!CORBA::is_nil(anArgSO)) {
            // Restore published sub-shapes of the argument
            GEOM::ListOfGO_var aSubParts;
            if (theFindMethod == GEOM::FSM_GetInPlaceByHistory)
              // pass theObject, because only it has the history
              aSubParts = RestoreSubShapesOneLevel(anArgSO, aSubSO,
                                                   theObject, anOutArgs, theFindMethod, theAddPrefix);
            else
              aSubParts = RestoreSubShapesOneLevel(anArgSO, aSubSO,
                                                   aSubO, anOutArgs, theFindMethod, theAddPrefix);
            // add to parts list
            addToListOfGO( aSubParts, aParts );
          }
        }
        else { // GetInPlace failed, try to build from published parts
          if (!CORBA::is_nil(anArgSO)) {
            SALOMEDS::SObject_var aSubSO;
            if (!CORBA::is_nil(theSObject))
            {
              aSubSO = aStudyBuilder->NewObject(theSObject);
              useCaseBuilder->AppendTo( theSObject, aSubSO );
            }

            // Restore published sub-shapes of the argument
            GEOM::ListOfGO_var aSubParts =
              RestoreSubShapesOneLevel(anArgSO, aSubSO,
                                       theObject, anOutArgs, theFindMethod, theAddPrefix);

            // add to parts list
            addToListOfGO( aSubParts, aParts );

            if (aSubParts->length() > 0) {
              // remember restored objects for Python Dump
              addToListOfGO(anArgO, anOutArgs);

              // try to build an argument from a set of its sub-shapes,
              // that published and will be reconstructed
              if (aSubParts->length() > 1) {
                aSubO = aShapesOp->MakeCompound(aSubParts);
                // add to parts list
                addToListOfGO( aSubO, aParts );
              }
              else {
                aSubO = aSubParts[0];
              }
              if (!CORBA::is_nil(aSubO) && !CORBA::is_nil(aSubSO)) {
                // Publish the sub-shape
                TCollection_AsciiString aSubName;
                if (theAddPrefix) {
                  aSubName = "from_parts_of_";
                }
                aSubName += anArgName;
                aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
                // Restore color
                aSubO->SetColor(anArgO->GetColor());
                // set the texture
                if (aSubO->GetShapeType() == GEOM::VERTEX) {
                  aSubO->SetMarkerStd(anArgO->GetMarkerType(), anArgO->GetMarkerSize());
                  if (anArgO->GetMarkerType() == GEOM::MT_USER)
                    aSubO->SetMarkerTexture(anArgO->GetMarkerTexture());
                }
              }
            }
            else if (!CORBA::is_nil(aSubSO)) {
              // remove created aSubSO, because no parts have been found
              aStudyBuilder->RemoveObject(aSubSO);
            }
          }
        } // try to build from published parts
    	if (!CORBA::is_nil(anArgSO))
          anArgSO->UnRegister();
      }
    } // process arguments
  }
  std::set<std::string> anObjEntryMap;
  GEOM::ListOfGO_var aResParts = new GEOM::ListOfGO;
  int nbRes = 0;
  int nb = aParts->length();
  aResParts->length(nb);
  if (nb > 0)
  {
    Handle(::GEOM_BaseObject) aMainObj = _impl->GetObject(theObject->GetEntry());
    Handle(::GEOM_Function) aFunction = aMainObj->GetLastFunction();
    GEOM::TPythonDump pd (aFunction, true);
    pd <<"[";
    int i = 0, j = 0;
    for ( ; i < nb; i++ )
    {
      GEOM::GEOM_Object_var anObj = GEOM::GEOM_Object::_duplicate( aParts[ i ] );
      if (CORBA::is_nil(anObj))
        continue;
      char* anEntry = anObj->GetEntry();
      if (anObjEntryMap.count(anEntry))
        continue; // already treated
      anObjEntryMap.insert(anEntry);
      aResParts[nbRes++] = anObj;
      // clear python dump of object
      Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anEntry);
      Handle(::GEOM_Function)   anObjFun = aGeomObj->GetLastFunction();
      if ( !anObjFun.IsNull() )
        anObjFun->SetDescription( "" );
      if ( j > 0 )
        pd << ", ";
      pd << aGeomObj;
      j++;
    }
    pd <<"]" << " = geompy.RestoreGivenSubShapes(" << aMainObj << ", " << "[";
    //i = 0; nb = theArgs.length(); j = 0;
    i = 0; nb = anOutArgs->length(); j = 0;
    for ( ; i < nb; i++ )
    {
      //GEOM::GEOM_Object_var anObj = theArgs[ i ];
      GEOM::GEOM_Object_var anObj = anOutArgs[ i ];
      if (CORBA::is_nil(anObj))
        continue;
      Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetEntry());
      if ( j > 0 )
        pd << ", ";
      pd << aGeomObj;
      j++;
    }
    pd <<"]" << ", " <<"GEOM.";
    switch (theFindMethod) {
    case GEOM::FSM_GetInPlace:
      pd << "FSM_GetInPlace"; break;
    case GEOM::FSM_MultiTransformed:
      pd << "FSM_MultiTransformed"; break;
    case GEOM::FSM_Transformed:
      pd << "FSM_Transformed"; break;
    case GEOM::FSM_GetSame:
      pd << "FSM_GetSame"; break;
    case GEOM::FSM_GetShapesOnShape:
      pd << "FSM_GetShapesOnShape"; break;
    case GEOM::FSM_GetInPlaceByHistory:
    default:
      pd << "FSM_GetInPlaceByHistory"; break;
    }
    pd << ", " << theInheritFirstArg << ", " << theAddPrefix << ")";
  }
  aResParts->length(nbRes);
  return aResParts._retn();
}

//============================================================================
// function : RestoreSubShapesOneLevel
// purpose  : Private method
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreSubShapesOneLevel (SALOMEDS::SObject_ptr   theOldSO,
                                                      SALOMEDS::SObject_ptr   theNewSO,
                                                      GEOM::GEOM_Object_ptr   theNewO,
                                                      GEOM::ListOfGO&         theOutArgs,
                                                      GEOM::find_shape_method theFindMethod,
                                                      CORBA::Boolean          theAddPrefix)
{
  int i = 0;
  SALOMEDS::Study_var aStudy = getStudyServant();
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  GEOM::ListOfGO_var aNewParts = new GEOM::ListOfGO;
  if (CORBA::is_nil(aStudy) || CORBA::is_nil(theOldSO) ||
      CORBA::is_nil(theNewO) /*|| CORBA::is_nil(theNewSO)*/)
    return aParts._retn();

  SALOMEDS::StudyBuilder_var     aStudyBuilder = aStudy->NewBuilder();
  SALOMEDS::UseCaseBuilder_wrap useCaseBuilder = aStudy->GetUseCaseBuilder();

  // Get interface, containing method, which we will use to reconstruct sub-shapes
  GEOM::GEOM_IShapesOperations_var  aShapesOp = GetIShapesOperations();
  GEOM::GEOM_IGroupOperations_var    aGroupOp = GetIGroupOperations();
  GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations();

  PortableServer::Servant aServant = _poa->reference_to_servant(aTrsfOp.in());
  GEOM_ITransformOperations_i*      aTrsfOpSv = dynamic_cast<GEOM_ITransformOperations_i*>(aServant);

  // Reconstruct published sub-shapes
  SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(theOldSO);

  int aLen = 0;
  for (it->Init(); it->More(); it->Next()) {
    aLen++;
  }
  aParts->length(aLen);

  for (it->Init(); it->More(); it->Next()) {
    SALOMEDS::SObject_var anOldSubSO = it->Value();

    TCollection_AsciiString anArgName = anOldSubSO->GetName();

    SALOMEDS::GenericAttribute_var anAttr;
    if (anOldSubSO->FindAttribute(anAttr, "AttributeIOR")) {
      SALOMEDS::AttributeIOR_var anAttrIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
      GEOM::GEOM_Object_var anOldSubO =
        GEOM::GEOM_Object::_narrow(_orb->string_to_object(anAttrIOR->Value()));
      if (!CORBA::is_nil(anOldSubO)) {
        // Find a sub-shape of theNewO in place of anOldSubO
        GEOM::GEOM_Object_var aNewSubO;
        switch (theFindMethod) {
        case GEOM::FSM_GetInPlace:
          {
            // Use GetInPlace
            aNewSubO = aShapesOp->GetInPlace(theNewO, anOldSubO);
          }
          break;
        case GEOM::FSM_MultiTransformed:
          {
            // Only for Multi-transformations
            GEOM::GEOM_Object_var anArgOTrsf = aTrsfOpSv->TransformLikeOtherCopy(anOldSubO, theNewO);
            if (!CORBA::is_nil(anArgOTrsf)) {
              CORBA::String_var anArgOTrsfEntry = anArgOTrsf->GetEntry();
              Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
              Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
              anArgOTrsfFun->SetDescription("");
              aNewSubO = aShapesOp->GetInPlace(theNewO, anArgOTrsf);
            }
          }
          break;
        case GEOM::FSM_Transformed:
          {
            // transformation, cannot use GetInPlace, operate with indices
            GEOM::ListOfLong_var anIDs = anOldSubO->GetSubShapeIndices();
            if (anIDs->length() > 1) {
              // group
              aNewSubO = aGroupOp->CreateGroup(theNewO, aGroupOp->GetType(anOldSubO));
              if (!CORBA::is_nil(aNewSubO))
                aGroupOp->UnionIDs(aNewSubO, anIDs);
            }
            else {
              // single sub-shape
              aNewSubO = aShapesOp->GetSubShape(theNewO, anIDs[0]);
            }
          }
          break;
        case GEOM::FSM_GetSame:
          {
            // Use GetSame
            aNewSubO = aShapesOp->GetSame(theNewO, anOldSubO);
          }
          break;
        case GEOM::FSM_GetShapesOnShape:
          {
            // Use GetShapesOnShape. Can work only on solids, so it has sense to search only solids
            aNewSubO = aShapesOp->GetShapesOnShapeAsCompound(anOldSubO, theNewO,
                                                             (short)GEOM::SOLID, GEOM::ST_ONIN);
          }
          break;
        case GEOM::FSM_GetInPlaceByHistory:
          {
            // Use GetInPlaceByHistory
            aNewSubO = aShapesOp->GetInPlaceByHistory(theNewO, anOldSubO);
          }
          break;
        default:
          {}
        }

        if (!CORBA::is_nil(aNewSubO)) {
          // remember restored objects for Python Dump
          addToListOfGO(anOldSubO, theOutArgs);

          // add the part to the list
          aParts[i] = aNewSubO;
          i++;
          // add to parts list
          addToListOfGO( aNewSubO, aNewParts );

          SALOMEDS::SObject_var aNewSubSO;
          if (!CORBA::is_nil(theNewSO)) {
              // Publish the sub-shape
            TCollection_AsciiString aSubName;
            if (theAddPrefix) {
              aSubName = "from_";
            }
            aSubName += anArgName;
            aNewSubSO = aStudyBuilder->NewObject(theNewSO);
            aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
            // Restore color
            aNewSubO->SetColor(anOldSubO->GetColor());
            // set the texture
            if (aNewSubO->GetShapeType() == GEOM::VERTEX) {
              aNewSubO->SetMarkerStd(anOldSubO->GetMarkerType(), anOldSubO->GetMarkerSize());
              if (anOldSubO->GetMarkerType() == GEOM::MT_USER)
                aNewSubO->SetMarkerTexture(anOldSubO->GetMarkerTexture());
            }
            // reference to arg
            SALOMEDS::SObject_wrap aReferenceSO = aStudyBuilder->NewObject( aNewSubSO );
            aStudyBuilder->Addreference( aReferenceSO, anOldSubSO );
            useCaseBuilder->AppendTo( theNewSO, aReferenceSO );
          }
          // Restore published sub-shapes of the argument
          GEOM::ListOfGO_var aSubParts;
          if (theFindMethod == GEOM::FSM_GetInPlaceByHistory)
            // pass the main shape as Object, because only it has the history
            aSubParts = RestoreSubShapesOneLevel(anOldSubSO, aNewSubSO,
                                                 theNewO, theOutArgs, theFindMethod, theAddPrefix);
          else
            aSubParts = RestoreSubShapesOneLevel(anOldSubSO, aNewSubSO,
                                                 aNewSubO, theOutArgs, theFindMethod, theAddPrefix);
          // add to parts list
          addToListOfGO( aSubParts, aNewParts );
        }
        else { // GetInPlace failed, try to build from published parts
          SALOMEDS::SObject_var aNewSubSO;
          if (!CORBA::is_nil(theNewSO))
          {
            aNewSubSO = aStudyBuilder->NewObject(theNewSO);
            useCaseBuilder->AppendTo( theNewSO, aNewSubSO );
          }
          // Restore published sub-shapes of the argument
          GEOM::ListOfGO_var aSubParts =
            RestoreSubShapesOneLevel(anOldSubSO, aNewSubSO,
                                     theNewO, theOutArgs, theFindMethod, theAddPrefix);
          // add to parts list
          addToListOfGO( aSubParts, aNewParts );

          if (aSubParts->length() > 0) {
            // remember restored objects for Python Dump
            addToListOfGO(anOldSubO, theOutArgs);

            // try to build an object from a set of its sub-shapes,
            // that published and will be reconstructed
            if (aSubParts->length() > 1) {
              aNewSubO = aShapesOp->MakeCompound(aSubParts);
              // add to parts list
              addToListOfGO( aNewSubO, aNewParts );
            }
            else {
              aNewSubO = aSubParts[0];
            }

            if (!CORBA::is_nil(aNewSubO)) {
              // add the part to the list
              aSubParts[i] = aNewSubO;
              i++;

              // Publish the sub-shape
              if (!CORBA::is_nil(aNewSubSO)) {
                TCollection_AsciiString aSubName;
                if (theAddPrefix) {
                  aSubName = "from_parts_of_";
                }
                aSubName += anArgName;
                aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
                // Restore color
                aNewSubO->SetColor(anOldSubO->GetColor());
                // set the texture
                if (aNewSubO->GetShapeType() == GEOM::VERTEX) {
                  aNewSubO->SetMarkerStd(anOldSubO->GetMarkerType(), anOldSubO->GetMarkerSize());
                  if (anOldSubO->GetMarkerType() == GEOM::MT_USER)
                    aNewSubO->SetMarkerTexture(anOldSubO->GetMarkerTexture());
                }
              }
            }
          }
          else if (!CORBA::is_nil(aNewSubSO)) {
            // remove created aSubSO, because no parts have been found
            aStudyBuilder->RemoveObject(aNewSubSO);
          }
        } // try to build from published parts
      }
    }
  } // iterate on published sub-shapes

  aParts->length(i);
  // add to parts list
  addToListOfGO( aNewParts, aParts );
  return aParts._retn();
}

//============================================================================
// function : RestoreGivenSubShapes
// purpose  : Private method. Works only if both theObject and theSObject
//            are defined, and does not check, if they correspond to each other.
//            List theArgs in this case contains not only operation arguments,
//            but also all subshapes, which must be published.
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreGivenSubShapes(GEOM::GEOM_Object_ptr   theObject,
                                                  SALOMEDS::SObject_ptr   theSObject,
                                                  const GEOM::ListOfGO&   theArgs,
                                                  GEOM::find_shape_method theFindMethod,
                                                  CORBA::Boolean          theInheritFirstArg,
                                                  CORBA::Boolean          theAddPrefix)
{
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  SALOMEDS::Study_var aStudy = getStudyServant();
  //PTv, IMP 0020001, The salome object <theSObject>
  //     is not obligatory in case of invocation from script
  if (CORBA::is_nil(aStudy) || CORBA::is_nil(theObject) /*|| CORBA::is_nil(theSObject)*/)
    return aParts._retn();

  // If theArgs list is empty, nothing to do
  Standard_Integer aLength = theArgs.length();
  if (aLength == 0)
    return aParts._retn();

  // Get all arguments
  GEOM::ListOfGBO_var anOpArgsList = theObject->GetDependency();
  Standard_Integer    nbOpArgs     = anOpArgsList->length();
  Standard_Integer    nbArgsActual = nbOpArgs;

  // If anOpArgsList list is empty, nothing to do
  if (nbArgsActual == 0)
    return aParts._retn();

  // Entries of arguments and subshapes
  std::set<std::string> anArgs;
  for (int i = 0; i < aLength; i++) {
    CORBA::String_var anEntry = theArgs[i]->GetEntry();
    anArgs.insert(anEntry.in());
  }

  // Arguments to be published
  // We try to publish all arguments, that are in theArgs list
  GEOM::ListOfGO_var aList = new GEOM::ListOfGO;
  aList->length(nbArgsActual);

  int k = 0;
  for (int j = 0; j < nbArgsActual; j++) {
    CORBA::String_var anEntry = anOpArgsList[j]->GetEntry();
    if (anArgs.count(anEntry.in())) {
      aList[k] = GEOM::GEOM_Object::_narrow(anOpArgsList[j]);
      k++;
    }
  }
  nbArgsActual = k;
  //aList->length(nbArgsActual);

  if (nbArgsActual < 1)
    return aParts._retn();

  if (theInheritFirstArg || (nbOpArgs == 1)) {
    // Do not publish argument's reflection,
    // but only reconstruct its published sub-shapes

    CORBA::String_var anIOR = _orb->object_to_string(aList[0]);
    SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());

    aParts = RestoreGivenSubShapesOneLevel(anArgSO, theSObject, theObject,
                                           anArgs, theFindMethod, theAddPrefix);

    // set the color of the transformed shape to the color of initial shape
    theObject->SetColor(aList[0]->GetColor());
    // set the texture
    if (theObject->GetShapeType() == GEOM::VERTEX) {
      theObject->SetMarkerStd(aList[0]->GetMarkerType(), aList[0]->GetMarkerSize());
      if (aList[0]->GetMarkerType() == GEOM::MT_USER)
        theObject->SetMarkerTexture(aList[0]->GetMarkerTexture());
    }

    anArgSO->UnRegister();
  }
  else {
    // Get interface, containing method, which we will use to reconstruct sub-shapes
    GEOM::GEOM_IShapesOperations_var  aShapesOp = GetIShapesOperations();
    GEOM::GEOM_IGroupOperations_var    aGroupOp = GetIGroupOperations();
    GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations();

    PortableServer::Servant aServant = _poa->reference_to_servant(aTrsfOp.in());
    GEOM_ITransformOperations_i*      aTrsfOpSv = dynamic_cast<GEOM_ITransformOperations_i*>(aServant);

    // Reconstruct arguments and tree of sub-shapes of the arguments
    CORBA::String_var anIOR;
    SALOMEDS::StudyBuilder_var      aStudyBuilder = aStudy->NewBuilder();
    SALOMEDS::UseCaseBuilder_wrap  useCaseBuilder = aStudy->GetUseCaseBuilder();
    for (Standard_Integer i = 0; i < nbArgsActual; i++)
    {
      GEOM::GEOM_Object_var anArgO = aList[i];
      if (!CORBA::is_nil(anArgO)) {
        anIOR = _orb->object_to_string(anArgO);
        SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());
        TCollection_AsciiString anArgName;
        if (CORBA::is_nil(anArgSO)) {
          anArgName = "arg_";
          anArgName += TCollection_AsciiString(i);
        }
        else {
          anArgName = anArgSO->GetName();
        }

        // Find a sub-shape of theObject in place of the argument
        GEOM::GEOM_Object_var aSubO;
        switch (theFindMethod) {
        case GEOM::FSM_GetInPlace:
          {
            // Use GetInPlace
            aSubO = aShapesOp->GetInPlace(theObject, anArgO);
          }
          break;
        case GEOM::FSM_MultiTransformed:
          {
            // Only for Multi-transformations
            GEOM::GEOM_Object_var anArgOTrsf = aTrsfOpSv->TransformLikeOtherCopy(anArgO, theObject);
            if (!CORBA::is_nil(anArgOTrsf)) {
              CORBA::String_var anArgOTrsfEntry = anArgOTrsf->GetEntry();
              Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
              Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
              anArgOTrsfFun->SetDescription("");
              aSubO = aShapesOp->GetInPlace(theObject, anArgOTrsf);
            }
          }
          break;
        case GEOM::FSM_Transformed:
          {
            // transformation, cannot use GetInPlace, operate with indices
            GEOM::ListOfLong_var anIDs = anArgO->GetSubShapeIndices();
            if (anIDs->length() > 1) {
              // group
              aSubO = aGroupOp->CreateGroup(theObject, aGroupOp->GetType(anArgO));
              if (!CORBA::is_nil(aSubO))
                aGroupOp->UnionIDs(aSubO, anIDs);
            }
            else if (anIDs->length() > 0) {
              // single sub-shape
              aSubO = aShapesOp->GetSubShape(theObject, anIDs[0]);
            }
          }
          break;
        case GEOM::FSM_GetSame:
          {
            // Use GetSame
            aSubO = aShapesOp->GetSame(theObject, anArgO);
          }
          break;
        case GEOM::FSM_GetShapesOnShape:
          {
            // Use GetShapesOnShape. Can work only on solids, so it has sense to search only solids
            aSubO = aShapesOp->GetShapesOnShapeAsCompound(anArgO, theObject,
              (short)GEOM::SOLID, GEOM::ST_ONIN);
          }
          break;
        case GEOM::FSM_GetInPlaceByHistory:
          {
            // Use GetInPlaceByHistory
            aSubO = aShapesOp->GetInPlaceByHistory(theObject, anArgO);
          }
          break;
        default:
          {}
        }

        if (!CORBA::is_nil(aSubO)) {
          // add to parts list
          addToListOfGO( aSubO, aParts );

          // Publish the sub-shape
          SALOMEDS::SObject_var aSubSO;
          if (!CORBA::is_nil(theSObject)) {
            TCollection_AsciiString aSubName;
            if (theAddPrefix) {
              aSubName = "from_";
            }
            aSubName += anArgName;
            aSubSO = aStudyBuilder->NewObject(theSObject);
            aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
            // Restore color
            aSubO->SetColor(anArgO->GetColor());
            // set the texture
            if (aSubO->GetShapeType() == GEOM::VERTEX) {
              aSubO->SetMarkerStd(anArgO->GetMarkerType(), anArgO->GetMarkerSize());
              if (anArgO->GetMarkerType() == GEOM::MT_USER)
                aSubO->SetMarkerTexture(anArgO->GetMarkerTexture());
            }
          }

          if (!CORBA::is_nil(anArgSO)) {
            // Restore published sub-shapes of the argument
            GEOM::ListOfGO_var aSubParts;
            if (theFindMethod == GEOM::FSM_GetInPlaceByHistory)
              // pass theObject, because only it has the history
              aSubParts = RestoreGivenSubShapesOneLevel(anArgSO, aSubSO,
                                                        theObject, anArgs, theFindMethod, theAddPrefix);
            else
              aSubParts = RestoreGivenSubShapesOneLevel(anArgSO, aSubSO,
                                                        aSubO, anArgs, theFindMethod, theAddPrefix);
            // add to parts list
            addToListOfGO( aSubParts, aParts );
          }
        }
        else { // GetInPlace failed, try to build from published parts
          if (!CORBA::is_nil(anArgSO)) {
            SALOMEDS::SObject_var aSubSO;
            if (!CORBA::is_nil(theSObject))
            {
              aSubSO = aStudyBuilder->NewObject(theSObject);
              useCaseBuilder->AppendTo( theSObject, aSubSO );
            }
            // Restore published sub-shapes of the argument
            GEOM::ListOfGO_var aSubParts =
              RestoreGivenSubShapesOneLevel(anArgSO, aSubSO,
                                            theObject, anArgs, theFindMethod, theAddPrefix);

            // add to parts list
            addToListOfGO( aSubParts, aParts );

            if (aSubParts->length() > 0) {
              // try to build an argument from a set of its sub-shapes,
              // that published and will be reconstructed
              if (aSubParts->length() > 1) {
                aSubO = aShapesOp->MakeCompound(aSubParts);
                // add to parts list
                addToListOfGO( aSubO, aParts );
              }
              else {
                aSubO = aSubParts[0];
              }
              if (!CORBA::is_nil(aSubO) && !CORBA::is_nil(aSubSO)) {
                // Publish the sub-shape
                TCollection_AsciiString aSubName;
                if (theAddPrefix) {
                  aSubName = "from_parts_of_";
                }
                aSubName += anArgName;
                aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
                // Restore color
                aSubO->SetColor(anArgO->GetColor());
                // set the texture
                if (aSubO->GetShapeType() == GEOM::VERTEX) {
                  aSubO->SetMarkerStd(anArgO->GetMarkerType(), anArgO->GetMarkerSize());
                  if (anArgO->GetMarkerType() == GEOM::MT_USER)
                    aSubO->SetMarkerTexture(anArgO->GetMarkerTexture());
                }
              }
            }
            else if (!CORBA::is_nil(aSubSO)) {
              // remove created aSubSO, because no parts have been found
              aStudyBuilder->RemoveObject(aSubSO);
            }
          }
        } // try to build from published parts
        anArgSO->UnRegister();
      }
    } // process arguments
  }
  std::set<std::string> anObjEntryMap;
  GEOM::ListOfGO_var aResParts = new GEOM::ListOfGO;
  int nbRes = 0;
  int nb = aParts->length();
  aResParts->length(nb);
  if (nb > 0)
  {
    Handle(::GEOM_BaseObject) aMainObj = _impl->GetObject(theObject->GetEntry());
    Handle(::GEOM_Function) aFunction = aMainObj->GetLastFunction();
    GEOM::TPythonDump pd (aFunction, true);
    pd <<"[";
    int i = 0, j = 0;
    for ( ; i < nb; i++ )
    {
      GEOM::GEOM_Object_var anObj = GEOM::GEOM_Object::_duplicate( aParts[ i ] );
      if (CORBA::is_nil(anObj))
        continue;
      char* anEntry = anObj->GetEntry();
      if (anObjEntryMap.count(anEntry))
        continue; // already treated
      anObjEntryMap.insert(anEntry);
      aResParts[nbRes++] = anObj;
      // clear python dump of object
      Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anEntry);
      Handle(::GEOM_Function)   anObjFun = aGeomObj->GetLastFunction();
      if ( !anObjFun.IsNull() )
        anObjFun->SetDescription( "" );
      if ( j > 0 )
        pd << ", ";
      pd << aGeomObj;
      j++;
    }
    pd <<"]" << " = geompy.RestoreGivenSubShapes(" << aMainObj << ", " << "[";
    i = 0; nb = theArgs.length(); j = 0;
    for ( ; i < nb; i++ )
    {
      GEOM::GEOM_Object_var anObj = theArgs[ i ];
      if (CORBA::is_nil(anObj))
        continue;
      Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetEntry());
      if ( j > 0 )
        pd << ", ";
      pd << aGeomObj;
      j++;
    }
    pd <<"]" << ", " <<"GEOM.";
    switch (theFindMethod) {
    case GEOM::FSM_GetInPlace:
      pd << "FSM_GetInPlace"; break;
    case GEOM::FSM_MultiTransformed:
      pd << "FSM_MultiTransformed"; break;
    case GEOM::FSM_Transformed:
      pd << "FSM_Transformed"; break;
    case GEOM::FSM_GetSame:
      pd << "FSM_GetSame"; break;
    case GEOM::FSM_GetShapesOnShape:
      pd << "FSM_GetShapesOnShape"; break;
    case GEOM::FSM_GetInPlaceByHistory:
    default:
      pd << "FSM_GetInPlaceByHistory"; break;
    }
    pd << ", " << theInheritFirstArg << ", " << theAddPrefix << ")";
  }
  aResParts->length(nbRes);
  return aResParts._retn();
}

//============================================================================
// function : RestoreGivenSubShapesOneLevel
// purpose  : Private method
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::RestoreGivenSubShapesOneLevel (SALOMEDS::SObject_ptr   theOldSO,
                                                           SALOMEDS::SObject_ptr   theNewSO,
                                                           GEOM::GEOM_Object_ptr   theNewO,
                                                           std::set<std::string>   theArgs,
                                                           GEOM::find_shape_method theFindMethod,
                                                           CORBA::Boolean          theAddPrefix)
{
  int i = 0;
  SALOMEDS::Study_var aStudy = getStudyServant();
  GEOM::ListOfGO_var aParts = new GEOM::ListOfGO;
  GEOM::ListOfGO_var aNewParts = new GEOM::ListOfGO;
  if (CORBA::is_nil(aStudy) || CORBA::is_nil(theOldSO) ||
      CORBA::is_nil(theNewO) /*|| CORBA::is_nil(theNewSO)*/)
    return aParts._retn();

  SALOMEDS::StudyBuilder_var      aStudyBuilder = aStudy->NewBuilder();
  SALOMEDS::UseCaseBuilder_wrap  useCaseBuilder = aStudy->GetUseCaseBuilder();

  // Get interface, containing method, which we will use to reconstruct sub-shapes
  GEOM::GEOM_IShapesOperations_var  aShapesOp = GetIShapesOperations();
  GEOM::GEOM_IGroupOperations_var    aGroupOp = GetIGroupOperations();
  GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations();

  PortableServer::Servant aServant = _poa->reference_to_servant(aTrsfOp.in());
  GEOM_ITransformOperations_i*      aTrsfOpSv = dynamic_cast<GEOM_ITransformOperations_i*>(aServant);

  // Reconstruct published sub-shapes
  SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(theOldSO);

  int aLen = 0;
  for (it->Init(); it->More(); it->Next()) {
    aLen++;
  }
  aParts->length(aLen);

  for (it->Init(); it->More(); it->Next()) {
    SALOMEDS::SObject_var anOldSubSO = it->Value();

    TCollection_AsciiString anArgName = anOldSubSO->GetName();

    SALOMEDS::GenericAttribute_var anAttr;
    if (anOldSubSO->FindAttribute(anAttr, "AttributeIOR")) {
      SALOMEDS::AttributeIOR_var anAttrIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
      GEOM::GEOM_Object_var anOldSubO =
        GEOM::GEOM_Object::_narrow(_orb->string_to_object(anAttrIOR->Value()));

      bool okToContinue = false;

      if (!CORBA::is_nil(anOldSubO)) {
        CORBA::String_var anEntry = anOldSubO->GetEntry();
        okToContinue = theArgs.count(anEntry.in());
      }

      if (okToContinue) {
        // Find a sub-shape of theNewO in place of anOldSubO
        GEOM::GEOM_Object_var aNewSubO;
        switch (theFindMethod) {
        case GEOM::FSM_GetInPlace:
          {
            // Use GetInPlace
            aNewSubO = aShapesOp->GetInPlace(theNewO, anOldSubO);
          }
          break;
        case GEOM::FSM_MultiTransformed:
          {
            // Only for Multi-transformations
            GEOM::GEOM_Object_var anArgOTrsf = aTrsfOpSv->TransformLikeOtherCopy(anOldSubO, theNewO);
            if (!CORBA::is_nil(anArgOTrsf)) {
              CORBA::String_var anArgOTrsfEntry = anArgOTrsf->GetEntry();
              Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
              Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
              anArgOTrsfFun->SetDescription("");
              aNewSubO = aShapesOp->GetInPlace(theNewO, anArgOTrsf);
            }
          }
          break;
        case GEOM::FSM_Transformed:
          {
            // transformation, cannot use GetInPlace, operate with indices
            GEOM::ListOfLong_var anIDs = anOldSubO->GetSubShapeIndices();
            if (anIDs->length() > 1) {
              // group
              aNewSubO = aGroupOp->CreateGroup(theNewO, aGroupOp->GetType(anOldSubO));
              if (!CORBA::is_nil(aNewSubO))
                aGroupOp->UnionIDs(aNewSubO, anIDs);
            }
            else {
              // single sub-shape
              aNewSubO = aShapesOp->GetSubShape(theNewO, anIDs[0]);
            }
          }
          break;
        case GEOM::FSM_GetSame:
          {
            // Use GetSame
            aNewSubO = aShapesOp->GetSame(theNewO, anOldSubO);
          }
          break;
        case GEOM::FSM_GetShapesOnShape:
          {
            // Use GetShapesOnShape. Can work only on solids, so it has sense to search only solids
            aNewSubO = aShapesOp->GetShapesOnShapeAsCompound(anOldSubO, theNewO,
                                                             (short)GEOM::SOLID, GEOM::ST_ONIN);
          }
          break;
        case GEOM::FSM_GetInPlaceByHistory:
          {
            // Use GetInPlaceByHistory
            aNewSubO = aShapesOp->GetInPlaceByHistory(theNewO, anOldSubO);
          }
          break;
        default:
          {}
        }

        if (!CORBA::is_nil(aNewSubO)) {
          // add the part to the list
          aParts[i] = aNewSubO;
          i++;
          // add to parts list
          addToListOfGO( aNewSubO, aNewParts );

          SALOMEDS::SObject_var aNewSubSO;
          if (!CORBA::is_nil(theNewSO)) {
              // Publish the sub-shape
            TCollection_AsciiString aSubName;
            if (theAddPrefix) {
              aSubName = "from_";
            }
            aSubName += anArgName;
            aNewSubSO = aStudyBuilder->NewObject(theNewSO);
            aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
            // Restore color
            aNewSubO->SetColor(anOldSubO->GetColor());
            // set the texture
            if (aNewSubO->GetShapeType() == GEOM::VERTEX) {
              aNewSubO->SetMarkerStd(anOldSubO->GetMarkerType(), anOldSubO->GetMarkerSize());
              if (anOldSubO->GetMarkerType() == GEOM::MT_USER)
                aNewSubO->SetMarkerTexture(anOldSubO->GetMarkerTexture());
            }
            // reference to arg
            SALOMEDS::SObject_wrap aReferenceSO = aStudyBuilder->NewObject( aNewSubSO );
            aStudyBuilder->Addreference( aReferenceSO, anOldSubSO );
            useCaseBuilder->AppendTo( theNewSO, aReferenceSO );
          }
          // Restore published sub-shapes of the argument
          GEOM::ListOfGO_var aSubParts;
          if (theFindMethod == GEOM::FSM_GetInPlaceByHistory)
            // pass the main shape as Object, because only it has the history
            aSubParts = RestoreGivenSubShapesOneLevel(anOldSubSO, aNewSubSO,
                                                      theNewO, theArgs, theFindMethod, theAddPrefix);
          else
            aSubParts = RestoreGivenSubShapesOneLevel(anOldSubSO, aNewSubSO,
                                                      aNewSubO, theArgs, theFindMethod, theAddPrefix);
          // add to parts list
          addToListOfGO( aSubParts, aNewParts );
        }
        else { // GetInPlace failed, try to build from published parts
          SALOMEDS::SObject_var aNewSubSO;
          if (!CORBA::is_nil(theNewSO))
          {
            aNewSubSO = aStudyBuilder->NewObject(theNewSO);
            useCaseBuilder->AppendTo( theNewSO, aNewSubSO );
          }
          // Restore published sub-shapes of the argument
          GEOM::ListOfGO_var aSubParts =
            RestoreGivenSubShapesOneLevel(anOldSubSO, aNewSubSO,
                                          theNewO, theArgs, theFindMethod, theAddPrefix);
          // add to parts list
          addToListOfGO( aSubParts, aNewParts );

          if (aSubParts->length() > 0) {
            // try to build an object from a set of its sub-shapes,
            // that published and will be reconstructed
            if (aSubParts->length() > 1) {
              aNewSubO = aShapesOp->MakeCompound(aSubParts);
              // add to parts list
              addToListOfGO( aNewSubO, aNewParts );
            }
            else {
              aNewSubO = aSubParts[0];
            }

            if (!CORBA::is_nil(aNewSubO)) {
              // add the part to the list
              aSubParts[i] = aNewSubO;
              i++;

              // Publish the sub-shape
              if (!CORBA::is_nil(aNewSubSO)) {
                TCollection_AsciiString aSubName;
                if (theAddPrefix) {
                  aSubName = "from_parts_of_";
                }
                aSubName += anArgName;
                aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
                // Restore color
                aNewSubO->SetColor(anOldSubO->GetColor());
                // set the texture
                if (aNewSubO->GetShapeType() == GEOM::VERTEX) {
                  aNewSubO->SetMarkerStd(anOldSubO->GetMarkerType(), anOldSubO->GetMarkerSize());
                  if (anOldSubO->GetMarkerType() == GEOM::MT_USER)
                    aNewSubO->SetMarkerTexture(anOldSubO->GetMarkerTexture());
                }
              }
            }
          }
          else if (!CORBA::is_nil(aNewSubSO)) {
            // remove created aSubSO, because no parts have been found
            aStudyBuilder->RemoveObject(aNewSubSO);
          }
        } // try to build from published parts
      }
    }
  } // iterate on published sub-shapes

  aParts->length(i);
  // add to parts list
  addToListOfGO( aNewParts, aParts );
  return aParts._retn();
}

//============================================================================
// function : register()
// purpose  : register 'name' in 'name_service'
//============================================================================
void GEOM_Gen_i::register_name(char * name)
{
  GEOM::GEOM_Gen_var g = _this();
  name_service->Register(g, name);
}

//============================================================================
// function : getStudyServant()
// purpose  : Get Study
//============================================================================
SALOMEDS::Study_var GEOM_Gen_i::getStudyServant()
{
  static SALOMEDS::Study_var aStudy;
  if(CORBA::is_nil(aStudy)){
    CORBA::Object_ptr anObject = name_service->Resolve("/Study");
    aStudy = SALOMEDS::Study::_narrow(anObject);
  }
  return aStudy;
}

//============================================================================
// function : Undo
// purpose  :
//============================================================================
void GEOM_Gen_i::Undo()
{
  _impl->Undo();
}

//============================================================================
// function : Redo
// purpose  :
//============================================================================
void GEOM_Gen_i::Redo()
{
  _impl->Redo();
}

//============================================================================
// function : GetIBasicOperations
// purpose  :
//============================================================================
GEOM::GEOM_IBasicOperations_ptr GEOM_Gen_i::GetIBasicOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIBasicOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  //transfer reference on engine
  GEOM_IBasicOperations_i* aServant =
    new GEOM_IBasicOperations_i(_poa, engine, _impl->GetIBasicOperations());

  PortableServer::ObjectId_var id = _poa->activate_object(aServant);
  // activate the CORBA servant
  GEOM::GEOM_IBasicOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetITransformOperations
// purpose  :
//============================================================================
GEOM::GEOM_ITransformOperations_ptr GEOM_Gen_i::GetITransformOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetITransformOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_ITransformOperations_i* aServant =
    new GEOM_ITransformOperations_i(_poa, engine, _impl->GetITransformOperations());

  // activate the CORBA servant
  GEOM::GEOM_ITransformOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetI3DPrimOperations
// purpose  :
//============================================================================
GEOM::GEOM_I3DPrimOperations_ptr GEOM_Gen_i::GetI3DPrimOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetI3DPrimOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_I3DPrimOperations_i* aServant =
    new GEOM_I3DPrimOperations_i(_poa, engine, _impl->GetI3DPrimOperations());
  PortableServer::ObjectId_var id = _poa->activate_object(aServant);

  // activate the CORBA servant
  GEOM::GEOM_I3DPrimOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIShapesOperations
// purpose  :
//============================================================================
GEOM::GEOM_IShapesOperations_ptr GEOM_Gen_i::GetIShapesOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIShapesOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IShapesOperations_i* aServant =
    new GEOM_IShapesOperations_i(_poa, engine, _impl->GetIShapesOperations());

  // activate the CORBA servant
  GEOM::GEOM_IShapesOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIBlocksOperations
// purpose  :
//============================================================================
GEOM::GEOM_IBlocksOperations_ptr GEOM_Gen_i::GetIBlocksOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIBlocksOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IBlocksOperations_i* aServant =
    new GEOM_IBlocksOperations_i(_poa, engine, _impl->GetIBlocksOperations());

  // activate the CORBA servant
  GEOM::GEOM_IBlocksOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIBooleanOperations
// purpose  :
//============================================================================
GEOM::GEOM_IBooleanOperations_ptr GEOM_Gen_i::GetIBooleanOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIBooleanOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IBooleanOperations_i* aServant =
    new GEOM_IBooleanOperations_i(_poa, engine, _impl->GetIBooleanOperations());

  // activate the CORBA servant
  GEOM::GEOM_IBooleanOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetICurvesOperations
// purpose  :
//============================================================================
GEOM::GEOM_ICurvesOperations_ptr GEOM_Gen_i::GetICurvesOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetICurvesOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_ICurvesOperations_i* aServant =
    new GEOM_ICurvesOperations_i(_poa, engine, _impl->GetICurvesOperations());

  // activate the CORBA servant
  GEOM::GEOM_ICurvesOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetILocalOperations
// purpose  :
//============================================================================
GEOM::GEOM_ILocalOperations_ptr GEOM_Gen_i::GetILocalOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetILocalOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_ILocalOperations_i* aServant =
    new GEOM_ILocalOperations_i(_poa, engine, _impl->GetILocalOperations());

  // activate the CORBA servant
  GEOM::GEOM_ILocalOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIHealingOperations
// purpose  :
//============================================================================
GEOM::GEOM_IHealingOperations_ptr GEOM_Gen_i::GetIHealingOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::IHealingOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IHealingOperations_i* aServant =
    new GEOM_IHealingOperations_i(_poa, engine, _impl->GetIHealingOperations());

  // activate the CORBA servant
  GEOM::GEOM_IHealingOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIInsertOperations
// purpose  :
//============================================================================
GEOM::GEOM_IInsertOperations_ptr GEOM_Gen_i::GetIInsertOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIInsertOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IInsertOperations_i* aServant =
    new GEOM_IInsertOperations_i(_poa, engine, _impl->GetIInsertOperations());

  // activate the CORBA servant
  GEOM::GEOM_IInsertOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIMeasureOperations
// purpose  :
//============================================================================
GEOM::GEOM_IMeasureOperations_ptr GEOM_Gen_i::GetIMeasureOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIMeasureOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IMeasureOperations_i* aServant =
    new GEOM_IMeasureOperations_i(_poa, engine, _impl->GetIMeasureOperations());

  // activate the CORBA servant
  GEOM::GEOM_IMeasureOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIGroupOperations
// purpose  :
//============================================================================
GEOM::GEOM_IGroupOperations_ptr GEOM_Gen_i::GetIGroupOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIGroupOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IGroupOperations_i* aServant =
    new GEOM_IGroupOperations_i(_poa, engine, _impl->GetIGroupOperations());

  // activate the CORBA servant
  GEOM::GEOM_IGroupOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetIFieldOperations
// purpose  :
//============================================================================
GEOM::GEOM_IFieldOperations_ptr GEOM_Gen_i::GetIFieldOperations()
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetIFieldOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM_IFieldOperations_i* aServant =
    new GEOM_IFieldOperations_i(_poa, engine, _impl->GetIFieldOperations());

  // activate the CORBA servant
  GEOM::GEOM_IFieldOperations_var operations = aServant->_this();
  return operations._retn();
}

//============================================================================
// function : GetPluginOperations
// purpose  :
//============================================================================
GEOM::GEOM_IOperations_ptr GEOM_Gen_i::GetPluginOperations(const char* theLibName)
     throw ( SALOME::SALOME_Exception )
{
  Unexpect aCatch(SALOME_SalomeException);
  MESSAGE( "GEOM_Gen_i::GetPluginOperations" );

  GEOM::GEOM_Gen_ptr engine = _this();

  GEOM::GEOM_IOperations_var operations;

  std::string aLibName = theLibName;

  try {
    // load plugin library
    LoadPlugin(aLibName);
    // create a new operations object, store its ref. in engine
    if ( myOpCreatorMap.find(aLibName) != myOpCreatorMap.end() ) {
      GEOM_IOperations_i* aServant = 0;
      aServant = myOpCreatorMap[aLibName]->Create(_poa, engine, _impl);
      // activate the CORBA servant
      if (aServant)
        operations = aServant->_this();
    }
  }
  catch (SALOME_Exception& S_ex) {
    THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
  }

  return operations._retn();
}

//============================================================================
// function : LoadPlugin
// purpose  : load plugin library and retrieve an instance of operations creator
//============================================================================
void GEOM_Gen_i::LoadPlugin(const std::string& theLibName)
{
  std::string aPlatformLibName;
#if !defined(WIN32)
  aPlatformLibName = "lib";
#endif
  aPlatformLibName += theLibName;
#if defined(WIN32)
  aPlatformLibName += ".dll" ;
#elif defined(__APPLE__)
  aPlatformLibName += ".dylib";
#else
  aPlatformLibName += ".so";
#endif

  // check, if corresponding operations are already created
  if (myOpCreatorMap.find(theLibName) == myOpCreatorMap.end()) {
#if WIN32
  #if UNICODE 
	std::wstring strL = Kernel_Utils::utf8_decode_s(aPlatformLibName);
    const wchar_t* aPath = strL.c_str();
  #else
    const char* aPath = aPlatformLibName.c_str();
  #endif
    // load plugin library
    LibHandle libHandle = LoadLib(aPath);
#else
    LibHandle libHandle = LoadLib(aPlatformLibName.c_str());
#endif
    if (!libHandle) {
      // report any error, if occurred
#ifndef WIN32
      throw(SALOME_Exception(dlerror()));
#else
      throw(SALOME_Exception(LOCALIZED( "Can't load server geometry plugin library" )));
#endif
    }

    // get method, returning operations creator
    typedef GEOM_GenericOperationsCreator* (*GetOperationsCreator)();
    GetOperationsCreator procHandle =
      (GetOperationsCreator)GetProc( libHandle, "GetOperationsCreator" );
    if (!procHandle) {
      UnLoadLib(libHandle);
      throw(SALOME_Exception(LOCALIZED("bad geometry plugin library")));
    }

    // get operations creator
    GEOM_GenericOperationsCreator* aCreator = procHandle();
    if (aCreator) {
      // map operations creator to a plugin name
      myOpCreatorMap[theLibName] = aCreator;
    }
    else {
      throw(SALOME_Exception(LOCALIZED("bad geometry plugin library implementation")));
    }
  }
}

//=============================================================================
/*!
 *  AddSubShape
 */
//=============================================================================
GEOM::GEOM_Object_ptr GEOM_Gen_i::AddSubShape (GEOM::GEOM_Object_ptr   theMainShape,
                                               const GEOM::ListOfLong& theIndices)
{
  if (CORBA::is_nil(theMainShape) || theIndices.length() < 1)
    return GEOM::GEOM_Object::_nil();
  CORBA::String_var entry = theMainShape->GetEntry();
  Handle(::GEOM_Object) aMainShape = Handle(::GEOM_Object)::DownCast
    ( _impl->GetObject( entry ));
  if (aMainShape.IsNull()) return GEOM::GEOM_Object::_nil();

  Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1, theIndices.length());
  for(CORBA::ULong i = 0; i<theIndices.length(); i++) anArray->SetValue(i+1, theIndices[i]);

  Handle(::GEOM_Object) anObject = _impl->AddSubShape(aMainShape, anArray, true);
  if(anObject.IsNull()) return GEOM::GEOM_Object::_nil();

  TCollection_AsciiString anEntry;
  TDF_Tool::Entry(anObject->GetEntry(), anEntry);
  return GEOM::GEOM_Object::_narrow( GetObject(anEntry.ToCString()));
}

//=============================================================================
/*!
 *  RemoveObject
 */
//=============================================================================
void GEOM_Gen_i::RemoveObject(GEOM::GEOM_BaseObject_ptr theObject)
{
  CORBA::String_var anEntry = theObject->GetEntry();
  Handle(::GEOM_BaseObject) anObject = _impl->GetObject(anEntry, false);
  if (!anObject.IsNull())
    _impl->RemoveObject(anObject);
}

//=================================================================================
// function : GetStringFromIOR()
// purpose  : returns a string that represents  a 'GEOM::GEOM_Object_var'
//=================================================================================
char* GEOM_Gen_i::GetStringFromIOR(GEOM::GEOM_Object_ptr theObject)
{
  return _orb->object_to_string(theObject);
}

//=================================================================================
// function : GetIORFromString()
// purpose  : returns a 'GEOM::GEOM_Object_var' from a string representing it
//=================================================================================
GEOM::GEOM_Object_ptr GEOM_Gen_i::GetIORFromString(const char* stringIOR) {
  GEOM::GEOM_Object_var aGeomObject;
  if(strcmp(stringIOR,"") != 0){
    CORBA::Object_var anObject = _orb->string_to_object(stringIOR);
    if(!CORBA::is_nil(anObject))
      aGeomObject =  GEOM::GEOM_Object::_narrow(anObject.in());
  }
  return aGeomObject._retn();
}

//=================================================================================
// function : GetObject()
// purpose  :
//=================================================================================
GEOM::GEOM_BaseObject_ptr GEOM_Gen_i::GetObject (const char* theEntry)
{
  GEOM::GEOM_BaseObject_var obj;
  Handle(::GEOM_BaseObject) handle_object = _impl->GetObject((char*)theEntry);
  if (handle_object.IsNull()) return obj._retn();

  TCollection_AsciiString stringIOR = handle_object->GetIOR();
  if (stringIOR.Length() > 1) {
    CORBA::Object_var corba_object = _orb->string_to_object(stringIOR.ToCString());
    if (!CORBA::is_nil(corba_object)) obj = GEOM::GEOM_BaseObject::_narrow(corba_object);
    return obj._retn();
  }

  GEOM::GEOM_Gen_ptr engine = _this();
  //transfer the reference to GEOM_Object_i
  GEOM_BaseObject_i* servant = 0;
  switch( handle_object->GetType() ) {
  case GEOM_FIELD: {
    servant = new GEOM_Field_i (_poa, engine, Handle(::GEOM_Field)::DownCast( handle_object ));
    break;
  }
  case GEOM_FIELD_STEP: {
    Handle(::GEOM_FieldStep) step = Handle(::GEOM_FieldStep)::DownCast( handle_object );
    Handle(::GEOM_Field)    field = step->GetField();
    int type = ( !field.IsNull() ? field->GetDataType() : 0 );
    switch( type ) {
    case GEOM::FDT_Bool:
      servant = new GEOM_BoolFieldStep_i (_poa, engine, step );
      break;
    case GEOM::FDT_Int:
      servant = new GEOM_IntFieldStep_i (_poa, engine, step );
      break;
    case GEOM::FDT_Double:
      servant = new GEOM_DoubleFieldStep_i (_poa, engine, step );
      break;
    default:
      servant = new GEOM_StringFieldStep_i (_poa, engine, step );
    }
    break;
  }
  default:
    servant = new GEOM_Object_i (_poa, engine, Handle(::GEOM_Object)::DownCast( handle_object ));
  }
  PortableServer::ObjectId_var id = _poa->activate_object(servant);

  obj = servant->_this();
  CORBA::String_var objStr = _orb->object_to_string(obj);
  TCollection_AsciiString anAscii( (char *)objStr.in() );
  handle_object->SetIOR( anAscii );
  return obj._retn();
}

//=================================================================================
// function : hasObjectInfo()
// purpose  : shows if module provides information for its objects
//=================================================================================
bool GEOM_Gen_i::hasObjectInfo()
{
  return true;
}

//=================================================================================
// function : getObjectInfo()
// purpose  : returns an information for a given object by its entry
//=================================================================================
char* GEOM_Gen_i::getObjectInfo(const char* entry)
{
  GEOM::GEOM_Object_var aGeomObject;

  SALOMEDS::SObject_var aSObj = getStudyServant()->FindObjectID( entry );
  SALOMEDS::SObject_var aResultSObj;
  if (aSObj->ReferencedObject(aResultSObj))
    aSObj = aResultSObj;

  SALOMEDS::GenericAttribute_var anAttr;
  if (!aSObj->_is_nil() && aSObj->FindAttribute(anAttr, "AttributeIOR")) {
    SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
    CORBA::String_var aVal = anIOR->Value();
    anIOR->UnRegister();
    CORBA::Object_var anObject = getStudyServant()->ConvertIORToObject(aVal);
    aGeomObject = GEOM::GEOM_Object::_narrow(anObject);
  }
  if (!aSObj->_is_nil() )
    aSObj->UnRegister();

  const char* aTypeInfo = "Object";
  if ( !aGeomObject->_is_nil() ) {
    GEOM::GEOM_IKindOfShape::shape_kind aKind;
    GEOM::ListOfLong_var anInts;
    GEOM::ListOfDouble_var aDbls;

    GEOM::GEOM_IMeasureOperations_var anOp = GetIMeasureOperations();
    aKind = anOp->KindOfShape( aGeomObject, anInts, aDbls );

    if ( anOp->IsDone() ) {
      switch ( aKind ) {
      case GEOM::GEOM_IKindOfShape::COMPOUND:
        aTypeInfo = "Compound";
        break;
      case GEOM::GEOM_IKindOfShape::COMPSOLID:
        aTypeInfo = "CompSolid";
        break;
      case GEOM::GEOM_IKindOfShape::SHELL:
        aTypeInfo = "Shell";
        break;
      case GEOM::GEOM_IKindOfShape::WIRE:
        if ( anInts[0] == 1 )
          aTypeInfo = "Closed Wire";
        else if ( anInts[0] == 2 )
          aTypeInfo = "Opened Wire";
        else
          aTypeInfo = "Wire";
        break;
        // SOLIDs
      case GEOM::GEOM_IKindOfShape::SPHERE:
        aTypeInfo = "Sphere";
        break;
      case GEOM::GEOM_IKindOfShape::CYLINDER:
        aTypeInfo = "Cylinder";
        break;
      case GEOM::GEOM_IKindOfShape::BOX:
      case GEOM::GEOM_IKindOfShape::ROTATED_BOX:
        aTypeInfo = "Box";
        break;
      case GEOM::GEOM_IKindOfShape::TORUS:
        aTypeInfo = "Torus";
        break;
      case GEOM::GEOM_IKindOfShape::CONE:
        aTypeInfo = "Cone";
        break;
      case GEOM::GEOM_IKindOfShape::POLYHEDRON:
        aTypeInfo = "Polyhedron";
        break;
      case GEOM::GEOM_IKindOfShape::SOLID:
        aTypeInfo = "Solid";
        break;
        // FACEs
      case GEOM::GEOM_IKindOfShape::SPHERE2D:
        aTypeInfo = "Spherical Face";
        break;
      case GEOM::GEOM_IKindOfShape::CYLINDER2D:
        aTypeInfo = "Cylindrical Face";
        break;
      case GEOM::GEOM_IKindOfShape::TORUS2D:
        aTypeInfo = "Toroidal Face";
        break;
      case GEOM::GEOM_IKindOfShape::CONE2D:
        aTypeInfo = "Conical Face";
        break;
      case GEOM::GEOM_IKindOfShape::DISK_CIRCLE:
        aTypeInfo = "Disk";
        break;
      case GEOM::GEOM_IKindOfShape::DISK_ELLIPSE:
        aTypeInfo = "Elliptical Face";
        break;
      case GEOM::GEOM_IKindOfShape::POLYGON:
        aTypeInfo = "Polygon";
        break;
      case GEOM::GEOM_IKindOfShape::PLANE:
        aTypeInfo = "Plane";
        break;
      case GEOM::GEOM_IKindOfShape::PLANAR:
        aTypeInfo = "Planar Face";
        break;
      case GEOM::GEOM_IKindOfShape::FACE:
        aTypeInfo = "Face";
        break;
        // EDGEs
      case GEOM::GEOM_IKindOfShape::CIRCLE:
        aTypeInfo = "Circle";
        break;
      case GEOM::GEOM_IKindOfShape::ARC_CIRCLE:
        aTypeInfo = "Arc Circle";
        break;
      case GEOM::GEOM_IKindOfShape::ELLIPSE:
        aTypeInfo = "Ellipse";
        break;
      case GEOM::GEOM_IKindOfShape::ARC_ELLIPSE:
        aTypeInfo = "Arc Ellipse";
        break;
      case GEOM::GEOM_IKindOfShape::LINE:
        aTypeInfo = "Line";
        break;
      case GEOM::GEOM_IKindOfShape::SEGMENT:
        aTypeInfo = "Segment";
        break;
      case GEOM::GEOM_IKindOfShape::EDGE:
        aTypeInfo = "Edge";
        break;
      case GEOM::GEOM_IKindOfShape::VERTEX:
        aTypeInfo = "Vertex";
        break;
      default:
        break;
      }
    }
  }

  CORBA::String_var compType = ComponentDataType();
  char* anInfo = new char[strlen("Module ") + strlen(compType.in()) + strlen(", ") + strlen(aTypeInfo) + 3];
  sprintf(anInfo, "Module %s, %s", compType.in(), aTypeInfo);

  char* ret = CORBA::string_dup(anInfo);
  delete [] anInfo;
  return ret;
}

// Version information
char* GEOM_Gen_i::getVersion()
{
#if GEOM_DEVELOPMENT
  return CORBA::string_dup(GEOM_VERSION_STR"dev");
#else
  return CORBA::string_dup(GEOM_VERSION_STR);
#endif
}

//=================================================================================
// function : CreateFolder()
// purpose  : Creates and returns a new folder object
//=================================================================================
SALOMEDS::SObject_ptr GEOM_Gen_i::CreateFolder(const char* theName,
                                               SALOMEDS::SObject_ptr theFather)
{
  SALOMEDS::SObject_var aFolderSO;

  if ( CORBA::is_nil(theFather) ) return aFolderSO._retn();

  SALOMEDS::GenericAttribute_var anAttr;
  if ( strcmp(theFather->GetFatherComponent()->GetID(), theFather->GetID()) != 0 ) {
    // not a GEOM component object was selected
    if ( !theFather->FindAttribute(anAttr, "AttributeLocalID") ) return aFolderSO._retn();
    SALOMEDS::AttributeLocalID_var aLocalID = SALOMEDS::AttributeLocalID::_narrow(anAttr);
    if( aLocalID->Value() != 999 ) {
      // not a Folder object was selected
      GEOM::GEOM_Object_var aGeomObject = GEOM::GEOM_Object::_narrow(theFather);
      if ( CORBA::is_nil(aGeomObject) ) return aFolderSO._retn();
      // another GEOM object was selected, so get GEOM component as father object
      theFather = theFather->GetFatherComponent();
    }
    aLocalID->UnRegister();
  }

  SALOMEDS::Study_var aStudy = getStudyServant();
  SALOMEDS::StudyBuilder_var aStudyBuilder( aStudy->NewBuilder() );
  aFolderSO = aStudyBuilder->NewObject( theFather );

  anAttr = aStudyBuilder->FindOrCreateAttribute(aFolderSO, "AttributeLocalID");
  SALOMEDS::AttributeLocalID_var aLocalID = SALOMEDS::AttributeLocalID::_narrow(anAttr);
  aLocalID->SetValue( 999 ); // mark of the "Folder" object
  aLocalID->UnRegister();

  anAttr = aStudyBuilder->FindOrCreateAttribute(aFolderSO, "AttributeName");
  SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
  aName->SetValue( theName );
  aName->UnRegister();

  anAttr = aStudyBuilder->FindOrCreateAttribute(aFolderSO, "AttributePixMap");
  SALOMEDS::AttributePixMap_var aPixMap = SALOMEDS::AttributePixMap::_narrow(anAttr);
  aPixMap->SetPixMap("ICON_FOLDER");
  aPixMap->UnRegister();

  // add object to the use case tree
  // (to support tree representation customization and drag-n-drop)
  SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
  useCaseBuilder->AppendTo( theFather, aFolderSO );

  return aFolderSO._retn();
}

//=================================================================================
// function : MoveToFolder()
// purpose  : Moves GEOM object to the specified folder
//=================================================================================
void GEOM_Gen_i::MoveToFolder(GEOM::GEOM_Object_ptr theObject,
                              SALOMEDS::SObject_ptr theFolder) {
  GEOM::object_list_var objects = new GEOM::object_list();
  objects->length( 1 );
  SALOMEDS::SObject_var aSO = getStudyServant()->FindObjectID( theObject->GetStudyEntry() );
  objects[0] = aSO;
  Move( objects, theFolder, -1 );
}

//=================================================================================
// function : MoveListToFolder()
// purpose  : Moves list of GEOM objects to the specified folder
//=================================================================================
void GEOM_Gen_i::MoveListToFolder (const GEOM::ListOfGO& theListOfGO,
                                   SALOMEDS::SObject_ptr theFolder) {
  int aLen = theListOfGO.length();
  GEOM::object_list_var objects = new GEOM::object_list();
  objects->length( aLen );
  GEOM::GEOM_Object_var aGO;
  SALOMEDS::SObject_var aSO;
  for (int i = 0; i < aLen; i++) {
    aGO = GEOM::GEOM_Object::_duplicate( theListOfGO[i] );
    aSO = getStudyServant()->FindObjectID( aGO->GetStudyEntry() );
    objects[i] = aSO;
  }
  if ( objects->length() > 0 )
    Move( objects, theFolder, -1 );
}

//=================================================================================
// function : Move()
// purpose  : Moves objects to the specified position.
//            Is used in the drag-n-drop functionality.
//=================================================================================
void GEOM_Gen_i::Move( const GEOM::object_list& what,
                       SALOMEDS::SObject_ptr where,
                       CORBA::Long row )
{
  if ( CORBA::is_nil( where ) ) return;

  SALOMEDS::Study_var study = getStudyServant();
  SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder();
  SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder();
  SALOMEDS::SComponent_var father = where->GetFatherComponent();
  std::string dataType = father->ComponentDataType();
  if ( dataType != "GEOM" ) return; // not a GEOM component

  SALOMEDS::SObject_var objAfter;
  if ( row >= 0 && useCaseBuilder->HasChildren( where ) ) {
    // insert at given row -> find insertion position
    SALOMEDS::UseCaseIterator_var useCaseIt = useCaseBuilder->GetUseCaseIterator( where );
    int i;
    for ( i = 0; i < row && useCaseIt->More(); i++, useCaseIt->Next() );
    if ( i == row && useCaseIt->More() ) {
      objAfter = useCaseIt->Value();
    }
  }

  for ( CORBA::ULong i = 0; i < what.length(); i++ ) {
    SALOMEDS::SObject_var sobj = what[i];
    if ( CORBA::is_nil( sobj ) ) continue; // skip bad object
    // insert the object to the use case tree
    if ( !CORBA::is_nil( objAfter ) )
      useCaseBuilder->InsertBefore( sobj, objAfter ); // insert at given row
    else
      useCaseBuilder->AppendTo( where, sobj );        // append to the end of list
  }
}

//=======================================================================
// function : GetDependencyTree
// purpose  : Collects dependencies of the given objects from other ones
//=======================================================================
SALOMEDS::TMPFile* GEOM_Gen_i::GetDependencyTree( const GEOM::string_array& theObjectEntries )
{
  // fill in the tree structure
  GEOMUtils::TreeModel tree;

  std::string entry;
  for ( CORBA::ULong i = 0; i < theObjectEntries.length(); i++ ) {
    // process objects one-by-one
    entry = theObjectEntries[i].in();
    GEOM::GEOM_BaseObject_var anObj = GetObject(entry.c_str() );
    if ( anObj->_is_nil() )
      continue;
    std::map< std::string, std::set<std::string> > passedEntries;
    GEOMUtils::LevelsList upLevelList;
    // get objects from which current one depends on recursively
    getUpwardDependency( anObj, upLevelList, passedEntries );
    GEOMUtils::LevelsList downLevelList;
    // get objects that depends on current one recursively
    getDownwardDependency( anObj, downLevelList, passedEntries );
    tree.insert( std::pair<std::string, std::pair<GEOMUtils::LevelsList,GEOMUtils::LevelsList> >(entry, std::pair<GEOMUtils::LevelsList,GEOMUtils::LevelsList>( upLevelList, downLevelList ) ) );
  }

  // translation the tree into string
  std::string treeStr;
  GEOMUtils::ConvertTreeToString( tree, treeStr );

  // put string into stream
  char* aBuffer = (char*)CORBA::string_dup(treeStr.c_str());
  int aBufferSize = strlen((char*)aBuffer);

  CORBA::Octet* anOctetBuf =  (CORBA::Octet*)aBuffer;

  SALOMEDS::TMPFile_var aStream = new SALOMEDS::TMPFile(aBufferSize, aBufferSize, anOctetBuf, 1);

  return aStream._retn();
}

//=======================================================================
// function : getUpwardDependency
// purpose  : Collects the entries of objects on that the given one depends
//=======================================================================
void GEOM_Gen_i::getUpwardDependency( GEOM::GEOM_BaseObject_ptr gbo,
                                      GEOMUtils::LevelsList &upLevelList,
                                      std::map< std::string, std::set<std::string> > &passedEntries,
                                      int level ) {
  std::string aGboEntry = gbo->GetEntry();
  GEOMUtils::NodeLinks anEntries;
  GEOMUtils::LevelInfo aLevelMap;
  if ( level > 0 ) {
    if ( level-1 >= (int)upLevelList.size() ) {
      // create a new map
      upLevelList.push_back( aLevelMap );
    } else {
      // get the existent map
      aLevelMap = upLevelList.at(level-1);
      if ( aLevelMap.count( aGboEntry ) > 0 ) {
        anEntries = aLevelMap[ aGboEntry ];
      }
    }
  }
  // get objects on that the current one depends
  GEOM::ListOfGBO_var depList = gbo->GetDependency();
  std::string aDepEntry;
  for( CORBA::ULong j = 0; j < depList->length(); j++ ) {
    if ( depList[j]->_is_nil() )
      continue;
    aDepEntry = depList[j]->GetEntry();
    if ( passedEntries.count( aGboEntry ) > 0 &&
         passedEntries[aGboEntry].count( aDepEntry ) > 0 ) {
      //avoid checking the passed objects
      continue;
    }
    passedEntries[aGboEntry].insert( aDepEntry );
    if ( level > 0 ) {
      anEntries.push_back( aDepEntry );
    }
    // get dependencies recursively
    getUpwardDependency(depList[j], upLevelList, passedEntries, level+1);
  }
  if ( level > 0 ) {
    aLevelMap.insert( std::pair<std::string, GEOMUtils::NodeLinks>(aGboEntry, anEntries) );
    upLevelList[level-1] = aLevelMap;
  }
}

//=======================================================================
// function : getDownwardDependency
// purpose  : Collects the entries of objects that depends on the given one
//=======================================================================
void GEOM_Gen_i::getDownwardDependency( GEOM::GEOM_BaseObject_ptr gbo,
                                        GEOMUtils::LevelsList &downLevelList,
                                        std::map< std::string, std::set<std::string> > &passedEntries,
                                        int level ) {
  std::string aGboEntry = gbo->GetEntry();
  Handle(TDocStd_Document) aDoc = GEOM_Engine::GetEngine()->GetDocument();
  Handle(TDataStd_TreeNode) aNode, aRoot;
  Handle(::GEOM_Function) aFunction;
  if (aDoc->Main().FindAttribute(GEOM_Function::GetFunctionTreeID(), aRoot)) {
    // go through the whole OCAF tree
    TDataStd_ChildNodeIterator Itr( aRoot );
    for (; Itr.More(); Itr.Next()) {
      aNode = Itr.Value();
      aFunction = GEOM_Function::GetFunction(aNode->Label());
      if (aFunction.IsNull()) {
        continue;
      }
      TDF_Label aLabel  = aFunction->GetOwnerEntry();
      if(aLabel.IsNull()) continue;
      TCollection_AsciiString anEntry;
      TDF_Tool::Entry(aLabel, anEntry);
      GEOM::GEOM_BaseObject_var geomObj = GetObject(anEntry.ToCString() );
      if( CORBA::is_nil( geomObj ) )
        continue;
      // get dependencies for current object in the tree
      GEOM::ListOfGBO_var depList = geomObj->GetDependency();
      if( depList->length() == 0 )
        continue;
      std::string aGoEntry = geomObj->GetEntry();
      // go through dependencies of current object to check whether it depends on the given object
      for( CORBA::ULong i = 0; i < depList->length(); i++ ) {
        if ( depList[i]->_is_nil() )
          continue;
        if ( depList[i]->_is_equivalent( gbo ) ) {
          // yes, the current object depends on the given object
          if ( passedEntries.count( aGoEntry ) > 0 &&
               passedEntries[aGoEntry].count( aGboEntry ) > 0 ) {
            //avoid checking the passed objects
            continue;
          }
          passedEntries[aGoEntry].insert( aGboEntry );
          GEOMUtils::NodeLinks anEntries;
          GEOMUtils::LevelInfo aLevelMap;
          anEntries.push_back( aGboEntry );
          if ( level >= (int)downLevelList.size() ) {
            downLevelList.push_back( aLevelMap );
          } else {
            aLevelMap = downLevelList.at(level);
            if ( aLevelMap.count( aGoEntry ) > 0 ) {
              anEntries = aLevelMap[ aGoEntry ];
            }
          }
          aLevelMap.insert( std::pair<std::string, GEOMUtils::NodeLinks>(aGoEntry, anEntries) );
          downLevelList[level] = aLevelMap;
          // get dependencies of the current object recursively
          getDownwardDependency(geomObj, downLevelList, passedEntries, level+1);
          break;
        }
      }
    }
  }
}

//==============================================================================
// function : GetEntriesToReduceStudy
// purpose  : Fills 3 lists that is used to clean study of redundant objects
//==============================================================================
void GEOM_Gen_i::GetEntriesToReduceStudy(GEOM::string_array& theSelectedEntries,
                                         GEOM::string_array& theParentEntries,
                                         GEOM::string_array& theSubEntries,
                                         GEOM::string_array& theOtherEntries)
{
  std::set<std::string> aSelected, aParents, aChildren, anOthers;
  for ( CORBA::ULong i = 0; i < theSelectedEntries.length(); i++ ) {
    aSelected.insert( CORBA::string_dup( theSelectedEntries[i] ) );
  }

  Handle(TDocStd_Document) aDoc = GEOM_Engine::GetEngine()->GetDocument();
  Handle(TDataStd_TreeNode) aNode, aRoot;
  Handle(::GEOM_Function) aFunction;
  if (aDoc->Main().FindAttribute(GEOM_Function::GetFunctionTreeID(), aRoot)) {
    // go through the whole OCAF tree
    TDF_Label aLabel;
    std::string anEntry;
    TCollection_AsciiString anAsciiEntry;
    TDataStd_ChildNodeIterator Itr( aRoot );
    for (; Itr.More(); Itr.Next()) {
      aNode = Itr.Value();
      aFunction = GEOM_Function::GetFunction(aNode->Label());
      if (aFunction.IsNull()) {
        continue;
      }
      aLabel = aFunction->GetOwnerEntry();
      if(aLabel.IsNull())
        continue;
      TDF_Tool::Entry(aLabel, anAsciiEntry);
      anEntry = anAsciiEntry.ToCString();
      GEOM::GEOM_BaseObject_var geomObj = GetObject(anEntry.c_str() );
      if( CORBA::is_nil( geomObj ) )
        continue;

      if ( aSelected.count( anEntry ) > 0 &&
           aParents.count( anEntry ) == 0 ) {
        includeParentDependencies( geomObj, aSelected, aParents, aChildren, anOthers );
      } else if ( aParents.count( anEntry ) == 0 &&
                  aChildren.count( anEntry ) == 0 ) {
        anOthers.insert( geomObj->GetEntry() );
      }
    }

    std::set<std::string>::iterator it;
    std::set<std::string>::iterator foundIt;
    TCollection_AsciiString stringIOR;
    GEOM::GEOM_Object_var geomObj;

    // filling list of sub-objects
    for ( it = aSelected.begin(); it != aSelected.end(); ++it ) {
      includeSubObjects( *it, aSelected, aParents, aChildren, anOthers );
    }

    // if some selected object is not a main shape,
    // we move it's main shapes into 'selected' list,
    // because they could not be modified anyhow.
    std::set<std::string> aToBeInSelected;
    for ( it = aSelected.begin(); it != aSelected.end(); ++it ) {
      Handle(::GEOM_BaseObject) handle_object = _impl->GetObject((*it).c_str(), false);
      if ( handle_object.IsNull() )
        continue;

      stringIOR = handle_object->GetIOR();
      if ( !stringIOR.Length() > 1 )
        continue;

      geomObj = GetIORFromString( stringIOR.ToCString() );
      while ( !geomObj->IsMainShape() ) {
        geomObj = geomObj->GetMainShape();
        anEntry = geomObj->GetEntry();

        foundIt = aParents.find( anEntry );
        if ( foundIt != aParents.end() )
          aParents.erase( foundIt );

        foundIt = aChildren.find( anEntry );
        if ( foundIt != aChildren.end() )
          aChildren.erase( foundIt );

        foundIt = anOthers.find( anEntry );
        if ( foundIt != anOthers.end() )
          anOthers.erase( foundIt );

        aToBeInSelected.insert( anEntry );
      }
    }
    aSelected.insert( aToBeInSelected.begin(), aToBeInSelected.end() );

    // fill the CORBA arrays with values from sets
    int i;
    theSelectedEntries.length( aSelected.size() );
    for ( i = 0, it = aSelected.begin(); it != aSelected.end(); ++it, i++ )
      theSelectedEntries[i]  = CORBA::string_dup( (*it).c_str() );
    theParentEntries.length( aParents.size() );
    for ( i = 0, it = aParents.begin(); it != aParents.end(); ++it, i++ )
      theParentEntries[i]  = CORBA::string_dup( (*it).c_str() );
    theSubEntries.length( aChildren.size() );
    for ( i = 0, it = aChildren.begin(); it != aChildren.end(); ++it, i++ )
      theSubEntries[i]  = CORBA::string_dup( (*it).c_str() );
    theOtherEntries.length( anOthers.size() );
    for ( i = 0, it = anOthers.begin(); it != anOthers.end(); ++it, i++ )
      theOtherEntries[i]  = CORBA::string_dup( (*it).c_str() );
  }
}

//==============================================================================
// function : includeParentDependencies
// purpose  :
//==============================================================================
void GEOM_Gen_i::includeParentDependencies(GEOM::GEOM_BaseObject_ptr geomObj,
                                           std::set<std::string>& aSelected,
                                           std::set<std::string>& aParents,
                                           std::set<std::string>& aChildren,
                                           std::set<std::string>& anOthers)
{
  std::string anEntry = geomObj->GetEntry();
  if ( aSelected.count( anEntry ) == 0 ) {
    aParents.insert( anEntry );
    std::set<std::string>::iterator it;
    it = aChildren.find( anEntry );
    if ( it != aChildren.end() )
      aChildren.erase( it );
    it = anOthers.find( anEntry );
    if ( it != anOthers.end() )
      anOthers.erase( it );
  }
  // get dependencies for current object in the tree
  GEOM::ListOfGBO_var depList = geomObj->GetDependency();
  if( depList->length() == 0 )
    return;
  // go through dependencies of current object to check whether it depends on the given object
  std::string aDepEntry;
  for( CORBA::ULong i = 0; i < depList->length(); i++ ) {
    aDepEntry = depList[i]->GetEntry();
    if ( depList[i]->_is_nil() ||
         aDepEntry == anEntry ||             // skip self-depending
         aSelected.count( aDepEntry ) > 0 || // skip selected objects
         aParents.count( aDepEntry ) > 0     // skip already processed objects
         )
      continue;
    includeParentDependencies( depList[i], aSelected, aParents, aChildren, anOthers );
  }
}

//==============================================================================
// function : includeSubObjects
// purpose  :
//==============================================================================
void GEOM_Gen_i::includeSubObjects(const std::string& aSelectedEntry,
                                   std::set<std::string>& aSelected,
                                   std::set<std::string>& aParents,
                                   std::set<std::string>& aChildren,
                                   std::set<std::string>& anOthers)
{
  std::set<std::string>::iterator foundIt;
  Handle(::GEOM_BaseObject) handle_object = _impl->GetObject(aSelectedEntry.c_str(), false);
  if ( handle_object.IsNull() )
    return;

  Handle(::GEOM_Function) aShapeFun = handle_object->GetFunction(1);
  if ( aShapeFun.IsNull() || !aShapeFun->HasSubShapeReferences() )
    return;

  const TDataStd_ListOfExtendedString& aListEntries = aShapeFun->GetSubShapeReferences();
  if ( aListEntries.IsEmpty() )
    return;

  TDataStd_ListIteratorOfListOfExtendedString anIt (aListEntries);
  for ( ; anIt.More(); anIt.Next() ) {
    TCollection_ExtendedString aSubEntry = anIt.Value();
    Standard_Integer aStrLen = aSubEntry.LengthOfCString();
    char* aSubEntryStr = new char[aStrLen+1];
    aSubEntry.ToUTF8CString( aSubEntryStr );
    foundIt = aParents.find( aSubEntryStr );
    if ( foundIt == aParents.end() ) { // add to sub-objects if it is not in parents list
      foundIt = aSelected.find( aSubEntryStr );
      if ( foundIt == aSelected.end() ) { // add to sub-objects if it is not in selected list
            aChildren.insert( aSubEntryStr );
            foundIt = anOthers.find( aSubEntryStr );
            if ( foundIt != anOthers.end() )
              anOthers.erase( foundIt );
      }
    }
    includeSubObjects( aSubEntryStr, aSelected, aParents, aChildren, anOthers );
  }
}
//=====================================================================================
// EXPORTED METHODS
//=====================================================================================
extern "C"
{
  /*
  GEOM_I_EXPORT
  PortableServer::ObjectId* GEOMEngine_factory(CORBA::ORB*, PortableServer::POA*, PortableServer::ObjectId*, const char*, const char*);
  */

  GEOM_I_EXPORT
  PortableServer::ObjectId* GEOMEngine_factory(CORBA::ORB_ptr            orb,
                                               PortableServer::POA_ptr   poa,
                                               PortableServer::ObjectId* contId,
                                               const char*               instanceName,
                                               const char*               interfaceName)
  {
    GEOM_Gen_i* myGEOM_Gen_i = new GEOM_Gen_i(orb, poa, contId, instanceName, interfaceName);
    return myGEOM_Gen_i->getId();
  }
}