Midad/MultiPage/GfxStripList.cxx

Go to the documentation of this file.

#include "GfxStripList.h"
#include "GfxStripListCfg.h"
#include "GfxProxy.h"
#include "GfxStripListMenu.h"
#include "MultiPage.h"
#include "ViewState.h"

#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/Mint.h>
#include <Midad/Base/Rainbow.h>
#include <Midad/Base/DigitText.h>
#include <Midad/Util/Range.h>
#include <Midad/Gui/GuiSlider.h>
//#include <Midad/Util/Util.h>

#include <Conventions/Munits.h>

#include <DataUtil/CDL2STL.h>
using namespace DataUtil;

#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandStripListHandle.h>
#include <Record/RecArrayAllocator.h>

#include <Buttons.h> // part of ROOT
#include <TClonesArray.h>

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

#include <iostream>
#include <string>
using namespace std;


GfxProxy<GfxStripList> 
gsGfxStripListProxy("StripList", new GfxStripListMenu());


GfxStripList::GfxStripList()
    : fCfg(0)
    , fColorRange(0)
    , fMultiPage(0)
    , fMint(0)
    , fStripCA(0)
    , fHideStrips(false)
{
    fCfg = new GfxStripListCfg();
    fCfg->modified_signal.connect
        (slot_class(*this,&GfxStripList::ReConfigure));

    RecArrayAllocator& a = RecArrayAllocator::Instance();
    fStripCA = a.GetArray("GfxStrip");
}

GfxStripList::~GfxStripList()
{
    RecArrayAllocator& a = RecArrayAllocator::Instance();
    if (fStripCA) { a.ReleaseArray(fStripCA); fStripCA = 0; }
}

void GfxStripList::Init(PageDisplay& pd, MultiPage& mp)
{
    fColorRange = &mp.GetColorRangeControl(this->GetPlaneView()).GetRange();
    ViewState* vs = this->GetViewState();
    vs->color_semantic.connect(slot_class(*this,&GfxStripList::ReConfigure));
    vs->spatial_metric.connect(slot_class(*this,&GfxStripList::ReConfigure));
    fPageDisplay = &pd;
    fMultiPage = &mp;
}

static bool select_strip(const CandStripHandle* csh, 
                         PlaneView::PlaneView_t view,
                         RangeDouble* time_range)
{
    if (!csh) return false;
    return csh->GetPlaneView() == view && time_range->InRange(csh->GetTime());
}

void GfxStripList::Configure(Mint& mint)
{
    fMint = &mint;

    const CandStripListHandle* cslh = mint.GetStrips();
    if (!cslh) { 
        this->ClearStripList();
        return;
    }

    RangeDouble& time_range = 
        fPageDisplay->GetTimeSlider().GetRangeCtrl().GetRange();

    Mint::StripVector_t sv = CDL2STLvector<CandStripHandle>(*cslh);

    Mint::StripVector_t::iterator it, first = sv.begin(), middle, last = sv.end();
    Slot1<bool,const CandStripHandle*> s =
        bind(slot(select_strip),this->GetPlaneView(),&time_range);
    middle = std::partition(first,last,s);

    this->ClearStripList();

    for (it = first; it != middle; ++it) {
        int last = fStripCA->GetLast()+1;
        new ((*fStripCA)[last]) GfxStrip(**it,*this);
        GfxStrip* gs = dynamic_cast<GfxStrip*>(fStripCA->UncheckedAt(last));
        fStrips.push_back(gs);
    }
    this->ReConfigure();

}

void GfxStripList::ReConfigure(void)
{
    if (!fMint) return;
    if (fHideStrips) return;

    // configure all GfxStrips
    GfxStripVector_t::iterator it, done = fStrips.end();
    for (it = fStrips.begin(); it != done; ++it) (*it)->Configure();
}

void GfxStripList::Draw(Option_t *option)
{
    GfxStripVector_t::iterator it, done = fStrips.end();
    for (it = fStrips.begin(); it != done; ++it) 
        (*it)->Draw(option);
}


// Private methods:
void GfxStripList::ClearStripList()
{
    fStrips.clear();
    fStripCA->Clear("C");
}

void GfxStripList::ExecuteEventStrip(int event, int /*px*/, int /*py*/,
                                     GfxStrip* gfx_strip)
{
    switch (event) {
    case kMouseEnter: {
        const CandStripHandle& csh = gfx_strip->GetStrip();
        PlexStripEndId seid = csh.GetStripEndId();
        const char* s = Form("Strip: %d digit%s, plane=%d, demux charge=%.1f, t0=%.1f ns, <t>=%.1f ns (%s)",
                             csh.GetNDigit(), csh.GetNDigit() == 1 ? "" : "s",
                             csh.GetPlane(),
                             csh.GetCharge(), csh.GetBegTime()/Munits::ns, 
                             csh.GetTime()/Munits::ns, seid.AsString());
        text_info.emit(s);

        vector<const CandDigitHandle*> dv = CDL2STLvector<CandDigitHandle>(csh);
        int siz = dv.size();
        if (!siz) break;

        DigitText* dt = fPageDisplay->GetDigitText();
        if (dt) {
            dt->Clear();
            for (int ind=0; ind < siz; ++ind)
                dt->AddCandDigitText(*dv[ind]);
        }
        if (fMint) {
            fMint->SetPickedStrip(csh);
            fMint->SetSelectedDigits(dv);
        }
        
        break;
    }
    default: // nothing
        break;
    }
}

bool GfxStripList::StripMasked(const CandStripHandle& csh) const
{
    if (!fColorRange) return false;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = csh.GetTime();
        break;
    case ViewState::color_is_charge:
        val = csh.GetCharge();
        break;
    default:
        return false;
        break;
    }

    bool ret = fColorRange->InRange(val);
    return !ret;
}

int GfxStripList::GetStripColor(const CandStripHandle& csh) const
{
    if (!fColorRange) return false;

    static Rainbow rainbow;

    if (this->StripMasked(csh)) return 0;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = csh.GetTime();
        break;
    case ViewState::color_is_charge:
        val = csh.GetCharge();
        break;
    default:
        return 0;
        break;
    }
    return rainbow.GetRelativeColor(fColorRange->Relative(val));
}
void GfxStripList::HideStrips(bool hide)
{
    fHideStrips = hide;
    this->ReConfigure();
    fMultiPage->UpdateCanvas();
}

---