KVDataAnalysisLauncher.h

#ifndef KVDataAnalysisLauncher_h
#define KVDataAnalysisLauncher_h
 
#include "TROOT.h"
#include "TSystem.h"
#include "TGClient.h"
#include "TGButton.h"
#include "TGTextEntry.h"
#include "TGComboBox.h"
#include "TGSlider.h"
#include "TGListBox.h"
#include "TGNumberEntry.h"
#include "TSortedList.h"
#include "TGLabel.h"
#include "TGTab.h"
#include "TEnv.h"
#include "TApplication.h"
 
 
#include "KVDBSystem.h"
#include "KVNumberList.h"
#include "KVDataSetAnalyser.h"
#include "KVListView.h"
#include "KVConfig.h"
 
class KVGFileList : public TGTransientFrame {
   enum ElementId {
      B_Add,
      B_Remove,
      B_AllRemove,
      LB_Files,
      TE_FileName
   };
 
protected:
   TGListBox*   lbFileList;
   TGTextEntry* teFileName;
   TGTextButton*   boutAdd;
   TGTextButton*   boutRem;
   TGTextButton*   boutAllRem;
   Int_t    entryMax;
   TString*     fileListString;
   TString     fileDialogDir;
 
   virtual void Init(TString& fileList, const Char_t* title);
   virtual void InitFileList();
 
public:
   KVGFileList(TString& st, const Char_t* titre = "File list",
               const TGWindow* p = 0, const TGWindow* main = 0, Bool_t ok = kTRUE);
   ~KVGFileList();
 
   virtual void AddFile(void);
   virtual void RemoveFiles(void);
   virtual void RemoveAllFiles(void);
   virtual void Done(void);
   virtual Char_t* GetFileFromDialog(void);
   virtual Bool_t CanAdd(const Char_t* s);
 
   ClassDef(KVGFileList, 0)
};
 
class KVGDirectoryList : public KVGFileList {
 
protected:
   void Init(TString& fileList, const Char_t* title) override;
public:
   KVGDirectoryList(TString& st, const Char_t* titre = "File list",
                    const TGWindow* p = 0, const TGWindow* main = 0, Bool_t ok = kTRUE);
   ~KVGDirectoryList();
 
   Char_t* GetFileFromDialog(void) override;
   Bool_t CanAdd(const Char_t* s) override;
 
   ClassDefOverride(KVGDirectoryList, 0)
};
 
class KVDataAnalysisLauncher : public TGMainFrame {
#ifdef __WITHOUT_TGCOMBOBOX_REMOVEALL
   void RemoveAll(TGComboBox* box) override;
   void RemoveAll(TGListBox* box) override;
#endif
   enum ElementId {
      CB_DataRepository,
      CB_AnalysisTask,
      CB_DataSet,
      CB_System,
      CB_Trigger,
      LB_Runs,
      B_Libs,
      B_Incs,
      B_Process,
      B_Quit
   };
 
protected:
   TEnv*      GUIenv;
    TList* ResourceNames;
    Int_t NbResNames;
   void SetResource(const Char_t* name, const Char_t* value);
   const Char_t* GetSavedResource(const Char_t* name, const Char_t* defaultvalue = "");
   const Char_t* GetResource(const Char_t* name, const Char_t* defaultvalue = "");
   void BuildResourceName(const Char_t* name, TString&, TString&);
 
   run_index_list  listOfRuns;
   run_index_list listOfSystemRuns;
 
   TGComboBox* cbRepository;
   TGComboBox* cbTask;
   TGComboBox* cbDataSet;
   KVListView* lvSystems;
   KVDBSystem* lastSelectedSystem;
   KVListView* lvRuns;
   TGLabel*    selectedRuns;
   Int_t     entryMax;
   Bool_t       selAll;
   std::unique_ptr<TList> list_of_runs;
 
   KVDataSetAnalyser* ia;
   TGCompositeFrame* cfAnalysis;
   TGComboBox* cbUserClass;
   TGPictureButton* btEditClass;
   TGLabel*         fUserClassLabel;
   TGTextEntry*   teUserOptions;
   TGNumberEntry* teNbToRead;
   TGTextButton* withBatch;
   TGTextButton* doBatchParams;
 
   TString         fUserLibraries;
   TString         fUserIncludes;
   Bool_t         checkCompilation;
   Bool_t noSystems;
   KVNameValueList fBatchParameters;
   KVDataSetAnalyser* GetDataAnalyser(KVDataAnalysisTask* task = 0);
 
    TList* UserClassNames;
   void FillListOfUserClasses();
   void SetUserClassList();
   void SetUserClass(const Char_t*);
   const Char_t* GetUserClass();
   void DisableUserClassList();
   void EnableUserClassList();
   void GenerateNewUserClass();
   TString SystemBatchName();
 
    UInt_t fMainGuiWidth;
    UInt_t fMainGuiHeight;
 
public:
   KVDataAnalysisLauncher(const TGWindow* p = 0, UInt_t w = 200, UInt_t h = 400);
   ~KVDataAnalysisLauncher();
 
   virtual void Exit(void)
   {
      gApplication->SetReturnFromRun(kTRUE);
      gApplication->Terminate(0);
   }
    void SetRepositoryList(void);
    void SetDataSetList(Char_t* s);
    void SetTaskList(Char_t* s);
    void SetSystemList(Int_t s);
    void SetRunsList();
   void UserClassSelected(char*);
    void SelectAll(void);
    void DeselectAll(void);
    void Process(void);
    void EnterRunlist(void);
 
   void SystemSelectionChanged();
 
    const Char_t* GetRepository(void);
    const Char_t* GetDataSet(void);
    const Char_t* GetTask(void);
    const Char_t* GetSystem(void);
    TString GetRuns(void);
 
    void SetRepository(const Char_t* r = "");
    void SetDataSet(const Char_t* ds = "");
    void SetTask(const Char_t* t = "");
    void SetSystem(const Char_t* s = "");
    void SetRuns(const Char_t* s = "");
 
    Bool_t IsBatch(void)
   {
      return withBatch->IsDown();
   }
   void SetBatch();
   Bool_t SetBatchParameters();
 
    void SetUserLibraries(void);
    void SetUserIncludes(void);
 
    Bool_t WarningBox(const char* title = "Warning", const char* msg = "Warning", Bool_t confirm = kFALSE);
   void UpdateListOfSelectedRuns();
   void ClearListOfSelectedRuns();
   void EditUserClassFiles();
 
   ClassDefOverride(KVDataAnalysisLauncher, 0) //Graphical interface for launching analysis tasks: KaliVedaGUI
};
 
#endif