Corrected according to the new scheme.

src/GEOMGUI/GeometryGUI_Swig.cxx

@@ -29,6 +29,24 @@
 #include "GeometryGUI_Swig.hxx"
 #include "SALOMEGUI_Swig.hxx"
 
+#include "GeometryGUI.h"
+
+#include <SUIT_Session.h>
+#include <SalomeApp_Application.h>
+#include <SalomeApp_Study.h>
+#include <SalomeApp_ImportOperation.h>
+
+#include <OB_Browser.h>
+
+#include <OCCViewer_ViewWindow.h>
+#include <OCCViewer_ViewManager.h>
+#include <SOCC_ViewModel.h>
+
+#include <VTKViewer_ViewWindow.h>
+#include <VTKViewer_ViewModel.h>
+#include <VTKViewer_RenderWindowInteractor.h>
+#include <SVTK_ViewWindow.h>
+#include <SVTK_RenderWindowInteractor.h>
 
 #include "GEOM_Actor.h"
 #include "GEOM_Client.hxx"
@@ -36,12 +54,55 @@
 #include "GEOM_AssemblyBuilder.h"
 #include "GEOM_InteractiveObject.hxx"
 
+#include <SALOME_Event.hxx>
+
+#include <TopExp_Explorer.hxx>
+#include <TopTools_MapOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <BRepAdaptor_Surface.hxx>
+#include <BRepAdaptor_Curve.hxx>
+#include <GeomAbs_CurveType.hxx>
+#include <GeomAbs_SurfaceType.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Iterator.hxx>
+#include <AIS_ListOfInteractive.hxx>
+#include <AIS_ListIteratorOfListOfInteractive.hxx>
+#include <V3d_Viewer.hxx>
+
 #include "utilities.h"
 
 using namespace std;
 
+#include "SALOMEDSClient.hxx"
+#include "SALOMEDS_SObject.hxx"
+#include "SALOMEDS_Study.hxx"
+
 static GEOM_Client ShapeReader;
 
+inline OCCViewer_Viewer* GetOCCViewer(SUIT_Application* theApp){
+  SUIT_ViewWindow* window = theApp->desktop()->activeWindow();
+  if(window && window->getViewManager()->getType() == OCCViewer_Viewer::Type()){
+    OCCViewer_ViewWindow* vw = dynamic_cast<OCCViewer_ViewWindow*>( window );
+    if ( vw ) {
+      OCCViewer_ViewManager* vm = dynamic_cast<OCCViewer_ViewManager*>( vw->getViewManager() );
+      if ( vm ) 
+	return vm->getOCCViewer();
+    }
+  }
+  
+  return 0;
+}
+
+inline SVTK_ViewWindow* GetSVTKViewWindow(SUIT_Application* theApp){
+  SUIT_ViewWindow* window = theApp->desktop()->activeWindow();
+  if(window && window->getViewManager()->getType() == VTKViewer_Viewer::Type())
+    return dynamic_cast<SVTK_ViewWindow*>( window );
+  
+  return 0;
+}
 
 GEOM_Swig::GEOM_Swig()
 {
@@ -57,35 +118,365 @@ void GEOM_Swig::createAndDisplayGO(const char* Entry)
 {
   // MESSAGE("createAndDisplayGO");
   
+  SUIT_Application* app = SUIT_Session::session()->activeApplication();
+  if ( !app ) return;
+  
+  SalomeApp_Study* ActiveStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
+  if ( !ActiveStudy ) return;
+  
+  _PTR(Study) aStudy(ActiveStudy->studyDS());
+  _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
+  
+  GEOM::GEOM_Gen_var Geom   = GeometryGUI::GetGeomGen();
+  if ( CORBA::is_nil( Geom ) )
+    return;
+
+  string aFatherIOR;
+  _PTR(SComponent) father = aStudy->FindComponent("GEOM");
+  aStudyBuilder->DefineComponentInstance( father, SalomeApp_Application::orb()->object_to_string(Geom) );
+  father->ComponentIOR(aFatherIOR);
+  
+  _PTR(SObject) fatherSF;
+
+  _PTR(SObject) obj = aStudy->FindObjectID(Entry);
+  _PTR(GenericAttribute) anAttr;
+  
+  // Create new actor
+  if ( !obj->FindAttribute(anAttr, "AttributeIOR")) 
+    return;
+  _PTR(AttributeIOR) anIOR(anAttr);
+  string anIORValue = anIOR->Value();
+  
+  GEOM::GEOM_Object_var aShape = Geom->GetIORFromString(anIORValue.c_str());
+  TopoDS_Shape Shape = ShapeReader.GetShape(Geom,aShape);
+  
+  if ( obj ) {
+    if (obj->FindAttribute(anAttr, "AttributeName")) {
+      _PTR(AttributeName) aName ( anAttr );
+      string aNameValue = aName->Value();
+      // open transaction
+      SUIT_Operation* op = new SalomeApp_ImportOperation( app );
+      op->start();
+      
+      _PTR(SObject) newObj1 = aStudyBuilder->NewObject(father);
+      aStudyBuilder->Addreference(newObj1, obj);
+      // commit transaction
+      op->commit();
+		  
+      Handle(GEOM_InteractiveObject) anIO = new GEOM_InteractiveObject(const_cast<char*>(anIORValue.c_str()),
+								       const_cast<char*>(aFatherIOR.c_str()),
+								       "GEOM",
+								       const_cast<char*>( obj->GetID().c_str() ));
+      
+      class TEvent: public SALOME_Event{
+        SUIT_Application* myApp;
+        TopoDS_Shape myShape;
+        Handle(SALOME_InteractiveObject) myIO;
+        const char* myName;
+      public:
+        TEvent(SUIT_Application* theApp, TopoDS_Shape theShape,
+	       const Handle(SALOME_InteractiveObject)& theIO, 
+	       const char* theName):
+	  myApp(theApp), myShape(theShape),
+	  myIO(theIO), myName(theName)
+        {}
+        virtual void Execute(){
+	  if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
+	    SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
+	    int aMode = myRenderInter->GetDisplayMode();
+	    
+	    vtkActorCollection* theActors = GEOM_AssemblyBuilder::BuildActors(myShape,0,aMode,true);
+	    theActors->InitTraversal();
+	    while(vtkActor* anActor = theActors->GetNextActor()){
+	      GEOM_Actor* GActor = GEOM_Actor::SafeDownCast(anActor);
+	      GActor->setName(const_cast<char*>(myName));
+	      GActor->setIO(myIO);
+	      myRenderInter->Display(GActor);
+	    }
+	    myRenderInter->Update();
+	  }else if( OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)){
+	    Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();
+	    Handle(GEOM_AISShape) aSh = new GEOM_AISShape(myShape,const_cast<char*>(myName));
+	    aSh->setName(const_cast<char*>(myName));
+	    aSh->setIO(myIO);
+	    ic->Display(aSh);
+	    ic->AddOrRemoveCurrentObject(aSh,true);
+	  }
+	  // update object browser
+	  SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(myApp);
+	  if (app) {
+	    CAM_Module* module = app->module( "Geometry" );
+	    SalomeApp_Module* appMod = dynamic_cast<SalomeApp_Module*>( module );
+	    if ( appMod )
+	      appMod->updateObjBrowser( true );
+	  }
+	  
+	}
+      };
+      ProcessVoidEvent(new TEvent(app,Shape,anIO,aNameValue.c_str()));
+    }
+  }
 }
 
 
 int  GEOM_Swig::getIndexTopology(const char* SubIOR, const char* IOR)
 {
+  GEOM::GEOM_Gen_var Geom   = GeometryGUI::GetGeomGen();
+  if ( CORBA::is_nil( Geom ) )
+    return -1;
   
+  GEOM::GEOM_Object_var aMainShape = Geom->GetIORFromString(IOR);
+  TopoDS_Shape shape = ShapeReader.GetShape(Geom, aMainShape);
+
+  GEOM::GEOM_Object_var aSubShape = Geom->GetIORFromString(SubIOR);
+  TopoDS_Shape subshape = ShapeReader.GetShape(Geom, aSubShape);
+
+  int index = 1;
+  if(subshape.ShapeType() == TopAbs_COMPOUND) { 
+    TopoDS_Iterator it; 
+    TopTools_ListOfShape CL; 
+    CL.Append(shape); 
+    TopTools_ListIteratorOfListOfShape itC; 
+    for(itC.Initialize(CL); itC.More(); itC.Next()) {
+      for(it.Initialize(itC.Value()); it.More(); it.Next()) { 
+	if (it.Value().ShapeType() == TopAbs_COMPOUND) {
+	  if (it.Value().IsSame(subshape))
+	    return index; 
+	  else 
+	    index++; 
+	  CL.Append(it.Value()); 
+	}
+      } 
+    } 
+  } 
+  else { 
+    TopExp_Explorer Exp(shape, subshape.ShapeType()); 
+    TopTools_MapOfShape M; 
+    while(Exp.More()) { 
+      if(M.Add(Exp.Current())) {
+	if(Exp.Current().IsSame(subshape)) 
+	  return index; 
+	index++; 
+      } 
+      Exp.Next(); 
+    } 
+  } 
   return -1;
 }
 
 const char* GEOM_Swig::getShapeTypeString(const char* IOR)
 {
+  GEOM::GEOM_Gen_var Geom   = GeometryGUI::GetGeomGen();
+  if ( CORBA::is_nil( Geom ) )
+    return 0;
  
+  GEOM::GEOM_Object_var aShape = Geom->GetIORFromString(IOR);
+  TopoDS_Shape shape    = ShapeReader.GetShape(Geom, aShape);
+
+  if( shape.IsNull() ) {
+    return "Null Shape" ;
+  }
+
+  switch (shape.ShapeType() )
+  {
+  case TopAbs_COMPOUND:
+    { return "Compound" ;}
+  case  TopAbs_COMPSOLID:
+    { return "Compound Solid" ;}
+  case TopAbs_SOLID:
+    { return "Solid" ;}
+  case TopAbs_SHELL:
+    { return "Shell" ;}
+  case TopAbs_FACE:
+    { 
+      BRepAdaptor_Surface surf(TopoDS::Face(shape));
+      if ( surf.GetType() == GeomAbs_Plane ) {
+	return "Plane" ;
+      } else if ( surf.GetType() == GeomAbs_Cylinder ) {
+	return "Cylindrical Face" ;
+      } else if ( surf.GetType() == GeomAbs_Sphere ) {
+	return "Spherical Face" ;
+      } else if ( surf.GetType() == GeomAbs_Torus ) {
+	return "Toroidal Face" ;
+      } else if ( surf.GetType() == GeomAbs_Cone ) {
+	return "Conical Face" ;
+      } else {
+	return "GEOM::FACE" ;
+      }
+    }
+  case TopAbs_WIRE:
+    { return "Wire" ;}
+  case TopAbs_EDGE:
+    { 
+      BRepAdaptor_Curve curv(TopoDS::Edge(shape));
+      if ( curv.GetType() == GeomAbs_Line ) {
+	if ( (Abs(curv.FirstParameter()) >= 1E6 ) || 
+	     (Abs(curv.LastParameter()) >= 1E6 )) {
+	  return "Line" ;
+	} else
+	  return "Edge" ;
+      } else if ( curv.GetType() == GeomAbs_Circle ) {
+	if ( curv.IsClosed() )
+	  return "Circle" ;
+	else
+	  return "Arc" ;
+      } else {
+	return "Edge" ;
+      }
+    }
+  case TopAbs_VERTEX:
+    { return "Vertex" ;}
+  case TopAbs_SHAPE:
+    { return "Shape" ;}
+  }
   return 0;
 }
 
 
 const char* GEOM_Swig::getShapeTypeIcon(const char* IOR)
 {
+  GEOM::GEOM_Gen_var Geom   = GeometryGUI::GetGeomGen();
+  if ( CORBA::is_nil( Geom ) )
+    return "None";
+  
+  GEOM::GEOM_Object_var aShape = Geom->GetIORFromString(IOR);
+  TopoDS_Shape shape = ShapeReader.GetShape(Geom, aShape);
+
+  if( shape.IsNull() ) {
+    return "None" ;
+  }
+      
+  switch (shape.ShapeType() )
+    {
+    case TopAbs_COMPOUND:
+      { return "ICON_OBJBROWSER_COMPOUND" ;}
+    case  TopAbs_COMPSOLID:
+      { return "ICON_OBJBROWSER_COMPSOLID" ;}
+    case TopAbs_SOLID:
+      { return "ICON_OBJBROWSER_SOLID" ;}
+    case TopAbs_SHELL:
+      { return "ICON_OBJBROWSER_SHELL" ;}
+    case TopAbs_FACE:
+      { return "ICON_OBJBROWSER_FACE" ;}
+    case TopAbs_WIRE:
+      { return "ICON_OBJBROWSER_WIRE" ;}
+    case TopAbs_EDGE:
+      { return "ICON_OBJBROWSER_EDGE" ;}
+    case TopAbs_VERTEX:
+      { return "ICON_OBJBROWSER_VERTEX" ;}
+    }
+  
   return "None";
 }
 
 void GEOM_Swig::setDisplayMode(const char* theEntry, int theMode)
 {
+  SUIT_Application* app = SUIT_Session::session()->activeApplication();
+  if ( !app ) return;
+  
+  Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry, "GEOM", "");
+  
+  class TEvent: public SALOME_Event{
+    SUIT_Application* myApp;
+    Handle(SALOME_InteractiveObject) myIO;
+    int myParam;
+  public:
+    TEvent(SUIT_Application* theApp, const Handle(SALOME_InteractiveObject)& theIO, int theParam):
+      myApp(theApp), myIO(theIO), myParam(theParam)
+    {}
+    virtual void Execute(){
+      if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
+	SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
+	myRenderInter->SetDisplayMode(myIO,myParam);
+	myRenderInter->Update();
+      }
+      else if(OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)) {
+	SOCC_Viewer* soccViewer = dynamic_cast<SOCC_Viewer*>( occViewer );
+	if (soccViewer)
+	  soccViewer->switchRepresentation(myIO,myParam);
+      }
+    }
+  };
+
+  ProcessVoidEvent(new TEvent(app,anIO,theMode));
 }
 
 void GEOM_Swig::setColor(const char* theEntry, int red, int green, int blue)
 {
+  SUIT_Application* app = SUIT_Session::session()->activeApplication();
+  if ( !app ) return;
+
+  Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry, "GEOM", "");
+
+  QColor aColor(red,green,blue);
+
+  class TEvent: public SALOME_Event{
+    SUIT_Application* myApp;
+    Handle(SALOME_InteractiveObject) myIO;
+    QColor myParam;
+  public:
+    TEvent(SUIT_Application* theApp, const Handle(SALOME_InteractiveObject)& theIO, const QColor& theParam):
+      myApp(theApp), myIO(theIO), myParam(theParam)
+    {}
+    virtual void Execute(){
+      if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
+	SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
+	myRenderInter->SetColor(myIO,myParam);
+	myRenderInter->Update();
+      }else if(OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)){
+	Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();
+	AIS_ListOfInteractive List;
+	ic->DisplayedObjects(List);
+	AIS_ListIteratorOfListOfInteractive ite(List);
+	for ( ; ite.More(); ite.Next() ) {
+	  Handle(SALOME_InteractiveObject) anObj =
+	    Handle(SALOME_InteractiveObject)::DownCast( ite.Value()->GetOwner() );
+	  if ( !anObj.IsNull() && anObj->hasEntry() && anObj->isSame( myIO ) ) {
+	    Quantity_Color CSFColor = Quantity_Color ( myParam.red()   / 255.,
+						       myParam.green() / 255.,
+						       myParam.blue()  / 255.,
+						       Quantity_TOC_RGB );
+	    ite.Value()->SetColor( CSFColor );
+	    if ( ite.Value()->IsKind( STANDARD_TYPE(GEOM_AISShape) ) )
+	      Handle(GEOM_AISShape)::DownCast( ite.Value() )->SetShadingColor( CSFColor );
+	    ite.Value()->Redisplay( Standard_True );
+	    occViewer->update();
+	    break;
+	  }
+	}
+      }
+    }
+  };
+  ProcessVoidEvent(new TEvent(app,anIO,aColor));
 }
 
 void GEOM_Swig::setTransparency(const char* theEntry, float transp)
 {
+  SUIT_Application* app = SUIT_Session::session()->activeApplication();
+  if ( !app ) return;
+  
+  Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry, "GEOM", "");
+  
+  class TEvent: public SALOME_Event{
+    SUIT_Application* myApp;
+    Handle(SALOME_InteractiveObject) myIO;
+    float myParam;
+  public:
+    TEvent(SUIT_Application* theApp, const Handle(SALOME_InteractiveObject)& theIO, float theParam):
+      myApp(theApp), myIO(theIO), myParam(theParam)
+    {}
+    virtual void Execute(){
+      if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
+	SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
+	myRenderInter->SetTransparency(myIO,myParam);
+	myRenderInter->Update();
+      }else if(OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)) {
+	SOCC_Viewer* soccViewer = dynamic_cast<SOCC_Viewer*>( occViewer );
+	if (soccViewer)
+	  soccViewer->setTransparency(myIO,myParam);
+      }
+    }
+  };
+  
+  ProcessVoidEvent(new TEvent(app,anIO,transp));
 }

src/GEOMGUI/GeometryGUI_Swig.hxx

@@ -32,6 +32,7 @@
 // IDL Headers
 #include <SALOMEconfig.h>
 #include CORBA_SERVER_HEADER(GEOM_Gen)
+#include CORBA_SERVER_HEADER(SALOMEDS)
 #include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
 
 class GEOM_Client;