PageDisplay.cxx

Go to the documentation of this file.

#include "PageDisplay.h"
#include "PageDisplayConfig.h"
#include "PageProxy.h"
#include "PageABC.h"
#include "RunSnarlEntry.h"
#include "TimeHist.h"
#include "DigitText.h"
#include "MCText.h"
#include "MCTree.h"
#include "MCVectors.h"
#include "PmtPixels.h"
#include "Mint.h"
#include "ZoomPad.h"
#include "RegistryGui.h"
#include "RegistryDialog.h"

#include <Midad/Gui/GuiMenu.h>
#include <Midad/Gui/GuiBox.h>
#include <Midad/Gui/GuiStatusBar.h>
#include <Midad/Gui/GuiTab.h>
#include <Midad/Gui/GuiFrame.h>
#include <Midad/Gui/GuiButton.h>
#include <Midad/Gui/GuiMainWindow.h>
#include <Midad/Gui/GuiTextView.h>
#include <Midad/Gui/GuiTextEntry.h>
#include <Midad/Gui/GuiTree.h>
#include <Midad/Gui/GuiSlider.h>
#include <Midad/Gui/GuiCanvas.h>
#include <Midad/Gui/GuiScrolled.h>

#include <JobControl/JobC.h>

#include <TCanvas.h>
#include <TGFileDialog.h>
#include <TROOT.h>
#include <TSystem.h>

#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>
#include <sigc++/retype_return.h>
using namespace SigC;

#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;

static void die_die_die(PageDisplay* pd)
{
    if (pd) delete pd;
    gROOT->ProcessLine(".q");   // whatever
}


ClassImp(PageDisplay)

PageDisplay::PageDisplay(TGWindow& parent, Mint* mint)
    : GuiBox(parent,kVerticalFrame,100,100)
    , fMint(mint)
    , fMenuBar(0)
    , fRSEntry(0)
    , fBBox(0)
    , fTabs(0)
    , fStatusBar(0)
    , fTimeSlider(0)
    , fTimeHist(0) // no delete
    , fPmtPixels(0)
    , fDigitText(0)
    , fMCText(0)
    , fMCTree(0)
    , fMCVectors(0)
{
}



PageDisplay::~PageDisplay()
{
    cerr << "PageDisplay::~PageDisplay()\n";
    int siz = fPageList.size();
    for (int ind = 0; ind < siz; ++ind)  
        delete(fPageList[ind]);
    siz = fSinglePageList.size();
    for (int ind = 0; ind < siz; ++ind)  
        delete(fSinglePageList[ind]);
}

void PageDisplay::BuildGUI(const PageDisplayConfig& cfg)
{

    // MENU
    this->SetupMenus();

    // RSE
    if (cfg.use_run_snarl_entry) {
        fRSEntry = manage(new RunSnarlEntry(*this));
        this->Add(*fRSEntry);
    }
    
    GuiBox* hbox = manage(new GuiBox(*this,kHorizontalFrame));
    this->Add(*hbox);

    // Button box
    fBBox = manage(new GuiBox(*hbox,kVerticalFrame));
    fBBox->SetLayoutHints(kLHintsExpandY);
    hbox->Add(*fBBox);
    this->SetupButtons();

    // Tabs
    fTabs = manage(new GuiTab(*hbox));
    hbox->Add(*fTabs);
    fTabs->selected.connect(slot(*this,&PageDisplay::UpdateTab));

    // Sliders
    this->SetupSliders();

    // status bar
    fStatusBar = manage(new GuiStatusBar(*this));
    this->Add(*fStatusBar);

}

static void add_to_page_menu(const char* name, GuiMenu* menu, PageDisplay* pd, bool tf)
{
    // This kludge is used to keep UserDisplay out of the menus.
    // UserDisplay is not a complete display and is intended to be
    // created and filled from a macro.
    if (string("UserCanvas") == name) return;

    menu->Add(name,retype_return<void>(bind(slot(*pd,&PageDisplay::AddPage),name,tf)));
}


void PageDisplay::SetupMenus()
{
    fMenuBar = manage(new GuiMenuBar(*this));
    this->Add(*fMenuBar);

    GuiMenu* file_menu = manage(new GuiMenu);
    fMenuBar->AddMenu(*file_menu,"File");
    file_menu->Add("Open...",slot(*this,&PageDisplay::OpenFile));
    file_menu->Add("Load Lib...",slot(*this,&PageDisplay::LoadLib));
    file_menu->Add("Print...",slot(*this,&PageDisplay::PrintDisplay));
    file_menu->Add("Close",close_window.slot());
    file_menu->Add("Quit",bind(slot(die_die_die),this));

    GuiMenu* pages_menu = manage(new GuiMenu);
    fMenuBar->AddMenu(*pages_menu,"Pages");
    
    GuiMenu* add_pages_menu = manage(new GuiMenu);
    pages_menu->Add("Add page",*add_pages_menu);
    GuiMenu* spawn_pages_menu = manage(new GuiMenu);
    pages_menu->Add("Spawn page",*spawn_pages_menu);

    vector<const char*> page_names = PageProxyBase::GetRegisteredNames();
    for (unsigned int ind = 0; ind < page_names.size(); ++ind) {
        add_to_page_menu(page_names[ind],add_pages_menu,this,true);
        add_to_page_menu(page_names[ind],spawn_pages_menu,this,false);
    }
    PageProxyBase::page_added.connect(bind(bind(bind(slot(add_to_page_menu),true),this),add_pages_menu));
    PageProxyBase::page_added.connect(bind(bind(bind(slot(add_to_page_menu),false),this),spawn_pages_menu));
    pages_menu->Add(0);

    GuiMenu* view_menu = manage(new GuiMenu);
    fMenuBar->AddMenu(*view_menu,"Views");
    view_menu->Add("3D Geometry",slot(*this,&PageDisplay::DrawGeometry));    
    view_menu->Add("Digit text",slot(*this,&PageDisplay::MakeDigitText));
    view_menu->Add("Time hist",slot(*this,&PageDisplay::MakeTimeHist));
    view_menu->Add("Pmt Pixels",slot(*this,&PageDisplay::MakePmtPixels));
    view_menu->Add("MC text",slot(*this,&PageDisplay::MakeMCText));
    view_menu->Add("MC tree",slot(*this,&PageDisplay::MakeMCTree));
    view_menu->Add("MC vectors",slot(*this,&PageDisplay::MakeMCVectors));

    GuiMenu* settings_menu = manage(new GuiMenu);
    fMenuBar->AddMenu(*settings_menu,"Settings");
    settings_menu->Add("Candidate Names",slot(*this,&PageDisplay::CandidateNames));

    GuiMenu* zoom_menu = manage(new GuiMenu);
    fMenuBar->AddMenu(*zoom_menu,"Zoom");
    zoom_menu->Add("Undo",slot(*this,&PageDisplay::Unzoom));
    zoom_menu->Add("Redo",slot(*this,&PageDisplay::Rezoom));
    zoom_menu->Add("Auto",slot(*this,&PageDisplay::AutoZoom));
    zoom_menu->Add("Full",slot(*this,&PageDisplay::FullZoom));
}

GuiMenuBar& PageDisplay::GetMenuBar()
{
    assert(fMenuBar);
    return *fMenuBar;
}
static void handle_free_run(PageDisplay* pd, GuiTextButton* but)
{
    TString label = but->GetString();
    if (label == "Free Running") {
        label = "Stop Running";
        but->SetText(label);
        pd->GetMint()->SetFreeRunning(true);
    }
    else {
        label = "Free Running";
        but->SetText(label);
        pd->GetMint()->SetFreeRunning(false);
    }
}
static void handle_pause_entry(PageDisplay* pd, GuiTextEntry* ent)
{
    Long_t ms = atoi(ent->GetText());
    pd->GetMint()->SetPause(ms);
}
void PageDisplay::SetupButtons()
{
    GuiTextButton* but;
    GuiTextEntry* ent;

    but = this->AddButton("Next -->");
    but->clicked.connect(slot_class(*fMint,&Mint::Next));

    but = this->AddButton("<-- Prev");
    but->clicked.connect(slot_class(*fMint,&Mint::Prev));

    but = this->AddButton("NextPass -->");
    but->clicked.connect(slot_class(*fMint,&Mint::NextPass));

    but = this->AddButton("Free Running");
    but->clicked.connect(bind(slot(handle_free_run),this,but));

    ent = this->AddEntry("0");
    ent->activated.connect(bind(slot(handle_pause_entry),this,ent));

}

void PageDisplay::SetupSliders()
{
    fTimeSlider = manage(new GuiSlider(*this,kHorizontalFrame));
    this->Add(*fTimeSlider);
    fTimeSlider->UseRange(fMint->GetTimeRange());
    fTimeSlider->UseExtrema(fMint->GetTimeExtrema());
}
GuiSlider& PageDisplay::GetTimeSlider()
{
    assert(fTimeSlider);
    return *fTimeSlider;
}

GuiTextButton* PageDisplay::AddButton(const char* text)
{
    GuiMainWindow* mw = fBBox->GetMainWindow();
    if (!mw) { 
        cerr << "PageDisplay::AddButton: can't get main window\n";
        return 0;
    }
    int width = mw->GetWidth();
    int height = mw->GetHeight();

    GuiTextButton* b = manage(new GuiTextButton(*fBBox,text));
    b->SetLayoutHints(kLHintsExpandX);
    fBBox->Add(*b);
    fButtonMap[text] = b;
    
    mw->ShowAll();
    mw->Resize(width,height);
    return b;
}
GuiTextButton* PageDisplay::GetButton(const char* text)
{
    ButtonMap_t::iterator mit = fButtonMap.find(text);
    if (mit == fButtonMap.end()) return 0;
    return mit->second;
}
GuiTextEntry* PageDisplay::AddEntry(const char* init_text)
{
    GuiMainWindow* mw = fBBox->GetMainWindow();
    if (!mw) { 
        cerr << "PageDisplay::AddButton: can't get main window\n";
        return 0;
    }
    int width = mw->GetWidth();
    int height = mw->GetHeight();

    GuiTextEntry* e = manage(new GuiTextEntry(*fBBox,init_text));
    e->SetLayoutHints(kLHintsExpandX);
    fBBox->Add(*e);
    
    mw->ShowAll();
    mw->Resize(width,height);
    return e;
}

TObject* PageDisplay::AddPage(const char* name, bool in_a_tab /*=true*/)
{
    PageProxyBase* ppb = dynamic_cast<PageProxyBase*>
        (NamedFactory::Instance("Page").GetProxy(name));
    if (!ppb) {
        cerr << "Can't get page named: \"" << name << "\"\n";
        return 0;
    }
    if (in_a_tab) {
        PageABC* page = ppb->Create();
        GuiFrame* frame = fTabs->Add(name);
        GuiBox* box = manage(new GuiBox(*frame->GetFrame(), kVerticalFrame));
        frame->Add(*box);

        TObject* obj = page->Init(fMint,this,*box);

        fPageList.push_back(page);
        GuiMainWindow* mw = fTabs->GetMainWindow();
        assert(mw);
        mw->ShowAll();
        return obj;
    }
    else {
        using namespace SigC;
        int width=this->GetWidth(), height=this->GetHeight();

        GuiMainWindow* gmw = new GuiMainWindow(width-1,height-1);
        gmw->SetWindowName("PageDisplay");
        
        PageDisplay* pd = new PageDisplay(*gmw,fMint);
        gmw->Add(*pd);
        pd->close_window.connect(slot(*gmw,&GuiMainWindow::SendCloseMessage));

        return pd->AddPage(name,true);
    }
}

TObject* PageDisplay::SpawnSinglePage(const char* name, int width, int height)
{
    PageProxyBase* ppb = dynamic_cast<PageProxyBase*>
        (NamedFactory::Instance("Page").GetProxy(name));
    if (!ppb) {
        cerr << "Can't get page named: \"" << name << "\"\n";
        return 0;
    }
    PageABC* page = ppb->Create();
    fSinglePageList.push_back(page);

    GuiMainWindow* gmw = new GuiMainWindow(width-1,height-1);
    gmw->SetWindowName(name);
    GuiBox* box = manage(new GuiBox(*gmw, kVerticalFrame));
    gmw->Add(*box);
    TObject* obj = page->Init(fMint,this,*box);
    gmw->ShowAll();
    return obj;
}


void PageDisplay::StatusBar(const char* msg)
{
//    cerr << "Status bar: \"" << msg << "\"\n";
    if (msg) fStatusBar->SetText(msg);
    else fStatusBar->SetText("");
}
void PageDisplay::ProcessEvents()
{
    fClient->HandleInput();
}
void PageDisplay::ClearDisplay()
{
    int siz = fPageList.size();
    for (int ind = 0; ind < siz; ++ind)  
        fPageList[ind]->Clear();
    siz = fSinglePageList.size();
    for (int ind = 0; ind < siz; ++ind)  
        fSinglePageList[ind]->Clear();
}
void PageDisplay::UpdateDisplay()
{
    if (! fMint->GetDetector()) return;

    if (fRSEntry) fRSEntry->Update(fMint);

    if(fTabs) this->UpdateTab(fTabs->GetCurrent());
    for (unsigned int ind = 0; ind < fSinglePageList.size(); ++ind) {
        fSinglePageList[ind]->Update();
    }
    
    if (fTimeHist) fTimeHist->Refresh();
    if (fPmtPixels) fPmtPixels->Refresh();
    if (fMCText) fMCText->Update(fMint);
    if (fMCTree) fMCTree->Update(fMint);
    if (fMCVectors) fMCVectors->Update(fMint);
}

void PageDisplay::UpdateTab(int tab_id)
{
    if (tab_id < 0 || tab_id >= (int)fPageList.size()) return;
    fPageList[tab_id]->Update();
}

void PageDisplay::Unzoom()
{
  if(fTabs) {
    int cur = fTabs->GetCurrent();
    if (cur<0) return;
    fPageList[cur]->Unzoom();
  }
  for (unsigned int ind = 0; ind < fSinglePageList.size(); ++ind) {
    fSinglePageList[ind]->Unzoom();
  }
}

void PageDisplay::Rezoom()
{
  if(fTabs) {
    int cur = fTabs->GetCurrent();
    if (cur<0) return;
    fPageList[cur]->Rezoom();
  }
  for (unsigned int ind = 0; ind < fSinglePageList.size(); ++ind) {
    fSinglePageList[ind]->Rezoom();
  }
}

void PageDisplay::FullZoom()
{
  if(fTabs) {
    int cur = fTabs->GetCurrent();
    if (cur<0) return;
    fPageList[cur]->FullZoom();
  }
  for (unsigned int ind = 0; ind < fSinglePageList.size(); ++ind) {
    fSinglePageList[ind]->FullZoom();
  }
}

void PageDisplay::AutoZoom()
{
  if(fTabs) {
    int cur = fTabs->GetCurrent();
    if (cur<0) return;
    fPageList[cur]->AutoZoom();
  }
  for (unsigned int ind = 0; ind < fSinglePageList.size(); ++ind) {
    fSinglePageList[ind]->AutoZoom();
  }
}

void PageDisplay::OpenFile() 
{
    GuiMainWindow* gmw = this->GetMainWindow();
    if (!gmw) {
        cerr << "PageDisplay::OpenFile no main window\n";
        return;
    }

    const char* filetypes[] = { "Data files", "*.root",
                                "All files",    "*",
                                0,              0 };
    static TString dir(".");
    TGFileInfo fi;
    fi.fFileTypes = filetypes;
    fi.fIniDir = StrDup(dir);
    new TGFileDialog(gClient->GetRoot(), gmw, kFDOpen, &fi);
    dir = fi.fIniDir;

    cerr << "dir: " << dir << " file: " << fi.fFilename << endl;

    if (!fi.fFilename) {
        cerr << "open file aborted\n";
        return;
    }

    fMint->GetJobC().Input.AddFile(fi.fFilename);

}
void PageDisplay::LoadLib() 
{
    GuiMainWindow* gmw = this->GetMainWindow();
    if (!gmw) {
        cerr << "PageDisplay::LoadLib no main window\n";
        return;
    }

    const char* filetypes[] = { "Library files", "*.so",
                                "All files",    "*",
                                0,              0 };

    // Use SRT_PUBLIC_CONTEXT/lib/SRT_SUBDIR as starting dir
    const char* spc = gSystem->Getenv("SRT_PUBLIC_CONTEXT");
    const char* ssd = gSystem->Getenv("SRT_SUBDIR");
    static TString dir = (spc&&ssd) ? Form("%s/lib/%s",spc,ssd) : ".";
        
    TGFileInfo fi;
    fi.fFileTypes = filetypes;
    fi.fIniDir = StrDup(dir);
    new TGFileDialog(gClient->GetRoot(), gmw, kFDOpen, &fi);
    dir = fi.fIniDir;

    cerr << "dir: " << dir << " file: " << fi.fFilename << endl;

    if (!fi.fFilename) {
        cerr << "open file aborted\n";
        return;
    }

    gSystem->Load(fi.fFilename);
}

void PageDisplay::PrintDisplay() 
{
  if(fTabs) this->PrintTab(fTabs->GetCurrent());
  for (unsigned int ind = 0; ind < fSinglePageList.size(); ++ind) {
    fSinglePageList[ind]->Print();
  }
}
void PageDisplay::PrintTab(int tab_id) const
{
    if (tab_id < 0 || tab_id >= (int)fPageList.size()) return;
    fPageList[tab_id]->Print();
}

DigitText* PageDisplay::GetDigitText()
{
    return fDigitText;
}

void PageDisplay::DrawGeometry()
{
    UgliGeomHandle ugh = fMint->GetUgliGeomHandle();
    ugh.Draw();
}


template<class TYPE> void killer(TYPE* obj) { delete obj; }

void PageDisplay::MakeDigitText()
{
    if (fDigitText) return;

    GuiMainWindow* gmw = new GuiMainWindow(300,300); // no delete
    GuiTextView* gtv = manage(new GuiTextView(*gmw,300,300)); // no delete
    gmw->Add(*gtv);

    fDigitText = new DigitText(gtv);
    gmw->close_window.connect(bind(slot(&killer<DigitText>),fDigitText));

    gmw->ShowAll();
    gmw->ConnectClose();
}
void PageDisplay::MakeMCText()
{
    if (fMCText) return;

    GuiMainWindow* gmw = new GuiMainWindow(300,300); // no delete
    GuiTextView* gtv = manage(new GuiTextView(*gmw,300,300)); // no delete
    gmw->Add(*gtv);

    fMCText = manage(new MCText(gtv));
    gmw->close_window.connect(bind(slot(&killer<MCText>),fMCText));

    gmw->ShowAll();
    gmw->ConnectClose();
    fMCText->Update(fMint);
}
void PageDisplay::MakeMCTree()
{
    if (fMCTree) return;

    GuiMainWindow* gmw = new GuiMainWindow(200,400); // no delete

    GuiScrolled* scrolled = manage(new GuiScrolled(*gmw));
    scrolled->SetLayoutHints(kLHintsExpandX | kLHintsExpandY);
    gmw->Add(*scrolled);

    GuiTree* gt = manage(new GuiTree(*scrolled->GetViewPort()));
    scrolled->Add(*gt);
    gt->SetCanvas(scrolled);

    fMCTree = manage(new MCTree(gt));
    gmw->close_window.connect(bind(slot(&killer<MCTree>),fMCTree));

    gmw->ShowAll();
    gmw->ConnectClose();
    fMCTree->Update(fMint);
}
void PageDisplay::MakeMCVectors()
{
    if (fMCVectors) return;

    GuiMainWindow* gmw = new GuiMainWindow(300,300); // no delete

    GuiCanvas* can = manage(new GuiCanvas(*gmw,300,300));
    can->SetLayoutHints(kLHintsExpandX|kLHintsExpandY);
    gmw->Add(*can);

    can->GetCanvas()->cd();
    fMCVectors = new MCVectors(0,0,1,1);

    gmw->close_window.connect(bind(slot(&killer<MCTree>),fMCTree));

    gmw->ShowAll();
    gmw->ConnectClose();
    fMCVectors->Update(fMint);
}

void PageDisplay::MakePmtPixels()
{
    if (fPmtPixels) return;
    const int hsiz = 200;
    GuiMainWindow* gmw = new GuiMainWindow(hsiz,hsiz); // no delete
    GuiCanvas* gc = manage(new GuiCanvas(*gmw,hsiz,hsiz));
    gmw->Add(*gc);
    fPmtPixels = new PmtPixels(0,0,1,1);
    gc->GetCanvas()->cd();
    fPmtPixels->Draw();
    fPmtPixels->SetMint(fMint);
    gc->GetCanvas()->cd();
    gmw->ShowAll();
    gmw->ConnectClose();
    fPmtPixels->Refresh();
}

void PageDisplay::MakeTimeHist()
{
    if (fTimeHist) return;

    const int hsiz = 200;
    GuiMainWindow* gmw = new GuiMainWindow(hsiz,hsiz); // no delete
    GuiCanvas* gc = manage(new GuiCanvas(*gmw,hsiz,hsiz));
    gmw->Add(*gc);

    TCanvas* canvas = gc->GetCanvas();
    canvas->cd();

    fTimeHist = new TimeHist();
    fTimeHist->SetMint(fMint);
    fTimeHist->Draw();

    gPad = 0;

    gmw->ShowAll();
    gmw->ConnectClose();
    fTimeHist->Refresh();
}

void apply_reg_gui(PageDisplay* pd, RegistryGui* rg)
{
    Registry& reg = pd->GetMint()->GetCandidateLookup();
    reg = rg->GetRegistry();
    pd->ClearDisplay();
    pd->UpdateDisplay();
}

void PageDisplay::CandidateNames()
{
    RegistryDialog rd;
    rd.fRegistryGui->SetRegistry(fMint->GetCandidateLookup());
    rd.fOkay->clicked.connect(bind(slot(apply_reg_gui),this,rd.fRegistryGui));
    rd.fApply->clicked.connect(bind(slot(apply_reg_gui),this,rd.fRegistryGui));
    rd.Spawn();
}

void PageDisplay::UpdateGui()
{
    GuiMainWindow* gmw = this->GetMainWindow();
    assert(gmw);
    gmw->Layout();
}

---