AliEveEventManager
authormtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Aug 2008 18:54:37 +0000 (18:54 +0000)
committermtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 20 Aug 2008 18:54:37 +0000 (18:54 +0000)
------------------

Add 3 new state-variables:
  Bool_t   fIsOpen;        // Are event-files opened.
  Bool_t   fHasEvent;      // Is an event available.
  Bool_t   fExternalCtrl;  // Are we under external event-loop.
and use them in all API functions to enforce consistency and avoid surprises.

Remove 'Bool_t fIsOnline' - it was replaced with fExternalCtrl.

AliEveEventManagerEditor
------------------------

Remove all GUI but the next-event button and event-info text-box. All
controls now available from AliEveEventManagerWindow.

AliEveEventManagerWindow
------------------------

Add controls for Refresh (Close/Open event) and auto-load.

Disable parts of event-navigation GUI that should not be used when under
external event-control or auto-load.

EVE/EveBase/AliEveEventManager.cxx
EVE/EveBase/AliEveEventManager.h
EVE/EveBase/AliEveEventManagerEditor.cxx
EVE/EveBase/AliEveEventManagerEditor.h

index 1c26e16..02880f3 100644 (file)
@@ -71,11 +71,9 @@ AliEveEventManager::AliEveEventManager() :
   fESDFile   (0), fESDTree (0), fESD (0),
   fESDfriend (0), fESDfriendExists(kFALSE),
   fRawReader (0),
-  fAutoLoad(kFALSE),
-  fAutoLoadTime(5.),
-  fAutoLoadTimer(0),
-  fIsOnline(kFALSE),
-  fExecutor(new AliEveMacroExecutor)
+  fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
+  fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
+  fExecutor  (new AliEveMacroExecutor)
 {
   // Default constructor.
 }
@@ -88,11 +86,9 @@ AliEveEventManager::AliEveEventManager(TString path, Int_t ev) :
   fESDFile   (0), fESDTree (0), fESD (0),
   fESDfriend (0), fESDfriendExists(kFALSE),
   fRawReader (0),
-  fAutoLoad(kFALSE),
-  fAutoLoadTime(5.),
-  fAutoLoadTimer(0),
-  fIsOnline(kFALSE),
-  fExecutor(new AliEveMacroExecutor)
+  fAutoLoad  (kFALSE), fAutoLoadTime (5.),     fAutoLoadTimer(0),
+  fIsOpen    (kFALSE), fHasEvent     (kFALSE), fExternalCtrl (kFALSE),
+  fExecutor  (new AliEveMacroExecutor)
 {
   // Constructor with event-directory URL and event-id.
 
@@ -104,6 +100,11 @@ AliEveEventManager::~AliEveEventManager()
 {
   // Destructor.
 
+  if (fIsOpen)
+  {
+    Close();
+  }
+
   if (fAutoLoadTimer) delete fAutoLoadTimer;
   // Somewhat unclear what to do here.
   // In principle should close all data sources and deregister from
@@ -156,6 +157,15 @@ void AliEveEventManager::Open()
 
   static const TEveException kEH("AliEveEventManager::Open ");
 
+  if (fExternalCtrl)
+  {
+    throw (kEH + "Event-loop is under external control.");
+  }
+  if (fIsOpen)
+  {
+    throw (kEH + "Event-files already opened.");
+  }
+
   gSystem->ExpandPathName(fPath);
   // The following magick is required for ESDriends to be loaded properly
   // from non-current directory.
@@ -328,18 +338,32 @@ void AliEveEventManager::Open()
 
   SetName(Form("Event %d", fEventId));
   SetTitle(fPath);
+  fIsOpen = kTRUE;
 }
 
 void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd)
 {
   // Set an event from an external source
   // The method is used in the online visualisation
+
+  static const TEveException kEH("AliEveEventManager::SetEvent ");
+
+  if (fIsOpen)
+  {
+    Warning(kEH, "Event-files were open. Closing and switching to external control.");
+    Close();
+  }
+
   fRunLoader = runLoader;
   fRawReader = rawReader;
-  fESD = esd;
-  fIsOnline = kTRUE;
+  fESD       = esd;
+
+  fEventId++;
+  fHasEvent     = kTRUE;
+  fExternalCtrl = kTRUE;
+
   SetTitle("Online event in memory");
-  SetName("Online Event");
+  SetName ("Online Event");
 
   ElementChanged();
   AfterNewEventLoaded();
@@ -348,6 +372,7 @@ void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawRead
 Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
 {
   // Returns maximum available event id.
+  // If under external control or event is not opened -1 is returned.
   // If raw-data is the only data-source this can not be known
   // and 10,000,000 is returned.
   // If neither data-source is initialised an exception is thrown.
@@ -356,6 +381,11 @@ Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
 
   static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
 
+  if (fExternalCtrl || fIsOpen == kFALSE)
+  {
+    return -1;
+  }
+
   if (fESDTree)
   {
     // Refresh crashes with root-5.21.1-alice.
@@ -396,6 +426,17 @@ void AliEveEventManager::GotoEvent(Int_t event)
 
   static const TEveException kEH("AliEveEventManager::GotoEvent ");
 
+  if (fExternalCtrl)
+  {
+    throw (kEH + "Event-loop is under external control.");
+  }
+  if (!fIsOpen)
+  {
+    throw (kEH + "Event-files not opened.");
+  }
+
+  fHasEvent = kFALSE;
+
   Int_t maxEvent = 0;
   if (fESDTree)
   {
@@ -489,7 +530,8 @@ void AliEveEventManager::GotoEvent(Int_t event)
     }
   }
 
-  fEventId = event;
+  fHasEvent = kTRUE;
+  fEventId  = event;
   SetName(Form("Event %d", fEventId));
   ElementChanged();
 
@@ -498,11 +540,10 @@ void AliEveEventManager::GotoEvent(Int_t event)
 
 void AliEveEventManager::NextEvent()
 {
-  // Loads next event
-  // either in automatic (online) or
-  // manual mode
+  // Loads next event.
+  // Does magick needed for online display when under external event control.
   
-  if (fIsOnline)
+  if (fExternalCtrl)
   {
     if (fAutoLoadTimer) fAutoLoadTimer->Stop();
 
@@ -522,12 +563,21 @@ void AliEveEventManager::NextEvent()
 
 void AliEveEventManager::PrevEvent()
 {
-  // Loads previous event
-  // only in case of manual mode
-  if (!fIsOnline) {
-    GotoEvent(fEventId - 1);
-    StartStopAutoLoadTimer();
+  // Loads previous event.
+
+  static const TEveException kEH("AliEveEventManager::PrevEvent ");
+
+  if (fExternalCtrl)
+  {
+    throw (kEH + "Event-loop is under external control.");
   }
+  if (!fIsOpen)
+  {
+    throw (kEH + "Event-files not opened.");
+  }
+
+  GotoEvent(fEventId - 1);
+  StartStopAutoLoadTimer();
 }
 
 void AliEveEventManager::Close()
@@ -535,6 +585,13 @@ void AliEveEventManager::Close()
   // Close the event data-files and delete ESD, ESDfriend, run-loader
   // and raw-reader.
 
+  static const TEveException kEH("AliEveEventManager::Close ");
+
+  if (!fIsOpen)
+  {
+    throw (kEH + "Event-files not opened.");
+  }
+
   if (fESDTree) {
     delete fESD;       fESD       = 0;
     delete fESDfriend; fESDfriend = 0;
@@ -550,39 +607,43 @@ void AliEveEventManager::Close()
   if (fRawReader) {
     delete fRawReader; fRawReader = 0;
   }
+
+  fEventId  = -1;
+  fIsOpen   = kFALSE;
+  fHasEvent = kFALSE;
 }
 
 
-/******************************************************************************/
+//------------------------------------------------------------------------------
 // Static convenience functions, mainly used from macros.
-/******************************************************************************/
+//------------------------------------------------------------------------------
 
 Bool_t AliEveEventManager::HasRunLoader()
 {
   // Check if AliRunLoader is initialized.
 
-  return gAliEveEvent && gAliEveEvent->fRunLoader;
+  return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRunLoader;
 }
 
 Bool_t AliEveEventManager::HasESD()
 {
   // Check if AliESDEvent is initialized.
 
-  return gAliEveEvent && gAliEveEvent->fESD;
+  return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESD;
 }
 
 Bool_t AliEveEventManager::HasESDfriend()
 {
   // Check if AliESDfriend is initialized.
 
-  return gAliEveEvent && gAliEveEvent->fESDfriend;
+  return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESDfriend;
 }
 
 Bool_t AliEveEventManager::HasRawReader()
 {
   // Check if raw-reader is initialized.
 
-  return gAliEveEvent && gAliEveEvent->fRawReader;
+  return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRawReader;
 }
 
 AliRunLoader* AliEveEventManager::AssertRunLoader()
@@ -593,7 +654,7 @@ AliRunLoader* AliEveEventManager::AssertRunLoader()
 
   static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
 
-  if (gAliEveEvent == 0)
+  if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
     throw (kEH + "ALICE event not ready.");
   if (gAliEveEvent->fRunLoader == 0)
     throw (kEH + "AliRunLoader not initialised.");
@@ -608,7 +669,7 @@ AliESDEvent* AliEveEventManager::AssertESD()
 
   static const TEveException kEH("AliEveEventManager::AssertESD ");
 
-  if (gAliEveEvent == 0)
+  if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
     throw (kEH + "ALICE event not ready.");
   if (gAliEveEvent->fESD == 0)
     throw (kEH + "AliESD not initialised.");
@@ -623,7 +684,7 @@ AliESDfriend* AliEveEventManager::AssertESDfriend()
 
   static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
 
-  if (gAliEveEvent == 0)
+  if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
     throw (kEH + "ALICE event not ready.");
   if (gAliEveEvent->fESDfriend == 0)
     throw (kEH + "AliESDfriend not initialised.");
@@ -636,7 +697,7 @@ AliRawReader* AliEveEventManager::AssertRawReader()
 
   static const TEveException kEH("AliEveEventManager::AssertRawReader ");
 
-  if (gAliEveEvent == 0)
+  if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
     throw (kEH + "ALICE event not ready.");
   if (gAliEveEvent->fRawReader == 0)
     throw (kEH + "RawReader not ready.");
@@ -646,10 +707,14 @@ AliRawReader* AliEveEventManager::AssertRawReader()
 
 AliMagF* AliEveEventManager::AssertMagField()
 {
-  // Make sure AliMagF is initialized and return it.
+  // Make sure AliMagF is initialized and returns it.
+  // Run-loader must be initialized to get the correct magnetic field!
   // Throws exception in case magnetic field is not available.
   // Static utility for macros.
 
+  // !!!! This should be fixed ... get field also in some other way,
+  // not only via run-loader.
+
   if (fgMagField == 0)
   {
     if (gAliEveEvent && gAliEveEvent->fRunLoader && gAliEveEvent->fRunLoader->GetAliRun())
@@ -694,9 +759,15 @@ TGeoManager* AliEveEventManager::AssertGeometry()
   return gGeoManager;
 }
 
+
+//------------------------------------------------------------------------------
+// Autoloading
+//------------------------------------------------------------------------------
+
 void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
 {
   // Set the automatic event loading mode
+
   fAutoLoad = autoLoad;
   StartStopAutoLoadTimer();
 }
@@ -704,6 +775,7 @@ void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
 void AliEveEventManager::SetAutoLoadTime(Double_t time)
 {
   // Set the auto-load time in seconds
+
   fAutoLoadTime = time;
   StartStopAutoLoadTimer();
 }
@@ -712,14 +784,15 @@ void AliEveEventManager::StartStopAutoLoadTimer()
 {
   // Create if needed and start
   // the automatic event loading timer
+
   if (fAutoLoad)
   {
     if (!fAutoLoadTimer)
     {
       fAutoLoadTimer = new TTimer;
-      fAutoLoadTimer->Connect("Timeout()","AliEveEventManager",this,"NextEvent()");
+      fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "NextEvent()");
     }
-    fAutoLoadTimer->Start((Long_t)fAutoLoadTime*1000,kTRUE);
+    fAutoLoadTimer->Start((Long_t)fAutoLoadTime*1000, kTRUE);
   }
   else
   {
@@ -727,6 +800,11 @@ void AliEveEventManager::StartStopAutoLoadTimer()
   }
 }
 
+
+//------------------------------------------------------------------------------
+// Post event-loading functions
+//------------------------------------------------------------------------------
+
 void AliEveEventManager::AfterNewEventLoaded()
 {
   // Execute registered macros and commands.
@@ -749,7 +827,10 @@ void AliEveEventManager::NewEventLoaded()
   Emit("NewEventLoaded()");
 }
 
-//==============================================================================
+
+//------------------------------------------------------------------------------
+// Event info dumpers
+//------------------------------------------------------------------------------
 
 TString AliEveEventManager::GetEventInfoHorizontal() const
 {
index dbfc5ce..1404e15 100644 (file)
@@ -86,7 +86,10 @@ public:
   Double_t      GetAutoLoadTime() const {return fAutoLoadTime;}
   void          SetAutoLoad(Bool_t autoLoad);
   void          SetAutoLoadTime(Double_t time);
-  Bool_t        GetIsOnline() const {return fIsOnline;}
+
+  Bool_t AreEventFilesOpened()    const { return fIsOpen;       }
+  Bool_t IsEventAvailable()       const { return fHasEvent;     }
+  Bool_t IsUnderExternalControl() const { return fExternalCtrl; }
 
   void          StartStopAutoLoadTimer();
 
@@ -112,7 +115,11 @@ protected:
   Bool_t        fAutoLoad;              // Automatic loading of events (online)
   Double_t      fAutoLoadTime;          // Auto-load time in seconds
   TTimer       *fAutoLoadTimer;         // Timer for automatic event loading
-  Bool_t        fIsOnline;              // Are we running online?
+
+  Bool_t        fIsOpen;                // Are event-files opened.
+  Bool_t        fHasEvent;              // Is an event available.
+  Bool_t        fExternalCtrl;          // Are we under external event-loop.
+
 
   AliEveMacroExecutor *fExecutor;       // Executor for std macros
 
index c53fe53..a7b9630 100644 (file)
@@ -26,47 +26,18 @@ ClassImp(AliEveEventManagerEditor)
 
 //______________________________________________________________________________
 AliEveEventManagerEditor::AliEveEventManagerEditor(const TGWindow *p, Int_t width, Int_t height,
-             UInt_t options, Pixel_t back) :
+                                                  UInt_t options, Pixel_t back) :
   TGedFrame(p, width, height, options | kVerticalFrame, back),
   fM(0),
-  fAutoLoad(0),
-  fAutoLoadTime(0),
   fNextEvent(0),
-  fPrevEvent(0),
-  fLastEvent(0),
-  fRefresh(0),
   fEventInfo(0)
 {
   // Constructor.
 
   MakeTitle("AliEveEventManager");
 
-  // Create widgets
-  {
-    fAutoLoadTime = new TEveGValuator(this, "Autoload time:", 110, 0);
-    fAutoLoadTime->SetShowSlider(kFALSE);
-    fAutoLoadTime->SetNELength(4);
-    fAutoLoadTime->Build();
-    fAutoLoadTime->SetLimits(0, 1000);
-    fAutoLoadTime->SetToolTip("Automatic event loading time in seconds");
-    fAutoLoadTime->Connect("ValueSet(Double_t)",
-                          "AliEveEventManagerEditor", this, "DoSetAutoLoadTime()");
-
-    fAutoLoad = new TGCheckButton(fAutoLoadTime,"Autoload");
-    fAutoLoad->SetToolTipText("Automatic event loading (online)");
-    fAutoLoadTime->AddFrame(fAutoLoad, new TGLayoutHints(kLHintsLeft, 12, 0, 2, 0));
-    fAutoLoad->Connect("Toggled(Bool_t)",
-                      "AliEveEventManagerEditor", this, "DoSetAutoLoad()");
-    AddFrame(fAutoLoadTime);
-  }
   {
     TGHorizontalFrame* f = new TGHorizontalFrame(this);
-    fPrevEvent = new TGTextButton(f, "Previous Event");
-    fPrevEvent->SetWidth(100);
-    fPrevEvent->ChangeOptions(fPrevEvent->GetOptions() | kFixedWidth);
-    f->AddFrame(fPrevEvent, new TGLayoutHints(kLHintsNormal, 0,4,0,0));
-    fPrevEvent->Connect("Clicked()",
-                       "AliEveEventManagerEditor", this, "DoPrevEvent()");
     fNextEvent = new TGTextButton(f, "Next Event");
     fNextEvent->SetWidth(100);
     fNextEvent->ChangeOptions(fNextEvent->GetOptions() | kFixedWidth);
@@ -76,23 +47,6 @@ AliEveEventManagerEditor::AliEveEventManagerEditor(const TGWindow *p, Int_t widt
     AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
   }
   {
-    TGHorizontalFrame* f = new TGHorizontalFrame(this);
-    fLastEvent = new TGTextButton(f, "Last Event");
-    fLastEvent->SetWidth(100);
-    fLastEvent->ChangeOptions(fLastEvent->GetOptions() | kFixedWidth);
-    f->AddFrame(fLastEvent, new TGLayoutHints(kLHintsNormal, 0,4,0,0));
-    fLastEvent->Connect("Clicked()",
-                       "AliEveEventManagerEditor", this, "DoLastEvent()");
-    fRefresh = new TGTextButton(f, "Refresh");
-    fRefresh->SetWidth(100);
-    fRefresh->ChangeOptions(fRefresh->GetOptions() | kFixedWidth);
-    f->AddFrame(fRefresh, new TGLayoutHints(kLHintsNormal, 4,0,0,0));
-    fRefresh->Connect("Clicked()",
-                       "AliEveEventManagerEditor", this, "DoRefresh()");
-    AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
-  }
-
-  {
     TGVerticalFrame* f = new TGVerticalFrame(this);
 
     TGLabel *eventInfoLabel = new TGLabel(f, "Event Information:");
@@ -107,80 +61,30 @@ AliEveEventManagerEditor::AliEveEventManagerEditor(const TGWindow *p, Int_t widt
 
 /******************************************************************************/
 
+//______________________________________________________________________________
 void AliEveEventManagerEditor::SetModel(TObject* obj)
 {
   // Set model object.
 
   fM = dynamic_cast<AliEveEventManager*>(obj);
 
-  // Set values of widgets
-  fAutoLoadTime->SetValue(fM->GetAutoLoadTime());
-  fAutoLoadTime->SetEnabled(fM->GetAutoLoad());
-  fAutoLoad->SetState(fM->GetAutoLoad() ? kButtonDown : kButtonUp);
-
-  fPrevEvent->SetEnabled(!fM->GetIsOnline()); 
-
   fEventInfo->LoadBuffer(fM->GetEventInfoVertical());
 }
 
 /******************************************************************************/
 
-// Implements callback/slot methods
-
-//______________________________________________________________________________
-void AliEveEventManagerEditor::DoSetAutoLoad()
-{
-  // Set the auto-load flag
-  //
-  fM->SetAutoLoad(fAutoLoad->IsOn());
-  Update();
-}
-
-//______________________________________________________________________________
-void AliEveEventManagerEditor::DoSetAutoLoadTime()
-{
-  // Set the auto-load time in seconds
-  //
-  fM->SetAutoLoadTime(fAutoLoadTime->GetValue());
-  fM->SetAutoLoad(fAutoLoad->IsOn());
-  Update();
-}
-
-//______________________________________________________________________________
-void AliEveEventManagerEditor::DoPrevEvent()
-{
-  // Load previous event
-  fM->PrevEvent();
-}
-
 //______________________________________________________________________________
 void AliEveEventManagerEditor::DoNextEvent()
 {
   // Load next event
-  fM->NextEvent();
-}
-
-//______________________________________________________________________________
-void AliEveEventManagerEditor::DoLastEvent()
-{
-  // Load last event
-  fM->GotoEvent(-1);
-}
 
-//______________________________________________________________________________
-void AliEveEventManagerEditor::DoRefresh()
-{
-  // Refresh / reopen data-files
-  Int_t ev = fM->GetEventId();
-  fM->Close();
-  fM->Open();
-  fM->GotoEvent(ev);
+  fM->NextEvent();
 }
 
 
-/******************************************************************************/
+//==============================================================================
 // AliEveEventManagerWindow
-/******************************************************************************/
+//==============================================================================
 
 //______________________________________________________________________________
 //
@@ -191,65 +95,70 @@ ClassImp(AliEveEventManagerWindow)
 
 AliEveEventManagerWindow::AliEveEventManagerWindow() :
   TGMainFrame(gClient->GetRoot(), 400, 100, kVerticalFrame),
-  fFirstEvent(0),
-  fPrevEvent(0),
-  fNextEvent(0),
-  fLastEvent(0),
-  fEventId  (0),
-  fInfoLabel(0),
-  fEventInfo(0)
+  fFirstEvent   (0),
+  fPrevEvent    (0),
+  fNextEvent    (0),
+  fLastEvent    (0),
+  fRefresh      (0),
+  fEventId      (0),
+  fInfoLabel    (0),
+  fAutoLoad     (0),
+  fAutoLoadTime (0),
+  fEventInfo    (0)
 {
   // Constructor.
 
+  TString cls("AliEveEventManagerWindow");
+  TGTextButton *b = 0;
   {
     Int_t width = 50;
 
     TGHorizontalFrame* f = new TGHorizontalFrame(this);
-    fFirstEvent = new TGTextButton(f, "First");
-    fFirstEvent->SetWidth(width);
-    fFirstEvent->ChangeOptions(fFirstEvent->GetOptions() | kFixedWidth);
-    f->AddFrame(fFirstEvent, new TGLayoutHints(kLHintsNormal, 2,2,0,0));
-    fFirstEvent->Connect("Clicked()",
-                         "AliEveEventManagerWindow", this, "DoFirstEvent()");
-    fPrevEvent = new TGTextButton(f, "Prev");
-    fPrevEvent->SetWidth(width);
-    fPrevEvent->ChangeOptions(fPrevEvent->GetOptions() | kFixedWidth);
-    f->AddFrame(fPrevEvent, new TGLayoutHints(kLHintsNormal, 2,2,0,0));
-    fPrevEvent->Connect("Clicked()",
-                       "AliEveEventManagerWindow", this, "DoPrevEvent()");
+    AddFrame(f, new TGLayoutHints(kLHintsExpandX, 0,0,2,2));
+
+    fFirstEvent = b = MkTxtButton(f, "First", width);
+    b->Connect("Clicked()", cls, this, "DoFirstEvent()");
+    fPrevEvent = b = MkTxtButton(f, "Prev", width);
+    b->Connect("Clicked()", cls, this, "DoPrevEvent()");
 
     fEventId = new TGNumberEntry(f, 0, 5, -1,TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative,
                                  TGNumberFormat::kNELLimitMinMax, 0, 10000);
     f->AddFrame(fEventId, new TGLayoutHints(kLHintsNormal, 10, 5, 0, 0));
-    fEventId->Connect("ValueSet(Long_t)",
-                      "AliEveEventManagerWindow", this, "DoSetEvent()");
+    fEventId->Connect("ValueSet(Long_t)", cls, this, "DoSetEvent()");
     fInfoLabel = new TGLabel(f);
     f->AddFrame(fInfoLabel, new TGLayoutHints(kLHintsNormal, 5, 10, 4, 0));
 
-    fNextEvent = new TGTextButton(f, "Next");
-    fNextEvent->SetWidth(width);
-    fNextEvent->ChangeOptions(fNextEvent->GetOptions() | kFixedWidth);
-    f->AddFrame(fNextEvent, new TGLayoutHints(kLHintsNormal, 2,2,0,0));
-    fNextEvent->Connect("Clicked()",
-                       "AliEveEventManagerWindow", this, "DoNextEvent()");
-    fLastEvent = new TGTextButton(f, "Last");
-    fLastEvent->SetWidth(width);
-    fLastEvent->ChangeOptions(fLastEvent->GetOptions() | kFixedWidth);
-    f->AddFrame(fLastEvent, new TGLayoutHints(kLHintsNormal, 2,2,0,0));
-    fLastEvent->Connect("Clicked()",
-                       "AliEveEventManagerWindow", this, "DoLastEvent()");
-    AddFrame(f, new TGLayoutHints(kLHintsExpandX, 0,0,2,2));
-  }
+    fNextEvent = b = MkTxtButton(f, "Next", width);
+    b->Connect("Clicked()", cls, this, "DoNextEvent()");
+    fLastEvent = b = MkTxtButton(f, "Last", width);
+    b->Connect("Clicked()", cls, this, "DoLastEvent()");
 
-  {
-    TGHorizontalFrame* f = new TGHorizontalFrame(this);
-    fEventInfo = new TGTextView(f, 800, 600);
-    f->AddFrame(fEventInfo, new TGLayoutHints(kLHintsNormal | kLHintsExpandX | kLHintsExpandY));
-    AddFrame(f, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0,0,2,2));
+    MkLabel(f, "||", 0, 8, 8);
+
+    fRefresh = b = MkTxtButton(f, "Refresh", width + 8);
+    b->Connect("Clicked()",cls, this, "DoRefresh()");
+
+    MkLabel(f, "||", 0, 8, 8);
+
+    fAutoLoad = new TGCheckButton(f, "Autoload");
+    f->AddFrame(fAutoLoad, new TGLayoutHints(kLHintsLeft, 0, 4, 3, 0));
+    fAutoLoad->SetToolTipText("Automatic event loading.");
+    fAutoLoad->Connect("Toggled(Bool_t)", cls, this, "DoSetAutoLoad()");
+
+    fAutoLoadTime = new TEveGValuator(f, "Time: ", 110, 0);
+    f->AddFrame(fAutoLoadTime);    
+    fAutoLoadTime->SetShowSlider(kFALSE);
+    fAutoLoadTime->SetNELength(4);
+    fAutoLoadTime->Build();
+    fAutoLoadTime->SetLimits(0, 1000);
+    fAutoLoadTime->SetToolTip("Automatic event loading time in seconds.");
+    fAutoLoadTime->Connect("ValueSet(Double_t)", cls, this, "DoSetAutoLoadTime()");
   }
 
-  gAliEveEvent->Connect("NewEventLoaded()",
-                        "AliEveEventManagerWindow", this, "Update()");
+  fEventInfo = new TGTextView(this, 400, 600);
+  AddFrame(fEventInfo, new TGLayoutHints(kLHintsNormal | kLHintsExpandX | kLHintsExpandY));
+
+  gAliEveEvent->Connect("NewEventLoaded()", cls, this, "Update()");
 
   SetCleanup(kDeepCleanup);
   Layout();
@@ -301,14 +210,97 @@ void AliEveEventManagerWindow::DoSetEvent()
 }
 
 //______________________________________________________________________________
+void AliEveEventManagerWindow::DoRefresh()
+{
+  // Refresh event status.
+
+  Int_t ev = gAliEveEvent->GetEventId();
+  gAliEveEvent->Close();
+  gAliEveEvent->Open();
+  gAliEveEvent->GotoEvent(ev);
+}
+
+//______________________________________________________________________________
+void AliEveEventManagerWindow::DoSetAutoLoad()
+{
+  // Set the auto-load flag
+
+  gAliEveEvent->SetAutoLoad(fAutoLoad->IsOn());
+  Update();
+}
+
+//______________________________________________________________________________
+void AliEveEventManagerWindow::DoSetAutoLoadTime()
+{
+  // Set the auto-load time in seconds
+
+  gAliEveEvent->SetAutoLoadTime(fAutoLoadTime->GetValue());
+  gAliEveEvent->SetAutoLoad(fAutoLoad->IsOn());
+  Update();
+}
+
+//______________________________________________________________________________
 void AliEveEventManagerWindow::Update()
 {
   // Update current event, number of available events.
 
+  Bool_t autoLoad = gAliEveEvent->GetAutoLoad();
+  Bool_t extCtrl  = gAliEveEvent->IsUnderExternalControl();
+  Bool_t evNavOn  = !autoLoad && !extCtrl;
+
+  fFirstEvent->SetEnabled(evNavOn);
+  fPrevEvent ->SetEnabled(evNavOn);
+  fLastEvent ->SetEnabled(evNavOn);
+  fNextEvent ->SetEnabled(!autoLoad);
+  fRefresh   ->SetEnabled(evNavOn);
+
   fEventId->SetNumber(gAliEveEvent->GetEventId());
+  fEventId->SetState(evNavOn);
   fInfoLabel->SetText(Form("/ %d", gAliEveEvent->GetMaxEventId()));
 
+  // fAutoLoadTime->SetEnabled(gAliEveEvent->GetAutoLoad());
+  fAutoLoad->SetState(gAliEveEvent->GetAutoLoad() ? kButtonDown : kButtonUp);
+  fAutoLoadTime->SetValue(gAliEveEvent->GetAutoLoadTime());
+
   fEventInfo->LoadBuffer(gAliEveEvent->GetEventInfoHorizontal());
 
   Layout();
 }
+
+//------------------------------------------------------------------------------
+// Protected methods
+//------------------------------------------------------------------------------
+
+//______________________________________________________________________________
+TGTextButton* AliEveEventManagerWindow::MkTxtButton(TGCompositeFrame* p,
+                                                   const char* txt, Int_t width,
+                                                   Int_t lo, Int_t ro, Int_t to, Int_t bo)
+{
+  // Create a standard button.
+  // If width is not zero, the fixed-width flag is set.
+
+  TGTextButton* b = new TGTextButton(p, txt);
+  if (width > 0) {
+    b->SetWidth(width);
+    b->ChangeOptions(b->GetOptions() | kFixedWidth);
+  }
+  p->AddFrame(b, new TGLayoutHints(kLHintsNormal, lo,ro,to,bo));
+  return b;
+}
+
+//______________________________________________________________________________
+TGLabel* AliEveEventManagerWindow::MkLabel(TGCompositeFrame* p,
+                                          const char* txt, Int_t width,
+                                          Int_t lo, Int_t ro, Int_t to, Int_t bo)
+{
+  // Create a standard button.
+  // If width is not zero, the fixed-width flag is set.
+
+  TGLabel* l = new TGLabel(p, txt);
+  if (width > 0) {
+    l->SetWidth(width);
+    l->ChangeOptions(l->GetOptions() | kFixedWidth);
+  }
+  p->AddFrame(l, new TGLayoutHints(kLHintsNormal, lo,ro,to,bo));
+  return l;
+}
index 7cdbd5f..748eee1 100644 (file)
 
 class AliEveEventManager;
 class TEveGValuator;
+class TGButton;
 class TGCheckButton;
+class TGTextButton;
 class TGTextView;
 class TGNumberEntry;
 class TGLabel;
 
+//==============================================================================
+// AliEveEventManagerEditor
+//==============================================================================
+
 //______________________________________________________________________________
 // Short description of AliEveEventManagerEditor
 //
@@ -32,27 +38,13 @@ public:
 
    virtual void SetModel(TObject* obj);
 
-   // Declare callback/slot methods
-   void DoSetAutoLoad();
-   void DoSetAutoLoadTime();
-   void DoPrevEvent();
    void DoNextEvent();
-   void DoLastEvent();
-   void DoRefresh();
 
 protected:
-   AliEveEventManager            *fM; // Model object.
-
-   // Declare widgets
-   TGCheckButton    *fAutoLoad;  // Check-box for automatic loading of events
-   TEveGValuator    *fAutoLoadTime; // Time for automatic loading of events
-
-   TGTextButton     *fNextEvent; // Load next event
-   TGTextButton     *fPrevEvent; // Load previous event
-   TGTextButton     *fLastEvent; // Load last event
-   TGTextButton     *fRefresh;   // Refresh opened data-files (reopen)
+   AliEveEventManager  *fM;         // Model object.
 
-   TGTextView       *fEventInfo; // Text box with event info
+   TGTextButton        *fNextEvent; // Load next event
+   TGTextView          *fEventInfo; // Text box with event info
 
 private:
    AliEveEventManagerEditor(const AliEveEventManagerEditor&);            // Not implemented
@@ -62,37 +54,58 @@ private:
 };
 
 
+//==============================================================================
+// AliEveEventManagerWindow
+//==============================================================================
+
+//______________________________________________________________________________
+// Short description of AliEveEventManagerWindow
+//
+
 class AliEveEventManagerWindow : public TGMainFrame
 {
 public:
-   AliEveEventManagerWindow();
-   virtual ~AliEveEventManagerWindow();
+  AliEveEventManagerWindow();
+  virtual ~AliEveEventManagerWindow();
 
-   void DoFirstEvent();
-   void DoPrevEvent();
-   void DoNextEvent();
-   void DoLastEvent();
+  void DoFirstEvent();
+  void DoPrevEvent();
+  void DoNextEvent();
+  void DoLastEvent();
+
+  void DoSetEvent();
 
-   void DoSetEvent();
+  void DoRefresh();
+  void DoSetAutoLoad();
+  void DoSetAutoLoadTime();
 
-   void Update();
+  void Update();
 
 protected:
-   TGTextButton         *fFirstEvent;
-   TGTextButton         *fPrevEvent;
-   TGTextButton         *fNextEvent;
-   TGTextButton         *fLastEvent;
+  TGTextButton         *fFirstEvent;   // Go to first event
+  TGTextButton         *fPrevEvent;    // Go to prev event
+  TGTextButton         *fNextEvent;    // Go to next event
+  TGTextButton         *fLastEvent;    // Go to last event
+  TGTextButton         *fRefresh;      // Refresh event-file state
+
+  TGNumberEntry        *fEventId;      // Display/edit current event id
+  TGLabel              *fInfoLabel;    // Display last available event id
+
+  TGCheckButton        *fAutoLoad;     // Check-box for automatic loading of events
+  TEveGValuator        *fAutoLoadTime; // Time for automatic loading of events
 
-   TGNumberEntry        *fEventId;
-   TGLabel              *fInfoLabel;
+  TGTextView           *fEventInfo;    // Text box with event info
 
-   TGTextView           *fEventInfo; // Text box with event info
+  TGTextButton* MkTxtButton(TGCompositeFrame* p, const char* txt, Int_t width=0,
+                           Int_t lo=0, Int_t ro=0, Int_t to=0, Int_t bo=0);
+  TGLabel* MkLabel(TGCompositeFrame* p, const char* txt, Int_t width,
+                  Int_t lo=0, Int_t ro=0, Int_t to=2, Int_t bo=0);
 
 private:
-   AliEveEventManagerWindow(const AliEveEventManagerWindow&);            // Not implemented
-   AliEveEventManagerWindow& operator=(const AliEveEventManagerWindow&); // Not implemented
+  AliEveEventManagerWindow(const AliEveEventManagerWindow&);            // Not implemented
+  AliEveEventManagerWindow& operator=(const AliEveEventManagerWindow&); // Not implemented
 
-   ClassDef(AliEveEventManagerWindow, 0); // GUI window for AliEveEventManager.
+  ClassDef(AliEveEventManagerWindow, 0); // GUI window for AliEveEventManager.
 };
 
 #endif