CheezyPage.cxx

Go to the documentation of this file.

#include "CheezyPage.h"

#include <Midad/Base/Mint.h>
#include <Midad/Base/Jint.h>
#include <Midad/Base/PageProxy.h>
#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/RegistryGui.h>

#include <Midad/Gui/GuiBox.h>
#include <Midad/Gui/GuiMenu.h>
#include <Midad/Gui/GuiButton.h>
#include <Midad/Gui/GuiMainWindow.h>

#include <DataUtil/GetCandidate.h>
#include <DataUtil/CDL2STL.h>
#include <RerootExodus/CheezyDisplay.h>
#include <MinosObjectMap/MomNavigator.h>
#include <Plex/PlexStripEndId.h>
#include <CandData/CandRecord.h>
#include <CandDigit/CandDigitHandle.h>
#include <CandDigit/CandDigitListHandle.h>
#include <Record/RecMinos.h>
#include <Record/RecMinosHdr.h>

#include <TCanvas.h>


#include <MessageService/MsgService.h>
CVSID("$Id: CheezyPage.cxx,v 1.5 2004/08/26 22:01:32 avva Exp $");


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

#include <cassert>

//
// This line registers this page with Midad at library link time.  The
// name you give will be what is used to spawn or add the page from .C
// macro or menu.  The actual name of the variable doesn't matter, it
// is never used.
static PageProxy<CheezyPage> gsCheezyPageProxy("Cheezy");

CheezyPage::CheezyPage()
    : fDisplay(0)
    , fMint(0)
    , fListPlex("canddigitlist")
    , fListTruth("candmcdigitlist")
    , fDrawEmpty(false)
{
    this->InitConfig();
}
CheezyPage::~CheezyPage()
{
    if (fDisplay) delete fDisplay; fDisplay=0;
}


TObject* CheezyPage::Init(Mint* mint, PageDisplay* pd, GuiBox& box)
{
    // Must call parent to build blank canvas
    this->CanvasPage::Init(mint,pd,box);

    // Save for future use below.
    fMint = mint;

    // Now can get the canvas
    TCanvas& canvas = this->GetCanvas();
    
    // Create the object that actually displays stuff.
    fDisplay = new CheezyDisplay("CheezyPage","CheezyPage display", &canvas);

    // Allow configurations through Midad menus.
    this->BuildMenus(pd);

    // Whatever we return gets returned by the caller of
    // PageDisplay::AddPage() or SpawnSinglePage().
    // We don't need to comunicate with anyone so just return 0.
    return 0;
}

void CheezyPage::Clear()
{
    fDisplay->ClearLists();
}

void CheezyPage::Update()
{
    TCanvas& canvas = this->GetCanvas();
    canvas.cd();

    const MomNavigator* mom = fMint->GetJint().GetMom();

    // The below is ripped from RerootExodus/CheezyDisplayModule::Ana().

    // Get either RawRecord or CandRecord from Mom
    RecMinos *rec = dynamic_cast<RecMinos *>(mom->GetFragment("RecMinos"));
    if ( ! rec ) {
        MSG("Cheezy", Msg::kWarning) << "CheezyPage: No RecMinos\n";
        return;
    }

    this->ApplyConfig();

    VldContext vldc = rec->GetHeader()->GetVldContext();
    fDisplay->SetVldContext(vldc);

    // This stanza tries to find the MC and data digitlists and if
    // successful, goes through and fills the CheezyDisplay with the
    // digits.

    // Draw TRUTH first so other digits won't be obscured
    // Find MC version of CandDigitList fragment in MOM.

    int ndigits = 0;
    const char* names[2] = {
        fListTruth.c_str(),
        fListPlex.c_str(),
    };
    bool is_mc[2] = { true, false }; // Is MC, Isn't MC
    for (int n=0; n<2; ++n) {
        const CandDigitListHandle *cdlh =
            DataUtil::GetCandidate<CandDigitListHandle>
            (mom,"CandDigitListHandle",names[n]);
        if (!cdlh) {
            MSG("Cheezy", Msg::kWarning)
                << "CheezyPage: No CandDigitListHandle named "
                << names[n]
                << endl;
            continue;
        }

        vector<const CandDigitHandle*> dv = 
            DataUtil::CDL2STLvector<const CandDigitHandle>(*cdlh);
        int siz = dv.size();
        ndigits += siz;
        for (int ind = 0; ind < siz; ++ind) {
            // Register each digit with CheezyDisplay
            PlexSEIdAltL altlist = dv[ind]->GetPlexSEIdAltL();
            fDisplay->AddSEIdAltL(altlist,is_mc[n]);
        }
    }  


    // Now actually draw these things
    if (ndigits || fDrawEmpty) fDisplay->Draw();

    return;
}


void CheezyPage::BuildMenus(PageDisplay* pd)
{
    // There are two ways to add menus:
    // 1) just add a top level one for this CLASS of page
    // 2) add one for each INSTANCE in the "Pages" menu
    // we will do the latter.

    // Get the menu:
    GuiMenuBar& mb = pd->GetMenuBar();
    GuiMenu* pm = mb.GetMenu("Pages");
    assert(pm);                 // this should always exist.

    // manage() tells the system to do memory management
    GuiMenu* mymenu = manage(new GuiMenu);
    pm->Add("Cheezy",*mymenu);

    
    // for configuring this we will rely on a registry and the
    // RegistryGui to set it.  To do this, we will add a single entry
    // in our menu with a suitable method to get called with the menu
    // entry is selected:
    mymenu->Add("Configure",slot_class(*this,&CheezyPage::SpawnConfigurator));

}

void CheezyPage::Configure(const Registry& reg)
{
    fConfig = reg;
}


void CheezyPage::InitConfig()
{
    Registry r;
    r.Set("ListPlex",fListPlex.c_str());
    r.Set("ListTruth",fListTruth.c_str());
    r.Set("DrawEmpty",0);
    r.Set("DrawTruth",1);
    r.Set("OnlyBest",0);
    r.Set("WgtThresh",-1);
    fConfig = r;

    Registry possibles;

    Registry list_possibles;
    list_possibles.Set("MC list","candmcdigitlist");
    list_possibles.Set("Data list","canddigitlist");

    list_possibles.SetName("Possible ListPlex types");
    possibles.Set("ListPlex",list_possibles);
    list_possibles.SetName("Possible ListTruth types");
    possibles.Set("ListTruth",list_possibles);    

    Registry tf_possibles;
    tf_possibles.Set("true",1);
    tf_possibles.Set("false",0);

    tf_possibles.SetName("Possible DrawEmpty values");
    possibles.Set("DrawEmpty",tf_possibles);
    tf_possibles.SetName("Possible DrawTruth values");
    possibles.Set("DrawTruth",tf_possibles);
    tf_possibles.SetName("Possible OnlyBest values");
    possibles.Set("OnlyBest",tf_possibles);
    
    fConfigPossibles = possibles;
}

void CheezyPage::ApplyConfig()
{
    const char* str = 0;
    int num = 0;
    double real = 0.0;

    if (fConfig.Get("ListPlex",str)) fListPlex = str;
    if (fConfig.Get("ListTruth",str)) fListTruth = str;
    if (fConfig.Get("DrawEmpty",num)) fDrawEmpty = num != 0;

    // The rest need fDisplay already, just quietly return.
    if (!fDisplay) return;
    
    if (fConfig.Get("DrawTruth",num)) fDisplay->SetDrawTruth(num != 0);
    if (fConfig.Get("OnlyBest",num))  fDisplay->SetDrawOnlyBest(num != 0);
    if (fConfig.Get("WgtThresh",real))  fDisplay->SetWgtThresh(real);
}

// Small connection helper
static void apply_reg_gui(CheezyPage* cp, RegistryGui* rg)
{
    cp->Configure(rg->GetRegistry());
    cp->Update();
}

void CheezyPage::SpawnConfigurator(void)
{
    GuiMainWindow* mw = new GuiMainWindow(100,300);
    RegistryGui* rg = manage(new RegistryGui(*mw));
    mw->Add(*rg);

    GuiBox* box = manage(new GuiBox(*mw,kHorizontalFrame));
    box->SetLayoutHints(kLHintsExpandX);
    mw->Add(*box);
 
    GuiTextButton* apply = manage(new GuiTextButton(*box,"Apply"));
    box->Add(*apply);
    apply->clicked.connect(bind(slot(apply_reg_gui),this,rg));
 
    GuiTextButton* okay = manage(new GuiTextButton(*box,"Okay"));
    box->Add(*okay);
    okay->clicked.connect(bind(slot(apply_reg_gui),this,rg));
    okay->clicked.connect(slot(*mw,&GuiMainWindow::SendCloseMessage));
 
    GuiTextButton* cancel = manage(new GuiTextButton(*box,"Cancel"));
    box->Add(*cancel);
    cancel->clicked.connect(slot(*mw,&GuiMainWindow::SendCloseMessage));
 
    rg->SetRegistry(fConfig);
    rg->SetPossibles(fConfigPossibles);
 
    mw->ShowAll();
    mw->ConnectClose(true);
    mw->Resize(mw->GetDefaultWidth(),mw->GetDefaultHeight());
    
}

---