TGo4AbstractInterface.cxx

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
//                     Planckstr. 1, 64291 Darmstadt, Germany
// Contact:            http://go4.gsi.de
//-----------------------------------------------------------------------
// This software can be used under the license agreements as stated
// in Go4License.txt file which is part of the distribution.
//-----------------------------------------------------------------------

#include "TGo4AbstractInterface.h"

#include <iostream>
#include <fstream>

#include "TROOT.h"
#include "TSystem.h"
#include "TInterpreter.h"
#include "TObjString.h"

#include "TGo4Log.h"
#include "TGo4Iter.h"
#include "TGo4BrowserProxy.h"
#include "TGo4ServerProxy.h"

TGo4AbstractInterface *TGo4AbstractInterface::fgInstance = nullptr;

TString TGo4AbstractInterface::fInitSharedLibs = "";


TGo4AbstractInterface *TGo4AbstractInterface::Instance()
{
   return fgInstance;
}

void TGo4AbstractInterface::DeleteInstance()
{
   if (fgInstance) {
      delete fgInstance;
      fgInstance = nullptr;
   }
}

const char *TGo4AbstractInterface::FileExtension()
{
   return ".hotstart";
}

const char *TGo4AbstractInterface::DefaultPicTitle()
{
   return "temporary object to setup viewpanel";
}

Int_t TGo4AbstractInterface::DelayMillisec()
{
   return 20;
}

void TGo4AbstractInterface::SetInitSharedLibs(const char *libs)
{
   fInitSharedLibs = libs ? libs : gInterpreter->GetSharedLibs();
}

TGo4AbstractInterface::TGo4AbstractInterface() :
   TObject(),
   fOM(nullptr),
   fBrowser(nullptr),
   fxCommands()
{
   fgInstance = this;
}

void TGo4AbstractInterface::Initialize(TGo4ObjectManager *om, TGo4BrowserProxy *br)
{
   fOM = om;
   fBrowser = br;

   Int_t error = 0;
   gROOT->ProcessLineSync("TGo4AbstractInterface *go4 = TGo4AbstractInterface::Instance();", &error);
   gROOT->ProcessLineSync("TGo4ObjectManager *om = TGo4AbstractInterface::Instance()->OM();", &error);
   gROOT->ProcessLineSync("TGo4BrowserProxy *br = TGo4AbstractInterface::Instance()->Browser();", &error);
   gROOT->ProcessLineSync(TString::Format(".x %s", TGo4Log::subGO4SYS("macros/go4macroinit.C").Data()).Data());
}

TGo4AbstractInterface::~TGo4AbstractInterface()
{
   FreeHotStartCmds();

   gROOT->ProcessLine(TString::Format(".x %s", TGo4Log::subGO4SYS("macros/go4macroclose.C").Data()).Data());

   gInterpreter->DeleteGlobal(fBrowser);
   gInterpreter->DeleteGlobal(fOM);
   gInterpreter->DeleteGlobal(this);

   fgInstance = nullptr;

}

TGo4AnalysisProxy *TGo4AbstractInterface::Analysis()
{
   return Browser() ? Browser()->FindAnalysis() : nullptr;
}

TGo4ServerProxy *TGo4AbstractInterface::Server()
{
   return Browser() ? Browser()->FindServer() : nullptr;
}

void TGo4AbstractInterface::LoadLibrary(const char *fname)
{
   if (!fname || (strlen(fname) == 0)) return;

   TString libs = gInterpreter->GetSharedLibs();

   const char *token = strtok((char *) libs.Data(), " ,\t\n");

   while(token != nullptr) {
      if (strcmp(token, fname) == 0) return;
      token = strtok(nullptr, " ,\t\n");
   }

   gSystem->Load(fname);
}

void TGo4AbstractInterface::OpenFile(const char *fname)
{
   Browser()->OpenFile(fname);
   ProcessEvents(-1);
}


Bool_t TGo4AbstractInterface::SaveToFile(const char *itemname,
                                         const char *filename,
                                         const char *filetitle)
{
   return Browser()->SaveBrowserToFile(filename, kFALSE, itemname, filetitle);
}

Bool_t TGo4AbstractInterface::ExportToFile(const char *itemname,
                                           const char *dirpath,
                                           const char *format,
                                           const char *filetitle)
{
    TGo4Slot *topslot = Browser()->ItemSlot(itemname);
    if (!topslot) return kFALSE;

    TObjArray items;

    TGo4Iter iter(topslot, kTRUE);

    TString buf;

    while (iter.next())
       if (Browser()->BrowserItemName(iter.getslot(), buf))
          items.Add(new TObjString(buf));

    Browser()->ExportItemsTo(&items, kFALSE, "null", dirpath, format, filetitle);

    items.Delete();

    return kTRUE;
}


void TGo4AbstractInterface::ConnectHServer(const char *servername,
                                       Int_t portnumber,
                                       const char *basename,
                                       const char *userpass,
                                       const char *filter)
{
   Browser()->ConnectHServer(servername,
                             portnumber,
                             basename,
                             userpass,
                             filter);
   ProcessEvents(200);
}

void TGo4AbstractInterface::ConnectDabc(const char *servername)
{
   Browser()->ConnectDabc(servername);
}

Bool_t TGo4AbstractInterface::IsAnalysisConnected()
{
   return !Server() ? kFALSE : Server()->IsConnected();
}

void TGo4AbstractInterface::ExecuteLine(const char *remotecmd)
{
   TGo4ServerProxy *anal = Server();
   if (anal && remotecmd) {
      anal->ExecuteLine(remotecmd);
      TGo4Log::Message(1, "Exec: %s", remotecmd);
   }
}

void TGo4AbstractInterface::RequestAnalysisConfig()
{
   TGo4ServerProxy *anal = Server();
   if (anal)
     anal->RequestAnalysisSettings();
}

void TGo4AbstractInterface::MonitorItem(const char *itemname, Bool_t on)
{
   TGo4Slot *itemslot = Browser()->BrowserSlot(itemname);
   if (itemslot)
     Browser()->SetItemMonitored(itemslot, on);
}

void TGo4AbstractInterface::StartMonitoring(Int_t period)
{
   Browser()->ToggleMonitoring(period*1000);
}

void TGo4AbstractInterface::StopMonitoring()
{
   Browser()->ToggleMonitoring(-1);
}

TString TGo4AbstractInterface::FindItem(const char *objname)
{
   // if itemname is specified, return as is
   if (Browser()->ItemSlot(objname)) return TString(objname);

   return Browser()->FindItem(objname);
}

Bool_t TGo4AbstractInterface::CopyItem(const char *itemname)
{
   return Browser()->ProduceExplicitCopy(itemname);
}

Bool_t TGo4AbstractInterface::DeleteItem(const char *itemname)
{
   return Browser()->DeleteDataSource(Browser()->ItemSlot(itemname));
}

void TGo4AbstractInterface::FetchItem(const char *itemname, Int_t wait_time)
{
   Browser()->FetchItem(itemname, wait_time);
}

void TGo4AbstractInterface::RedrawItem(const char *itemname)
{
   Browser()->RedrawItem(itemname);
}

TObject *TGo4AbstractInterface::GetObject(const char *itemname, Int_t updatelevel)
{
   if (!itemname || (strlen(itemname) == 0)) return nullptr;

   return Browser()->GetBrowserObject(itemname, updatelevel);
}

TString TGo4AbstractInterface::SaveToMemory(const char *path, TObject *obj, Bool_t ownership)
{
   TString res = Browser()->SaveToMemory(path, obj, ownership, kTRUE);

   ProcessEvents();

   return res;
}

Bool_t TGo4AbstractInterface::LoadHotStart(const char *filename)
{
   FreeHotStartCmds();

   std::ifstream f(filename);

   if (!f.good()) return kFALSE;

   char buf[10000];

   while (!f.eof()) {
      f.getline(buf, 10000);
      fxCommands.Add(new TObjString(buf));
   }

   if (fxCommands.IsEmpty()) return kFALSE;

   // Add empty string, which will be deleted first
   fxCommands.AddFirst(new TObjString(""));
   return kTRUE;
}

Bool_t TGo4AbstractInterface::IsHotStart() const
{
   return !fxCommands.IsEmpty();
}

const char *TGo4AbstractInterface::NextHotStartCmd()
{
   if (fxCommands.IsEmpty()) return nullptr;
   TObject *obj = fxCommands.First();
   fxCommands.Remove(obj);
   delete obj;
   const char *res = nullptr;
   do {
      if (fxCommands.IsEmpty()) return nullptr;
      TObjString* str = (TObjString*) fxCommands.First();
      res = str->GetName();
      if (!res || (strlen(res) == 0)) {
         res = nullptr;
         fxCommands.Remove(str);
         delete str;
      }

   } while (!res);
   return res;
}

void TGo4AbstractInterface::FreeHotStartCmds()
{
   fxCommands.Delete();
}

void TGo4AbstractInterface::ProduceLoadLibs(std::ostream &fs)
{
   TString rootsys;
   if (gSystem->Getenv("ROOTSYS") != nullptr) {
      rootsys = gSystem->Getenv("ROOTSYS");
      if (rootsys[rootsys.Length()-1] != '/') rootsys+="/";
   }

   TString go4sys = TGo4Log::GO4SYS();

   TString libs = gInterpreter->GetSharedLibs();
   const char *token = strtok((char *) libs.Data(), " ,\t\n");
   while(token != nullptr) {
      if ((fInitSharedLibs.Index(token) == kNPOS)
//           !strstr(token,"libGX11.") &&
//           !strstr(token,"libGX11TTF.") &&
           && !strstr(token,"libHistPainter.")) {
              fs << "go4->LoadLibrary(\"";
              if ((go4sys.Length() > 0) && strstr(token, go4sys.Data()) == token)
                 fs << "$GO4SYS/" << (token + go4sys.Length());
              else
              if ((rootsys.Length() > 0) && strstr(token, rootsys.Data()) == token)
                 fs << "$ROOTSYS/" << (token + rootsys.Length());
              else
                 fs << token;

              fs << "\");" << std::endl;
          }
      token = strtok(nullptr, " ,\t\n");
   }
}