MagicDisplay.h

#ifndef MAGICDISPLAY_H
#define MAGICDISPLAY_H

//Includes
#include "TChain.h"
#include "MagicDisplayConventions.h"
#include "AnitaConventions.h"
#include "CalibratedAnitaEvent.h"
#include "AnalysisReco.h"
#include "Analyzer.h"
#include "FilterStrategy.h"
#include "FourierBuffer.h"

#include "AnitaDataset.h"
#include "TGFrame.h"

// #include <RQ_OBJECT.h>
#include "TRootEmbeddedCanvas.h"


class TCanvas;

class TPad;
class RawAnitaHeader;
class PrettyAnitaHk;
class RawAnitaEvent;
//class CalibratedAnitaEvent;
class UsefulAnitaEvent;
class Adu5Pat;

class TurfRate;
class SummedTurfRate;
class AveragedSurfHk;
class SurfHk;

class Adu5Pat;
class Adu5Sat;
class Adu5Vtg;
class G12Pos;
class G12Sat;
class GpsGga;

class TButton;
class TTreeIndex;
class TFile;
class TEventList;




class MagicControlPanel;
class FilteringPanel;
class AnitaEmbeddedCanvas;


class MagicDisplay : public TGMainFrame
{

  friend class MagicControlPanel;
  friend class FilteringPanel;
  friend class AnitaEmbeddedCanvas;
  
 public:


  MagicDisplay(const char *baseDir, int run, WaveCalType::WaveCalType_t calType=WaveCalType::kDefault, AnitaDataset::BlindingStrategy blinding=AnitaDataset::kDefault);
  /*
    \param run The run number to start with
    \param calType The calibration option desired (see <a HREF="/uhen/anita/eventReader/">the event reader documentation for the different available calibration options</A>)
    */
  MagicDisplay(int run, AnitaDataset::DataDirectory datadir = AnitaDataset::ANITA_ROOT_DATA, WaveCalType::WaveCalType_t calType=WaveCalType::kDefault, AnitaDataset::BlindingStrategy blinding=AnitaDataset::kDefault);
  MagicDisplay(const char* playlist, AnitaDataset::DataDirectory datadir = AnitaDataset::ANITA_ROOT_DATA, WaveCalType::WaveCalType_t calType=WaveCalType::kDefault, AnitaDataset::BlindingStrategy blinding=AnitaDataset::kDefault);
  MagicDisplay(); 
  ~MagicDisplay(); 

  //Control Panel Functions
  void startControlPanel(); 
  void startFilteringPanel(); 

  Int_t getCurrentRun()
  {return fCurrentRun;} 
  UInt_t getCurrentEvent(); 

  void startEventPlaying(); 
  void startEventPlayingReverse(); 
  void stopEventPlaying(); 

  void closeCurrentRun(); 

  // int loadEventTree(); ///< Loads the event tree corresponding to the current run number <i>fCurrentRun</i>
  int loadDataset(); 
  void startEventDisplay(); 

  int displayThisEvent(UInt_t eventNumber, Int_t run=-1); 
  int displayNextEvent(int nskip = 0); 
  int displayFirstEvent(); 
  int displayLastEvent(); 
  int displayPreviousEvent(int nskip =0); 
  void refreshEventDisplay(bool forceRedo=false); 
  int getEventEntry(); 
  void drawEventButtons(); 
  

  void setCanvasLayout(MagicDisplayCanvasLayoutOption::MagicDisplayCanvasLayoutOption_t option); 
  void swapWaveformButtonFunctionsAndTitles(MagicDisplayCanvasLayoutOption::MagicDisplayCanvasLayoutOption_t option);

  void setWaveformFormat(MagicDisplayFormatOption::MagicDisplayFormatOption_t waveformView);
  // void setInterferometryTypeFlags(AnalysisReco::mapMode_t mapMode, AnalysisReco::zoomMode_t zoomMode);

  // For UCorrelator integration
  void setFilterStrategy(FilterStrategy * filter_strategy);
  void setAnalysisConfig(const UCorrelator::AnalysisConfig * config);


  void toggleTimeEventOrdering(); 
  void applyCut(const char *cutString); 

  int loadTurfTree(); 
  void startTurfDisplay(); 
  int displayNextTurf(); 
  int displayPreviousTurf(); 
  void refreshTurfDisplay(); 
  int getTurfEntry(); 
  void drawTurfButtons(); 
  void toggleTurfYScale(); 

  int loadSurfTree(); 
  void startSurfDisplay(); 
  int displayNextSurf(); 
  int displayPreviousSurf(); 
  void refreshSurfDisplay(); 
  int getSurfEntry(); 
  void drawSurfButtons(); 
  void setSurfHkDisplay(MagicDisplaySurfHkDisplay::MagicDisplaySurfHkDisplay_t surfDisplay); 
  void toggleSurfRfPowerView(Int_t kelvinView); 
  void toggleSurfLogView(); 
  void startSurfHkPlaying(); 
  void stopSurfHkPlaying(); 

  int loadAvgSurfTree(); 
  void startAvgSurfDisplay(); 
  int displayNextAvgSurf(); 
  int displayPreviousAvgSurf(); 
  void refreshAvgSurfDisplay(); 
  int getAvgSurfEntry(); 
  void drawAvgSurfButtons(); 
  void toggleAvgSurfRfPowerView(Int_t kelvinView); 
  void toggleAvgSurfLogView(); 
  void setAvgSurfHkDisplay(MagicDisplaySurfHkDisplay::MagicDisplaySurfHkDisplay_t surfDisplay); 
  void startAvgSurfHkPlaying(); 
  void stopAvgSurfHkPlaying(); 


  int loadSumTurfTree(); 
  void startSumTurfDisplay(); 
  int displayNextSumTurf(); 
  int displayPreviousSumTurf();
  void refreshSumTurfDisplay(); 
  int getSumTurfEntry(); 
  void drawSumTurfButtons(); 
  void toggleSumTurfYScale(); 

  int loadGpsTrees(); 
  void startGpsDisplay(); 
  int displayNextGps(); 
  int displayPreviousGps(); 
  void refreshGpsDisplay(); 
  int getGpsEntry(); 
  void drawGpsButtons(); 
  void startGpsPlaying(); 
  void stopGpsPlaying(); 
  void setGpsView(MagicDisplayGpsDisplay::MagicDisplayGpsDisplay_t theDisplay);

  void dumpWaveformsForPeter();
  


  static MagicDisplay*  Instance();

  AnitaDataset* fDataset; 
  // TFile *fHeadFile; ///< A pointer to the current header file.
  // TFile *fEventFile; ///< A pointer to the current event file.
  // TFile *fTurfRateFile; ///< A pointer to the current TURF rate file.
  // TFile *fSumTurfRateFile; ///< A pointer to the current summed TURF rate file.
  // TFile *fSurfHkFile; ///< A pointer to the current SURF hk file.
  // TFile *fAvgSurfHkFile; ///< A pointer to the current averaged SURF hk file.
  // TFile *fGpsFile; ///<A pointer to the current GPS file.

  // //Here are the data managers
  // TTree *fHeadTree; ///< A pointer to the current header tree.
  // TTree *fEventTree; ///< A pointer to the current event tree.
  // TTree *fPrettyHkTree; ///< A pointer to the current pretty hk tree.
  // TTree *fTurfRateTree; ///< A pointer to the current TURF rate tree.
  // TTree *fSurfHkTree; ///< A pointer to the current SURF hk tree.
  // TTree *fSumTurfRateTree; ///< A pointer to the current summed TURF rate tree.
  // TTree *fAvgSurfHkTree;///< A pointer to the current averaged SURF hk tree.
  // TTree *fG12PosTree;///< A pointer to the current G12 position tree.
  // TTree *fG12SatTree;///< A pointer to the current G12 satellite tree.
  // TTree *fAdu5aPatTree; ///< A pointer to the current ADU5 A position tree.
  // TTree *fAdu5aSatTree; ///< A pointer to the current ADU5 A satellite tree.
  // TTree *fAdu5aVtgTree; ///< A pointer to the current ADU5 A velocity tree.
  // TTree *fAdu5bPatTree; ///< A pointer to the current ADU5 B position tree.
  // TTree *fAdu5bSatTree; ///< A pointer to the current ADU5 B satellite tree.
  // TTree *fAdu5bVtgTree; ///< A pointer to the current ADU5 B velocity tree.

  //And some useful info to keep track of what is where
  Long64_t fEventCutListEntry; 
  Long64_t fEventTreeIndexEntry; 
  Long64_t fEventEntry; 
  Long64_t fPrettyHkEntry; 
  Long64_t fTurfRateEntry; 
  Long64_t fSurfHkEntry; 
  Long64_t fSumTurfRateEntry; 
  Long64_t fAvgSurfHkEntry; 
  Long64_t fG12PosEntry; 
  Long64_t fG12SatEntry; 
  Long64_t fAdu5aPatEntry; 
  Long64_t fAdu5aSatEntry; 
  Long64_t fAdu5aVtgEntry; 
  Long64_t fAdu5bPatEntry; 
  Long64_t fAdu5bSatEntry; 
  Long64_t fAdu5bVtgEntry; 

  //And something to help with the indexing
  TTreeIndex *fHeadIndex; 
  TTreeIndex *fAdu5aSatIndex; 
  TTreeIndex *fAdu5bSatIndex; 


  Int_t  fWhichEventFileKind; 
  UInt_t fCurrentRun; 
  Char_t fCurrentBaseDir[180]; 


  Acclaim::AnalysisReco& getAnalysisReco(); 


  UCorrelator::Analyzer * getUCorr() { return fUCorr; }
  FilterStrategy * getStrategy() { return fStrategy; }
  const FilteredAnitaEvent * getFilteredEvent() { return fFilteredEventPtr; }
  // FilterStrategy * getNoFilterStrategy();
  // FilterStrategy * getDefaultFilterStrategy();

  std::map<TString, FilterStrategy*>& getFilterStrats(){return filterStrats;}  

  const TPad * getMainPad() const { return fMagicMainPad; } 

 protected:
  static MagicDisplay *fgInstance;  
   // protect against multiple instances

 private:
  virtual Bool_t HandleSelection(Event_t* event);
  virtual Bool_t HandleKey(Event_t* event);    
  int doKeyboardShortcut(Event_t* event);
  void prepareKeyboardShortcuts();
  
  void loadPlaylist(const char* playlist);
  std::vector<std::vector<long> > fPlaylist;
  int fPlaylistEntry;

  UInt_t getPlaylistRun() { return fPlaylist[fPlaylistEntry][0]; }
  Long64_t getPlaylistEvent() { return fPlaylist[fPlaylistEntry][1]; }

  void zeroPointers();
  MagicDisplayFormatOption::MagicDisplayFormatOption_t fWaveformFormat; 
  MagicDisplayCanvasLayoutOption::MagicDisplayCanvasLayoutOption_t fCanvasLayout; 
  
   // TGMainFrame *fMainFrame; ///< The magic display frame, we need this to do fancy connecting
  AnitaEmbeddedCanvas* fMagicEmbedded; 
  // TRootEmbeddedCanvas *fMagicEmbedded; 
   TCanvas *fMagicCanvas; 
   TPad *fMagicMainPad; 
   TPad *fMagicEventInfoPad; 

   TCanvas *fTurfCanvas; 
   TPad *fTurfMainPad; 
   TPad *fTurfInfoPad; 

   TCanvas *fSumTurfCanvas; 
   TPad *fSumTurfMainPad; 
   TPad *fSumTurfInfoPad; 

   TCanvas *fSurfCanvas; 
   TPad *fSurfMainPad; 
   TPad *fSurfInfoPad; 

   TCanvas *fAvgSurfCanvas; 
   TPad *fAvgSurfMainPad; 
   TPad *fAvgSurfInfoPad; 

   TCanvas *fGpsCanvas; 
   TPad *fGpsMainPad; 
   TPad *fGpsInfoPad; 

   RawAnitaHeader *fHeadPtr; 
   PrettyAnitaHk *fHkPtr; 
   RawAnitaEvent *fRawEventPtr; 
   CalibratedAnitaEvent *fCalEventPtr; 
   FilteredAnitaEvent* fFilteredEventPtr; 
   UInt_t fLastFilteredEventNumber; 
   UsefulAnitaEvent *fUsefulEventPtr; 
   TurfRate *fTurfPtr; 
   SurfHk *fSurfPtr; 
   SummedTurfRate *fSumTurfPtr; 
   AveragedSurfHk *fAvgSurfPtr; 

   Adu5Pat* fPatPtr; 


  
  G12Pos *fG12PosPtr; 
  G12Sat *fG12SatPtr; 
  Adu5Pat *fAdu5APatPtr; 
  Adu5Sat *fAdu5ASatPtr; 
  Adu5Vtg *fAdu5AVtgPtr; 
  Adu5Pat *fAdu5BPatPtr; 
  Adu5Sat *fAdu5BSatPtr; 
  Adu5Vtg *fAdu5BVtgPtr; 

  TButton *fVertButton; 
  TButton *fHorizButton; 
  TButton *fBothButton; 
  TButton *fSurfButton; 
  TButton *fPayloadButton; 
  TButton *fInterferometryButton; 
  TButton *fUCorrelatorButton; 
  TButton *butFiltering; 

  TButton *fWaveformButton; 
  TButton *fPowerButton; 
  TButton *fHilbertButton; 
  TButton *fAverageFFTButton; 
  TButton *fTimeEntryButton; 


  TButton *fTurfYScaleButton; 
  TButton *fSurfSurfViewButton; 
  TButton *fSurfPhiViewButton; 
  TButton *fSurfTimeViewButton; 
  TButton *fSurfAdcViewButton; 
  TButton *fSurfKelvinViewButton; 
  TButton *fSurfMeasuredKelvinViewButton; 
  TButton *fSurfLogButton; 

  TButton *fSumTurfYScaleButton; 
  TButton *fAvgSurfSurfViewButton; 
  TButton *fAvgSurfPhiViewButton; 
  TButton *fAvgSurfAdcViewButton; 
  TButton *fAvgSurfKelvinViewButton; 
  TButton *fAvgSurfMeasuredKelvinViewButton; 
  TButton *fAvgSurfLogButton; 


  TButton *fGpsSatViewButton; 
  TButton *fGpsMapViewButton; 

  Int_t fInEventPlayMode; 
  Int_t fEventPlaySleepMs; 
  Int_t fOrderByEventNumber; 
  Int_t fApplyEventCut; 
  TEventList *fCutEventList; 


  Int_t fInSurfPlayMode; 
  Int_t fInAvgSurfPlayMode; 
  Int_t fInGpsPlayMode; 

  WaveCalType::WaveCalType_t fCalType; 

  // AnalysisReco::mapMode_t fInterferometryMapMode;
  // AnalysisReco::zoomMode_t fInterferometryZoomMode;


  void initializeFilterStrategies(); // If you want your favourite filter strategy to be available in MagicDisplay... add it here!
  void clearFilterStrategies(); //destroy the strategies
  void drawUCorrelatorFilterButtons();
  void setNextFilter(); // cycle through available filters...
  UCorrelator::Analyzer * fUCorr;
  FilterStrategy * fStrategy;
  std::map<TString, FilterStrategy*> filterStrats;

  MagicControlPanel* fControlPanel;
  FilteringPanel* fFilteringPanel;  
  AnitaDataset::DataDirectory fDataDirectory;

  AnitaDataset::BlindingStrategy fBlindingStrategy;

  ClassDef(MagicDisplay,0); 

};


// turn off the fucking keyboard stealing...
class AnitaEmbeddedCanvas : public TRootEmbeddedCanvas{
public:
  AnitaEmbeddedCanvas(const char *name=0, const TGWindow *p=0, UInt_t w=10, UInt_t h=10, UInt_t options=kSunkenFrame|kDoubleBorder, Pixel_t back=GetDefaultFrameBackground())
    : TRootEmbeddedCanvas(name, p, w, h, options, back) {;}
protected:
  virtual Bool_t    HandleContainerKey (Event_t *ev){
    MagicDisplay* md = MagicDisplay::Instance();
    return md->HandleKey(ev);
  }
};



#endif //MAGICDISPLAY_H