TGo4AbstractInterface.h

Go to the documentation of this file.

//-------------------------------------------------------------
//        Go4 Release Package v3.04-01 (build 30401)
//                      28-November-2008
//---------------------------------------------------------------
//   The GSI Online Offline Object Oriented (Go4) Project
//   Experiment Data Processing at EE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    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"

class TGo4ObjectManager;
class TGo4BrowserProxy;
class TGo4AnalysisProxy;
class TPad;
class TGo4Picture;

typedef void* ViewPanelHandle;


class TGo4AbstractInterface : public TObject {
   protected:
      TGo4AbstractInterface();

      static TGo4AbstractInterface* fgInstance;

      void Initialize(TGo4ObjectManager* om, TGo4BrowserProxy* br);

      virtual void ProcessEvents(Int_t timeout = -1) = 0;

      Bool_t LoadHotStart(const char* filename);
      Bool_t IsHotStart();
      const char* NextHotStartCmd();
      void FreeHotStartCmds();

   public:

      virtual ~TGo4AbstractInterface();

      static TGo4AbstractInterface* Instance();

      static void DeleteInstance();

      TGo4ObjectManager* OM() const { return fOM; }

      TGo4BrowserProxy* Browser() const { return fBrowser; }

      TGo4AnalysisProxy* Analysis();

      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 = 0);

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

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

      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,      // 1 = rsh  2 = ssh
                          Int_t TermMode = 1)  {}     // 1 = Qt   2 = Xterm 3 = konsole

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

      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() {}

      virtual void StartAnalysis() {}

      virtual void StopAnalysis() {}

      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,
                             int stop,
                             int interval) {}

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

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

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

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

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

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

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

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

      // windows management

      virtual ViewPanelHandle StartViewPanel() { return 0; }

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

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

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

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

      virtual ViewPanelHandle GetActiveViewPanel() { return 0; }

      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 0; }

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

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

      virtual void RedrawItem(const char* itemname);

   private:
      TGo4ObjectManager* fOM;
      TGo4BrowserProxy* fBrowser;
      TList  fxCommands;

   ClassDef(TGo4AbstractInterface, 1);
};


#endif

//----------------------------END OF GO4 SOURCE FILE ---------------------

---