QGSessionHandler.cc

Go to the documentation of this file.

#include "QGSessionHandler.hh"
#include <iostream>
#include <list>
#include <sstream>
#include <typeinfo>
#include <vector>
#include <utility>
#include "QGCalibrationWindow.hh"
#include "QGCanvasWindow.hh"
#include "QGDefaultsHandler.hh"
#include "QGFileHandler.hh"
#include "QGGraphicalCut.hh"
#include "QGHistogram.hh"
#include "QGPlotListWindow.hh"
#include "QGPulse.hh"
#include "QGScatterPlot.hh"
#include "QGTextFileHandler.hh"
#include "QGWindow.hh"
#include "TGFileDialog.h"
#include "TString.h"
 
ClassImp(QGSessionHandler)
 
using std::cout;
using std::endl;
using std::flush;
using std::list;
using std::pair;
using std::string;
using std::stringstream;
using std::vector;
 
QGSessionHandler::QGSessionHandler() :
fCurrentCalibrationWindow(0), fCurrentCanvasWindow(0), fCurrentPlot(0)
{
}
 
QGSessionHandler::~QGSessionHandler()
{
}
 
void QGSessionHandler::OpenSession(QGCanvasWindow *window)
{
    string sessionDirectory = QGDefaultsHandler::Instance()->GetSessionDirectory();
    TString dir(sessionDirectory.c_str());
    TGFileInfo fi;
    fi.fIniDir = StrDup(dir);
    const char *filetypes[] = {"GUI session files" , "*.gui",
                               0,                    0};
    fi.fFileTypes = filetypes;
    new TGFileDialog(gClient->GetRoot(), 0, kFDOpen, &fi);
    if (fi.fFilename) {
        OpenSession(fi.fFilename, window);
        string currentDirectory = fi.fIniDir;
        if (currentDirectory != sessionDirectory) {
            QGDefaultsHandler::Instance()->SetSessionDirectory(currentDirectory);
        }
    }
}
 
void QGSessionHandler::OpenSession(string filename, QGCanvasWindow *window)
{
    QGTextFileHandler *textFileHandler = new QGTextFileHandler();
    if (textFileHandler->ReadFile(filename)) {
        const vector<pair<string, string> >& lines = textFileHandler->GetLines();
        vector<pair<string, string> >::const_iterator lineIter;
        for (lineIter = lines.begin(); lineIter != lines.end(); ++lineIter) {
            const string& key = lineIter->first;
            const string& value = lineIter->second;
            if (key == CANVAS_WINDOW_KEY) {
                if (window) {
                    fCurrentCanvasWindow = window;
                    window = 0;
                } else {
                    fCurrentCanvasWindow = new QGCanvasWindow();
                }
                fCurrentPlot = 0;
            } else if (key == HISTOGRAM_KEY) {
                fCurrentPlot = new QGHistogram();
                fCurrentCanvasWindow = 0;
                fCurrentCalibrationWindow = 0;
                fCurrentPlot->AutoSetStyle();
            } else if (key == SCATTER_PLOT_KEY) {
                fCurrentPlot = new QGScatterPlot();
                fCurrentCanvasWindow = 0;
                fCurrentCalibrationWindow = 0;
                fCurrentPlot->AutoSetStyle();
            } else if (key == PULSE_KEY) {
                fCurrentPlot = new QGPulse();
                fCurrentCanvasWindow = 0;
                fCurrentCalibrationWindow = 0;
                fCurrentPlot->AutoSetStyle();
            } else if (key == GRAPHICAL_CUT_KEY) {
                fCurrentPlot = new QGGraphicalCut();
                fCurrentCanvasWindow = 0;
                fCurrentCalibrationWindow = 0;
                fCurrentPlot->AutoSetStyle();
            } else if (key == CALIBRATION_WINDOW_KEY) {
                fCurrentCalibrationWindow = new QGCalibrationWindow();
                fCurrentCanvasWindow = 0;
                fCurrentPlot = 0;
            } else if (key == NAME_KEY) {
                if (fCurrentCanvasWindow) {
                    fCurrentCanvasWindow->SetWindowName(value.c_str());
                    fCanvasWindowsMap[value] = fCurrentCanvasWindow;
                } else if (fCurrentPlot) {
                    fCurrentPlot->SetName(value.c_str());
                }
            } else if (key == CANVAS_WINDOW_NAME_KEY) {
                if (fCurrentPlot) {
                    if (fCanvasWindowsMap.count(value) != 0) {
                        fCurrentPlot->SetCanvasWindow(fCanvasWindowsMap[value]);
                    }
                }
            } else {
                if (fCurrentCanvasWindow) {
                    fCurrentCanvasWindow->SetProperty(key, value);
                } else if (fCurrentPlot) {
                    fCurrentPlot->SetProperty(key, value);
                } else if (fCurrentCalibrationWindow) {
                    fCurrentCalibrationWindow->SetProperty(key, value);
                }
            }
        }
        QGPlotListWindow::Update();
    } else {
        cout << "Unable to read file " << filename << endl;
    }
    delete textFileHandler;
}
 
void QGSessionHandler::SaveSession()
{
    string sessionDirectory = QGDefaultsHandler::Instance()->GetSessionDirectory();
    TString dir(sessionDirectory.c_str());
    TGFileInfo fi;
    fi.fIniDir = StrDup(dir);
    const char *filetypes[] = {"GUI session files" , "*.gui",
                               0,                    0};
    fi.fFileTypes = filetypes;
    new TGFileDialog(gClient->GetRoot(), 0, kFDSave, &fi);
    if (fi.fFilename) {
        TString filename(fi.fFilename);
        TString extension(fi.fFileTypes[fi.fFileTypeIdx+1]);
        extension.Remove(TString::kLeading, '*');
        if (!filename.EndsWith(extension)) {
            filename.Append(extension);
        }
        SaveSession(filename.Data());
        string currentDirectory = fi.fIniDir;
        if (currentDirectory != sessionDirectory) {
            QGDefaultsHandler::Instance()->SetSessionDirectory(currentDirectory);
        }
    }
}
 
void QGSessionHandler::SaveSession(string filename)
{
    // open file for output
    QGTextFileHandler *textFileHandler = new QGTextFileHandler();
 
    // add canvas windows to output
    const list<QGWindow*>& windows = QGWindow::GetWindows();
    list<QGWindow*>::const_iterator windowIter;
    for (windowIter = windows.begin(); windowIter != windows.end(); ++windowIter) {
        if (QGCanvasWindow *canvasWindow = dynamic_cast<QGCanvasWindow*>(*windowIter)) {
            string name = canvasWindow->GetWindowName();
            vector<string> filenames = canvasWindow->GetFileHandler()->GetFilenames();
            textFileHandler->AppendLine(CANVAS_WINDOW_KEY);
            textFileHandler->AppendLine(NAME_KEY, name);
            vector<string>::const_iterator fileIter;
            for (fileIter = filenames.begin(); fileIter != filenames.end(); ++fileIter) {
                textFileHandler->AppendLine(FILE_KEY, *fileIter);
            }
            textFileHandler->AppendLine();
        }
    }
    
    // add plots to output
    const list<QGPlot*>& plots = QGPlot::GetPlots();
    list<QGPlot*>::const_iterator plotIter;
    for (plotIter = plots.begin(); plotIter != plots.end(); ++plotIter) {
        string name = (*plotIter)->GetName();
        string xVariable = (*plotIter)->GetXVariable();
        string xUnits = (*plotIter)->GetXUnits();
        string yVariable = (*plotIter)->GetYVariable();
        string yUnits = (*plotIter)->GetYUnits();
        bool superimpose = (*plotIter)->IsSuperimposeSet();
        const vector<string>& cuts = (*plotIter)->GetCuts();
        vector<string>::const_iterator cutIter;
        
        if (QGHistogram *histogram = dynamic_cast<QGHistogram*>(*plotIter)) {
            textFileHandler->AppendLine(HISTOGRAM_KEY);
            textFileHandler->AppendLine(NAME_KEY, name);
            textFileHandler->AppendLine(X_VARIABLE_KEY, xVariable);
            textFileHandler->AppendLine(X_UNITS_KEY, xUnits);
            if (histogram->IsXMinSet()) {
                Double_t min = histogram->GetXMin();
                textFileHandler->AppendLine(MIN_KEY, min);
            }
            if (histogram->IsXMaxSet()) {
                Double_t max = histogram->GetXMax();
                textFileHandler->AppendLine(MAX_KEY, max);
            }
            if (histogram->IsNumberOfBinsSet()) {
                Int_t numberOfBins = histogram->GetNumberOfBins();
                textFileHandler->AppendLine(NUMBER_OF_BINS_KEY, numberOfBins);
            }
            if (superimpose) {
                textFileHandler->AppendLine(SUPERIMPOSE_KEY, "true");
            }
            for (cutIter = cuts.begin(); cutIter != cuts.end(); ++ cutIter) {
                textFileHandler->AppendLine(CUT_KEY, *cutIter);
            }
            textFileHandler->AppendLine(FILL_COLOR_KEY, histogram->GetFillColor());
            textFileHandler->AppendLine(FILL_STYLE_KEY, histogram->GetFillStyle());
            textFileHandler->AppendLine(LINE_COLOR_KEY, histogram->GetLineColor());
            textFileHandler->AppendLine(LINE_STYLE_KEY, histogram->GetLineStyle());
            textFileHandler->AppendLine(LINE_WIDTH_KEY, histogram->GetLineWidth());
            textFileHandler->AppendLine(MARKER_COLOR_KEY, histogram->GetMarkerColor());
            textFileHandler->AppendLine(MARKER_SIZE_KEY, histogram->GetMarkerSize());
            textFileHandler->AppendLine(MARKER_STYLE_KEY, histogram->GetMarkerStyle());
        }
        else if (QGScatterPlot *scatterPlot = dynamic_cast<QGScatterPlot*>(*plotIter)) {
            textFileHandler->AppendLine(SCATTER_PLOT_KEY);
            textFileHandler->AppendLine(NAME_KEY, name);
            textFileHandler->AppendLine(X_VARIABLE_KEY, xVariable);
            textFileHandler->AppendLine(X_UNITS_KEY, xUnits);
            textFileHandler->AppendLine(Y_VARIABLE_KEY, yVariable);
            textFileHandler->AppendLine(Y_UNITS_KEY, yUnits);
            if (superimpose) {
                textFileHandler->AppendLine(SUPERIMPOSE_KEY, "true");
            }
            
            for (cutIter = cuts.begin(); cutIter != cuts.end(); ++ cutIter) {
                textFileHandler->AppendLine(CUT_KEY, *cutIter);
            }
            textFileHandler->AppendLine(MARKER_COLOR_KEY, scatterPlot->GetMarkerColor());
            textFileHandler->AppendLine(MARKER_SIZE_KEY, scatterPlot->GetMarkerSize());
            textFileHandler->AppendLine(MARKER_STYLE_KEY, scatterPlot->GetMarkerStyle());
        }
        else if (QGPulse *pulse = dynamic_cast<QGPulse*>(*plotIter)) {
            textFileHandler->AppendLine(PULSE_KEY);
            textFileHandler->AppendLine(NAME_KEY, name);
            Int_t eventIndex = pulse->GetEventIndex();
            textFileHandler->AppendLine(EVENT_INDEX_KEY, eventIndex);
            const string& orderVariable = pulse->GetOrderVariable();
            if (orderVariable != "") {
                textFileHandler->AppendLine(ORDER_VARIABLE_KEY, orderVariable);
            }
            const string& samplesVariable = pulse->GetSamplesLabel();
            if (samplesVariable != "") {
                textFileHandler->AppendLine(PULSE_VARIABLE_KEY, samplesVariable);
            }
            if (superimpose) {
                textFileHandler->AppendLine(SUPERIMPOSE_KEY, "true");
            }
            for (cutIter = cuts.begin(); cutIter != cuts.end(); ++ cutIter) {
                textFileHandler->AppendLine(CUT_KEY, *cutIter);
            }
            textFileHandler->AppendLine(LINE_COLOR_KEY, pulse->GetLineColor());
            textFileHandler->AppendLine(LINE_STYLE_KEY, pulse->GetLineStyle());
            textFileHandler->AppendLine(LINE_WIDTH_KEY, pulse->GetLineWidth());
            textFileHandler->AppendLine(MARKER_COLOR_KEY, pulse->GetMarkerColor());
            textFileHandler->AppendLine(MARKER_SIZE_KEY, pulse->GetMarkerSize());
            textFileHandler->AppendLine(MARKER_STYLE_KEY, pulse->GetMarkerStyle());
        }
        else if (QGGraphicalCut *graphicalCut = dynamic_cast<QGGraphicalCut*>(*plotIter)) {
            textFileHandler->AppendLine(GRAPHICAL_CUT_KEY);
            textFileHandler->AppendLine(NAME_KEY, name);
            textFileHandler->AppendLine(X_VARIABLE_KEY, xVariable);
            textFileHandler->AppendLine(Y_VARIABLE_KEY, yVariable);
            for (Int_t vertex = 0; vertex < graphicalCut->GetN() - 1; ++vertex) {
                stringstream vertexStream;
                vertexStream.precision(16);
                vertexStream << graphicalCut->GetX()[vertex] << " , " << graphicalCut->GetY()[vertex] << flush;
                textFileHandler->AppendLine(VERTEX_KEY, vertexStream.str());
            }
        }
        if ((*plotIter)->GetCanvasWindow()) {
            string canvasWindowName = (*plotIter)->GetCanvasWindow()->GetWindowName();
            textFileHandler->AppendLine(CANVAS_WINDOW_NAME_KEY, canvasWindowName);
        }
        textFileHandler->AppendLine();
    }
    
    // write file
    textFileHandler->WriteFile(filename);
    delete textFileHandler;
}