MultiPage.cxx

Go to the documentation of this file.

#include "MultiPage.h"
#include "GfxProxy.h"
#include "GfxCfg.h"
#include "ViewState.h"
#include "MultiPageObject.h"

#include <Midad/Base/PageProxy.h>
#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/DigitText.h>
#include <Midad/Base/ZoomPad.h>
#include <Midad/Base/ColorAxis.h>
#include <Midad/Base/RangeAxis.h>
#include <Midad/Base/Mint.h>
#include <Midad/Base/GfxButton.h>

#include <Midad/Util/RangeControl.h>
#include <Midad/Util/CompositeRange.h>
#include <Midad/Gui/GuiBox.h>
#include <Midad/Gui/GuiCanvas.h>
#include <Midad/Gui/GuiSlider.h>

#include <JobControl/JobC.h>
#include <Conventions/Munits.h>

#include <TCanvas.h>
#include <TH1F.h>


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


static PageProxy<MultiPage> gsMultiPageProxy("Multi");

MultiPage::MultiPage()
    : fPageDisplay(0)
    , fMint(0)
    , fZoomHistory(0)
    , fCompositeRange(0)
{
    fZoomHistory = manage(new UndoHistory);
    fCompositeRange = manage(new CompositeRange<double>);
}

MultiPage::~MultiPage()
{
    fPad[0]->Clear();
    fPad[1]->Clear();
}

TObject* MultiPage::Init(Mint* mint, PageDisplay* pd, GuiBox& box)
{
    this->CanvasPage::Init(mint,pd,box);

    fMint = mint;
    fPageDisplay = pd;

    fViewState[0] = manage(new ViewState);
    fViewState[1] = manage(new ViewState);

    this->BuildMenus();

//    cerr << "MultiPage::Init()\n";

    fRClist.push_back(fPageDisplay->GetTimeSlider().GetSignals().released.connect
                      (slot_class(*this,&MultiPage::Update)));
    
    TCanvas& canvas = this->GetCanvas();

    RangeDouble*  spatial_range[3];
    for (int i=0; i<3; ++i) {
        spatial_range[i] = manage(new RangeDouble(0,1));
        fSpatialControl[i] = new RangeControl<double>(fZoomHistory,
                                                      spatial_range[i]);
    }

    // right to left
    const double x1=0.03, x2=0.90, x3=0.95;
    // bottom to top
    const double centerline = 0.50, separation=0.02;
    const double y1=0.05, y2=centerline-separation;
    const double y3=centerline+separation, y4=0.95;
    const double xruv=x1*0.75, yrz=0.5*(y2+y3);

    fPad[0] = new ZoomPad("U View", "U View", x1,y3, x2,y4);
    fPad[1] = new ZoomPad("V View", "V View", x1,y1, x2,y2);

    fRangeAxis[0] = new RangeAxis(xruv,y3, xruv,y4);
    fRangeAxis[1] = new RangeAxis(xruv,y1, xruv,y2);
    fRangeAxis[2] = new RangeAxis(x1,yrz, x2,yrz);

    for (int i = 0; i < 3; ++i) {
        fRangeAxis[i]->UseRange(spatial_range[i]);
        fRangeAxis[i]->SetLabelSize(0.5*fRangeAxis[i]->GetLabelSize());
    }

    RangeDouble* color_range[2];
    for (int i = 0; i<2; ++i) {
        color_range[i] = manage(new RangeDouble(0,1));
        fColorControl[i] = new RangeControl<double>(fZoomHistory,color_range[i]);//leak

        fPad[i]->UseCurRangeX(spatial_range[2]);
        fPad[i]->selection.connect(bind(slot_class(*this,&MultiPage::SelectionZoom),fPad[i]));
    }
    fPad[0]->UseCurRangeY(spatial_range[0]);
    fPad[1]->UseCurRangeY(spatial_range[1]);

    fColorAxis[0] = new ColorAxis(50,0.05, color_range[0], x3,y3+0.05, x3,y4-0.05, 505,"+L");
    fColorAxis[1] = new ColorAxis(50,0.05, color_range[1], x3,y1+0.05, x3,y2-0.05, 505,"+L");
    fColorButton[0] = manage(new GfxButton("time",x2,y4-0.05,x3,y4));
    fColorButton[1] = manage(new GfxButton("time",x2,y2-0.05,x3,y2));

    for (int i=0; i<2; ++i) {
        fColorAxis[i]->SetScale(Munits::ns);
        RangeDouble& sel = fColorAxis[i]->GetSelectionRange();
        sel.modified.connect(bind(slot(*(fColorControl[i]),&RangeControl<double>::Apply),&sel));
        sel.modified.connect(slot_class(*this,&MultiPage::UpdateCanvas));

        fColorButton[i]->clicked.connect(slot(*fViewState[i],&ViewState::ToggleColorSemantic));
        fViewState[i]->color_semantic.connect(bind(slot_class(*this,
                                                              &MultiPage::ColorSemanticHandler),i));
        fViewState[i]->show_multiplex.connect(slot_class(*this,&MultiPage::Update));
        fViewState[i]->spatial_metric.connect(slot_class(*this,&MultiPage::Update));
    }

    for (int i=0; i<3; ++i) {
        RangeDouble& s = fRangeAxis[i]->GetSelectionRange();
        s.modified.connect(bind(slot(*(fSpatialControl[i]),
                                     &RangeControl<double>::Apply),&s));

        fRClist.push_back(spatial_range[i]->modified.connect
                          (slot_class(*this,&MultiPage::UpdateCanvas)));
    }

    canvas.cd();

    this->Clear();
    fPad[0]->SetBorderSize(1);
    fPad[1]->SetBorderSize(1);
    fPad[0]->SetBorderMode(1);
    fPad[1]->SetBorderMode(1);
    fColorButton[0]->SetFillColor(2);
    fColorButton[1]->SetFillColor(2);

    fPad[0]->Draw();
    fPad[1]->Draw();
    fRangeAxis[0]->Draw();
    fRangeAxis[1]->Draw();
    fRangeAxis[2]->Draw();

    canvas.cd();
    fColorAxis[0]->Draw();
    fColorAxis[1]->Draw();
    fColorButton[0]->Draw();
    fColorButton[1]->Draw();


//    this->InitView(PlaneView::kU);
//    this->InitView(PlaneView::kV);

    const char* default_gfx[] = {
        "DigitList",
        "TrackList",
        0
    };
    for (int ind=0; default_gfx[ind]; ++ind) this->AddGfx(default_gfx[ind]);


    this->Clear();
    this->Update();
    return new MultiPageObject(this); // small leak
}


static void toggle_mux(GuiMenu* menu,
                       GuiMenu::GuiMenuList::iterator mit,
                       ViewState* view_state)
{
    bool show_mux = view_state->ShowMultiplex();
    menu->CheckEntry(mit,show_mux);
}

void MultiPage::BuildMenus(void)
{
    GuiMenuBar& mb = fPageDisplay->GetMenuBar();
    GuiMenu* pm = mb.GetMenu("Pages");
    if (!pm) return;

    static int ninstances = 0;

    // Generic entries
    GuiMenu* mymenu = manage(new GuiMenu);
    pm->Add(Form("Multi (%d)",++ninstances),*mymenu);

    GuiMenu::GuiMenuList::iterator mit;

    // Whether to show multiplexing or now
    const char* mux_labels[2] = {
        "U vs. Z multiplexing",
        "V vs. Z multiplexing",
    };        
    for (int ind = 0; ind < 2; ++ind) {
        mit = mymenu->Add(mux_labels[ind]);

        ViewState* vs = fViewState[ind];
        mymenu->CheckEntry(mit,vs->ShowMultiplex());
        (*mit)->Connect(slot(*vs,&ViewState::ToggleMultiplex));
        vs->show_multiplex.connect(bind(bind(bind(slot(toggle_mux),vs),mit),mymenu));
    }

    // Real or discrete coords.
    mit = mymenu->Add("Use real coords");
    (*mit)->Connect(bind(slot_class(*this,&MultiPage::ToggleRealCoords),mymenu,mit));

    mymenu->Add(0);

    GuiMenu* add_menu = manage(new GuiMenu);
    mymenu->Add("Add Gfx",*add_menu);

    list<const char*> gfx_names = GfxProxyBase::GetRegisteredNames();
    list<const char*>::iterator it, done = gfx_names.end();

    for (it = gfx_names.begin(); it != done; ++it) {
        const char* name = *it;
        mit = add_menu->Add(name,bind(slot_class(*this,&MultiPage::AddGfx),name));
        (*mit)->Connect(slot_class(*this,&MultiPage::Update));
    }

    mymenu->Add(0);

    NamedFactory& nf = NamedFactory::Instance("Gfx");
    for (it = gfx_names.begin(); it != done; ++it) {
        const char* name = *it;
        GfxProxyBase* gpb = dynamic_cast<GfxProxyBase*>(nf.GetProxy(name));
        if (!gpb) {
            cerr << "Failed to get GfxProxy for " << name << endl;
            continue;
        }
        GuiMenu * gfx_menu = gpb->MakeMenu(this);
        if (! gfx_menu) continue;
        gfx_menu = manage(gfx_menu);
        mymenu->Add(name, *gfx_menu);

    }
}

void MultiPage::ToggleRealCoords(GuiMenu* menu, GuiMenu::GuiMenuList::iterator mit)
{

    bool is_real = ! menu->IsEntryChecked(mit);
    menu->CheckEntry(mit,is_real);

    for (int ind = 0; ind < 2; ++ind) {
        fViewState[ind]->SetSpatialMetric(is_real ? 
                                          ViewState::metric_is_continuous : 
                                          ViewState::metric_is_discreet);
    }

    this->FullZoom();
}

void MultiPage::AddGfx(const char* gfx_name)
{
    GfxProxyBase* gpb = dynamic_cast<GfxProxyBase*>
        (NamedFactory::Instance("Gfx").GetProxy(gfx_name));
    if (!gpb) {
        cerr << "Failed to get " << gfx_name << " proxy\n";
        return;
    }

    PlaneView::PlaneView_t view[2] = {
        PlaneView::kU,
        PlaneView::kV
    };

    TVirtualPad* old_pad = gPad;
    for (int ind = 0; ind < 2; ++ind) {
        fPad[ind]->cd();
        
        GfxBase* gfx_base = gpb->Create();
        if (!gfx_base) {
            cerr << "Failed to create " << gfx_name << endl;
            break;
        }
        
        gfx_base->text_info.connect(slot_class(*fPageDisplay,&PageDisplay::StatusBar));
        gfx_base->SetPlaneView(view[ind]);
        gfx_base->SetViewState(fViewState[ind]);

        gfx_base->GetCfg().modified_signal.connect(slot_class(*this,&MultiPage::UpdateCanvas));
        gfx_base->Init(*fPageDisplay,*this);
        
        fGfxList[gfx_base] = GfxInfo(view[ind]);
    }
    gPad = old_pad;
    this->Update();
}

void MultiPage::InitView(PlaneView::PlaneView_t view)
{
    // \begin{evil}
    int ind = view - PlaneView::kU; 
    fPad[ind]->cd();
    char cview[2] = "U";
    cview[0] += ind;
    // \end{evil}


    const char* hard_coded_default_gfx[] = {
        "DigitList",
        "StripList",
        "TrackList",
        0
    };

    for (int ind=0; hard_coded_default_gfx[ind]; ++ind) {
        const char* gfx_name = hard_coded_default_gfx[ind];
        this->AddGfx(gfx_name);
    }
    
}


void MultiPage::Clear()
{
    fZoomHistory->Clear();

    this->BlockRanges(true);
    this->FullZoom();
    this->BlockRanges(false);
}

void MultiPage::FullZoom()
{
    if (!fMint) return;
    if (fMint->GetDetector() == Detector::kUnknown) return;
    UgliGeomHandle ugh = fMint->GetUgliGeomHandle();
    if (! ugh.IsValid()) {
        cerr << "MultiPage::FullZoom: no valid geometry\n";
        return;
    }


    if (fViewState[0]->GetSpatialMetric() == ViewState::metric_is_discreet) {
        vector<UgliScintPlnHandle> usphv = ugh.GetScintPlnHandleVector();
        vector<UgliScintPlnHandle>::reverse_iterator rit, rdone = usphv.rend();
            
        for (rit = usphv.rbegin(); rit != rdone; ++rit) {
            if (! rit->GetPlexPlaneId().IsVetoShield()) break;
        }
        if (rit == rdone) {
            cerr << "MultiPage::FullZoom: WTF, can't get last plane!\n";
            return;
        }

        int first_plane = usphv[0].GetPlaneNumber(), last_plane = rit->GetPlaneNumber();
        
        // This is the wrong thing to do for NearDet....
        int n_strips = usphv[0].NumberOfStrips();

        fPad[0]->Range(first_plane,0,last_plane+1,n_strips);
        fPad[1]->Range(first_plane,0,last_plane+1,n_strips);

    }
    else {
        float tmin, tmax, zmin, zmax;
        ugh.GetZExtent(zmin,zmax);

        ugh.GetTransverseExtent(PlaneView::kU,tmin,tmax);
        fPad[0]->Range(zmin,tmin,zmax,tmax);

        ugh.GetTransverseExtent(PlaneView::kV,tmin,tmax);
        fPad[1]->Range(zmin,tmin,zmax,tmax);
    }
}

void MultiPage::BlockRanges(bool tf)
{
    for (unsigned int ind = 0; ind < fRClist.size(); ++ind) 
        fRClist[ind].block(tf);
}

void MultiPage::Update()
{
    if (!fMint) return;

    this->ColorSemanticHandler(0);
    this->ColorSemanticHandler(1);

    this->UpdateView(PlaneView::kU);
    this->UpdateView(PlaneView::kV);
    this->UpdateCanvas();
}
void MultiPage::UpdateCanvas()
{
    fPad[0]->Modified();
    fPad[1]->Modified();
    this->GetCanvas().Modified();
    this->GetCanvas().Update();
}

void MultiPage::UpdateView(PlaneView::PlaneView_t view)
{
    // \begin{evil}
    int ind = view - PlaneView::kU; 
    fPad[ind]->cd();
    // \end{evil}

    GfxList::iterator it, done = fGfxList.end();
    for (it = fGfxList.begin(); it != done; ++it) {
        if (it->second.view_type == view) {
            it->first->Configure(*fMint);
            it->first->Draw();
        }
    }
}

void MultiPage::SelectionZoom(ZoomPad* zp)
{
    fCompositeRange->push_back(fPad[0]->GetCurRange().x);
    fCompositeRange->push_back(fPad[0]->GetCurRange().y);
    fCompositeRange->push_back(fPad[1]->GetCurRange().x);
    fCompositeRange->push_back(fPad[1]->GetCurRange().y);
    fZoomHistory->Store(*fCompositeRange);
    zp->ApplySelectionToZoom();
}

void MultiPage::Unzoom()
{
    fZoomHistory->Undo();
    this->UpdateCanvas();
}
void MultiPage::Rezoom()
{
    fZoomHistory->Redo();
    this->UpdateCanvas();
}
RangeControl<double> MultiPage::GetColorRangeControl(PlaneView::PlaneView_t view)
{
    int iview = 0;
    if (view == PlaneView::kV) iview = 1;
    return *fColorControl[iview];
}
void MultiPage::ColorSemanticHandler(int which)
{
    if (which < 0 || which > 2) return;

    GfxButton* but = fColorButton[which];

    RangeDouble& cr = fColorControl[which]->GetRange();

    switch (fViewState[which]->GetColorSemantic()) {
    case ViewState::color_is_charge:
        but->SetTitle("charge");
        fColorAxis[which]->SetScale(1.0);
        cr.SetFrom(fMint->GetChargeRange());
        break;
    case ViewState::color_is_time:
        but->SetTitle("time");
        fColorAxis[which]->SetScale(Munits::ns);
        cr.SetFrom(fMint->GetTimeRange());
        break;
    default:
        break;
    }
    fPad[which]->Modified();
    this->GetCanvas().Modified();
    but->Modified();
}

ViewState* MultiPage::GetViewState(PlaneView::PlaneView_t view)
{
    int iview = 0;
    if (view == PlaneView::kV) iview = 1;
    return fViewState[iview];
}

---