QGPlot.cc

Go to the documentation of this file.

#include "QGPlot.hh"
#include <algorithm>
#include <iostream>
#include <sstream>
#include "QGCanvasWindow.hh"
#include "QGCutsFrame.hh"
#include "QGFileHandler.hh"
#include "QGPlotEditButtonsFrame.hh"
#include "QGPlotEditWindow.hh"
#include "QGPlotFrame.hh"
#include "QGPlotListWindow.hh"
#include "QGSessionHandler.hh"
#include "TCanvas.h"
#include "TRootEmbeddedCanvas.h"
 
ClassImp(QGPlot)
 
using std::cout;
using std::endl;
using std::flush;
using std::list;
using std::string;
using std::stringstream;
using std::vector;
 
list<QGPlot*> QGPlot::fPlots;
 
QGPlot::QGPlot() :
fCanvasWindow(0), fPlotEditWindow(0), fSuperimpose(false)
{
    fPlots.push_back(this);
    SetRegenerate();
}
 
QGPlot::QGPlot(const QGPlot& plot) :
fCanvasWindow(plot.fCanvasWindow), fCuts(plot.fCuts), fCutsString(plot.fCutsString), 
fNeedsRegeneration(plot.fNeedsRegeneration), fPlotEditWindow(0), fSuperimpose(plot.fSuperimpose), 
fXVariable(plot.fXVariable), fXUnits(plot.fXUnits), fYVariable(plot.fYVariable), fYUnits(plot.fYUnits)
{
    fPlots.push_back(this);
    if (fCanvasWindow) {
        fCanvasWindow->AddPlot(this);
    }
}
 
QGPlot::~QGPlot()
{
    if (find(fPlots.begin(), fPlots.end(), this) != fPlots.end()) {
        fPlots.erase(find(fPlots.begin(), fPlots.end(), this));
    }
    if (fCanvasWindow) {
        fCanvasWindow->RemovePlot(this);
    }
    if (QGPlotListWindow::IsVisible()) {
        QGPlotListWindow::Instance()->RemoveEntry(this);
        QGPlotListWindow::Instance()->Refresh();
    }
}
 
void QGPlot::AddCut(const string& cut)
{
    fCuts.push_back(cut);
    MakeCutsString();
    SetRegenerate();
}
 
void QGPlot::AutoSetStyle()
{
    // Should be overridden by derived classes
}
 
void QGPlot::Display()
{
    // Should be overridden by derived classes
}
 
void QGPlot::DisplayEditWindow()
{
    // Should be overridden by derived classes
}
 
void QGPlot::Duplicate()
{
    cout << "Duplicate not implemented for this type" << endl;
    // Should be overridden by derived classes
}
 
void QGPlot::Erase()
{
    // Should be overridden by derived classes
}
 
void QGPlot::Generate(QChain *chain)
{
    // Should be overridden by derived classes
}
 
string QGPlot::GeneratePlotName(const string& baseName) const
{
    string name;
    int i = 0;
    do {
        ++i;
        stringstream index;
        index << i << flush;
        name = baseName + index.str();
    } while (IsNameInUse(name));
    return name;
}
 
TCanvas *QGPlot::GetCanvas()
{
    return fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas();
}
 
void QGPlot::GetCanvasWindowFromEditWindow()
{
    if (fPlotEditWindow && fPlotEditWindow->GetButtonsFrame()) {
        string canvasWindow = fPlotEditWindow->GetButtonsFrame()->GetCanvasWindowName();
        if (canvasWindow != "") {
            QGWindow *window = QGWindow::GetWindowByName(canvasWindow);
            if (QGCanvasWindow *newCanvasWindow = dynamic_cast<QGCanvasWindow*>(window)) {
                //QGCanvasWindow *oldCanvasWindow = GetCanvasWindow();
                if (newCanvasWindow != fCanvasWindow) { //oldCanvasWindow) {
                    //Erase();
                    //if (oldCanvasWindow) {
                    //    oldCanvasWindow->RemovePlot(this);
                    //}
                    SetCanvasWindow(newCanvasWindow);
                    //newCanvasWindow->AddPlot(this);
                }
            }
        }
    }
}
 
void QGPlot::GetCutsFromEditWindow()
{
    if (fPlotEditWindow && fPlotEditWindow->GetCutsFrame()) {
        SetCuts(fPlotEditWindow->GetCutsFrame()->GetCuts());
    }
}
 
const char *QGPlot::GetName() const
{
    // Should be overridden by derived class
    return "";
}
 
void QGPlot::GetParametersFromEditWindow()
{
    // Should be overridden by derived class
}
 
QGPlot *QGPlot::GetPlotByName(const string& name)
{
    QGPlot *plot = 0;
    list<QGPlot*>::const_iterator plotIter;
    for (plotIter = fPlots.begin(); plotIter != fPlots.end(); ++plotIter) {
        if ((*plotIter)->GetName() == name) {
            plot = *plotIter;
            break;
        }
    }
    return plot;
}
 
bool QGPlot::IsNameInUse(const string& name) const
{
    bool inUse = false;
    list<QGPlot*>::const_iterator plotIter;
    for (plotIter = fPlots.begin(); plotIter != fPlots.end(); ++plotIter) {
        if ((*plotIter)->GetName() == name) {
            inUse = true;
            break;
        }
    }
    return inUse;
}
 
void QGPlot::MakeCutsString()
{
    fCutsString.clear();
    if (fCuts.size() != 0) {
        vector<string>::const_iterator cutIter = fCuts.begin();
        fCutsString = "(" + *cutIter + ")";
        ++cutIter;
        while (cutIter != fCuts.end()) {
            fCutsString += " && (" + *cutIter + ")";
            ++cutIter;
        }
    }
}
 
void QGPlot::Plot()
{
    GetCanvasWindowFromEditWindow();
    GetCutsFromEditWindow();
    GetParametersFromEditWindow();
    if (fCanvasWindow && fCanvasWindow->GetFileHandler()) {
        if (fCanvasWindow->GetFileHandler()->CheckForModifiedFiles()) {
            fCanvasWindow->SetPlotsToRegenerate();
            fCanvasWindow->UpdateVariablesDropDownBoxes();
        }
    }
    if (NeedsRegeneration()) {
        Generate();
        SetRegenerate(false);
    }
    if (fCanvasWindow) {
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
    }
    Display();
}
 
void QGPlot::SetCanvasWindow(QGCanvasWindow *window)
{
    if (fCanvasWindow != window) {
        if (fCanvasWindow) {
            Erase();
            fCanvasWindow->RemovePlot(this);
        }
        if (window) {
            window->AddPlot(this);
        }
        fCanvasWindow = window;
        SetRegenerate();
    }
}
 
void QGPlot::SetCuts(const vector<string>& cuts)
{
    if (fCuts != cuts) {
        fCuts = cuts;
        MakeCutsString();
        SetRegenerate();
    }
}
 
void QGPlot::SetName(const char *name)
{
    // Should be overridden by derived class
}
 
void QGPlot::SetProperty(const string& key, const string& value)
{
    if (key == NAME_KEY) {
        SetName(value.c_str());
    }
    else if (key == CUT_KEY) {
        AddCut(value);
    }
    else if (key == X_VARIABLE_KEY) {
        SetXVariable(value);
    }
    else if (key == X_UNITS_KEY) {
        SetXUnits(value);
    }
    else if (key == Y_VARIABLE_KEY) {
        SetYVariable(value);
    }
    else if (key == Y_UNITS_KEY) {
        SetYUnits(value);
    }
    else if (key == SUPERIMPOSE_KEY) {
        SetSuperimpose(value == "true");
    }
}
 
void QGPlot::SetXVariable(const string& x)
{
    if (fXVariable != x) {
        fXVariable = x;
        SetRegenerate();
    }
}
 
void QGPlot::SetYVariable(const string& y)
{
    if (fYVariable != y) {
        fYVariable = y;
        SetRegenerate();
    }
}
 
void QGPlot::ShowPlotsList()
{
    QGPlotListWindow::Instance();
}