TGo4AbstractInterface.h

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.
//-----------------------------------------------------------------------
 
#ifndef TGO4ABSTRACTINTERFACE_H
#define TGO4ABSTRACTINTERFACE_H
 
#include "TObject.h"
 
#include "TString.h"
#include "TList.h"
#include <ostream>
 
class TGo4ObjectManager;
class TGo4BrowserProxy;
class TGo4AnalysisProxy;
class TGo4ServerProxy;
class TPad;
class TGo4Picture;
 
typedef void *ViewPanelHandle;
 
enum EGo4ViewPanelMode { Go4_hidden = -1, Go4_minimized = 0, Go4_normal = 1, Go4_maximized = 2 };
 

 
class TGo4AbstractInterface : public TObject {
   private:
      TGo4ObjectManager *fOM{nullptr};
      TGo4BrowserProxy * fBrowser{nullptr};
      TList              fxCommands;
 
   protected:
      TGo4AbstractInterface();
 
      static TGo4AbstractInterface *fgInstance;        
      static TString                fInitSharedLibs;   
 
      void Initialize(TGo4ObjectManager *om, TGo4BrowserProxy *br);
 
      virtual void ProcessEvents(Int_t timeout = -1) = 0;
 
      Bool_t LoadHotStart(const char *filename);
      Bool_t IsHotStart() const;
      const char *NextHotStartCmd();
      void FreeHotStartCmds();
      static void ProduceLoadLibs(std::ostream &fs);

      static const char *DefaultPicTitle();
 
 
   public:

      static void SetInitSharedLibs(const char *libs = nullptr);

      virtual ~TGo4AbstractInterface();

      static TGo4AbstractInterface *Instance();

      static void DeleteInstance();

      static const char *FileExtension();

      static Int_t DelayMillisec();

      TGo4ObjectManager *OM() const { return fOM; }

      TGo4BrowserProxy *Browser() const { return fBrowser; }

      TGo4AnalysisProxy *Analysis();

      TGo4ServerProxy *Server();

      virtual void HotStart(const char *filename) = 0;
 
      // general purpose

      virtual void LoadLibrary(const char *fname);

      virtual void OpenFile(const char *fname);

      virtual TString FindItem(const char *objname);

      virtual Bool_t CopyItem(const char *itemname);

      virtual Bool_t DeleteItem(const char *itemname);

      virtual void FetchItem(const char *itemname, Int_t wait_time = 2000);

      virtual TObject *GetObject(const char *itemname, Int_t updatelevel = 1);

      virtual TString SaveToMemory(const char *path, TObject *obj, Bool_t ownership = kFALSE);

      virtual Bool_t SaveToFile(const char *itemname,
                                const char *filename,
                                const char *filetitle = nullptr);

      virtual Bool_t ExportToFile(const char *itemname,
                                  const char *dirpath,
                                  const char *format,
                                  const char *filetitle = nullptr);

      virtual void ConnectHServer(const char *servername,
                                  Int_t portnumber,
                                  const char *basename,
                                  const char *userpass,
                                  const char *filter);

      virtual void ConnectDabc(const char *servername);

      virtual TGo4ServerProxy *ConnectHttp(const char *servername, const char *account = nullptr, const char *pass = nullptr) { return nullptr; }

      virtual void Wait(double tm_sec) {}

      virtual void Message(const char *msg) {}
 
      // analysis start and configuration

      virtual void LaunchAnalysis() {}

      virtual void LaunchAnalysis(const char *ClientName,
                          const char *ClientDir,
                          const char *ClientExec,
                          const char *ClientNode,
                          Int_t ShellMode =  2,     //   0 = exec, 1 = rsh,  2 = ssh
                          Int_t TermMode = 1,       //   1 = Qt,   2 = Xterm, 3 = konsole
                          Int_t ExeMode = 0,        //   0 = exe,  1 = lib
                          const char *UserArgs = nullptr) {}

      virtual void ConnectAnalysis(const char *ServerNode,
                                   Int_t ServerPort,
                                   Int_t UserMode,  // 0 - observer, 1- controller, 2 - administrator
                                   const char *password = nullptr)  {}

      virtual void WaitAnalysis(Int_t delay_sec) {}

      virtual Bool_t IsAnalysisConnected();

      virtual void DisconnectAnalysis() {}

      virtual void ShutdownAnalysis() {}

      virtual void ExecuteLine(const char *remotecmd);

      virtual void RequestAnalysisConfig();

      virtual void SubmitAnalysisConfig(int tmout = 20) {}

      virtual void StartAnalysis() {}

      virtual void StopAnalysis() {}

      virtual void RefreshNamesList(int tmout = 10) {}

      virtual void SetAnalysisTerminalMode(int mode) {}

      virtual void SetAnalysisConfigMode(int mode) {}

      virtual void MonitorItem(const char *itemname, Bool_t on = kTRUE);

      virtual void StartMonitoring(Int_t period = 10);

      virtual void StopMonitoring();

      virtual void AnalysisAutoSave(const char *filename,
                                    Int_t interval,
                                    Int_t compression,
                                    Bool_t enabled,
                                    Bool_t overwrite) {}

      virtual void AnalysisConfigName(const char *filename) {}
 
      // steps configuration

      virtual void ConfigStep(const char *stepname,
                              Bool_t enableprocess,
                              Bool_t enablesource,
                              Bool_t enablestore) {}

      virtual void StepFileSource(const char *stepname,
                                  const char *sourcename,
                                  int timeout) {}

      virtual void StepMbsFileSource(const char *stepname,
                                     const char *sourcename,
                                     int timeout,
                                     const char *TagFile,
                                     int start = 0,
                                     int stop = 0,
                                     int interval = 0) {}

      virtual void StepMbsStreamSource(const char *stepname,
                                       const char *sourcename,
                                       int timeout,
                                       int start = 0,
                                       int stop = 0,
                                       int interval = 0) {}

      virtual void StepMbsTransportSource(const char *stepname,
                                          const char *sourcename,
                                          int timeout,
                                          int start = 0,
                                          int stop = 0,
                                          int interval = 0) {}

      virtual void StepMbsEventServerSource(const char *stepname,
                                    const char *sourcename,
                                    int timeout,
                                    int start = 0,
                                    int stop = 0,
                                    int interval = 0) {}

      virtual void StepMbsRevServSource(const char *stepname,
                                const char *sourcename,
                                int timeout,
                                int port = 0,
                                int start = 0,
                                int stop = 0,
                                int interval = 0) {}

      virtual void StepMbsSelection(const char *stepname,
                                    int start,
                                    int stop,
                                    int interval) {}

      virtual void StepRandomSource(const char *stepname,
                            const char *sourcename,
                            int timeout) {}

      virtual void StepMbsPort(const char *stepname,
                              int port) {}

      virtual void StepMbsRetryCnt(const char *stepname,
                                   int cnt) {}

      virtual void StepUserSource(const char *stepname,
                          const char *sourcename,
                          int timeout,
                          int port,
                          const char *expr) {}

      virtual void StepHDF5Source(const char *stepname,
                                  const char *sourcename,
                                  int timeout) {}

      virtual void StepFileStore(const char *stepname,
                         const char *storename,
                         bool overwrite,
                         int bufsize,
                         int splitlevel,
                         int compression,
                         int autosaveperiod = 0) {}

      virtual void StepBackStore(const char *stepname,
                         const char *storename,
                         int bufsize,
                         int splitlevel) {}

      virtual void StepUserStore(const char *stepname,
                         const char *storename) {}

      virtual void StepHDF5Store(const char *stepname,
                                  const char *storename,
                                  int flags) {}
 
      // windows management

      virtual void SetMainWindowState(int qtversion, const char *val) {}

      virtual void SetMainWindowGeometry(int qtversion, const char *val) {}

      virtual ViewPanelHandle StartViewPanel() { return nullptr; }

      virtual ViewPanelHandle StartViewPanel(int x, int y, int width, int height, int mode = 1, TGo4Picture *pic = nullptr) { return nullptr; }

      virtual TString GetViewPanelName(ViewPanelHandle panel) { return TString(); }

      virtual ViewPanelHandle FindViewPanel(const char *name) { return nullptr; }

      virtual Bool_t SetViewPanelName(ViewPanelHandle panel, const char *newname) { return kFALSE; }

      virtual ViewPanelHandle GetActiveViewPanel() { return nullptr; }

      virtual void RedrawPanel(ViewPanelHandle panel) {}

      virtual void DivideViewPanel(ViewPanelHandle panel, Int_t numX, Int_t numY) {}

      virtual TPad *SelectPad(ViewPanelHandle panel, Int_t number = 0) { return nullptr; }

      virtual TGo4Picture *GetPadOptions(ViewPanelHandle panel, Int_t padnumber = 0) { return nullptr; }

      virtual void SetSuperimpose(ViewPanelHandle panel, Bool_t on = kTRUE) {}

      virtual void SetApplyToAll(ViewPanelHandle panel, Bool_t on = kTRUE) {}

      virtual Bool_t DrawItem(const char *itemname, ViewPanelHandle panel = nullptr, const char *drawopt = nullptr) { return kFALSE; }

      virtual void RedrawItem(const char *itemname);

      virtual const char *GetDrawnItemName(ViewPanelHandle panel, int cnt = 0) { return nullptr; }

      virtual void StartFitPanel() {}
 
   ClassDefOverride(TGo4AbstractInterface, 0);
};
 
 
#endif