TGo4AbstractInterface.h

Go to the documentation of this file.

// $Id: TGo4AbstractInterface.h 1995 2017-03-10 12:40:46Z linev $
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum f�r 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;
      TGo4BrowserProxy*  fBrowser;
      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 char* NextHotStartCmd();
      void FreeHotStartCmds();
      static void ProduceLoadLibs(std::ostream& fs);

      static const char* DefaultPicTitle();


   public:

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

      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 = 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 ConnectDabc(const char* servername);

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

      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 = 0) {}

      virtual void ConnectAnalysis(const char* ServerNode,
                           Int_t ServerPort,
                           Int_t UserMode,  // 0 - observer, 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(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 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) {}

      // windows management

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

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

      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 TGo4Picture* GetPadOptions(ViewPanelHandle panel, Int_t padnumber = 0) { return 0; }

      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 = 0, const char* drawopt = 0) { return kFALSE; }

      virtual void RedrawItem(const char* itemname);

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

   ClassDef(TGo4AbstractInterface, 1);
};


#endif