TBBQManager.cxx

Go to the documentation of this file.

#include "TBBQManager.h"
#include "TBBQEventManager.h"
#include "vistpc.h"

// C++

#include <iostream>
#include <sstream>
#include <string>
#include <vector>

// ROOT

#include <TApplication.h>
#include <TClass.h>
#include <TROOT.h>
#include <TRootBrowser.h>
#include <TSystem.h>
#include <TString.h>

#include <TGButton.h>
#include <TGFileDialog.h>
#include <TGFrame.h>
#include <TGLabel.h>
#include <TGListBox.h>
#include <TGMenu.h>
#include <TGObject.h>
#include <TGTextEntry.h>

// Eve

#include <TEveBrowser.h>
#include <TEveEventManager.h>
#include <TEveScene.h>

// LCIO

#include "lcio.h"

#include "IMPL/LCEventImpl.h"
#include "IMPL/LCCollectionVec.h"
#include "Exceptions.h"

// GEAR

#include <gearimpl/Util.h>
#include <gearxml/GearXML.h>
#include <gear/GearMgr.h>
#include <gear/GEAR.h>
#include <gear/TPCParameters.h>

TBBQManager* gBBQ = NULL;

enum BBQMenu_enum
{
   kMenuOpenGEARFile,
   kMenuOpenLCIOFile,
   kMenuReloadGEARFile,
   kMenuClearGlobalScene,
   kMenuClearEventScene,
   kMenuTestGetNearestPadModule,
   kMenuTestGetNearestPadGlobal,
   kMenuTestGetLeftRightNeighbour
};

//------------------------------------------------------------------------------
// Constructors & Destructor
//------------------------------------------------------------------------------

TBBQManager::TBBQManager(
   UInt_t   w,
   UInt_t   h,
   Bool_t   map_window,
   Option_t *opt
) :
   TEveManager(w, h, map_window, opt),
   fGearMgr(0),
   fVisTPC(new VisTPC()),
   fHitsCollections(0),
   fTracksCollections(0),
   fPulsesCollections(0)
{
   gBBQ = this;

   TGLayoutHints* fillx = new TGLayoutHints(kLHintsExpandX);

   //---------------------------------------------------------------------------
   // Construct the dropdown menu
   // Ref: http://root.cern.ch/root/html526/src/TEveBrowser.cxx.html

   TGMenuBar         *menuBar   = GetBrowser()->GetMenuBar();
   TGHorizontalFrame *menuFrame = GetBrowser()->GetTopMenuFrame();
   TGPopupMenu       *bbqMenu   = new TGPopupMenu(gClient->GetRoot());

   bbqMenu->AddEntry("Open &GEAR file", kMenuOpenGEARFile);
   bbqMenu->AddEntry("Open &LCIO file", kMenuOpenLCIOFile);
   bbqMenu->AddSeparator();
   bbqMenu->AddEntry("&Reload GEAR file", kMenuReloadGEARFile);
   bbqMenu->AddSeparator();
   bbqMenu->AddEntry("Clear global scene", kMenuClearGlobalScene);
   bbqMenu->AddEntry("Clear event scene", kMenuClearEventScene);
   bbqMenu->AddSeparator();
   bbqMenu->AddEntry("Test getNearestPad() (first module)", kMenuTestGetNearestPadModule);
   bbqMenu->AddEntry("Test getNearestPad() (global)", kMenuTestGetNearestPadGlobal);
   bbqMenu->AddEntry("Test getLeftRightNeighbour()", kMenuTestGetLeftRightNeighbour);

   bbqMenu->Connect("Activated(Int_t)", "TBBQManager", this, "slotMenu(Int_t)");

   menuBar->AddPopup("BBQ", bbqMenu, new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0));
   menuFrame->MapSubwindows();
   menuFrame->Layout();

   //---------------------------------------------------------------------------
   // Create minimal GUI for event navigation.
   // Ref: http://root.cern.ch/root/html/tutorials/eve/alice_vsd.C.html

   AddEvent(new TBBQEventManager(fVisTPC));

   TEveBrowser* browser = gEve->GetBrowser();
   browser->StartEmbedding(TRootBrowser::kLeft);

   TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
   frmMain->SetWindowName("XX GUI");
   frmMain->SetCleanup(kDeepCleanup);
   
   TGGroupFrame      *group = NULL;
   TGHorizontalFrame *hf    = NULL;

   TBBQEventManager* eventManager = (TBBQEventManager*) GetCurrentEvent();

   //-----------------
   // Event navigation
   
   group = new TGGroupFrame(frmMain, "Event navigation");
   
   // Text fields indicating current run # and event #.
   
   hf = new TGHorizontalFrame(group);
   {
      TGLabel*     runLabel = new TGLabel(hf, "Run #");
      TGTextEntry* runEntry = new TGTextEntry(hf);

      hf->AddFrame(runLabel);
      hf->AddFrame(runEntry, new TGLayoutHints(kLHintsRight));
      fGUI["RunEntry"] = runEntry;

      runEntry->SetWidth(100);
      runEntry->Connect(
         "ReturnPressed()",
         "TBBQEventManager",
         eventManager,
         "handleRunEntry()"
      );

      eventManager->fRunNumberEntry = runEntry;
   }
   group->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 0));

   hf = new TGHorizontalFrame(group);
   {
      TGLabel*     eventLabel = new TGLabel(hf, "Event #");
      TGTextEntry* eventEntry = new TGTextEntry(hf);

      eventEntry->SetWidth(100);
      hf->AddFrame(eventLabel);
      hf->AddFrame(eventEntry, new TGLayoutHints(kLHintsRight));
      fGUI["EventEntry"] = eventEntry;

      eventEntry->Connect(
         "ReturnPressed()",
         "TBBQEventManager",
         eventManager,
         "handleEventEntry()"
      );

      eventManager->fEventNumberEntry = eventEntry;
   }
   group->AddFrame(hf, fillx);

   // Buttons to go backward and forward

   hf = new TGHorizontalFrame(group);
   {
      TString icondir(TString::Format("%s/icons/", gSystem->Getenv("ROOTSYS")) );
      TGPictureButton* b = 0;

      b = new TGPictureButton(hf, gClient->GetPicture(icondir + "GoBack.gif"));
      hf->AddFrame(b);
      fGUI["PrevEventButton"] = b;
      b->Connect(
         "Clicked()",
         "TBBQEventManager",
         eventManager,
         "PrevEvent()"
      );

      b = new TGPictureButton(hf, gClient->GetPicture(icondir + "ReloadPage.gif"));
      hf->AddFrame(b);
      fGUI["ReloadEventButton"] = b;
      b->Connect(
         "Clicked()",
         "TBBQEventManager",
         eventManager,
         "ReloadEvent()"
      );

      b = new TGPictureButton(hf, gClient->GetPicture(icondir + "GoForward.gif"));
      hf->AddFrame(b);
      fGUI["NextEventButton"] = b;
      b->Connect(
         "Clicked()",
         "TBBQEventManager",
         eventManager,
         "NextEvent()"
      );
   }
   group->AddFrame(hf, new TGLayoutHints(kLHintsCenterX, 0, 0, 5, 0));
   
   frmMain->AddFrame(group);

   //---------------------------------------------------------------------------
   // ListBoxes for the LCIO Collections

   group = new TGGroupFrame(frmMain, "Pulses");
   hf    = new TGHorizontalFrame(group);
   {
      fPulsesCollections = new TGListBox(hf);
      fPulsesCollections->Resize(200, 100);
      fPulsesCollections->SetMultipleSelections(kTRUE);
      hf->AddFrame(fPulsesCollections);
   }
   group->AddFrame(hf);
   frmMain->AddFrame(group, fillx);

   group = new TGGroupFrame(frmMain, "Hits");
   hf    = new TGHorizontalFrame(group);
   {
      fHitsCollections = new TGListBox(hf);
      fHitsCollections->Resize(200, 100);
      fHitsCollections->SetMultipleSelections(kTRUE);
      hf->AddFrame(fHitsCollections);
   }
   group->AddFrame(hf);
   frmMain->AddFrame(group, fillx);

   group = new TGGroupFrame(frmMain, "Tracks");
   hf    = new TGHorizontalFrame(group);
   {
      fTracksCollections = new TGListBox(hf);
      fTracksCollections->Resize(200, 250);
      fTracksCollections->SetMultipleSelections(kTRUE);
      hf->AddFrame(fTracksCollections);
   }
   group->AddFrame(hf);
   frmMain->AddFrame(group, fillx);


   //

   frmMain->MapSubwindows();
   frmMain->Resize();
   frmMain->MapWindow();

   browser->StopEmbedding("Event");
   //browser->SetTabTitle("Event Control", 0);

   //---------------------------------------------------------------------------
   // Tab for options

   browser->StartEmbedding(TRootBrowser::kLeft);

   frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
   frmMain->SetWindowName("XX GUI");
   frmMain->SetCleanup(kDeepCleanup);

   group = new TGGroupFrame(frmMain, "TPC properties");

   // Max drift length

   hf = new TGHorizontalFrame(group);
   {
      TGLabel*     driftLabel = new TGLabel(hf, "Max drift length");
      TGTextEntry* driftEntry = new TGTextEntry(hf);

      hf->AddFrame(driftLabel);
      hf->AddFrame(driftEntry, new TGLayoutHints(kLHintsRight));
      fGUI["TPC_MaxDriftLengthEntry"] = driftEntry;

      driftEntry->SetWidth(100);
      driftEntry->Connect(
         "TextChanged(const char*)",
         "TBBQManager",
         this,
         "handleMaxDriftLengthEntry(const char*)"
      );
   }
   group->AddFrame(hf, fillx);

   // Readout frequency

   hf = new TGHorizontalFrame(group);
   {
      TGLabel*     frequencyLabel = new TGLabel(hf, "Readout frequency");
      TGTextEntry* frequencyEntry = new TGTextEntry(hf);

      hf->AddFrame(frequencyLabel);
      hf->AddFrame(frequencyEntry, new TGLayoutHints(kLHintsRight));
      fGUI["TPC_ReadoutFrequencyEntry"] = frequencyEntry;

      frequencyEntry->SetWidth(100);
      frequencyEntry->Connect(
         "TextChanged(const char*)",
         "TBBQManager",
         this,
         "handleReadoutFrequencyEntry(const char*)"
      );
   }
   group->AddFrame(hf, fillx);

   // Drift velocity

   hf = new TGHorizontalFrame(group);
   {
      TGLabel*     driftVelocityLabel = new TGLabel(hf, "Drift velocity");
      TGTextEntry* driftVelocityEntry = new TGTextEntry(hf);

      hf->AddFrame(driftVelocityLabel);
      hf->AddFrame(driftVelocityEntry, new TGLayoutHints(kLHintsRight));
      fGUI["TPC_DriftVelocityEntry"] = driftVelocityEntry;

      driftVelocityEntry->SetWidth(100);
      driftVelocityEntry->Connect(
         "TextChanged(const char*)",
         "TBBQManager",
         this,
         "handleDriftVelocityEntry(const char*)"
      );
   }
   group->AddFrame(hf, fillx);

   frmMain->AddFrame(group, fillx);
   
   //--------------------
   // Module draw options
   
   TGCheckButton *checkbutton = NULL;
   
   group = new TGGroupFrame(frmMain, "Module visualisation");
   
   //checkbutton = new TGCheckButton(group, "Draw parallel borders");
   //checkbutton->Connect("Clicked()", "TBBQManager", this, "handleCheckbutton(=\"module.parallelBorders\")");
   //fGUI["module.parallelBorders"] = checkbutton;
   //group->AddFrame(checkbutton);
   
   checkbutton = new TGCheckButton(group, "Draw pads by default");
   checkbutton->Connect("Clicked()", "TBBQManager", this, "handleCheckbutton(=\"module.drawPadsByDefault\")");
   fGUI["module.drawPadsByDefault"] = checkbutton;
   group->AddFrame(checkbutton);

   checkbutton = new TGCheckButton(group, "Draw outline by default");
   checkbutton->SetOn();
   checkbutton->Connect("Clicked()", "TBBQManager", this, "handleCheckbutton(=\"module.drawOutlineByDefault\")");
   fGUI["module.drawOutlineByDefault"] = checkbutton;
   group->AddFrame(checkbutton);

   frmMain->AddFrame(group, fillx);

   //

   frmMain->MapSubwindows();
   frmMain->Resize();
   frmMain->MapWindow();

   browser->StopEmbedding("Options");


   // TODO

   // Takeover the Checked signal from the tree.

   //GetListTree()->Disconnect("Checked(TObject*, Bool_t)");
   //
   //GetListTree()->Connect(
   //   "Checked(TObject*, Bool_t)",
   //   "TBBQManager",
   //   this,
   //   "slotTreeItemChecked(TEveListTreeItem*, Bool_t)"
   //);

   //

   updateGUIState();
}

TBBQManager::~TBBQManager()
{
   // TODO

   //GetListTree()->Disconnect(
   //   "Checked(TObject*, Bool_t)",
   //   this,
   //   "slotTreeItemChecked(TEveListTreeItem*, Bool_t)"
   //);

   delete fVisTPC;
}

//------------------------------------------------------------------------------
// Methods (alphabetical order)
//------------------------------------------------------------------------------

void TBBQManager::clearEventCollections(){
   if (fHitsCollections)
      fHitsCollections->RemoveAll();

   if (fPulsesCollections)
      fPulsesCollections->RemoveAll();

   if (fTracksCollections)
      fTracksCollections->RemoveAll();
}

void TBBQManager::clearEventScene() {
   std::cout << "Clearing current event scene: ";

   gEve->GetCurrentEvent()->DestroyElements();
   this->Redraw3D();

   std::cout << "done." << std::endl;
}

void TBBQManager::clearGlobalScene() {
   std::cout << "Clearing current global scene: ";

   gEve->GetGlobalScene()->DestroyElements();
   this->Redraw3D();

   std::cout << "done." << std::endl;
}

TBBQManager* TBBQManager::Create(Bool_t map_window, Option_t* opt) {
   // If global TEveManager* gEve is not set initialize it.
   // Returns gEve.

   static const TEveException eh("TEveManager::Create ");

   if (gBBQ == 0)
   {
      // Make sure that the GUI system is initialized.
      if (gROOT->IsBatch())
      {
         throw eh + "ROOT is running in batch mode.";
      }
      TApplication::NeedGraphicsLibs();
      gApplication->InitializeGraphics();
      if (gROOT->IsBatch() || gClient == 0 || gClient->IsZombie())
      {
         throw eh + "window system not initialized.";
      }

      Int_t w = 1024;
      Int_t h =  768;

      TEveUtil::SetupEnvironment();
      TEveUtil::SetupGUI();
      gBBQ = new TBBQManager(w, h, map_window, opt);
   }

   return gBBQ;
}

std::string TBBQManager::dialogOpenFile(const char** fileTypes) {

   // Setup necessary stuff

   TGFileInfo selectedFile;

   static TString dir(".");

   selectedFile.fFileTypes         = fileTypes;
   selectedFile.fIniDir            = StrDup(dir);
   selectedFile.fMultipleSelection = kFALSE;

   // show File dialog

   new TGFileDialog(
      gClient->GetDefaultRoot(),
      this->GetMainWindow(),
      kFDOpen,
      &selectedFile
   );

   // Retrieve info

   std::string returnStr(gSystem->UnixPathName(selectedFile.fFilename));

   return returnStr;
}

void TBBQManager::dialogOpenGEARFile() {
   const char* fileTypes[] = {
      "GEAR file", "*.xml",
      "GEAR file", "*.gear",
      "All files", "*.*",
      0,           0
   };

   try {

      std::string selectedFile = dialogOpenFile(fileTypes);

      if (selectedFile.empty())
         return;

      importGEARFile(selectedFile);

   } catch (gear::Exception e) {

      std::cout << e.what() << std::endl;

   } catch (...) {
      return;
   }

}

void TBBQManager::dialogOpenLCIOFile() {
   const char* fileTypes[] = {
      "LCIO file", "*.slcio",
      "All files", "*.*",
      0,           0
   };

   try {

      std::string selectedFile = dialogOpenFile(fileTypes);

      if (selectedFile.empty())
         return;

      importLCIOFile(selectedFile);

   } catch (...) {
      return;
   }

}

void TBBQManager::displayEventCollections(const EVENT::LCEvent* event) {
   if (
      fHitsCollections->GetNumberOfEntries()
      + fPulsesCollections->GetNumberOfEntries()
      + fTracksCollections->GetNumberOfEntries()
   )
      return;

   const std::vector<std::string> * names = event->getCollectionNames();

   int i = 0;
   for (
      std::vector<std::string>::const_iterator it = names->begin();
      it != names->end();
      ++it
   ) {

      switch (fVisTPC->getCollectionType(event->getCollection(*it)->getTypeName())) {
         case VisTPC::kHIT:
            fHitsCollections->AddEntry(it->c_str(), i++);
            break;
         case VisTPC::kPULSE:
            fPulsesCollections->AddEntry(it->c_str(), i++);
            break;
         case VisTPC::kTRACK:
            fTracksCollections->AddEntry(it->c_str(), i++);
            break;
      }
   }

   fHitsCollections->Layout();
   fPulsesCollections->Layout();
   fTracksCollections->Layout();
}

void TBBQManager::handleCheckbutton(const char * button) {
   std::string option(button);
   
   std::map<std::string, TGObject*>::iterator it = fGUI.find(option);
   
   if (it == fGUI.end())
      return;
   
   fVisTPC->setOption(option, (dynamic_cast<TGCheckButton*>(fGUI[option]))->IsOn());
}

void TBBQManager::handleDriftVelocityEntry(const char* text) {
   std::stringstream sstr(text);

   if (sstr.str().empty())
      return;

   float driftVelocity;

   if (sstr >> driftVelocity)
      fVisTPC->setDriftVelocity(driftVelocity);
   else
      std::cout << "\"" << text << "\""
                << "is not a number." << std::endl;
}

void TBBQManager::handleMaxDriftLengthEntry(const char* text) {
   std::stringstream sstr(text);

   if (sstr.str().empty())
      return;

   float maxDriftLength;

   if (sstr >> maxDriftLength)
      fVisTPC->setMaxDriftLength(maxDriftLength);
   else
      std::cout << "\"" << text << "\""
                << "is not a number." << std::endl;
}

void TBBQManager::handleReadoutFrequencyEntry(const char* text) {
   std::stringstream sstr(text);

   if (sstr.str().empty())
      return;

   float readoutFrequency;

   if (sstr >> readoutFrequency)
      fVisTPC->setReadoutFrequency(readoutFrequency);
   else
      std::cout << "\"" << text << "\""
                << "is not a number." << std::endl;
}

void TBBQManager::importGEARFile(const std::string& filePath) {
   if (filePath.empty())
      return;

   std::cout << "importing GEAR: " << filePath << std::endl;

   fCurrentGEARFile = filePath;

   //

   if (fGearMgr) {
      this->clearGlobalScene();
      this->clearEventScene();

      delete fGearMgr;
      fGearMgr = NULL;
   }

   //

   gear::GearXML gearXML(filePath);

   fGearMgr = gearXML.createGearMgr();

   // Update the "TPC" tab & VisTPC with the correct info

   fVisTPC->updateGearMgr( fGearMgr );

   std::stringstream text;

   // 1. maxDriftLength
   text << fGearMgr->getTPCParameters().getMaxDriftLength();

   (dynamic_cast<TGTextEntry *> (fGUI["TPC_MaxDriftLengthEntry"]))
      ->SetText(text.str().c_str());

   //fVisTPC->setMaxDriftLength(fGearMgr->getTPCParameters().getMaxDriftLength());

   // 2. readoutFrequency
   text.str("");
   text << fVisTPC->getReadoutFrequency();
   (dynamic_cast<TGTextEntry *> (fGUI["TPC_ReadoutFrequencyEntry"]))
      ->SetText(text.str().c_str(), kFALSE);

   // 3. driftVelocity
   text.str("");
   text << fVisTPC->getDriftVelocity();
   (dynamic_cast<TGTextEntry *> (fGUI["TPC_DriftVelocityEntry"]))
      ->SetText(text.str().c_str(), kFALSE);

   //

   fVisTPC->drawTPC();
}

void TBBQManager::importLCIOFile(const std::string& filePath) {
   if (filePath.empty())
      return;

   std::cout << "importing LCIO: " << filePath << std::endl;

   TBBQEventManager* eventManager = (TBBQEventManager*) GetCurrentEvent();

   eventManager->readFile(filePath);
   eventManager->GotoEvent(eventManager->getCurrentEvent()->getEventNumber());
}

void TBBQManager::slotMenu(Int_t menuId) {
   const std::vector<gear::TPCModule *> * modules = 0;

   switch (menuId) {
      case kMenuOpenGEARFile:
         dialogOpenGEARFile();
         this->Redraw3D(kTRUE);
         break;

      case kMenuOpenLCIOFile:
         if (fGearMgr == NULL) {
            std::cout << " error -> first load GEAR." << std::endl;
            return;
         }

         dialogOpenLCIOFile();
         break;
      
      case kMenuReloadGEARFile:
         if (fGearMgr == NULL)
            return;
         
         importGEARFile(fCurrentGEARFile);
         this->Redraw3D();
         break;

      case kMenuClearGlobalScene:
         clearGlobalScene();
         break;

      case kMenuClearEventScene:
         clearEventScene();
         break;

      case kMenuTestGetNearestPadModule:
         modules = & fGearMgr->getTPCParameters().getModules();
         fVisTPC->testNearestPad((*modules)[0]->getModuleID());
         break;

      case kMenuTestGetNearestPadGlobal:
         fVisTPC->testNearestPadGlobal();
         break;

      case kMenuTestGetLeftRightNeighbour:
         modules = & fGearMgr->getTPCParameters().getModules();
         fVisTPC->testLeftRightNeighbour((*modules)[0]->getModuleID());
         break;

      default:
         break;
   }

   updateGUIState();
}

void TBBQManager::slotTreeItemChecked(TEveListTreeItem* item, Bool_t check) {
   std::cout << "slotTreeItemChecked: " << item->GetText() << (check ? " Checked!" : " not Checked!") << std::endl;

   if (strcmp(item->GetText(), "All hits") == 0) {
      std::cout << "item is All hits" << std::endl;

      TEveElementList* list = static_cast<TEveElementList*>(item->GetUserData());
      //TEveElementList* list = static_cast<TEveElementList*>(item->GetUserData());

      //list->EnableListElements(check, check);
      std::cout << "ElementTitle: " << list->GetElementName() << std::endl;
   }

   //for (
   //   TGListTreeItem* child = item->GetFirstChild();
   //   child != item->GetLastChild();
   //   child = item->GetNextSibling()
   //) {
   //   std::cout << "Child: " << child->GetText() << std::endl;
   //   child->CheckItem(check);
   //}

   //TEveElement* el = ((TEveElement*) item->GetUserData());
   //
   //if (el)
   //   el->EnableListElements(check, check);

   //if ( (obj->InheritsFrom("TGListItem")) )
   //   std::cout << "Inherits from TGListItem" << std::endl;

   //   return;
   //
   //std::cout << obj->ClassName() << " Checked!" << std::endl;
   //((TEveElement*) obj)->EnableListElements(check, check);
}
void TBBQManager::Terminate() {
   TEveManager::Terminate();

   gBBQ = 0;
}

void TBBQManager::updateGUIState() {
   TGPopupMenu* bbqMenu = GetBrowser()->GetMenuBar()->GetPopup("BBQ");

   // Disable everything

   bbqMenu->DisableEntry(kMenuOpenGEARFile);
   bbqMenu->DisableEntry(kMenuOpenLCIOFile);
   bbqMenu->DisableEntry(kMenuReloadGEARFile);
   bbqMenu->DisableEntry(kMenuClearGlobalScene);
   bbqMenu->DisableEntry(kMenuClearEventScene);
   bbqMenu->DisableEntry(kMenuTestGetNearestPadModule);
   bbqMenu->DisableEntry(kMenuTestGetNearestPadGlobal);
   bbqMenu->DisableEntry(kMenuTestGetLeftRightNeighbour);

   ((TGPictureButton*) fGUI["PrevEventButton"]  )->SetEnabled(kFALSE);
   ((TGPictureButton*) fGUI["ReloadEventButton"])->SetEnabled(kFALSE);
   ((TGPictureButton*) fGUI["NextEventButton"]  )->SetEnabled(kFALSE);
   ((TGTextEntry*)     fGUI["EventEntry"]       )->SetEnabled(kFALSE);
   ((TGTextEntry*)     fGUI["RunEntry"]         )->SetEnabled(kFALSE);

   ((TGTextEntry*)     fGUI["TPC_MaxDriftLengthEntry"]  )->SetEnabled(kFALSE);
   ((TGTextEntry*)     fGUI["TPC_DriftVelocityEntry"]   )->SetEnabled(kFALSE);
   ((TGTextEntry*)     fGUI["TPC_ReadoutFrequencyEntry"])->SetEnabled(kFALSE);

   // Enable things bit by bit

   bbqMenu->EnableEntry(kMenuOpenGEARFile);

   if (fGearMgr) {
      bbqMenu->EnableEntry(kMenuOpenLCIOFile);
      bbqMenu->EnableEntry(kMenuReloadGEARFile);
      bbqMenu->EnableEntry(kMenuClearGlobalScene);
      bbqMenu->EnableEntry(kMenuTestGetNearestPadModule);
      bbqMenu->EnableEntry(kMenuTestGetNearestPadGlobal);
      bbqMenu->EnableEntry(kMenuTestGetLeftRightNeighbour);

      ((TGTextEntry*) fGUI["TPC_MaxDriftLengthEntry"]  )->SetEnabled(kTRUE);
      ((TGTextEntry*) fGUI["TPC_DriftVelocityEntry"]   )->SetEnabled(kTRUE);
      ((TGTextEntry*) fGUI["TPC_ReadoutFrequencyEntry"])->SetEnabled(kTRUE);
   }

   if (gBBQ->GetCurrentEvent()->getCurrentEvent()) {
      bbqMenu->EnableEntry(kMenuClearEventScene);

      ((TGPictureButton*) fGUI["PrevEventButton"]  )->SetEnabled(kTRUE);
      ((TGPictureButton*) fGUI["ReloadEventButton"])->SetEnabled(kTRUE);
      ((TGPictureButton*) fGUI["NextEventButton"]  )->SetEnabled(kTRUE);
      ((TGTextEntry*)     fGUI["EventEntry"]       )->SetEnabled(kTRUE);
      ((TGTextEntry*)     fGUI["RunEntry"]         )->SetEnabled(kTRUE);
   }
}