Midad/MultiPage/GfxDigit.cxx

Go to the documentation of this file.

#include "GfxDigit.h"
#include "GfxDigitList.h"
#include "GfxDigitListCfg.h"
#include "ViewState.h"
#include <Midad/Base/Mint.h>
#include <Midad/Util/Util.h>

#include <UgliGeometry/UgliGeomHandle.h>
#include <UgliGeometry/UgliStripHandle.h>

#include <CandDigit/CandDigitHandle.h>
#include <Plex/PlexSEIdAltL.h>

#include <MessageService/MsgService.h>
CVSID("$Id: GfxDigit.cxx,v 1.7 2005/02/02 14:52:23 tagg Exp $");

#include <TEllipse.h>
#include <TBox.h>
#include <TPad.h>

#include <iostream>
using namespace std;

ClassImp(GfxDigit)

#if 0
GfxDigit::GfxDigit()
    : fDigit(0)
      ,fParent(0)
      ,fImp(0)
{
}
#endif
GfxDigit::GfxDigit(const CandDigitHandle& csh, GfxDigitList& parent)
    : fDigit(&csh)
      ,fItem(0)
      ,fParent(&parent)
      ,fImp(0)
{
}
GfxDigit::GfxDigit(const CandDigitHandle& csh, 
                   const PlexSEIdAltLItem& itm, GfxDigitList& parent)
    : fDigit(&csh)
      ,fItem(&itm)
      ,fParent(&parent)
      ,fImp(0)
{
//   if (fItem) {
//     PlexStripEndId seid = fItem->GetSEId(); 
//     MSG("Midad",Msg::kInfo) << "fItem on " << seid.AsString() << endl;
//  }
}
GfxDigit::GfxDigit(const GfxDigit& rhs)
    : TObject()
    , fDigit(rhs.fDigit), fItem(rhs.fItem), fParent(rhs.fParent), fImp(0)
{
}
GfxDigit& GfxDigit::operator=(const GfxDigit& rhs)
{
    if (this == &rhs) return *this;
    fDigit = rhs.fDigit;
    fItem = rhs.fItem;
    fParent = rhs.fParent;
    fImp = 0;
    return *this;
}

GfxDigit::~GfxDigit()
{
    this->Clear();
}

void GfxDigit::Clear(const Option_t*)
{
    if (fImp) delete fImp; fImp = 0;
}

bool GfxDigit::GetRealCoords(double& cx, double& cy, double& dx, double& dy)
{
    UgliGeomHandle ugh(*fDigit->GetVldContext());
    UgliStripHandle ush;

    if (!fItem) {
        ush = ugh.GetStripHandle(fDigit->GetPlexSEIdAltL().GetBestItem().GetSEId());
    }
    else {
        ush = ugh.GetStripHandle(fItem->GetSEId());
    }

    if (!ush.IsValid()) return false;

    cx = ush.GlobalPos(0).Z();
    cy = ush.GetTPos();
    dx = ush.GetHalfThickness();
    dy = ush.GetHalfWidth();
    return true;
}
bool GfxDigit::GetDiscreteCoords(double& cx, double& cy, double& dx, double& dy)
{
    PlexStripEndId seid;

    if (!fItem) {
        seid = fDigit->GetPlexSEIdAltL().GetBestItem().GetSEId();
    }
    else {
        seid = fItem->GetSEId();
    }
    cx = seid.GetPlane();
    cy = seid.GetStrip();
    dx = 0.5;
    dy = 0.5;
    if (fItem) 
        MSG("Midad",Msg::kVerbose) << seid.AsString() 
                                   << " cx = " << cx  
                                   << " cy = " << cy << endl;
    return true;
}

float GfxDigit::GetRelativeValue(GfxDigitListCfg::MeasureScale_t ms)
{
    if (ms == GfxDigitListCfg::kCharge) {
        RangeDouble& qrange = fParent->GetMint().GetChargeRange();
        double den = qrange.Min() - qrange.Max();
        if (den > 0)
            return (fDigit->GetCharge() - qrange.Min()) / den;
    }
    else {                      // time
        RangeDouble& trange = fParent->GetMint().GetTimeRange();
        double den = trange.Max() - trange.Min();
        if (den > 0)
            return (fDigit->GetTime() - trange.Min()) / den;
    }
    return 1.0;
}

void GfxDigit::ModifyCoords(double& cx, double& cy, double& dx, double& dy)
{
    int strip_sign = 0;

    StripEnd::StripEnd_t end; 
    if (!fItem) {
        end = fDigit->GetPlexSEIdAltL().GetBestItem().GetSEId().GetEnd();
    }
    else {
        end = fItem->GetSEId().GetEnd();
    }
    if (end == StripEnd::kNegative) strip_sign = -1;
    if (end == StripEnd::kPositive) strip_sign = +1;

    GfxDigitListCfg& cfg = fParent->GetCfg();
    
    // Scale down size of strip
    GfxDigitListCfg::SizeBy_t sb = cfg.GetSizeBy();
    double size_scale = this->GetRelativeValue(cfg.GetSizeIs());

    size_scale *= cfg.GetSizeFactor();

    switch (sb) {
    case GfxDigitListCfg::kFixed:
        // nothing
        break;
    case GfxDigitListCfg::kLinear:
        dx *= size_scale;
        dy *= size_scale;
        break;
    case GfxDigitListCfg::kLogLinear:
        dx *= logify_relative(size_scale);
        dy *= logify_relative(size_scale);
        break;
    case GfxDigitListCfg::kLogArea:
        dx *= logify_relative(sqrt(size_scale));
        dy *= logify_relative(sqrt(size_scale));
        break;
    case GfxDigitListCfg::kArea: default:
        dx *= sqrt(size_scale);
        dy *= sqrt(size_scale);
        break;
    }

    // modify for any odd shape
    GfxDigitListCfg::DigitEnd_t si = cfg.GetStripEnd();
    switch (si) {
    case GfxDigitListCfg::kHalf:
        dy *= strip_sign * 0.5;
        cy += dy;
        break;
    case GfxDigitListCfg::kBowTie:
        dx *= strip_sign * 0.5;
        dy *= strip_sign * 0.5;
        cx += dx;
        cy += dy;
        break;
    case GfxDigitListCfg::kFull: 
        // fall through
    case GfxDigitListCfg::kBit:
        // fall through
    default:
        // do nothing
        break;
    }    
}

bool GfxDigit::SetColor()
{
    int color = 0; 
    if (!fItem) {color = fParent->GetDigitColor(*fDigit); }
    else        {color = fParent->GetDigitColor(*fDigit, *fItem);}

    if (!color) {
        return false;
    }

    TAttFill* att_fill = dynamic_cast<TAttFill*>(fImp);
    if (!att_fill) return false;
    att_fill->SetFillColor(color);

    if (!fItem) {
        att_fill->SetFillStyle(1001);
    }
    else {
        att_fill->SetFillStyle(0);
        const PlexSEIdAltLItem& best = fDigit->GetPlexSEIdAltL().GetBestItem();
        if ( fItem == &best) att_fill->SetFillStyle(1001); 
    }

    TAttLine* att_line = dynamic_cast<TAttLine*>(fImp);
    if (!att_line) return false;
    att_line->SetLineColor(color);
    return true;
}

void GfxDigit::Configure()
{

    // here we make our imp.
    if (fImp) { delete fImp; fImp = 0; }

    GfxDigitListCfg& cfg = fParent->GetCfg();

    fCx = fCy = fDx = fDy = 0.0;


    switch (fParent->GetViewState()->GetSpatialMetric()) {
    case ViewState::metric_is_continuous:
        this->GetRealCoords(fCx,fCy,fDx,fDy);
        break;
    case ViewState::metric_is_discreet: default:
        this->GetDiscreteCoords(fCx,fCy,fDx,fDy);
        break;
    }


    double dx = fDx, dy = fDy;
    if (cfg.GetScaleIs() == GfxDigitListCfg::kAbsolute) {
        fDx = 1.0;
        fDy = 4.0;
        this->ModifyCoords(fCx,fCy,fDx,fDy);
        this->RelToAbs(dx,dy);
    }
    else {
        this->ModifyCoords(fCx,fCy,fDx,fDy);
    }

    switch (cfg.GetShapeIs()) {
    case GfxDigitListCfg::kEllipse: 
        fImp = new TEllipse(fCx,fCy,dx,dy);
        break;
    default:
        fImp = new TBox(fCx+dx,fCy+dy,fCx-dx,fCy-dy);
        break;
    }

//    TAttFill* att_fill = dynamic_cast<TAttFill*>(fImp);
//    if (att_fill) {
//      att_fill->SetFillStyle(0);
//      att_fill->SetFillStyle(1001);
//    } 

//    cerr << "GfxDigit::Configure (" << cx << "," << cy << ")\n";

}


void GfxDigit::ExecuteEvent(int event, int px, int py)
{
    fParent->ExecuteEventDigit(event,px,py,this);
}
void GfxDigit::Paint(Option_t* option)
{
    if (!fImp) return;

    if (fParent->DigitsHidden()) return;

    if (!this->SetColor()) return;

    GfxDigitListCfg& cfg = fParent->GetCfg();
    if (cfg.GetScaleIs() == GfxDigitListCfg::kAbsolute) {
        double dx, dy;
        this->RelToAbs(dx,dy);

        switch (cfg.GetShapeIs()) {
        case GfxDigitListCfg::kEllipse: {
            TEllipse* el= dynamic_cast<TEllipse*>(fImp);
            el->SetR1(dx);
            el->SetR2(dy);
            el->Paint(option);
           break;
        }
        default:
            TBox* box = dynamic_cast<TBox*>(fImp);
            box->SetX1(fCx+dx);
            box->SetY1(fCy+dy);
            box->SetX2(fCx-dx);
            box->SetY2(fCy-dy);
            box->Paint();
            break;
        }
    }
    else {
        fImp->Paint(option);
    }
}
int GfxDigit::DistancetoPrimitive(int px, int py)
{
    if (fImp) return fImp->DistancetoPrimitive(px,py);
    return 0xdead;
}

void GfxDigit::RelToAbs(double& dx, double& dy)
{
    dx = gPad->AbsPixeltoX((int)fDx) - gPad->AbsPixeltoX(0);
    dy = gPad->AbsPixeltoY((int)fDy) - gPad->AbsPixeltoY(0);
//    cerr << Form("dx=%f(%f)  dy=%f(%f)",fDx,dx,fDy,dy) << endl;
}

void GfxDigit::ConfigGui(void)
{
    if (!fParent) return;
    GfxDigitListCfg& cfg = fParent->GetCfg();
    cfg.GuiConfig();
}

---