-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2022 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.
+// 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
// 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 )
#include "Utils_ExceptHandlers.hxx"
#include "utilities.h"
-#include "GEOM_Object_i.hh"
#include "GEOM_Object.hxx"
#include "GEOM_Function.hxx"
#include "GEOM_ISubShape.hxx"
#include "GEOMImpl_CopyDriver.hxx"
#include "GEOMImpl_IInsertOperations.hxx"
#include "GEOM_wrap.hxx"
+#include "GEOMUtils_XmlHandler.hxx"
// Cascade headers
#include <BRep_Builder.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 <SALOME_DataContainer_i.hxx>
#include <Basics_DirUtils.hxx>
+#include <Basics_Utils.hxx>
#include <set>
#include <sstream>
#define UnLoadLib( handle ) FreeLibrary( handle );
#else
#define LibHandle void*
- #define LoadLib( name ) dlopen( name, RTLD_LAZY )
+ #define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_GLOBAL )
#define GetProc dlsym
#define UnLoadLib( handle ) dlclose( handle );
#endif
PortableServer::POA_ptr poa,
PortableServer::ObjectId* contId,
const char* instanceName,
- const char* interfaceName) :
- Engines_Component_i(orb, poa, contId, instanceName, interfaceName)
+ const char* interfaceName,
+ bool withRegistry) :
+ Engines_Component_i(orb, poa, contId, instanceName, interfaceName, false, withRegistry)
{
_thisObj = this;
_id = _poa->activate_object(_thisObj);
- name_service = new SALOME_NamingService(_orb);
-
_impl = new ::GEOMImpl_Gen;
//PAL10867: disable signals catching with "noexcepthandler" option
{
//work around PAL12004, PAL12628
//OSD::SetSignal( true );
- bool raiseFPE;
+ 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;
-#else
- raiseFPE = false;
+ 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);
+ }
+ }
}
//============================================================================
// purpose : destructor
//============================================================================
GEOM_Gen_i::~GEOM_Gen_i() {
- delete name_service;
delete _impl;
+ for (auto it = myOpCreatorMap.cbegin(); it != myOpCreatorMap.cend(); ++it)
+ delete (*it).second;
}
// function : IORToLocalPersistentID()
// purpose :
//============================================================================
-char* GEOM_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
+char* GEOM_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr /*theSObject*/,
const char* IORString,
- CORBA::Boolean isMultiFile,
- CORBA::Boolean isASCII)
+ 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 CORBA::string_dup(anObject->GetEntry());
+ return anObject->GetEntry();
}
return 0;
}
// : Used when a study is loaded
// : The IOR (IORName) of object created is returned
//============================================================================
-char* GEOM_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
+char* GEOM_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr /*theSObject*/,
const char* aLocalPersistentID,
- CORBA::Boolean isMultiFile,
- CORBA::Boolean isASCII)
+ CORBA::Boolean /*isMultiFile*/,
+ CORBA::Boolean /*isASCII*/)
{
- SALOMEDS::Study_var aStudy = theSObject->GetStudy();
-
- Handle(GEOM_BaseObject) anObject =
- _impl->GetObject(aStudy->StudyId(), aLocalPersistentID);
+ 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(anObject->GetDocID(), anEntry.ToCString());
+ GEOM::GEOM_BaseObject_var obj = GetObject(anEntry.ToCString());
CORBA::String_var aPersRefString = _orb->object_to_string(obj);
return CORBA::string_dup(aPersRefString);
// function : PublishInStudy
// purpose :
//============================================================================
-SALOMEDS::SObject_ptr GEOM_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy,
- SALOMEDS::SObject_ptr theSObject,
+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;
- if(CORBA::is_nil(theObject) || theStudy->_is_nil()) return 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 = theStudy->NewBuilder();
- SALOMEDS::UseCaseBuilder_var useCaseBuilder = theStudy->GetUseCaseBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
+ SALOMEDS::UseCaseBuilder_wrap useCaseBuilder = aStudy->GetUseCaseBuilder();
- SALOMEDS::SComponent_var aFather = theStudy->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
- }
+ SALOMEDS::SComponent_var aFather = findOrCreateComponent();
if (aFather->_is_nil()) return aResultSO;
if (CORBA::is_nil(theSObject)) {
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() )
+ if ( !aShape->_is_nil() && mytype != GEOM_GROUP)
{
- // recieve current TopoDS shape
+ // receive current TopoDS shape
CORBA::String_var entry = aShape->GetEntry();
- Handle(GEOM_Object) aGShape = Handle(GEOM_Object)::DownCast
- ( _impl->GetObject( aShape->GetStudyID(), entry ));
+ 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;
aMainSh = aMainSh->GetMainShape();
}
entry = aMainSh->GetEntry();
- Handle(GEOM_BaseObject) anObj = _impl->GetObject( aMainSh->GetStudyID(), entry );
+ Handle(::GEOM_BaseObject) anObj = _impl->GetObject( entry );
TDF_Label aMainLbl = anObj->GetFunction(1)->GetNamingEntry();
// check all named shapes using iterator
}
// END: try to find existed name for current shape
- CORBA::Long mytype=aBaseObj->GetType();
if ( mytype == GEOM_GROUP ) {
- GEOM::GEOM_IGroupOperations_var anOp = GetIGroupOperations( theStudy->StudyId() );
+ GEOM::GEOM_IGroupOperations_var anOp = GetIGroupOperations();
switch ( (TopAbs_ShapeEnum)anOp->GetType( aShape )) {
case TopAbs_VERTEX:
aResultSO->SetAttrString("AttributePixMap","ICON_OBJBROWSER_GROUP_PNT" );
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 > ADVANCED_BASE ) {
+ } 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;
SALOMEDS::SObject_var obj;
do {
anObjectName = aNamePrefix + TCollection_AsciiString(++i);
- obj = theStudy->FindObject( anObjectName.ToCString() );
+ obj = aStudy->FindObject( anObjectName.ToCString() );
}
while ( !obj->_is_nil() );
}
//Set NoteBook variables used in the object creation
TCollection_AsciiString aVars;
CORBA::String_var aString=aBaseObj->GetParameters();
- SALOMEDS::ListOfListOfStrings_var aSections = theStudy->ParseVariables(aString);
+ 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(theStudy->IsVariable(aListOfVars[j].in()))
+ if(aStudy->IsVariable(aListOfVars[j].in()))
aVars += aListOfVars[j].in();
if(j != m-1)
aVars += ":";
//============================================================================
// function : CreateAndPublishGroup
-// purpose : auxilary for PublishNamedShapesInStudy
+// purpose : auxiliary for PublishNamedShapesInStudy
//============================================================================
-void GEOM_Gen_i::CreateAndPublishGroup(SALOMEDS::Study_ptr theStudy,
- GEOM::GEOM_Object_var theMainShape,
+void GEOM_Gen_i::CreateAndPublishGroup(GEOM::GEOM_Object_var theMainShape,
const TopTools_IndexedMapOfShape& anIndices,
const TopTools_SequenceOfShape& SeqS,
- const TColStd_SequenceOfAsciiString& SeqN,
+ const TColStd_SequenceOfAsciiString& /*SeqN*/,
const Standard_CString& GrName,
- GEOM::ListOfGO_var aResList)
+ GEOM::ListOfGO_var /*aResList*/)
{
CORBA::String_var entry = theMainShape->GetEntry();
- //Handle(GEOM_Object) aMainShape = _impl->GetObject(theMainShape->GetStudyID(), entry);
+ //Handle(::GEOM_Object) aMainShape = _impl->GetObject(entry);
Handle(TColStd_HArray1OfInteger) anArray;
if(SeqS.Length()>0) {
// create a group
- GEOM::GEOM_IGroupOperations_var GOp = GetIGroupOperations(theStudy->StudyId());
+ GEOM::GEOM_IGroupOperations_var GOp = GetIGroupOperations();
GEOM::GEOM_Object_wrap GrObj = GOp->CreateGroup( theMainShape, SeqS(1).ShapeType() );
- AddInStudy(theStudy, GrObj, GrName, theMainShape._retn());
+ AddInStudy(GrObj, GrName, theMainShape._retn());
//CORBA::String_var GrEntry = GrObj->GetEntry();
- //Handle(GEOM_Object) HGrObj = _impl->GetObject(GrObj->GetStudyID(), GrEntry);
+ //Handle(::GEOM_Object) HGrObj = _impl->GetObject(GrEntry);
// add named objects
- //Handle(GEOM_Object) anObj;
+ //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(aMainShape->GetDocID(), GEOM_SUBSHAPE);
+ //anObj = GEOM_Engine::GetEngine()->AddObject(GEOM_SUBSHAPE);
//if (anObj.IsNull()) continue;
- //Handle(GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
+ //Handle(::GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
//if (aFunction.IsNull()) continue;
//GEOM_ISubShape aSSI(aFunction);
//aSSI.SetMainShape(aMainShape->GetLastFunction());
//SALOMEDS::SObject_var aResultSO;
//TCollection_AsciiString anEntry;
//TDF_Tool::Entry(anObj->GetEntry(),anEntry);
- //GEOM::GEOM_Object_var aGObj = GetObject(anObj->GetDocID(), anEntry.ToCString());
- //AddInStudy(theStudy, aGObj._retn(), SeqN.Value(i).ToCString(), GrObj);
+ //GEOM::GEOM_Object_var aGObj = GetObject(anEntry.ToCString());
+ //AddInStudy(aGObj._retn(), SeqN.Value(i).ToCString(), GrObj);
}
}
}
// purpose :
//============================================================================
GEOM::ListOfGO* GEOM_Gen_i::
- PublishNamedShapesInStudy(SALOMEDS::Study_ptr theStudy,
- //SALOMEDS::SObject_ptr theSObject,
+ PublishNamedShapesInStudy(//SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theObject)
{
//Unexpect aCatch(SALOME_SalomeException);
if(theMainShape->_is_nil()) return aResList._retn();
CORBA::String_var entry = theMainShape->GetEntry();
- Handle(GEOM_Object) aMainShape = Handle(GEOM_Object)::DownCast
- ( _impl->GetObject( theMainShape->GetStudyID(), entry ));
+ Handle(::GEOM_Object) aMainShape = Handle(::GEOM_Object)::DownCast
+ ( _impl->GetObject( entry ));
if (aMainShape.IsNull()) return aResList._retn();
TopoDS_Shape MainSh = aMainShape->GetValue();
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(MainSh, anIndices);
- CreateAndPublishGroup(theStudy, theMainShape, anIndices, SolidSeqS, SolidSeqN,
+ CreateAndPublishGroup(theMainShape, anIndices, SolidSeqS, SolidSeqN,
"Group_Of_Named_Solids", aResList);
- CreateAndPublishGroup(theStudy, theMainShape, anIndices, FaceSeqS, FaceSeqN,
+ CreateAndPublishGroup(theMainShape, anIndices, FaceSeqS, FaceSeqN,
"Group_Of_Named_Faces", aResList);
- CreateAndPublishGroup(theStudy, theMainShape, anIndices, EdgeSeqS, EdgeSeqN,
+ CreateAndPublishGroup(theMainShape, anIndices, EdgeSeqS, EdgeSeqN,
"Group_Of_Named_Edges", aResList);
- CreateAndPublishGroup(theStudy, theMainShape, anIndices, VertSeqS, VertSeqN,
+ 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,
+SALOMEDS::TMPFile* GEOM_Gen_i::Save(SALOMEDS::SComponent_ptr /*theComponent*/,
const char* theURL,
bool isMultiFile) {
SALOMEDS::TMPFile_var aStreamFile;
}
// Create a list to store names of created files
- SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
- aSeq->length(1);
+ 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
- (theComponent->GetStudy()->URL())).c_str());
- aNameWithExt += TCollection_AsciiString("_GEOM.sgd");
- aSeq[0] = CORBA::string_dup(aNameWithExt.ToCString());
+ 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(theComponent->GetStudy()->StudyId(),(char*) aFullName.ToCString());
- // Conver a file to the byte stream
- aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.c_str(), aSeq.in(), isMultiFile);
- // Remove the created file and tmp directory
- if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);
-
+ if (_impl->Save((char*) aFullName.ToCString())) {
+ // Convert 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();
}
}
// Conver the byte stream theStream to a file and place it in tmp directory
- SALOMEDS::ListOfFileNames_var aSeq =
+ 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 = theComponent->GetStudy();
- if (isMultiFile) {
- CORBA::String_var url = study->URL();
- aNameWithExt = (char*)SALOMEDS_Tool::GetNameFromPath(url.in()).c_str();
+ 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;
+ }
}
- aNameWithExt += "_GEOM.sgd";
+
TCollection_AsciiString aFullName = (TCollection_AsciiString((char*)aTmpDir.c_str()) + aNameWithExt);
// Open document
- if (!_impl->Load(study->StudyId(),(char*) aFullName.ToCString())) return false;
+ if (!_impl->Load((char*) aFullName.ToCString())) return false;
// Remove the created file and tmp directory
- if (!isMultiFile) SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);
+ 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:
useCaseBuilder->SetRootCurrent();
useCaseBuilder->Append( theComponent ); // component object is added as the top level item
}
-
- SALOMEDS::ChildIterator_wrap it = study->NewChildIterator( theComponent );
+
+ 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() );
// function : Close()
// purpose :
//============================================================================
-void GEOM_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
+void GEOM_Gen_i::Close(SALOMEDS::SComponent_ptr /*theComponent*/)
{
- SALOMEDS::Study_var aStudy= theComponent->GetStudy();
- _impl->Close(aStudy->StudyId());
+ _impl->Close();
}
//============================================================================
// function : CanPaste()
// purpose :
//============================================================================
-CORBA::Boolean GEOM_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) {
+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;
CORBA::Long theObjectID,
SALOMEDS::SObject_ptr theObject) {
// Find the current Study and StudyBuilder
- SALOMEDS::Study_var aStudy = theObject->GetStudy();
+ SALOMEDS::Study_var aStudy = getStudyServant();
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
SALOMEDS::UseCaseBuilder_var anUseCaseBuilder = aStudy->GetUseCaseBuilder();
SALOMEDS::SObject_var aNewSO;
BRep_Builder aBuilder;
try {
BRepTools::Read(aTopology, aStreamedBrep, aBuilder);
- } catch (Standard_Failure) {
+ } catch (Standard_Failure&) {
return aNewSO._retn();
}
//Create a new GEOM_Object
- Handle(GEOM_Object) anObj = _impl->AddObject(aNewSO->GetStudy()->StudyId(), theObjectID);
- Handle(GEOM_Function) aFunction = anObj->AddFunction(GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF);
+ 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(anObj->GetDocID(), anEntry.ToCString());
+ GEOM::GEOM_BaseObject_var obj = GetObject(anEntry.ToCString());
//Set the study entry of the published GEOM_Object
obj->SetStudyEntry(aNewSO->GetID());
// function : AddInStudy
// purpose :
//============================================================================
-SALOMEDS::SObject_ptr GEOM_Gen_i::AddInStudy (SALOMEDS::Study_ptr theStudy,
- GEOM::GEOM_BaseObject_ptr theObject,
+SALOMEDS::SObject_ptr GEOM_Gen_i::AddInStudy (GEOM::GEOM_BaseObject_ptr theObject,
const char* theName,
GEOM::GEOM_BaseObject_ptr theFather)
{
SALOMEDS::SObject_var aResultSO;
- if(theObject->_is_nil() || theStudy->_is_nil()) return aResultSO;
+ SALOMEDS::Study_var aStudy = getStudyServant();
+ if(theObject->_is_nil() || aStudy->_is_nil()) return aResultSO;
- SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
+ SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
CORBA::String_var IOR;
if(!theFather->_is_nil()) {
IOR = _orb->object_to_string(theFather);
- SALOMEDS::SObject_wrap aFatherSO = theStudy->FindObjectIOR(IOR.in());
+ 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(theStudy, aResultSO, theObject, theName);
+ aResultSO = PublishInStudy(aResultSO, theObject, theName);
if(aResultSO->_is_nil()) return aResultSO._retn();
GEOM::ListOfGBO_var aList = theObject->GetDependency();
GEOM::GEOM_BaseObject_var anObject = aList[i];
if(anObject->_is_nil()) continue;
IOR = _orb->object_to_string(anObject);
- SALOMEDS::SObject_wrap aSO = theStudy->FindObjectIOR(IOR.in());
+ 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);
- theStudy->GetUseCaseBuilder()->AppendTo( aResultSO, aSubSO );
+ aStudy->GetUseCaseBuilder()->AppendTo( aResultSO, aSubSO );
}
return aResultSO._retn();
// 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 (SALOMEDS::Study_ptr theStudy,
- GEOM::GEOM_Object_ptr theObject,
+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;
- if (CORBA::is_nil(theStudy) || CORBA::is_nil(theObject))
+ 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 = theStudy->FindObjectIOR(anIORo.in());
+ SALOMEDS::SObject_var aSO = aStudy->FindObjectIOR(anIORo.in());
//PTv, IMP 0020001, The salome object <aSO>
- // is not obligatory in case of invokation from script
+ // is not obligatory in case of invocation from script
// if (CORBA::is_nil(aSO))
// return aParts._retn();
- aParts = RestoreSubShapes(theStudy, theObject, aSO, theArgs,
+ aParts = RestoreSubShapes(theObject, aSO, theArgs,
theFindMethod, theInheritFirstArg, theAddPrefix);
if (!CORBA::is_nil(aSO)) aSO->UnRegister();
return aParts._retn();
// 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 (SALOMEDS::Study_ptr theStudy,
- GEOM::GEOM_Object_ptr theObject,
+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(theStudy) || CORBA::is_nil(theObject))
+ 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 = theStudy->FindObjectIOR(anIORo.in());
+ SALOMEDS::SObject_var aSO = getStudyServant()->FindObjectIOR(anIORo.in());
//PTv, IMP 0020001, The salome object <aSO>
- // is not obligatory in case of invokation from script
+ // is not obligatory in case of invocation from script
// if (CORBA::is_nil(aSO))
// return aParts._retn();
- aParts = RestoreGivenSubShapes(theStudy, theObject, aSO, theArgs,
+ aParts = RestoreGivenSubShapes(theObject, aSO, theArgs,
theFindMethod, theInheritFirstArg, theAddPrefix);
if (!CORBA::is_nil(aSO)) aSO->UnRegister();
return aParts._retn();
// 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::Study_ptr theStudy,
- SALOMEDS::SObject_ptr theSObject,
+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(theStudy) || CORBA::is_nil(theSObject))
+ if (CORBA::is_nil(getStudyServant()) || CORBA::is_nil(theSObject))
return aParts._retn();
SALOMEDS::GenericAttribute_var anAttr;
if (CORBA::is_nil(anO))
return aParts._retn();
- aParts = RestoreSubShapes(theStudy, anO, theSObject, theArgs,
+ aParts = RestoreSubShapes(anO, theSObject, theArgs,
theFindMethod, theInheritFirstArg, theAddPrefix);
return aParts._retn();
}
// 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(SALOMEDS::Study_ptr theStudy,
- GEOM::GEOM_Object_ptr theObject,
+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 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 invokation from script
- if (CORBA::is_nil(theStudy) || CORBA::is_nil(theObject) /*|| CORBA::is_nil(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)
// but only reconstruct its published sub-shapes
CORBA::String_var anIOR = _orb->object_to_string(aList[0]);
- SALOMEDS::SObject_var anArgSO = theStudy->FindObjectIOR(anIOR.in());
+ SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());
// remember restored objects for Python Dump
addToListOfGO(aList[0], anOutArgs);
- aParts = RestoreSubShapesOneLevel(theStudy, anArgSO, theSObject, theObject,
+ aParts = RestoreSubShapesOneLevel(anArgSO, theSObject, theObject,
anOutArgs, theFindMethod, theAddPrefix);
// set the color of the transformed shape to the color of initial shape
if (aList[0]->GetMarkerType() == GEOM::MT_USER)
theObject->SetMarkerTexture(aList[0]->GetMarkerTexture());
}
-
- anArgSO->UnRegister();
+ 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(theStudy->StudyId());
- GEOM::GEOM_IGroupOperations_var aGroupOp = GetIGroupOperations(theStudy->StudyId());
- GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations(theStudy->StudyId());
+ 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 = theStudy->NewBuilder();
+ 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 = theStudy->FindObjectIOR(anIOR.in());
+ SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());
TCollection_AsciiString anArgName;
if (CORBA::is_nil(anArgSO)) {
anArgName = "arg_";
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(anArgOTrsf->GetStudyID(), anArgOTrsfEntry);
- Handle(GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
+ 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();
+ Handle(::GEOM_Function) anOFun = theObject->GetLastFunction();
if (!anOFun.IsNull()) {
CORBA::String_var entryArg = anArgO->GetEntry();
- Handle(GEOM_Object) anArgOImpl = _impl->GetObject(anArgO->GetStudyID(), entryArg);
+ Handle(::GEOM_Object) anArgOImpl = _impl->GetObject(entryArg);
if (!anArgOImpl.IsNull()) {
TopoDS_Shape anArgOShape = anArgOImpl->GetValue();
TopoDS_Shape aMultiArgShape;
{}
}
GEOM::GEOM_Object_var anArgOMulti = (aMultiArgShape); // TODO
- Handle(GEOM_Function) anArgOMultiFun = anArgOMulti->GetLastFunction();
+ Handle(::GEOM_Function) anArgOMultiFun = anArgOMulti->GetLastFunction();
anArgOMultiFun->SetDescription("");
aSubO = aShapesOp->GetInPlace(theObject, anArgOMulti);
}
}
aSubName += anArgName;
aSubSO = aStudyBuilder->NewObject(theSObject);
- aSubSO = PublishInStudy(theStudy, aSubSO, aSubO, aSubName.ToCString());
+ aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
// Restore color
aSubO->SetColor(anArgO->GetColor());
// set the texture
GEOM::ListOfGO_var aSubParts;
if (theFindMethod == GEOM::FSM_GetInPlaceByHistory)
// pass theObject, because only it has the history
- aSubParts = RestoreSubShapesOneLevel(theStudy, anArgSO, aSubSO,
+ aSubParts = RestoreSubShapesOneLevel(anArgSO, aSubSO,
theObject, anOutArgs, theFindMethod, theAddPrefix);
else
- aSubParts = RestoreSubShapesOneLevel(theStudy, anArgSO, aSubSO,
+ aSubParts = RestoreSubShapesOneLevel(anArgSO, aSubSO,
aSubO, anOutArgs, theFindMethod, theAddPrefix);
// add to parts list
addToListOfGO( aSubParts, aParts );
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(theStudy, anArgSO, aSubSO,
+ RestoreSubShapesOneLevel(anArgSO, aSubSO,
theObject, anOutArgs, theFindMethod, theAddPrefix);
// add to parts list
aSubName = "from_parts_of_";
}
aSubName += anArgName;
- aSubSO = PublishInStudy(theStudy, aSubSO, aSubO, aSubName.ToCString());
+ aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
// Restore color
aSubO->SetColor(anArgO->GetColor());
// set the texture
}
}
} // try to build from published parts
- anArgSO->UnRegister();
+ if (!CORBA::is_nil(anArgSO))
+ anArgSO->UnRegister();
}
} // process arguments
}
aResParts->length(nb);
if (nb > 0)
{
- Handle(GEOM_BaseObject) aMainObj = _impl->GetObject(theObject->GetStudyID(), theObject->GetEntry());
- Handle(GEOM_Function) aFunction = aMainObj->GetLastFunction();
+ 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;
anObjEntryMap.insert(anEntry);
aResParts[nbRes++] = anObj;
// clear python dump of object
- Handle(GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetStudyID(), anEntry);
- Handle(GEOM_Function) anObjFun = aGeomObj->GetLastFunction();
+ Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anEntry);
+ Handle(::GEOM_Function) anObjFun = aGeomObj->GetLastFunction();
if ( !anObjFun.IsNull() )
anObjFun->SetDescription( "" );
if ( j > 0 )
GEOM::GEOM_Object_var anObj = anOutArgs[ i ];
if (CORBA::is_nil(anObj))
continue;
- Handle(GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetStudyID(), anObj->GetEntry());
+ Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetEntry());
if ( j > 0 )
pd << ", ";
pd << aGeomObj;
// function : RestoreSubShapesOneLevel
// purpose : Private method
//============================================================================
-GEOM::ListOfGO* GEOM_Gen_i::RestoreSubShapesOneLevel (SALOMEDS::Study_ptr theStudy,
- SALOMEDS::SObject_ptr theOldSO,
+GEOM::ListOfGO* GEOM_Gen_i::RestoreSubShapesOneLevel (SALOMEDS::SObject_ptr theOldSO,
SALOMEDS::SObject_ptr theNewSO,
GEOM::GEOM_Object_ptr theNewO,
GEOM::ListOfGO& theOutArgs,
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(theStudy) || CORBA::is_nil(theOldSO) ||
+ if (CORBA::is_nil(aStudy) || CORBA::is_nil(theOldSO) ||
CORBA::is_nil(theNewO) /*|| CORBA::is_nil(theNewSO)*/)
return aParts._retn();
- SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
+ 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(theStudy->StudyId());
- GEOM::GEOM_IGroupOperations_var aGroupOp = GetIGroupOperations(theStudy->StudyId());
- GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations(theStudy->StudyId());
+ 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 = theStudy->NewChildIterator(theOldSO);
+ SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(theOldSO);
int aLen = 0;
for (it->Init(); it->More(); it->Next()) {
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(anArgOTrsf->GetStudyID(), anArgOTrsfEntry);
- Handle(GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
+ Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
+ Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
anArgOTrsfFun->SetDescription("");
aNewSubO = aShapesOp->GetInPlace(theNewO, anArgOTrsf);
}
}
aSubName += anArgName;
aNewSubSO = aStudyBuilder->NewObject(theNewSO);
- aNewSubSO = PublishInStudy(theStudy, aNewSubSO, aNewSubO, aSubName.ToCString());
+ aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
// Restore color
aNewSubO->SetColor(anOldSubO->GetColor());
// set the texture
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(theStudy, anOldSubSO, aNewSubSO,
+ aSubParts = RestoreSubShapesOneLevel(anOldSubSO, aNewSubSO,
theNewO, theOutArgs, theFindMethod, theAddPrefix);
else
- aSubParts = RestoreSubShapesOneLevel(theStudy, anOldSubSO, aNewSubSO,
+ 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(theStudy, anOldSubSO, aNewSubSO,
+ RestoreSubShapesOneLevel(anOldSubSO, aNewSubSO,
theNewO, theOutArgs, theFindMethod, theAddPrefix);
// add to parts list
addToListOfGO( aSubParts, aNewParts );
aSubName = "from_parts_of_";
}
aSubName += anArgName;
- aNewSubSO = PublishInStudy(theStudy, aNewSubSO, aNewSubO, aSubName.ToCString());
+ aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
// Restore color
aNewSubO->SetColor(anOldSubO->GetColor());
// set the texture
// List theArgs in this case contains not only operation arguments,
// but also all subshapes, which must be published.
//============================================================================
-GEOM::ListOfGO* GEOM_Gen_i::RestoreGivenSubShapes(SALOMEDS::Study_ptr theStudy,
- GEOM::GEOM_Object_ptr theObject,
+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 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 invokation from script
- if (CORBA::is_nil(theStudy) || CORBA::is_nil(theObject) /*|| CORBA::is_nil(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
// Get all arguments
GEOM::ListOfGBO_var anOpArgsList = theObject->GetDependency();
- Standard_Integer nbArgsActual = anOpArgsList->length();
+ Standard_Integer nbOpArgs = anOpArgsList->length();
+ Standard_Integer nbArgsActual = nbOpArgs;
// If anOpArgsList list is empty, nothing to do
if (nbArgsActual == 0)
if (nbArgsActual < 1)
return aParts._retn();
- if (theInheritFirstArg || (nbArgsActual == 1)) {
+ 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 = theStudy->FindObjectIOR(anIOR.in());
+ SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());
- aParts = RestoreGivenSubShapesOneLevel(theStudy, anArgSO, theSObject, theObject,
+ aParts = RestoreGivenSubShapesOneLevel(anArgSO, theSObject, theObject,
anArgs, theFindMethod, theAddPrefix);
// set the color of the transformed shape to the color of initial shape
}
else {
// Get interface, containing method, which we will use to reconstruct sub-shapes
- GEOM::GEOM_IShapesOperations_var aShapesOp = GetIShapesOperations(theStudy->StudyId());
- GEOM::GEOM_IGroupOperations_var aGroupOp = GetIGroupOperations(theStudy->StudyId());
- GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations(theStudy->StudyId());
+ 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 = theStudy->NewBuilder();
+ 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 = theStudy->FindObjectIOR(anIOR.in());
+ SALOMEDS::SObject_var anArgSO = aStudy->FindObjectIOR(anIOR.in());
TCollection_AsciiString anArgName;
if (CORBA::is_nil(anArgSO)) {
anArgName = "arg_";
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(anArgOTrsf->GetStudyID(), anArgOTrsfEntry);
- Handle(GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
+ Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
+ Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
anArgOTrsfFun->SetDescription("");
aSubO = aShapesOp->GetInPlace(theObject, anArgOTrsf);
}
}
aSubName += anArgName;
aSubSO = aStudyBuilder->NewObject(theSObject);
- aSubSO = PublishInStudy(theStudy, aSubSO, aSubO, aSubName.ToCString());
+ aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
// Restore color
aSubO->SetColor(anArgO->GetColor());
// set the texture
GEOM::ListOfGO_var aSubParts;
if (theFindMethod == GEOM::FSM_GetInPlaceByHistory)
// pass theObject, because only it has the history
- aSubParts = RestoreGivenSubShapesOneLevel(theStudy, anArgSO, aSubSO,
+ aSubParts = RestoreGivenSubShapesOneLevel(anArgSO, aSubSO,
theObject, anArgs, theFindMethod, theAddPrefix);
else
- aSubParts = RestoreGivenSubShapesOneLevel(theStudy, anArgSO, aSubSO,
+ aSubParts = RestoreGivenSubShapesOneLevel(anArgSO, aSubSO,
aSubO, anArgs, theFindMethod, theAddPrefix);
// add to parts list
addToListOfGO( aSubParts, aParts );
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(theStudy, anArgSO, aSubSO,
+ RestoreGivenSubShapesOneLevel(anArgSO, aSubSO,
theObject, anArgs, theFindMethod, theAddPrefix);
// add to parts list
aSubName = "from_parts_of_";
}
aSubName += anArgName;
- aSubSO = PublishInStudy(theStudy, aSubSO, aSubO, aSubName.ToCString());
+ aSubSO = PublishInStudy(aSubSO, aSubO, aSubName.ToCString());
// Restore color
aSubO->SetColor(anArgO->GetColor());
// set the texture
aResParts->length(nb);
if (nb > 0)
{
- Handle(GEOM_BaseObject) aMainObj = _impl->GetObject(theObject->GetStudyID(), theObject->GetEntry());
- Handle(GEOM_Function) aFunction = aMainObj->GetLastFunction();
+ 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;
anObjEntryMap.insert(anEntry);
aResParts[nbRes++] = anObj;
// clear python dump of object
- Handle(GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetStudyID(), anEntry);
- Handle(GEOM_Function) anObjFun = aGeomObj->GetLastFunction();
+ Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anEntry);
+ Handle(::GEOM_Function) anObjFun = aGeomObj->GetLastFunction();
if ( !anObjFun.IsNull() )
anObjFun->SetDescription( "" );
if ( j > 0 )
GEOM::GEOM_Object_var anObj = theArgs[ i ];
if (CORBA::is_nil(anObj))
continue;
- Handle(GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetStudyID(), anObj->GetEntry());
+ Handle(::GEOM_BaseObject) aGeomObj = _impl->GetObject(anObj->GetEntry());
if ( j > 0 )
pd << ", ";
pd << aGeomObj;
// function : RestoreGivenSubShapesOneLevel
// purpose : Private method
//============================================================================
-GEOM::ListOfGO* GEOM_Gen_i::RestoreGivenSubShapesOneLevel (SALOMEDS::Study_ptr theStudy,
- SALOMEDS::SObject_ptr theOldSO,
+GEOM::ListOfGO* GEOM_Gen_i::RestoreGivenSubShapesOneLevel (SALOMEDS::SObject_ptr theOldSO,
SALOMEDS::SObject_ptr theNewSO,
GEOM::GEOM_Object_ptr theNewO,
std::set<std::string> theArgs,
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(theStudy) || CORBA::is_nil(theOldSO) ||
+ if (CORBA::is_nil(aStudy) || CORBA::is_nil(theOldSO) ||
CORBA::is_nil(theNewO) /*|| CORBA::is_nil(theNewSO)*/)
return aParts._retn();
- SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
+ 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(theStudy->StudyId());
- GEOM::GEOM_IGroupOperations_var aGroupOp = GetIGroupOperations(theStudy->StudyId());
- GEOM::GEOM_ITransformOperations_var aTrsfOp = GetITransformOperations(theStudy->StudyId());
+ 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 = theStudy->NewChildIterator(theOldSO);
+ SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(theOldSO);
int aLen = 0;
for (it->Init(); it->More(); it->Next()) {
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(anArgOTrsf->GetStudyID(), anArgOTrsfEntry);
- Handle(GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
+ Handle(::GEOM_BaseObject) anArgOTrsfImpl = _impl->GetObject(anArgOTrsfEntry);
+ Handle(::GEOM_Function) anArgOTrsfFun = anArgOTrsfImpl->GetLastFunction();
anArgOTrsfFun->SetDescription("");
aNewSubO = aShapesOp->GetInPlace(theNewO, anArgOTrsf);
}
}
aSubName += anArgName;
aNewSubSO = aStudyBuilder->NewObject(theNewSO);
- aNewSubSO = PublishInStudy(theStudy, aNewSubSO, aNewSubO, aSubName.ToCString());
+ aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
// Restore color
aNewSubO->SetColor(anOldSubO->GetColor());
// set the texture
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(theStudy, anOldSubSO, aNewSubSO,
+ aSubParts = RestoreGivenSubShapesOneLevel(anOldSubSO, aNewSubSO,
theNewO, theArgs, theFindMethod, theAddPrefix);
else
- aSubParts = RestoreGivenSubShapesOneLevel(theStudy, anOldSubSO, aNewSubSO,
+ 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(theStudy, anOldSubSO, aNewSubSO,
+ RestoreGivenSubShapesOneLevel(anOldSubSO, aNewSubSO,
theNewO, theArgs, theFindMethod, theAddPrefix);
// add to parts list
addToListOfGO( aSubParts, aNewParts );
aSubName = "from_parts_of_";
}
aSubName += anArgName;
- aNewSubSO = PublishInStudy(theStudy, aNewSubSO, aNewSubO, aSubName.ToCString());
+ aNewSubSO = PublishInStudy(aNewSubSO, aNewSubO, aSubName.ToCString());
// Restore color
aNewSubO->SetColor(anOldSubO->GetColor());
// set the texture
}
//============================================================================
-// function : register()
-// purpose : register 'name' in 'name_service'
+// function : findOrCreateComponent()
+// purpose : Find root study component; create if it does not exist
//============================================================================
-void GEOM_Gen_i::register_name(char * name)
+SALOMEDS::SComponent_var GEOM_Gen_i::findOrCreateComponent()
{
- GEOM::GEOM_Gen_var g = _this();
- name_service->Register(g, name);
+ SALOMEDS::SComponent_var aComponent;
+
+ SALOMEDS::Study_var aStudy = getStudyServant();
+ if (aStudy->_is_nil()) return aComponent;
+
+ SALOMEDS::GenericAttribute_var anAttr;
+ SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
+ SALOMEDS::UseCaseBuilder_wrap useCaseBuilder = aStudy->GetUseCaseBuilder();
+
+ aComponent = aStudy->FindComponent(ComponentDataType());
+ if (aComponent->_is_nil()) {
+ aComponent = aStudyBuilder->NewComponent(ComponentDataType());
+ anAttr = aStudyBuilder->FindOrCreateAttribute(aComponent.in(), "AttributeName");
+ SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
+ aName->SetValue("Geometry");
+ aName->UnRegister();
+ anAttr = aStudyBuilder->FindOrCreateAttribute(aComponent.in(), "AttributePixMap");
+ SALOMEDS::AttributePixMap_var aPixMap=SALOMEDS::AttributePixMap::_narrow(anAttr);
+ aPixMap->SetPixMap("ICON_OBJBROWSER_Geometry");
+ aPixMap->UnRegister();
+ aStudyBuilder->DefineComponentInstance(aComponent.in(), (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(aComponent.in()); // component object is added as the top level item
+ }
+ return aComponent;
}
//============================================================================
// function : Undo
// purpose :
//============================================================================
-void GEOM_Gen_i::Undo(CORBA::Long theStudyID)
+void GEOM_Gen_i::Undo()
{
- _impl->Undo(theStudyID);
+ _impl->Undo();
}
//============================================================================
// function : Redo
// purpose :
//============================================================================
-void GEOM_Gen_i::Redo(CORBA::Long theStudyID)
+void GEOM_Gen_i::Redo()
{
- _impl->Redo(theStudyID);
+ _impl->Redo();
}
//============================================================================
// function : GetIBasicOperations
// purpose :
//============================================================================
-GEOM::GEOM_IBasicOperations_ptr GEOM_Gen_i::GetIBasicOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IBasicOperations_ptr GEOM_Gen_i::GetIBasicOperations()
{
Unexpect aCatch(SALOME_SalomeException);
MESSAGE( "GEOM_Gen_i::GetIBasicOperations" );
//transfer reference on engine
GEOM_IBasicOperations_i* aServant =
- new GEOM_IBasicOperations_i(_poa, engine, _impl->GetIBasicOperations(theStudyID));
+ new GEOM_IBasicOperations_i(_poa, engine, _impl->GetIBasicOperations());
PortableServer::ObjectId_var id = _poa->activate_object(aServant);
// activate the CORBA servant
// function : GetITransformOperations
// purpose :
//============================================================================
-GEOM::GEOM_ITransformOperations_ptr GEOM_Gen_i::GetITransformOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_ITransformOperations_ptr GEOM_Gen_i::GetITransformOperations()
{
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(theStudyID));
+ new GEOM_ITransformOperations_i(_poa, engine, _impl->GetITransformOperations());
// activate the CORBA servant
GEOM::GEOM_ITransformOperations_var operations = aServant->_this();
// function : GetI3DPrimOperations
// purpose :
//============================================================================
-GEOM::GEOM_I3DPrimOperations_ptr GEOM_Gen_i::GetI3DPrimOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_I3DPrimOperations_ptr GEOM_Gen_i::GetI3DPrimOperations()
+
{
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(theStudyID));
+ new GEOM_I3DPrimOperations_i(_poa, engine, _impl->GetI3DPrimOperations());
PortableServer::ObjectId_var id = _poa->activate_object(aServant);
// activate the CORBA servant
// function : GetIShapesOperations
// purpose :
//============================================================================
-GEOM::GEOM_IShapesOperations_ptr GEOM_Gen_i::GetIShapesOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IShapesOperations_ptr GEOM_Gen_i::GetIShapesOperations()
+
{
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(theStudyID));
+ new GEOM_IShapesOperations_i(_poa, engine, _impl->GetIShapesOperations());
// activate the CORBA servant
GEOM::GEOM_IShapesOperations_var operations = aServant->_this();
// function : GetIBlocksOperations
// purpose :
//============================================================================
-GEOM::GEOM_IBlocksOperations_ptr GEOM_Gen_i::GetIBlocksOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IBlocksOperations_ptr GEOM_Gen_i::GetIBlocksOperations()
+
{
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(theStudyID));
+ new GEOM_IBlocksOperations_i(_poa, engine, _impl->GetIBlocksOperations());
// activate the CORBA servant
GEOM::GEOM_IBlocksOperations_var operations = aServant->_this();
// function : GetIBooleanOperations
// purpose :
//============================================================================
-GEOM::GEOM_IBooleanOperations_ptr GEOM_Gen_i::GetIBooleanOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IBooleanOperations_ptr GEOM_Gen_i::GetIBooleanOperations()
+
{
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(theStudyID));
+ new GEOM_IBooleanOperations_i(_poa, engine, _impl->GetIBooleanOperations());
// activate the CORBA servant
GEOM::GEOM_IBooleanOperations_var operations = aServant->_this();
// function : GetICurvesOperations
// purpose :
//============================================================================
-GEOM::GEOM_ICurvesOperations_ptr GEOM_Gen_i::GetICurvesOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_ICurvesOperations_ptr GEOM_Gen_i::GetICurvesOperations()
+
{
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(theStudyID));
+ new GEOM_ICurvesOperations_i(_poa, engine, _impl->GetICurvesOperations());
// activate the CORBA servant
GEOM::GEOM_ICurvesOperations_var operations = aServant->_this();
// function : GetILocalOperations
// purpose :
//============================================================================
-GEOM::GEOM_ILocalOperations_ptr GEOM_Gen_i::GetILocalOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_ILocalOperations_ptr GEOM_Gen_i::GetILocalOperations()
+
{
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(theStudyID));
+ new GEOM_ILocalOperations_i(_poa, engine, _impl->GetILocalOperations());
// activate the CORBA servant
GEOM::GEOM_ILocalOperations_var operations = aServant->_this();
// function : GetIHealingOperations
// purpose :
//============================================================================
-GEOM::GEOM_IHealingOperations_ptr GEOM_Gen_i::GetIHealingOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IHealingOperations_ptr GEOM_Gen_i::GetIHealingOperations()
+
{
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(theStudyID));
+ new GEOM_IHealingOperations_i(_poa, engine, _impl->GetIHealingOperations());
// activate the CORBA servant
GEOM::GEOM_IHealingOperations_var operations = aServant->_this();
// function : GetIInsertOperations
// purpose :
//============================================================================
-GEOM::GEOM_IInsertOperations_ptr GEOM_Gen_i::GetIInsertOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IInsertOperations_ptr GEOM_Gen_i::GetIInsertOperations()
+
{
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(theStudyID));
+ new GEOM_IInsertOperations_i(_poa, engine, _impl->GetIInsertOperations());
// activate the CORBA servant
GEOM::GEOM_IInsertOperations_var operations = aServant->_this();
// function : GetIMeasureOperations
// purpose :
//============================================================================
-GEOM::GEOM_IMeasureOperations_ptr GEOM_Gen_i::GetIMeasureOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IMeasureOperations_ptr GEOM_Gen_i::GetIMeasureOperations()
+
{
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(theStudyID));
+ new GEOM_IMeasureOperations_i(_poa, engine, _impl->GetIMeasureOperations());
// activate the CORBA servant
GEOM::GEOM_IMeasureOperations_var operations = aServant->_this();
// function : GetIGroupOperations
// purpose :
//============================================================================
-GEOM::GEOM_IGroupOperations_ptr GEOM_Gen_i::GetIGroupOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IGroupOperations_ptr GEOM_Gen_i::GetIGroupOperations()
+
{
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(theStudyID));
+ new GEOM_IGroupOperations_i(_poa, engine, _impl->GetIGroupOperations());
// activate the CORBA servant
GEOM::GEOM_IGroupOperations_var operations = aServant->_this();
// function : GetIFieldOperations
// purpose :
//============================================================================
-GEOM::GEOM_IFieldOperations_ptr GEOM_Gen_i::GetIFieldOperations(CORBA::Long theStudyID)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_IFieldOperations_ptr GEOM_Gen_i::GetIFieldOperations()
+
{
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(theStudyID));
+ new GEOM_IFieldOperations_i(_poa, engine, _impl->GetIFieldOperations());
// activate the CORBA servant
GEOM::GEOM_IFieldOperations_var operations = aServant->_this();
}
//============================================================================
-// function : GetPluginOperations
+// function : GetITestOperations
// purpose :
//============================================================================
-GEOM::GEOM_IOperations_ptr GEOM_Gen_i::GetPluginOperations(CORBA::Long theStudyID,
- const char* theLibName)
- throw ( SALOME::SALOME_Exception )
+GEOM::GEOM_ITestOperations_ptr GEOM_Gen_i::GetITestOperations()
{
- std::string aPlatformLibName;
-#ifdef WIN32
- aPlatformLibName = theLibName;
- aPlatformLibName += ".dll" ;
-#else
- aPlatformLibName = "lib";
- aPlatformLibName += theLibName;
- aPlatformLibName += ".so";
-#endif
+ Unexpect aCatch(SALOME_SalomeException);
+ MESSAGE( "GEOM_Gen_i::GetITestOperations" );
+
+ GEOM::GEOM_Gen_ptr engine = _this();
+
+ GEOM_ITestOperations_i* aServant =
+ new GEOM_ITestOperations_i(_poa, engine, _impl->GetITestOperations());
+ // activate the CORBA servant
+ GEOM::GEOM_ITestOperations_var operations = aServant->_this();
+ return operations._retn();
+}
+
+//============================================================================
+// function : GetICanonicalRecognition
+// purpose :
+//============================================================================
+GEOM::GEOM_ICanonicalRecognition_ptr GEOM_Gen_i::GetICanonicalRecognition()
+{
Unexpect aCatch(SALOME_SalomeException);
- MESSAGE( "GEOM_Gen_i::GetPluginOperations" );
+ MESSAGE("GEOM_Gen_i::GetICanonicalRecognition");
GEOM::GEOM_Gen_ptr engine = _this();
- GEOM_IOperations_i* aServant = 0;
- GEOM::GEOM_IOperations_var operations;
+ GEOM_ICanonicalRecognition_i* aServant =
+ new GEOM_ICanonicalRecognition_i(_poa, engine, _impl->GetICanonicalRecognition());
- try {
- // check, if corresponding operations are already created
- if (myOpCreatorMap.find(std::string(theLibName)) == myOpCreatorMap.end()) {
- // load plugin library
- LibHandle libHandle = LoadLib( aPlatformLibName.c_str()/*theLibName*/ );
- if (!libHandle) {
- // report any error, if occured
-#ifndef WIN32
- const char* anError = dlerror();
- throw(SALOME_Exception(anError));
-#else
- throw(SALOME_Exception(LOCALIZED( "Can't load server geometry plugin library" )));
-#endif
- }
+ // activate the CORBA servant
+ GEOM::GEOM_ICanonicalRecognition_var operations = aServant->_this();
+ return operations._retn();
+}
- // get method, returning operations creator
- typedef GEOM_GenericOperationsCreator* (*GetOperationsCreator)();
- GetOperationsCreator procHandle =
- (GetOperationsCreator)GetProc( libHandle, "GetOperationsCreator" );
- if (!procHandle) {
- throw(SALOME_Exception(LOCALIZED("bad geometry plugin library")));
- UnLoadLib(libHandle);
- }
+//============================================================================
+// function : GetPluginOperations
+// purpose :
+//============================================================================
+GEOM::GEOM_IOperations_ptr GEOM_Gen_i::GetPluginOperations(const char* theLibName)
+
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ MESSAGE( "GEOM_Gen_i::GetPluginOperations" );
- // get operations creator
- GEOM_GenericOperationsCreator* aCreator = procHandle();
- if (!aCreator) {
- throw(SALOME_Exception(LOCALIZED("bad geometry plugin library implementation")));
- }
+ GEOM::GEOM_Gen_ptr engine = _this();
- // map operations creator to a plugin name
- myOpCreatorMap[std::string(theLibName)] = aCreator;
- }
+ 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
- aServant = myOpCreatorMap[std::string(theLibName)]->Create(_poa, theStudyID, engine, _impl);
- //??? aServant->SetLibName(aPlatformLibName/*theLibName*/); // for persistency assurance
+ 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);
}
- if (!aServant)
- return operations._retn();
-
- // activate the CORBA servant
- operations = GEOM::GEOM_IOperations::_narrow( aServant->_this() );
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
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( theMainShape->GetStudyID(), entry ));
+ 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(Standard_Integer i = 0; i<theIndices.length(); i++) anArray->SetValue(i+1, theIndices[i]);
+ for(CORBA::ULong i = 0; i<theIndices.length(); i++) anArray->SetValue(i+1, theIndices[i]);
- Handle(GEOM_Object) anObject = _impl->AddSubShape(aMainShape, anArray, true);
+ 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(anObject->GetDocID(), anEntry.ToCString()));
+ return GEOM::GEOM_Object::_narrow( GetObject(anEntry.ToCString()));
}
//=============================================================================
void GEOM_Gen_i::RemoveObject(GEOM::GEOM_BaseObject_ptr theObject)
{
CORBA::String_var anEntry = theObject->GetEntry();
- Handle(GEOM_BaseObject) anObject = _impl->GetObject(theObject->GetStudyID(), anEntry, false);
+ Handle(::GEOM_BaseObject) anObject = _impl->GetObject(anEntry, false);
if (!anObject.IsNull())
_impl->RemoveObject(anObject);
}
// function : GetObject()
// purpose :
//=================================================================================
-GEOM::GEOM_BaseObject_ptr GEOM_Gen_i::GetObject (CORBA::Long theStudyID, const char* theEntry)
+GEOM::GEOM_BaseObject_ptr GEOM_Gen_i::GetObject (const char* theEntry)
{
GEOM::GEOM_BaseObject_var obj;
- Handle(GEOM_BaseObject) handle_object = _impl->GetObject(theStudyID, (char*)theEntry);
+ Handle(::GEOM_BaseObject) handle_object = _impl->GetObject((char*)theEntry);
if (handle_object.IsNull()) return obj._retn();
TCollection_AsciiString stringIOR = handle_object->GetIOR();
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 ));
+ 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();
+ 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:
break;
}
default:
- servant = new GEOM_Object_i (_poa, engine, Handle(GEOM_Object)::DownCast( handle_object ));
+ servant = new GEOM_Object_i (_poa, engine, Handle(::GEOM_Object)::DownCast( handle_object ));
}
PortableServer::ObjectId_var id = _poa->activate_object(servant);
// function : getObjectInfo()
// purpose : returns an information for a given object by its entry
//=================================================================================
-char* GEOM_Gen_i::getObjectInfo(CORBA::Long studyId, const char* entry)
+char* GEOM_Gen_i::getObjectInfo(const char* entry)
{
GEOM::GEOM_Object_var aGeomObject;
- CORBA::Object_var aSMObject = name_service->Resolve( "/myStudyManager" );
- SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow( aSMObject );
- SALOMEDS::Study_var aStudy = aStudyManager->GetStudyByID( studyId );
- SALOMEDS::SObject_var aSObj = aStudy->FindObjectID( entry );
+ SALOMEDS::SObject_var aSObj = getStudyServant()->FindObjectID( entry );
SALOMEDS::SObject_var aResultSObj;
if (aSObj->ReferencedObject(aResultSObj))
aSObj = aResultSObj;
SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
CORBA::String_var aVal = anIOR->Value();
anIOR->UnRegister();
- CORBA::Object_var anObject = aStudy->ConvertIORToObject(aVal);
+ CORBA::Object_var anObject = getStudyServant()->ConvertIORToObject(aVal);
aGeomObject = GEOM::GEOM_Object::_narrow(anObject);
}
if (!aSObj->_is_nil() )
GEOM::ListOfLong_var anInts;
GEOM::ListOfDouble_var aDbls;
- GEOM::GEOM_IMeasureOperations_var anOp = GetIMeasureOperations( studyId );
+ GEOM::GEOM_IMeasureOperations_var anOp = GetIMeasureOperations();
aKind = anOp->KindOfShape( aGeomObject, anInts, aDbls );
if ( anOp->IsDone() ) {
case GEOM::GEOM_IKindOfShape::SEGMENT:
aTypeInfo = "Segment";
break;
+ case GEOM::GEOM_IKindOfShape::CRV_BSPLINE:
+ aTypeInfo = "Crv BSpline";
+ break;
+ case GEOM::GEOM_IKindOfShape::CRV_BEZIER:
+ aTypeInfo = "Crv Bezier";
+ break;
+ case GEOM::GEOM_IKindOfShape::HYPERBOLA:
+ aTypeInfo = "Hyperbola";
+ break;
+ case GEOM::GEOM_IKindOfShape::PARABOLA:
+ aTypeInfo = "Parabola";
+ break;
case GEOM::GEOM_IKindOfShape::EDGE:
aTypeInfo = "Edge";
break;
}
}
- char* anInfo = new char[strlen("Module ") + strlen(ComponentDataType()) + strlen(", ") + strlen(aTypeInfo) + 3];
- sprintf(anInfo, "Module %s, %s", ComponentDataType(), aTypeInfo);
+ 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;
// 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_ptr GEOM_Gen_i::CreateFolder(const char* theName,
+ SALOMEDS::SObject_ptr theFather)
{
SALOMEDS::SObject_var aFolderSO;
+ if ( CORBA::is_nil(theFather) ) {
+ SALOMEDS::SComponent_var aComponent = findOrCreateComponent();
+ if (aComponent->_is_nil()) return aFolderSO._retn();
+ theFather = SALOMEDS::SObject::_narrow(aComponent);
+ }
if ( CORBA::is_nil(theFather) ) return aFolderSO._retn();
SALOMEDS::GenericAttribute_var anAttr;
aLocalID->UnRegister();
}
- SALOMEDS::Study_var aStudy = theFather->GetStudy();
+ SALOMEDS::Study_var aStudy = getStudyServant();
SALOMEDS::StudyBuilder_var aStudyBuilder( aStudy->NewBuilder() );
aFolderSO = aStudyBuilder->NewObject( theFather );
// function : MoveToFolder()
// purpose : Moves GEOM object to the specified folder
//=================================================================================
-void GEOM_Gen_i::MoveToFolder(GEOM::GEOM_Object_ptr theObject,
- SALOMEDS::SObject_ptr theFolder) {
+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 = theFolder->GetStudy()->FindObjectID( theObject->GetStudyEntry() );
+ 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) {
+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 );
SALOMEDS::SObject_var aSO;
for (int i = 0; i < aLen; i++) {
aGO = GEOM::GEOM_Object::_duplicate( theListOfGO[i] );
- aSO = theFolder->GetStudy()->FindObjectID( aGO->GetStudyEntry() );
+ aSO = getStudyServant()->FindObjectID( aGO->GetStudyEntry() );
objects[i] = aSO;
}
if ( objects->length() > 0 )
//=================================================================================
// function : Move()
-// purpose : Moves objects to the specified position.
+// 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 )
+ SALOMEDS::SObject_ptr where,
+ CORBA::Long row )
{
if ( CORBA::is_nil( where ) ) return;
- SALOMEDS::Study_var study = where->GetStudy();
+ 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
objAfter = useCaseIt->Value();
}
}
-
- for ( int i = 0; i < what.length(); i++ ) {
+
+ 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
}
}
-//=================================================================================
-// function : importData
-// purpose : imports geometrical data file into the GEOM internal data structure
-//=================================================================================
-Engines::ListOfIdentifiers* GEOM_Gen_i::importData(
- CORBA::Long studyId, Engines::DataContainer_ptr data, const Engines::ListOfOptions& options)
+//=======================================================================
+// function : GetDependencyTree
+// purpose : Collects dependencies of the given objects from other ones
+//=======================================================================
+SALOMEDS::TMPFile* GEOM_Gen_i::GetDependencyTree( const GEOM::string_array& theObjectEntries )
{
- CORBA::Object_var aSMObject = name_service->Resolve( "/myStudyManager" );
- SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow( aSMObject );
- SALOMEDS::Study_var aStudy = aStudyManager->GetStudyByID( studyId );
-
- Engines::ListOfIdentifiers_var aResult = new Engines::ListOfIdentifiers;
- GEOM::GEOM_IInsertOperations_var aInsOp = GetIInsertOperations(aStudy->StudyId());
- if (aInsOp->_is_nil()) {
- MESSAGE("No insert operations!");
- return aResult._retn();
+ // 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 ) ) );
}
- // Get a temporary directory to store a file
- std::string aTmpDir = SALOMEDS_Tool::GetTmpDir();
- std::string aFileName("file");
- if (aFileName.rfind("/") != std::string::npos) { // remove folders from the name
- aFileName = aFileName.substr(aFileName.rfind("/") + 1);
- }
+ // translation the tree into string
+ std::string treeStr;
+ GEOMUtils::ConvertTreeToString( tree, treeStr );
- std::string anExtension(data->extension());
- aFileName += "." + anExtension;
- // convert extension to upper case
- std::transform(anExtension.begin(), anExtension.end(), anExtension.begin(), ::toupper);
- std::string aFullPath = aTmpDir + aFileName;
+ // put string into stream
+ char* aBuffer = (char*)CORBA::string_dup(treeStr.c_str());
+ int aBufferSize = strlen((char*)aBuffer);
- Engines::TMPFile* aFileStream = data->get();
- const char *aBuffer = (const char*)aFileStream->NP_data();
-#ifdef WIN32
- std::ofstream aFile(aFullPath.c_str(), std::ios::binary);
-#else
- std::ofstream aFile(aFullPath.c_str());
-#endif
- aFile.write(aBuffer, aFileStream->length());
- aFile.close();
-
- GEOM::GEOM_Object_var aShapeObj;
- GEOM::ListOfGO_var aSubShape = new GEOM::ListOfGO;
- GEOM::ListOfGO_var aGroups = new GEOM::ListOfGO;
- GEOM::ListOfFields_var aFields = new GEOM::ListOfFields;
-
- CORBA::Boolean isResultOK = aInsOp->ImportXAO(aFullPath.c_str(), aShapeObj.out(), aSubShape.out(), aGroups.out(), aFields.out());
-
- if ( isResultOK && !aShapeObj->_is_nil() && aInsOp->IsDone() ) {
- SALOMEDS::SObject_var aSO = PublishInStudy(aStudy, SALOMEDS::SObject::_nil(), aShapeObj, aShapeObj->GetName());
- aResult->length(aGroups->length() + 1);
- aResult[0] = aSO->GetID(); // unioque identifer of the object in GEOM is entry of SObject
- //Iteration for objects of the group.
- for (int i = 0; i < aGroups->length(); i++) {
- SALOMEDS::SObject_var aSOChild = AddInStudy(aStudy, aGroups[i], aGroups[i]->GetName(), aShapeObj);
- aResult[i+1] = aSOChild->GetID();
- }
- }
- else {
- if (aShapeObj->_is_nil())
- MESSAGE("Result of the import operation is incorrect for file "<<aFullPath.c_str());
- if (!aInsOp->IsDone())
- MESSAGE("Import operation is not done for file "<<aFullPath.c_str());
- if (!isResultOK)
- MESSAGE("ImportXAO operation is failed for file "<<aFullPath.c_str());
- return aResult._retn();
- }
+ CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer;
- // remove temporary file and directory
- SALOMEDS::ListOfFileNames aTmpFiles;
- aTmpFiles.length(1);
- aTmpFiles[0] = aFileName.c_str();
- SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir, aTmpFiles, true);
+ SALOMEDS::TMPFile_var aStream = new SALOMEDS::TMPFile(aBufferSize, aBufferSize, anOctetBuf, 1);
- _impl->DocumentModified(studyId, false);
- return aResult._retn();
+ return aStream._retn();
}
-//=================================================================================
-// function : getModifiedData
-// purpose : exports all geometry of this GEOM module into one BRep file
-//=================================================================================
-Engines::ListOfData* GEOM_Gen_i::getModifiedData(CORBA::Long studyId)
-{
- Engines::ListOfData_var aResult = new Engines::ListOfData;
-
- if (!_impl->DocumentModified(studyId)) {
- MESSAGE("Document is not modified")
- return aResult._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;
+ }
+}
- CORBA::Object_var aSMObject = name_service->Resolve("/myStudyManager");
- SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow( aSMObject );
- SALOMEDS::Study_var aStudy = aStudyManager->GetStudyByID( studyId );
- SALOMEDS::SComponent_var aComponent = aStudy->FindComponent("GEOM");
- if (CORBA::is_nil(aComponent))
- return aResult._retn();
- SALOMEDS::ChildIterator_var anIter = aStudy->NewChildIterator(aComponent); // check only published shapes
-
- GEOM::GEOM_Object_var shapeObj;
- GEOM::ListOfGO_var groups = new GEOM::ListOfGO;
- GEOM::ListOfFields_var fields = new GEOM::ListOfFields;
- std::string anAuthorName = "SIMAN Author";
-
- GEOM::GEOM_IShapesOperations_var aShapesOp = GetIShapesOperations(aStudy->StudyId());
- GEOM::GEOM_IInsertOperations_var aInsOp = GetIInsertOperations(aStudy->StudyId());
-
- int aSeqLength = 0; // the sequence length
- for(; anIter->More(); anIter->Next()) {
- SALOMEDS::SObject_var aSO = anIter->Value();
- SALOMEDS::SObject_var aRefSO;
- // export only not referenced objects, or referenced outside of GEOM
- if (!aSO->ReferencedObject(aRefSO) || aRefSO->GetFatherComponent()->GetID() != aComponent->GetID()) {
- CORBA::Object_var anObj = aSO->GetObject();
- if (!CORBA::is_nil(anObj)) {
- GEOM::GEOM_Object_var aCORBAMainShape = GEOM::GEOM_Object::_narrow(anObj);
- if(!aCORBAMainShape->_is_nil()) {
- CORBA::String_var entry = aCORBAMainShape->GetEntry();
- Handle(GEOM_Object) aMainShape = Handle(GEOM_Object)::DownCast(_impl->GetObject(studyId, entry));
-
- GEOM::shape_type aCORBAShapeType = aCORBAMainShape->GetShapeType();
- if (!aMainShape.IsNull() && !(aCORBAShapeType == GEOM::VERTEX) && !(aCORBAShapeType == GEOM::EDGE)) {
- aSeqLength++;
- shapeObj = aCORBAMainShape;
- if (aShapesOp->_is_nil()) {
- MESSAGE("No shapes operations!");
- return aResult._retn();
+//=======================================================================
+// 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 ];
}
- groups = aShapesOp->GetExistingSubObjects(aCORBAMainShape, true);
- break;
}
+ 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;
}
}
}
}
+}
- if (aInsOp->_is_nil()) {
- MESSAGE("No insert operations!");
- return aResult._retn();
+//==============================================================================
+// 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] ) );
}
- if (aSeqLength > 0) { // Shape is correct, write it to the temporary file
+ 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;
- std::string aFullXaoPath = Kernel_Utils::GetTmpFileName() + ".xao";
- CORBA::Boolean isResultOK = aInsOp->ExportXAO(shapeObj.in(), groups.in(), fields.in(), anAuthorName.c_str(), aFullXaoPath.c_str());
+ // filling list of sub-objects
+ for ( it = aSelected.begin(); it != aSelected.end(); ++it ) {
+ includeSubObjects( *it, aSelected, aParents, aChildren, anOthers );
+ }
- aResult->length(1);
- Engines::DataContainer_var aData = (new Engines_DataContainer_i(
- aFullXaoPath.c_str(), "", "", true))->_this();
- aResult[0] = aData;
- } else {
- MESSAGE("No shapes to export");
+ // 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() );
}
+}
- return aResult._retn();
+//==============================================================================
+// 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 );
+ }
}
-
-//=====================================================================================
-// EXPORTED METHODS
-//=====================================================================================
-extern "C"
+
+//==============================================================================
+// 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)
{
- /*
- 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();
+ 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 );
}
}
+
