QGCalibrationPeakFrame.cc

Go to the documentation of this file.

#include "QGCalibrationPeakFrame.hh"
#include <algorithm>
#include <sstream>
#include "QGCalibrationWindow.hh"
#include "QGCanvasWindow.hh"
#include "QGPlot.hh"
#include "QGPlotFrame.hh"
#include "TCanvas.h"
#include "TFrame.h"
#include "TGButton.h"
#include "TGTextEntry.h"
#include "TRootEmbeddedCanvas.h"
#include "TString.h"
 
ClassImp(QGCalibrationPeakFrame)
 
using std::flush;
using std::stringstream;
 
QGCalibrationPeakFrame::QGCalibrationPeakFrame(TGWindow *p, UInt_t w, UInt_t h) : 
TGHorizontalFrame(p, w, h)
{
    SetCleanup(kDeepCleanup);
    
    fPeakEnergyBox = new TGTextEntry(this);
    fPeakEnergyBox->Resize(fPeakEnergyBox->GetDefaultWidth(), 25);
    fPeakEnergyBox->SetAlignment(kTextCenterX);
    fPeakEnergyBox->SetEnabled(kFALSE);
    AddFrame(fPeakEnergyBox, new TGLayoutHints(kLHintsCenterY, 5, 0, 0, 0));
    
    fMinAmplitudeBox = new TGTextEntry(this);
    fMinAmplitudeBox->Resize(fMinAmplitudeBox->GetDefaultWidth(), 25);
    AddFrame(fMinAmplitudeBox, new TGLayoutHints(kLHintsCenterY, 5, 0, 0, 0));
    
    fMaxAmplitudeBox = new TGTextEntry(this);
    fMaxAmplitudeBox->Resize(fMaxAmplitudeBox->GetDefaultWidth(), 25);
    AddFrame(fMaxAmplitudeBox, new TGLayoutHints(kLHintsCenterY, 5, 0, 0, 0));
 
    fSetButton = new TGTextButton(this, "Set");
    AddFrame(fSetButton, new TGLayoutHints(kLHintsCenterY, 5, 0, 0, 0));
    fSetButton->Connect("Clicked()", "QGCalibrationPeakFrame", this, "HandleSetButton()");
}
 
QGCalibrationPeakFrame::~QGCalibrationPeakFrame()
{
    Cleanup();
}
 
void QGCalibrationPeakFrame::Clear(Option_t* opt)
{
    fMinAmplitudeBox->Clear(opt);
    fMaxAmplitudeBox->Clear(opt);
}
 
Double_t QGCalibrationPeakFrame::GetMaxAmplitude() const
{
    TString text(fMaxAmplitudeBox->GetText());
    return text.Atof();
}
 
Double_t QGCalibrationPeakFrame::GetMinAmplitude() const
{
    TString text(fMinAmplitudeBox->GetText());
    return text.Atof();
}
 
void QGCalibrationPeakFrame::HandleSetButton()
{
    if (const QGCalibrationWindow *calibrationWindow = dynamic_cast<const QGCalibrationWindow*>(GetParent())) {
        QGPlot *plot = calibrationWindow->GetCurrentPlot();
        if (plot) {
            QGCanvasWindow *canvasWindow = plot->GetCanvasWindow();
            if (canvasWindow) {
                const std::list<QGPlot*>& drawnPlots = canvasWindow->GetDrawnPlots();
                if (find(drawnPlots.begin(), drawnPlots.end(), plot) != drawnPlots.end()) {
                    Double_t min = canvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->GetFrame()->GetX1();
                    Double_t max = canvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->GetFrame()->GetX2();
                    SetMinAmplitude(min);
                    SetMaxAmplitude(max);
                }
            }
        }
    }
}
 
Bool_t QGCalibrationPeakFrame::IsMaxAmplitudeSet() const
{
    TString text(fMaxAmplitudeBox->GetText());
    return text.IsFloat();
}
 
Bool_t QGCalibrationPeakFrame::IsMinAmplitudeSet() const
{
    TString text(fMinAmplitudeBox->GetText());
    return text.IsFloat();
}
 
void QGCalibrationPeakFrame::SetEnergy(Double_t energy)
{
    stringstream energyStream;
    energyStream << energy << " keV" << flush;
    fPeakEnergyBox->SetText(energyStream.str().c_str());
         fEnergy = energy;
}
 
void QGCalibrationPeakFrame::SetMaxAmplitude(Double_t max)
{
    stringstream maxStream;
    maxStream.precision(16);
    maxStream << max << flush;
    fMaxAmplitudeBox->SetText(maxStream.str().c_str());
}
 
void QGCalibrationPeakFrame::SetMinAmplitude(Double_t min)
{
    stringstream minStream;
    minStream.precision(16);
    minStream << min << flush;
    fMinAmplitudeBox->SetText(minStream.str().c_str());
}