In This Package:

OnXSvc.cpp

Go to the documentation of this file.

// this :
#include <OnXSvc/OnXSvc.h>

// Slash :
#include <Slash/Core/IWriter.h>
#include <Slash/Data/IProcessor.h>
#include <Slash/Core/IManager.h>
#include <Slash/UI/IUI_Manager.h>

// Lib :
#include <Lib/Interfaces/ISession.h>

#include <Lib/smanip.h>
#include <Lib/Printer.h>
#include <Lib/Manager.h>
#include <Lib/System.h>
#include <Lib/Arguments.h>

// OnX :
#include <OnX/Interfaces/IUI.h>
#include <OnX/Interfaces/IWidgetClass.h>

// Gaudi :
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/IAppMgrUI.h>
#include <GaudiKernel/IDataProviderSvc.h>
#include <GaudiKernel/IDataManagerSvc.h>
#include <GaudiKernel/IRegistry.h>
#include <GaudiKernel/IHistogramSvc.h>
#include <GaudiKernel/IEvtSelector.h>
#include <GaudiKernel/SvcFactory.h>
#include <GaudiKernel/SmartIF.h>
#include <GaudiKernel/MsgStream.h>
#include <GaudiKernel/SmartDataPtr.h>
#include <GaudiKernel/GaudiException.h>
#include <GaudiKernel/System.h>

// AIDA :
#include <AIDA/IHistogram.h>

#include <XmlTools/IXmlSvc.h>

// VisSvc :
#include <VisSvc/IVisualizationSvc.h>

// OnXSvc :
#include <OnXSvc/ISoConversionSvc.h>
#include <OnXSvc/ISvcLocatorManager.h>
//#include <OnXSvc/MetaType.h>
#include <OnXSvc/Helpers.h>

// Xlib.h define CPP "Status", then clash with IInterface.h !
#include <OnX/Core/Main.h>

DECLARE_SERVICE_FACTORY( OnXSvc );

class SvcLocatorManager 
:public virtual Slash::Core::IManager 
,public virtual ISvcLocatorManager {
public: //IManager
  virtual std::string name() const { return fName;  }
  virtual void* cast(const std::string& aString) const { 
    if(aString=="ISvcLocatorManager") {
      return ((ISvcLocatorManager*)this);
    } else if(aString=="Slash::Core::IManager") {
      return ((Slash::Core::IManager*)this);
    } else {
      return 0;
    }
  }
public: //ISvcLocatorManager
  virtual ISvcLocator* serviceLocator() const {
    return fSvcLocator;
  }
  virtual IService* service(const std::string& aName) const {
    IService* svc;
    fSvcLocator->service(aName,svc);
    return svc;
  }
public:
  SvcLocatorManager(ISvcLocator* aSvcLocator)
    :fName("SvcLocatorManager"),fSvcLocator(aSvcLocator){}
  virtual ~SvcLocatorManager(){}
private:
  std::string fName;
  ISvcLocator* fSvcLocator;
};

class Printer : public virtual Slash::Core::IWriter {
public:
  virtual void disable() {}
  virtual void enable() {}
  virtual bool enabled() const {  return true;}
  virtual bool write(const std::string& aString) { 
    fLog << aString;
    return true;
  }
  virtual bool flush() {
    return true;
  }
public:
  Printer(MsgStream& aLog):fLog(aLog){}
  virtual ~Printer(){}
private:
  MsgStream& fLog;
};

OnXSvc::OnXSvc(
 const std::string& aName
,ISvcLocator* aSvcLoc
) 
:Service(aName,aSvcLoc)
,fAppMgrUI(0)
,fSoCnvSvc(0)
,fEventDataSvc(0)
,fDetectorDataSvc(0) 
,fHistogramSvc(0)
,fSession(0)
,fThreaded(false)
,fToolkit("NATIVE")
,fFile("$ONXFILE")
,fVerboseLevel(0)
,fOutputToTerminal(false)
,fLog(0)
,fOnXMain(0)
,fTypeManager(0)
,fMetaType(0)
,fLibPrinter(0)
,fGaudiPrinter(0)
{
  declareProperty("Threaded",fThreaded);
  declareProperty("Toolkit",fToolkit);
  declareProperty("File",fFile);
  declareProperty("VerboseLevel",fVerboseLevel);
  declareProperty("OutputToTerminal",fOutputToTerminal);
  // Create a default printer. The printer() method may be called
  // before the service is initialized (through the declaration of types).
  fLibPrinter = new Lib::Printer();
}
OnXSvc::~OnXSvc(
) 


{ 
}
StatusCode OnXSvc::queryInterface(
 const InterfaceID& aRIID
,void** aPPVIF
) 


{
  if (aRIID==IRunable::interfaceID())   {
    *aPPVIF = static_cast<IRunable*>(this);
    addRef();
    return StatusCode::SUCCESS;
  } else if(aRIID==IUserInterfaceSvc::interfaceID()) {
    *aPPVIF = static_cast<IUserInterfaceSvc*>(this);
    addRef();
    return StatusCode::SUCCESS;
  } else {
    return Service::queryInterface(aRIID, aPPVIF);
  }
}
StatusCode OnXSvc::initialize(
) 


{
  StatusCode status = Service::initialize();
  if( status.isFailure() ) return status;

  fLog = new MsgStream(messageService(), Service::name());

  fGaudiPrinter = new Printer(*fLog);

  MsgStream log(messageService(), Service::name());

  log << MSG::INFO << "OnXSvc::initialize " << endreq;

  setProperties();

  if(!serviceLocator()) {
    log << MSG::INFO << "Service locator not found " << endreq;
    return StatusCode::FAILURE;
  }

  if(fAppMgrUI) {
    fAppMgrUI->release();
    fAppMgrUI = 0;
  }
  status = serviceLocator()->service("ApplicationMgr",fAppMgrUI);
  if( status.isFailure() || !fAppMgrUI) {
    log << MSG::INFO << "ApplicationMgr not found " << endreq;
    return StatusCode::FAILURE;
  }
  fAppMgrUI->addRef();

  // Dynamic load OnX GUI driver :
  if(fToolkit=="NONE") {
    log << MSG::INFO << "GUI toolkit NONE." << endreq;
  } else {
    Lib::Arguments gaudi_args(System::cmdLineArgs());

    //args relevant to OnX::Main :
    Lib::Arguments args;
   {std::string key = "-debug_check_class";
    if(gaudi_args.isAnArgument(key)) {
      std::string value;
      gaudi_args.find(key,value);
      args.add(key,value);
    }}
   {std::string key = "-Qt";
    if(gaudi_args.isAnArgument(key)) {
      std::string value;
      gaudi_args.find(key,value);
      args.add(key,value);
    }}
        
    fOnXMain = new OnX::Main(false,false,args.tovector());
    if(!fOnXMain->isValid()) {
      log << MSG::INFO << "Can't create a valid OnX::Main" << endreq;
      delete fOnXMain;
      fOnXMain = 0;
      return StatusCode::FAILURE;
    }

    // Do the below also if fThreaded ?
    // Have a property to control the below ?
    if(!fOnXMain->loadInterpreter("Python")) {
      // Not fatal.
      log << MSG::INFO << "Can't load the OnX Python module." << endreq;
    }

    //#601 ISession* session = fOnXMain->session();
    ISession* session = fOnXMain;
    if(!session) {
      log << MSG::INFO << "OnX::Main don't have a ISession." << endreq;
      delete fOnXMain;
      fOnXMain = 0;
      return StatusCode::FAILURE;
    }

    if(fOutputToTerminal) session->setParameter("session.output","terminal");

    session->setParameter("UI_Manager.thread",fThreaded?"true":"false");

    setSession(session);

    std::string driver;
    if(fToolkit=="NATIVE") {
      driver = ""; //Let OnX decide. Decided also from program (argc,argv).
    } else {
      driver = fToolkit;
    }

    log << MSG::INFO << "GUI toolkit " << driver << "." << endreq;
    log << MSG::INFO << "OnX GUI file " << fFile << "." << endreq;

    if(fOnXMain->createUI(driver,fFile,true)) {
      log << MSG::INFO << "GUI created." << endreq;
    } else {
      log << MSG::INFO << "GUI creation failed." << endreq;
      delete fOnXMain;
      fOnXMain = 0;
      fSession = 0;
      return StatusCode::FAILURE;
    }
  }

  return status;
}
StatusCode OnXSvc::finalize(
) 


{
  if(fAppMgrUI) {
    fAppMgrUI->release();
    fAppMgrUI = 0;
  }
  if(fSoCnvSvc) {
    fSoCnvSvc->release();
    fSoCnvSvc = 0;
  }
  if(fEventDataSvc) {
    fEventDataSvc->release();
    fEventDataSvc = 0;
  }
  if(fDetectorDataSvc) {
    fDetectorDataSvc->release();
    fDetectorDataSvc = 0;
  }
  if(fHistogramSvc) {
    fHistogramSvc->release();
    fHistogramSvc = 0;
  }

  MsgStream log(messageService(), Service::name());
  log << MSG::INFO << "OnXSvc finalizing..." << endreq;

  delete fOnXMain;
  fOnXMain = 0;
  fSession = 0;

  delete fGaudiPrinter;
  fGaudiPrinter = 0;
  delete fLibPrinter;
  fLibPrinter = 0;
  delete fLog;
  fLog = 0;

  log << MSG::INFO << "OnXSvc finalized successfully" << endreq;

  return StatusCode::SUCCESS;
}
StatusCode OnXSvc::run(
) 

// Called only in "GaudiMain" mode.
{
  MsgStream log(messageService(), Service::name());
  if(!fSession) {
    log << MSG::INFO << "No ISession given " << endreq;
    return StatusCode::FAILURE;
  }
  IUI* ui = findUI();
  if(!ui) return StatusCode::FAILURE;
  log << MSG::INFO << "Enter in GUI toolkit mainloop... " << endreq;
  ui->steer();
  log << MSG::INFO << "GUI toolkit mainloop exited. " << endreq;
  return StatusCode::SUCCESS;
}
SoPage* OnXSvc::currentSoPage(
) 


{
  if(!fSession) {
    MsgStream log(messageService(), Service::name());
    log << MSG::INFO << "No ISession given " << endreq;
    return 0;
  }
  IUI* ui = findUI();
  if(!ui) return 0;
  return ui_SoPage(*ui);
}
SoRegion* OnXSvc::currentSoRegion(
) 


{
  SoPage* soPage = currentSoPage();
  if(!soPage) {
    MsgStream log(messageService(), Service::name());
    log << MSG::INFO << "SoPage not found " << endreq;
    return 0;
  }
  return page_currentRegion(*soPage);
}
IWidget* OnXSvc::currentWidget(
) 


{
  if(!fSession) {
    MsgStream log(messageService(), Service::name());
    log << MSG::INFO << "No ISession given " << endreq;
    return 0;
  }
  IUI* ui = findUI();
  if(!ui) return 0;
  return ui->currentWidget();
}
Slash::Data::IProcessor* OnXSvc::typeManager(
) 


{
  return fTypeManager;
}
Slash::Data::IAccessor* OnXSvc::metaType(
) 


{
  return fMetaType;
}
void OnXSvc::setSession(
 Slash::Core::ISession* aSession
) 

// Used when the service is started in NONE mode.
// Should be executed once.
{
  if(fSession) return; //done.
  if(!aSession) return;
  fSession = aSession;
  
  fSession->addManager(new SvcLocatorManager(serviceLocator()));

  fTypeManager = 
    Lib_findManager(*fSession,"AccessorManager",Slash::Data::IProcessor);

  if(fTypeManager) {
    std::vector<Slash::Data::IAccessor*>::const_iterator it;
    for(it=fTypes.begin(); it!=fTypes.end(); it++) {
      fTypeManager->addAccessor(*it);
    }
    fTypes.clear();

    /*
    IIntrospectionSvc* introspectionSvc = 0;
    serviceLocator()->service("IntrospectionSvc",introspectionSvc);
    if(!introspectionSvc) {
      MsgStream log(messageService(), Service::name());
      log << MSG::INFO << "IntrospectionSvc not found " << endreq;
    }
    
    if(introspectionSvc) {
      fMetaType = new MetaType(fSession->printer(),introspectionSvc);
      fTypeManager->addType(fMetaType);
    }
    */
  }

}
ISession* OnXSvc::session(
) 


{
  return fSession;
}
void OnXSvc::nextEvent(
) 


{
  if(!fAppMgrUI) return;
  fAppMgrUI->nextEvent(1);
}
void OnXSvc::eventInfo(
) 


{
  MsgStream log(messageService(), Service::name());

  if(!fSession) {
    log << MSG::INFO << "No ISession given " << endreq;
    return;
  }

  if(!fEventDataSvc) {
    StatusCode status = service("EventDataSvc",fEventDataSvc,true);
    if(status.isFailure() || !fEventDataSvc) {
      log << MSG::INFO << "EventDataSvc not found " << endreq;
      return;
    }
    fEventDataSvc->addRef();
  }

  //SmartDataPtr<DataObject> smartDataObject(fEventDataSvc,"/Event");
  //if(smartDataObject) {}

  DataObject* dataObject;
  StatusCode sc = fEventDataSvc->retrieveObject("/Event", dataObject);
  if(!sc.isSuccess()) {
    log << MSG::ERROR << "Unable to retrieve /Event " << endreq;
    return;
  }
  if(!dataObject) {
    log << MSG::ERROR << "Unable to retrieve /Event " << endreq;
    return;
  }

  //Event* event = dynamic_cast<Event*>(dataObject);
  //if(!event) return;
  //fSession->out().println("run %d event %d ",event->run(),event->event());
}
StatusCode OnXSvc::visualize(
 const DataObject& aDataObject
) 


{
  MsgStream log(messageService(), Service::name());

  log << MSG::INFO << " visualize DataObject... " << endreq;

  if(!fSoCnvSvc) {
    StatusCode status = service("SoConversionSvc",fSoCnvSvc,true);
    if(status.isFailure() || !fSoCnvSvc) {
      log << MSG::INFO << "SoConversionSvc not found " << endreq;
      return StatusCode::FAILURE;
    }
    fSoCnvSvc->addRef();
  }

  try {
    IOpaqueAddress* addr = 0;
    fCuts = "";
    StatusCode sc = fSoCnvSvc->createRep ((DataObject*)&aDataObject, addr);
    fCuts = "";
    if (sc.isSuccess()) 
      sc = fSoCnvSvc->fillRepRefs(addr,(DataObject*)&aDataObject);
    if (sc.isFailure()) {
      log << MSG::WARNING 
          << "Error creating graphical representations" 
          << endreq;
      return sc;
    }
  } catch (GaudiException e) {
    fCuts = "";
    log << MSG::ERROR 
        << "Unable to create graphical representation, received exception :";
    e.printOut(log);
    log << endreq;
    return StatusCode::FAILURE;
  }

  return StatusCode::SUCCESS;
}
StatusCode OnXSvc::visualize(
 const AIDA::IHistogram& aHistogram
) 


{
  MsgStream log(messageService(), Service::name());

  const DataObject* dataObject = dynamic_cast<const DataObject*>(&aHistogram);
  if(!dataObject) {
    log << MSG::ERROR << "histogram not a DataObject." << endreq;
    return StatusCode::FAILURE;
  }

  return visualize(*dataObject);
}
IDataProviderSvc* OnXSvc::dataProvider(const std::string& aPath) 


{
  MsgStream log(messageService(), Service::name());
  if(aPath.find_first_of("E", 1) == 1) {
    if(!fEventDataSvc) {
      StatusCode status = service("EventDataSvc",fEventDataSvc,true);
      if(status.isFailure() || !fEventDataSvc) {
        log << MSG::INFO << "EventDataSvc not found " << endreq;
        return 0;
      }
      fEventDataSvc->addRef();
    }
    return fEventDataSvc;
  } else if( aPath.find_first_of("d", 1) == 1) {
    if(!fDetectorDataSvc) {
      StatusCode status = service("DetectorDataSvc",fDetectorDataSvc,true);
      if(status.isFailure() || !fDetectorDataSvc) {
        log << MSG::INFO << "DetectorDataSvc not found " << endreq;
        return 0;
      }
      fDetectorDataSvc->addRef();
    }
    return fDetectorDataSvc;
  } else if(aPath.find_first_of("s",1)==1) {
    if(!fHistogramSvc) {
      StatusCode status = service("HistogramDataSvc",fHistogramSvc,true);
      if(status.isFailure() || !fHistogramSvc) {
        log << MSG::INFO << "HistogramDataSvc not found " << endreq;
        return 0;
      }
      fHistogramSvc->addRef();
    }
    return fHistogramSvc;
  } else {
    log << MSG::INFO 
        << "Data service not found for \"" << aPath << "\"." 
        << endreq;
    return 0;
  }
}  
StatusCode OnXSvc::visualize(
 const std::string& aWhat
) 


{
  MsgStream log(messageService(), Service::name());

  if(!fSoCnvSvc) {
    StatusCode status = service("SoConversionSvc",fSoCnvSvc,true);
    if(status.isFailure() || !fSoCnvSvc) {
      log << MSG::INFO << "SoConversionSvc not found " << endreq;
      return StatusCode::FAILURE;
    }
    fSoCnvSvc->addRef();
  }

  StatusCode sc = StatusCode::FAILURE;

  std::string path = aWhat;
  std::string cuts;

  std::string::size_type sp;
  if((sp=aWhat.find(' '))!=std::string::npos){
    path = aWhat.substr(0,sp);
    cuts = aWhat.substr(sp+1,aWhat.size()-(sp+1));
  }
  log << MSG::INFO << "Path \"" << path << "\"" << endreq;
  log << MSG::INFO << "Cuts \"" << cuts << "\"" << endreq;

  IDataProviderSvc* dataSvc = dataProvider(path);
  if(!dataSvc) return StatusCode::FAILURE;

  DataObject* dataObject = 0;
  sc = dataSvc->retrieveObject(path, dataObject);
  if(!sc.isSuccess()) {
    log << MSG::ERROR << "Unable to retrieve " << path << endreq;
    return sc;
  }
  if(!dataObject) {
    log << MSG::ERROR << "Unable to retrieve " << path << endreq;
    return StatusCode::FAILURE;
  }

  try {
    IOpaqueAddress* addr = 0;
    fCuts = cuts;
    sc = fSoCnvSvc->createRep(dataObject,addr);
    fCuts = "";
    if (sc.isSuccess()) sc = fSoCnvSvc->fillRepRefs(addr,dataObject); 
    if (sc.isFailure()) {
      log << MSG::WARNING 
          << "Error creating graphical representations" << endreq;
      return sc;
    } 
  } catch (GaudiException e) {
    fCuts = "";
    log << MSG::ERROR << "Unable to convert : " 
        << path << endreq;
    return StatusCode::FAILURE;
  }

  return StatusCode::SUCCESS;  
}
std::vector<std::string> OnXSvc::dataChildren(const std::string& aPath) 


{
  MsgStream log(messageService(), Service::name());

  std::vector<std::string> text;

  IDataProviderSvc* dataSvc = dataProvider(aPath);
  if(!dataSvc) return text;
  SmartIF<IDataManagerSvc> dataManagerSvc(dataSvc);
  if(dataManagerSvc==0) {
    log << MSG::ERROR 
        << "Unable to get DataManager interface." 
        << endreq;
    return text;
  }
  
  SmartDataPtr<DataObject> dataObject(dataSvc,aPath);
  if(dataObject==0) {
    log << MSG::ERROR 
        << "Can't get \"" << aPath << "\"." 
        << endreq;
    return text;
  }

  std::vector<IRegistry*> children;
  dataManagerSvc->objectLeaves(dataObject->registry(),children);
  std::vector<IRegistry*>::iterator it;
  for (it = children.begin();it != children.end();it++) {
    text.push_back((*it)->identifier());
  }

  return text;
}
bool OnXSvc::ls (
 IDataProviderSvc* aDataSvc 
,SmartIF<IDataManagerSvc>& aDataManagerSvc
,SmartDataPtr<DataObject>& aDataObject
,MsgStream& aLog
,int aWantedDepth
,int& aDepth //default = -1 = no limits.
) 


{
  if((aWantedDepth!=-1)&&(aDepth>=aWantedDepth)) return true;

  std::vector<IRegistry*> children;
  aDataManagerSvc->objectLeaves(aDataObject->registry(),children);
  std::vector<IRegistry*>::iterator it;
  for (it = children.begin();it != children.end();it++) {
    try {

      aLog << MSG::INFO << (*it)->identifier() << endreq;
      SmartDataPtr<DataObject> obj(aDataSvc,(*it));

      if(obj) { // To compell loading of things in the sub directory.
        aDepth++;
        if(!ls(aDataSvc,aDataManagerSvc,obj,aLog,aWantedDepth,aDepth)) 
          return false;
        aDepth--;
      } else {
        aLog << MSG::ERROR 
             << "Unable to load \"" << (*it)->identifier() << "\"." << endreq;
      }

    } catch (GaudiException e) {
      aLog << MSG::ERROR 
           << "Unable to load \"" << (*it)->identifier() << "\"." << endreq;
      return false;
    }

  }

  return true; //continue;
}
void OnXSvc::ls (
 const std::string& aPath
,int aDepth //default = -1 = no limits.
) 


{
  MsgStream log(messageService(), Service::name());

  IDataProviderSvc* dataSvc = dataProvider(aPath);
  if(!dataSvc) return;
  SmartIF<IDataManagerSvc> dataManagerSvc(dataSvc);
  if (dataManagerSvc==0) {
    log << MSG::ERROR 
        << "Unable to get DataManager interface " 
        << endreq;
    return;
  }

  SmartDataPtr<DataObject> dataObject(dataSvc,aPath);
  if(dataObject==0) {
    log << MSG::ERROR 
        << "Can't get \"" << aPath << "\"." 
        << endreq;
    return;
  }

  log << MSG::INFO << aPath << endreq;

  int depth = 0;
  ls(dataSvc,dataManagerSvc,dataObject,log,aDepth,depth);
}
void OnXSvc::clearDetectorStore(
) 


{
  MsgStream log(messageService(), Service::name());

  if(!fDetectorDataSvc) {
    StatusCode status = service("DetectorDataSvc",fDetectorDataSvc,true);
    if(status.isFailure() || !fDetectorDataSvc) {
      log << MSG::INFO << "DetectorDataSvc not found " << endreq;
      return;
    }
    fDetectorDataSvc->addRef();
  }

  SmartIF<IDataManagerSvc> dm(fDetectorDataSvc);
  if(dm==0) {
    log << MSG::ERROR << "No DataManagerSvc. Store not cleared." << endreq;
    return;
  }

  IXmlSvc* xs = 0;
  service ("XmlCnvSvc", xs);
  if(!xs) {
    log << MSG::ERROR << "No XmlCnvSvc. Store not cleared." << endreq;
    return;
  }

  IVisualizationSvc* vs = 0;
  service ("VisualizationSvc", vs);
  if(!vs) {
    log << MSG::WARNING
        << "No VisualizationSvc. Visualization attributes not reloaded."
        << endreq;
    return;
  }

  StatusCode sc = dm->clearStore();
  if (!sc.isSuccess()) {
    log << MSG::ERROR << "Unable to clear store !!!" << endreq;
    return;
  }
  xs->clearCache();
  vs->reload();
}
StatusCode OnXSvc::changeGeometry(const std::string& file)
{
  MsgStream log(messageService(), Service::name());

  // Change some properties
  IProperty* pdm = 0;
  service ("DetectorDataSvc", pdm);
  if(!pdm) {
    log << MSG::ERROR
        << "No DetectorDataSvc found (Looking for IProperty Interface)."
        << endreq;
    return StatusCode::FAILURE;
  }
  pdm->setProperty("DetDbLocation", file);

  // Now Reinitialize services
  IService* dm = 0;
  service ("DetectorDataSvc", dm);
  if(!dm) {
    log << MSG::ERROR << "No DetectorDataSvc found." << endreq;
    return StatusCode::FAILURE;
  }

  IService* xs = 0;
  service ("XmlCnvSvc", xs);
  if(!xs) {
    log << MSG::ERROR << "No XmlCnvSvc found." << endreq;
    return StatusCode::FAILURE;
  }

  StatusCode sc = dm->reinitialize();
  if (!sc.isSuccess()) {
    log << MSG::ERROR << "Unable to reinitialize DetectorDataSvc !" << endreq;
    return sc;
  }
  sc = xs->reinitialize();
  if (!sc.isSuccess()) {
    log << MSG::ERROR << "Unable to reinitialize XmlCnvSvc !" << endreq;
    return sc;
  }
  return StatusCode::SUCCESS;
}
StatusCode OnXSvc::changeColors(const std::string& file)
{
  MsgStream log(messageService(), Service::name());

  // Change some properties
  IProperty* pvs = 0;
  service ("VisualizationSvc", pvs);
  if(!pvs) {
    log << MSG::ERROR
        << "No VisualizationSvc found (Looking for IProperty Interface)."
        << endreq;
    return StatusCode::FAILURE;
  }
  pvs->setProperty("ColorDbLocation", file);

  // Now Reinitialize services
  IService* vs = 0;
  service ("VisualizationSvc", vs);
  if(!vs) {
    log << MSG::WARNING << "No VisualizationSvc found." << endreq;
    return StatusCode::FAILURE;
  }

  StatusCode sc = vs->reinitialize();
  if (!sc.isSuccess()) {
    log << MSG::ERROR << "Unable to reinitialize VisualizationSvc !" << endreq;
    return sc;
  }
  return StatusCode::SUCCESS;
}
void OnXSvc::openEventFile(
 const std::string& aFile
)
{
  if(aFile=="") return;

  MsgStream log(messageService(), Service::name());

  log << MSG::INFO << "Try to open " << aFile << "..." << endreq;

  IEvtSelector* eventSelector = 0;
  StatusCode status = service("EventSelector",eventSelector,true);
  if(status.isFailure() || !eventSelector) {
    log << MSG::INFO << "EventSelector not found " << endreq;
    return;
    //return StatusCode::FAILURE;
  }
  eventSelector->addRef();

  SmartIF<IProperty> prp(eventSelector);
  std::string prop = 
    std::string("[\"DATAFILE='") + aFile + "' TYP='ROOT' OPT='READ'\"]";

  prp->setProperty("Input",prop);
  SmartIF<IService> prp2(eventSelector);
  prp2->reinitialize();
  
  eventSelector->release();

  IService* eventLoopMgr = 0;
  status = service("EventLoopMgr",eventLoopMgr,true);
  if(status.isFailure() || !eventLoopMgr) {
    log << MSG::INFO << "EventLoopMgr not found " << endreq;
    return;
  }
  eventLoopMgr->addRef();
  eventLoopMgr->reinitialize();
  eventLoopMgr->release();
}
bool OnXSvc::visitToXML(
 IDataProviderSvc* aDataSvc
,SmartIF<IDataManagerSvc>& aDataManagerSvc
,SmartDataPtr<DataObject>& aDataObject
,std::string& aOut
) 


{
  std::vector<IRegistry*> children;
  aDataManagerSvc->objectLeaves(aDataObject->registry(), children);
  std::vector<IRegistry*>::iterator it;
  for(it=children.begin();it != children.end();it++) {

    std::string path = (*it)->identifier();
    std::string name = path;
   {std::string::size_type pos = path.find_last_of("/");
    if(pos!=std::string::npos) name = path.substr(pos+1,path.size()-pos);}

    aOut +=  "<treeItem><label>" + name + "</label>";

    try {

      SmartDataPtr<DataObject> obj(aDataSvc,(*it));
      if(obj) { // To compell loading of things in the sub directory.
        if(!visitToXML(aDataSvc,aDataManagerSvc,obj,aOut)) {
          aOut = "";
          return false;
        }
      } else {
        MsgStream log(messageService(), Service::name());
        log << MSG::ERROR 
            << "Unable to load \"" << (*it)->identifier() << "\"." 
            << endreq;
      }

    } catch (GaudiException e) {
      MsgStream log(messageService(), Service::name());
      log << MSG::ERROR 
          << "Unable to load \"" << (*it)->identifier() << "\"." 
          << endreq;
      aOut = "";
      return false;
    }

    aOut += "</treeItem>";
  }

  return true;
}
bool OnXSvc::writeToString(
 const std::string& aPath
,std::string& aOut
) 


{
  aOut = "";
  if(!fSession) return false;
  MsgStream log(messageService(), Service::name());

  IDataProviderSvc* dataSvc = dataProvider(aPath);
  if(!dataSvc) return false;
  SmartIF<IDataManagerSvc> dataManagerSvc(dataSvc);
  if (dataManagerSvc==0) {
    log << MSG::ERROR 
        << "Unable to get DataManager interface " 
        << endreq;
    return false;
  }

  SmartDataPtr<DataObject> dataObject(dataSvc,aPath);
  if(dataObject==0) {
    log << MSG::ERROR 
        << "Can't get \"" << aPath << "\"." 
        << endreq;
    return false;
  }

  aOut = "<tree>";

  std::string name = aPath;
 {std::string::size_type pos = aPath.find_last_of("/");
  if(pos!=std::string::npos) name = aPath.substr(pos+1,aPath.size()-pos);}
  aOut +=  "<treeItem><label>" + name + "</label>";

  if(!visitToXML(dataSvc,dataManagerSvc,dataObject,aOut)) return false;

  aOut += "</treeItem>";
  aOut += "</tree>";
  return true;
}
void OnXSvc::addType(
 Slash::Data::IAccessor* aType
)
{
  if(!aType) return;
  if(!fSession) { 
    // Session not yet set, store types in a temporary list.
    fTypes.push_back(aType);
  } else {
    if(!fTypeManager) return; // Should never happen.
    fTypeManager->addAccessor(aType);
  }
}
IService* OnXSvc::getService(
 const std::string& aName
) 


{
  MsgStream log(messageService(), Service::name());
  if(!serviceLocator()) {
    log << MSG::INFO << "service locator not found " << endreq;
    return 0;
  }
  IService* svc = 0;
  StatusCode status = serviceLocator()->service(aName,svc);
  if(status.isFailure() || !svc) {
    log << MSG::INFO << aName << " not found " << endreq;
    return 0;
  }
  return svc;
}
const std::string& OnXSvc::cuts(
) const
{
  return fCuts;
}
Slash::Core::IWriter& OnXSvc::printer(
)
{
  return fGaudiPrinter ? *fGaudiPrinter : *fLibPrinter;
}

std::string OnXSvc::torgb(
 const std::string& aColor
) 


{
  double r,g,b;
  if(!Lib::smanip::torgb(aColor,r,g,b)) return "";
  std::string s;
  Lib::smanip::printf(s,128,"%g %g %g",r,g,b);
  return s;
}
void* OnXSvc::topointer(
 const std::string& aValue
) const
{
  void* p;
  Lib::smanip::topointer(aValue,p); 
  return p;
}
IAppMgrUI* OnXSvc::appMgr(
) const
{
  return fAppMgrUI;
}
Slash::UI::IUI* OnXSvc::findUI(
) 


{
  if(!fSession) {
    MsgStream log(messageService(), Service::name());
    log << MSG::INFO << "No ISession given " << endreq;
    return 0;
  }
  Slash::UI::IUI_Manager* uiManager = 
    Lib_findManager(*fSession,"UI_Manager",Slash::UI::IUI_Manager);
  if(!uiManager) {
    MsgStream log(messageService(), Service::name());
    log << MSG::INFO << "UI manager not found " << endreq;
    return 0;
  }
  IUI* ui = uiManager->find("default");
  if(!ui) {
    MsgStream log(messageService(), Service::name());
    log << MSG::INFO << "UI not found " << endreq;
    return 0;
  }
  return ui;
}


// Inventor :
#include <Inventor/SbPlane.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoLightModel.h>
#include <Inventor/nodes/SoDrawStyle.h>
#include <Inventor/nodes/SoNormalBinding.h>

// HEPVis :
#include <HEPVis/SbStyle.h>
#include <HEPVis/nodes/SoHighlightMaterial.h>
#include <HEPVis/misc/SoTools.h>

// SoUtils :
#include <SoUtils/SbProjector.h>

SbMarkerStyle SoTools_markerStyle (
 const std::string& aString 
)
{
  SbStyle sbStyle;
  std::string s = "markerStyle " + aString;
  sbStyle.setFromString(s.c_str());
  return sbStyle.getMarkerStyle();
}
StatusCode OnXSvc::visualize(
 const Gaudi::XYZPoint& aData
) 


{
  MsgStream log(messageService(), Service::name());
  log << MSG::INFO << " visualize Gaudi::XYZPoint... " << endreq;

  SoRegion* region = currentSoRegion();
  if(!region) {
    log << MSG::INFO << " can't get viewing region." << endreq;
    return StatusCode::FAILURE; 
  }

  double r = 0.5, g = 0.5, b = 0.5;
  double hr = 1.0, hg = 1.0, hb = 0.0;
  std::string value;
  if(fSession->parameterValue("modeling.color",value))
    Lib::smanip::torgb(value,r,g,b);
  if(fSession->parameterValue("modeling.highlightColor",value))
    Lib::smanip::torgb(value,hr,hg,hb);
  // Non linear projections :
  fSession->parameterValue("modeling.projection",value);
  SoUtils::SbProjector projector(value.c_str());

  SbMarkerStyle mStyle = SbMarkerPlus;
  if(fSession->parameterValue("modeling.markerStyle",value))
    mStyle = SoTools_markerStyle(value);
  int mSize = 5;
  if(fSession->parameterValue("modeling.markerSize",value))
    if(!Lib::smanip::toint(value,mSize)) mSize = 5;

  SoSeparator* separator = new SoSeparator;
  separator->setName("sceneGraph");

  // Material :
  SoHighlightMaterial* highlightMaterial = new SoHighlightMaterial;
  highlightMaterial->setName("highlight");
  highlightMaterial->diffuseColor.setValue
    (SbColor(float(r),float(g),float(b)));
  highlightMaterial->highlightColor.setValue
    (SbColor(float(hr),float(hg),float(hb)));
  //highlightMaterial->transparency.setValue((float)transparency);
  separator->addChild(highlightMaterial);

  SbVec3f point;
  point.setValue((float)aData.x(), (float)aData.y(), (float)aData.z());
  projector.project(1,&point);

  SoTools::addPointsToNode(separator,1,&point,mStyle,mSize);

  //  Send scene graph to the viewing region
  // (in the "dynamic" sub-scene graph) :
  region_addToDynamicScene(*region,separator);

  return StatusCode::SUCCESS;
}
StatusCode OnXSvc::visualize(
 const std::vector<Gaudi::XYZPoint>& aData
,RepType aType
) 


{
  MsgStream log(messageService(), Service::name());
  log << MSG::INFO << " visualize std::vector<Gaudi::XYZPoint>... " << endreq;

  if(!aData.size()) return StatusCode::SUCCESS; 
  if((aType==POLYGON)&&(aData.size()<=2)) return StatusCode::FAILURE; 

  SoRegion* region = currentSoRegion();
  if(!region) {
    log << MSG::INFO << " can't get viewing region." << endreq;
    return StatusCode::FAILURE; 
  }

  double r = 0.5, g = 0.5, b = 0.5;
  double hr = 1.0, hg = 1.0, hb = 0.0;
  std::string value;
  if(fSession->parameterValue("modeling.color",value))
    Lib::smanip::torgb(value,r,g,b);
  if(fSession->parameterValue("modeling.highlightColor",value))
    Lib::smanip::torgb(value,hr,hg,hb);
  // Non linear projections :
  fSession->parameterValue("modeling.projection",value);
  SoUtils::SbProjector projector(value.c_str());

  int pointn = aData.size();
  SbVec3f* points = new SbVec3f[pointn];
  for(int index=0;index<pointn;index++) {
    points[index].setValue
     ((float)aData[index].x(),(float)aData[index].y(),(float)aData[index].z());
  }
  projector.project(pointn,points);

  SoSeparator* separator = new SoSeparator;
  separator->setName("sceneGraph");

  // Material :
  SoHighlightMaterial* highlightMaterial = new SoHighlightMaterial;
  highlightMaterial->setName("highlight");
  highlightMaterial->diffuseColor.setValue
    (SbColor((float)r,(float)g,(float)b));
  highlightMaterial->highlightColor.setValue
    (SbColor((float)hr,(float)hg,(float)hb));
  //highlightMaterial->transparency.setValue((float)transparency);
  separator->addChild(highlightMaterial);

  switch(aType) {
  case POINTS: {
    SbMarkerStyle mStyle = SbMarkerPlus;
    if(fSession->parameterValue("modeling.markerStyle",value))
      mStyle = SoTools_markerStyle(value);
    int mSize = 5;
    if(fSession->parameterValue("modeling.markerSize",value))
      if(!Lib::smanip::toint(value,mSize)) mSize = 5;
    SoTools::addPointsToNode(separator,pointn,points,mStyle,mSize);
  }break;
  case LINES: {
    SoLightModel* lightModel = new SoLightModel;
    lightModel->model = SoLightModel::BASE_COLOR;
    separator->addChild(lightModel);
      
    SoDrawStyle* drawStyle = new SoDrawStyle;
    drawStyle->style.setValue(SoDrawStyle::LINES);
    drawStyle->linePattern.setValue(0xFFFF);
    separator->addChild(drawStyle);
      
    SoTools::addLinesToNode(separator,pointn,points);
  }break;
  case SEGMENTS: {
    SoLightModel* lightModel = new SoLightModel;
    lightModel->model = SoLightModel::BASE_COLOR;
    separator->addChild(lightModel);
      
    SoDrawStyle* drawStyle = new SoDrawStyle;
    drawStyle->style.setValue(SoDrawStyle::LINES);
    drawStyle->linePattern.setValue(0xFFFF);
    separator->addChild(drawStyle);

    SoTools::addSegmentsToNode(separator,pointn,points);
  }break;
  case POLYGON: {
    SoLightModel* lightModel = new SoLightModel;
    lightModel->model = SoLightModel::PHONG;
    separator->addChild(lightModel);
      
    SoDrawStyle* drawStyle = new SoDrawStyle;
    drawStyle->style.setValue(SoDrawStyle::FILLED);
    separator->addChild(drawStyle);

    SoNormalBinding* normalBinding = new SoNormalBinding;
    normalBinding->value=SoNormalBinding::PER_FACE;
    separator->addChild(normalBinding);

    // It is assumed that the points are in the same plane.
    //WARNING : get the normal from the three first points.
    // It assumes that the three first points can form a plane...
    SbPlane plane(points[0],points[1],points[2]);
    SbVec3f normal = plane.getNormal();
    if(normal.length()<=0) normal.setValue(0,0,1); //Anomaly. Continue anyway.
    SoTools::addPolygonToNode(separator,pointn,points,normal);
  }break;
  }

  //  Send scene graph to the viewing region
  // (in the "dynamic" sub-scene graph) :
  region_addToDynamicScene(*region,separator);

  delete [] points;

  return StatusCode::SUCCESS;
}
#include <Inventor/nodes/SoShape.h>
#include <Inventor/actions/SoSearchAction.h>
std::vector<std::string> OnXSvc::getHighlightedSoShapeNames() 

// From OnX/source/Callbacks/OnX::SceneGraphAccessor::getSceneGraphs
{
  std::vector<std::string> names;

  MsgStream log(messageService(), Service::name());

  SoRegion* region = currentSoRegion();
  if(!region) {
    log << MSG::INFO << " can't get viewing region." << endreq;
    return names;
  }

  //typedef std::pair<std::string,void*> Loc;
  //std::vector<Loc> locs;

  SoNode* node = region->findNode("part","topSeparator");
  if(!node) {
    log << MSG::INFO << " part not found." << endreq;
    return names;
  }
 
  // Need to search in nodekits (for exa SoDetectorTreeKit) :
  SbBool oldsearch = SoBaseKit::isSearchingChildren();
  SoBaseKit::setSearchingChildren(TRUE);
  SoSearchAction searchAction;
  searchAction.setFind(SoSearchAction::NAME);
  searchAction.setName("sceneGraph");
  //searchAction.setSearchingAll(TRUE); //to search all under an SoSwitch.
  searchAction.setInterest(SoSearchAction::ALL);
  searchAction.apply(node);
  SoBaseKit::setSearchingChildren(oldsearch);

  SoPathList& pathList = searchAction.getPaths();
  unsigned int number = pathList.getLength();

  for(unsigned int index=0;index<number;index++) {
    SoFullPath* path = (SoFullPath*)pathList[index];

    SoNode* sep_sceneGraph = path->getTail();

    // highlighted ?
    bool highlighted = false;
   {SoSearchAction searchAction;
    searchAction.setFind(SoSearchAction::TYPE);
    searchAction.setType(SoHighlightMaterial::getClassTypeId());
    searchAction.apply(sep_sceneGraph);
    SoPath* path = searchAction.getPath();
    if(path) {
      SoHighlightMaterial* material = (SoHighlightMaterial*)path->getTail();
      if(material->getSavedMaterial()) highlighted = true;
    }}

    if(highlighted) {
      SoSearchAction searchAction;
      searchAction.setFind(SoSearchAction::TYPE);
      searchAction.setType(SoShape::getClassTypeId());
      searchAction.apply(sep_sceneGraph);
      SoPath* path = searchAction.getPath();
      std::string spath = path ? path->getTail()->getName().getString():"nil";
      //printf("debug : %s\n",spath.c_str());
      names.push_back(spath);
    }

  }

  return names;
}
std::vector<ContainedObject*> OnXSvc::getHighlightedContainedObject(
)
{
  MsgStream log(messageService(), Service::name());

  std::vector<ContainedObject*> objs;

  std::vector<std::string> names = getHighlightedSoShapeNames(); 
  std::vector<std::string>::const_iterator it;
  for(it=names.begin();it!=names.end(); it++) {

    std::vector<std::string> fields;
    Lib::smanip::words(*it,"/",fields);
    if(fields.size()<=1) {
      log << MSG::INFO << " bad syntax in " << (*it) << "." << endreq;
      objs.clear();
      break;
    }
      
    //std::string sclass = fields[0];
      
    std::string sid = fields[1];
    void* id = 0;
    if(!Lib::smanip::topointer(sid,id)) {
      log << MSG::INFO << " bad syntax in " << sid << "." << endreq;
      objs.clear();
      break;
    }

    //WARNING : it assumes that the deposited address is a ContainedObject* !

    objs.push_back((ContainedObject*)id);


  }

  return objs;
}

---