DAQ++ git-vmedaq

#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <config/ConfigParser.h>
#include <config/IOConfig.h>
#include <config/PathConfig.h>
#include <config/GeneralConfig.h>
#include "Preferences.h"
#include "gtkutils.h"

#include <DAQ++/DAQmanager.h>
#include <daq/GenModule.h>
#include <data/Analysis.h>

Preferences::Preferences()
{}

void Preferences::user_init()
{

    //---------------------------------------------------------------------
    // Set default values
    //---------------------------------------------------------------------
    ConfigParser *cfg = ConfigParser::theConfig();
    SectionParser *sp = cfg->get_handler("IO");
    if ( sp )
    {
        IOConfig *io = dynamic_cast<IOConfig *>(sp);
        set_text("entryDataDirectory", io->get_output_path());
        set_text("entryPrefix",io->get_prefix());
        int2entry("entryRunNumber", io->get_run_number());
        int2entry("entryFileSize", io->get_max_size());
        activate_button("BtnCompress", (io->get_compression() ? 1 : 0));
    }

    // Pedestals
    GeneralConfig *gnrl = dynamic_cast<GeneralConfig *>(cfg->get_handler("general"));
    int2spin("spinNped", gnrl->get_ped_nevts());
    int2spin("spinMinSample", gnrl->get_ped_min_sample());
    int2spin("spinPedPeriod", gnrl->get_ped_period());
    if ( gnrl->get_ped_method() == GeneralConfig::fast )
    {
        activate_button("btnFastPedestals", true);
    }
    else
    {
        activate_button("btnProperPedestals", true);
    }
    activate_button("btnUpdatePedestals", gnrl->get_ped_update());

    // Corba
    int2spin("spinCorbaPort", gnrl->get_corba_port());
    if ( gnrl->get_corba_use_ip() )
    {
        activate_button("btnCorbaIP", true);
    }
    else
    {
        activate_button("btnCorbaLinux", true);
    }

    // Monitor
    int2spin("spinMonitorBuffer", gnrl->get_monitor_buffer());

    // Paths
    GtkTreeView *tree = GTK_TREE_VIEW(get_widget("treePaths"));
    gtk_tree_view_insert_column_with_attributes(tree, -1, "Path list", gtk_cell_renderer_text_new(),"text",0,NULL);
    create_store(PathConfig::libpath);
    create_store(PathConfig::gladepath);
    create_store(PathConfig::configpath);

    path_type = PathConfig::libpath;
    write_path_list();

#if  GTK_CHECK_VERSION(2,3,0)
    // Monitor colors
    GdkColor color;
    hcolor =gnrl->hsts();
    tcolor =gnrl->tracers();
    if ( !gnrl->hsts().bg().empty())
    {
        gdk_color_parse( gnrl->hsts().bg().c_str(),&color );
        gtk_color_button_set_color(GTK_COLOR_BUTTON(get_widget("btnHstBg")), &color);
    }
    if ( !gnrl->hsts().fg().empty())
    {
        gdk_color_parse( gnrl->hsts().fg().c_str(),&color );
        gtk_color_button_set_color(GTK_COLOR_BUTTON(get_widget("btnHstFg")), &color);
    }
    if (!gnrl->hsts().axis().empty())
    {
        gdk_color_parse( gnrl->hsts().axis().c_str(),&color );
        gtk_color_button_set_color(GTK_COLOR_BUTTON(get_widget("btnHstAx")), &color);
    }
    if (!gnrl->tracers().bg().empty())
    {
        gdk_color_parse( gnrl->tracers().bg().c_str(),&color );
        gtk_color_button_set_color(GTK_COLOR_BUTTON(get_widget("btnTrBg")), &color);
    }
    if (!gnrl->tracers().fg().empty())
    {
        gdk_color_parse( gnrl->tracers().fg().c_str(),&color );
        gtk_color_button_set_color(GTK_COLOR_BUTTON(get_widget("btnTrFg")), &color);
    }
    if (!gnrl->tracers().axis().empty())
    {
        gdk_color_parse( gnrl->tracers().axis().c_str(),&color );
        gtk_color_button_set_color(GTK_COLOR_BUTTON(get_widget("btnTrAx")), &color);
    }
#endif
}

Preferences::~Preferences()
{
    std::map<PathConfig::PathType, GtkTreeModel *>::iterator it;
    for (it=stores.begin(); it!=stores.end();it++)
        g_object_unref(it->second);
}

void
Preferences::auto_connect()
{
    SET_CONNECT( on_OK );
    SET_CONNECT( on_Apply );
    SET_CONNECT( on_Cancel );
    SET_CONNECT( on_Help );
    SET_CONNECT( on_path_type);
    SET_CONNECT( on_btnAddPath);
    SET_CONNECT( on_btnRemovePath);
    SET_CONNECT( on_btnPathUp);
    SET_CONNECT( on_btnPathDown);
    SET_CONNECT( on_btn_color_set);
}

void Preferences::set_handlers()
{
    handlers["create_color_button"] = (GladeHandler)create_color_button;
}
GtkWidget *Preferences::create_color_button(Preferences *M, char *name, char *, char *, int,  int)
{
#if  GTK_CHECK_VERSION(2,3,0)
    GtkWidget *wdgt = gtk_color_button_new();
#else
	GtkWidget *wdgt = gtk_label_new(name);
#endif
    return wdgt;
}
void Preferences::on_btnAddPath(GtkWidget *w, Preferences *P)
{
    GtkTreeView *tree = GTK_TREE_VIEW(P->get_widget("treePaths"));
    GtkListStore *list = GTK_LIST_STORE(gtk_tree_view_get_model(tree));
    GtkTreeIter iter;
    std::string new_path = get_a_string("Path", "Introduce the new path");
    gtk_list_store_append(list, &iter);
    gtk_list_store_set(list, &iter,0, new_path.c_str(),-1);

    std::cout << "New path is: " << new_path << std::endl;
}

void Preferences::on_btnRemovePath(GtkWidget *w, Preferences *P)
{
    GtkTreeModel *model;
    GtkTreeIter iter;
    GtkTreeView *list = GTK_TREE_VIEW( P->get_widget("treePaths") );
    GtkTreeSelection  *selection = gtk_tree_view_get_selection(list);
    if ( gtk_tree_selection_get_selected (selection, &model, &iter))
    {
        gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
    }
}
void Preferences::on_btnPathUp(GtkWidget *w, Preferences *P)
{
    P->move_row(TRUE);
}
void Preferences::on_btnPathDown(GtkWidget *w, Preferences *P)
{
    P->move_row(FALSE);
}


void Preferences::on_path_type(GtkWidget *w, Preferences *P)
{
    const gchar *path = gtk_widget_get_name(w);
    if ( !strcmp("library", path) )
    {
        P->path_type = PathConfig::libpath;
    }
    else if ( !strcmp("glade", path))
    {
        P->path_type = PathConfig::gladepath;
    }
    else
    {
        P->path_type = PathConfig::configpath;
    }
    P->write_path_list();
}

void Preferences::create_store(PathConfig::PathType type)
{
    ConfigParser *cfg = ConfigParser::theConfig();
    PathConfig *cpath = dynamic_cast<PathConfig *>(cfg->get_handler("paths"));
    GtkListStore *list = gtk_list_store_new(1,G_TYPE_STRING);
    GtkTreeIter iter;
    SearchPath spath(cpath->get_path(type));
    SearchPath::iterator ip;
    for (ip=spath.begin(); ip!=spath.end(); ip++)
    {
        std::string text = *ip;
        gtk_list_store_append(list, &iter);
        gtk_list_store_set(list, &iter,0, text.c_str(),-1);
    }
    stores[type] = GTK_TREE_MODEL(list);
}

void Preferences::write_path_list()
{
    GtkTreeModel *model = stores[path_type];
    GtkTreeView *tree = GTK_TREE_VIEW(get_widget("treePaths"));
    gtk_tree_view_set_model( tree, model);
}

void Preferences::on_Help(GtkWidget *w, Preferences *pr)
{
    int page = gtk_notebook_get_current_page( GTK_NOTEBOOK(pr->get_widget("notebookPreferences")) );
    switch (page)
    {
        case 0:
            gtk_help_display("acquire-data");
            break;
        case 1:
            gtk_help_display("general-config");
            break;
    }
}

void Preferences::on_Apply(GtkWidget *w, Preferences *pr)
{
    ConfigParser *cfg = ConfigParser::theConfig();
    SectionParser *sp = cfg->get_handler("IO");
    if ( sp )
    {
        IOConfig *io = dynamic_cast<IOConfig *>(sp);

        io->set_output_path( pr->get_text("entryDataDirectory") );
        io->set_prefix( pr->get_text("entryPrefix") );
        io->set_run_number( pr->entry2int("entryRunNumber") );
        io->set_max_size( pr->entry2int("entryFileSize"));
        io->set_compression( pr->btn_active("BtnCompress"));
    }

    // Pedestals
    GeneralConfig *gnrl = dynamic_cast<GeneralConfig *>(cfg->get_handler("general"));
    gnrl->set_ped_nevts( pr->spin2int("spinNped") );
    gnrl->set_ped_min_sample( pr->spin2int("spinMinSample") );
    gnrl->set_ped_method( pr->btn_active("btnFastPedestals") ? GeneralConfig::fast : GeneralConfig::normal);
    gnrl->set_ped_update( pr->btn_active("btnUpdatePedestals") );
    gnrl->set_ped_period( pr->spin2int("spinPedPeriod") );

    DAQpp::RunManager *rm =
        DAQpp::DAQmanager::theDAQmanager()->find_runmanager("main");
    ObserverList::iterator ip;
    for (ip = (*rm)()->begin();ip != (*rm)()->end();++ip)
    {
        GenModule *md = dynamic_cast<GenModule *>(*ip);
        if (md)
        {
	  if ( md->get_analysis() )
            md->get_analysis()->DoPedestalUpdate(gnrl->get_ped_update());
        }
    }

    // Corba
    gnrl->set_corba_port( pr->spin2int("spinCorbaPort") );
    gnrl->set_corba_use_ip( pr->btn_active("btnCorbaIP") );

    // Monitor
    gnrl->set_monitor_buffer( pr->spin2int("spinMonitorBuffer") );

    //Paths
    PathConfig *cpath = dynamic_cast<PathConfig *>(cfg->get_handler("paths"));
    std::map<PathConfig::PathType, GtkTreeModel *>::iterator it;
    for (it=pr->stores.begin(); it!=pr->stores.end();it++)
    {
        SearchPath path;
        GtkTreeModel *model = it->second;
        GtkTreeIter iter;
        gboolean valid;
        gchar *gpath;

        valid = gtk_tree_model_get_iter_first(model, &iter);

        while (valid)
        {
            gtk_tree_model_get(model, &iter, 0, &gpath, -1);
            path.add_path(gpath);
            g_free(gpath);
            valid = gtk_tree_model_iter_next(model, &iter);
        }
        path.purge();
        cpath->set_path(it->first, path);
    }


    // Monitor colors
    GdkColor color;
    gnrl->hsts(pr->hcolor);
    gnrl->tracers(pr->tcolor);
}

void Preferences::on_OK(GtkWidget *w, Preferences *pr)
{
    on_Apply(w, pr);
    on_Cancel(w, pr);
}

void Preferences::on_Cancel(GtkWidget *w, Preferences *pr)
{
    delete pr;
}

void
Preferences::move_row(gboolean up)
{
    GtkTreeView *cl = GTK_TREE_VIEW(get_widget("treePaths"));
    GtkTreeModel *model;
    GtkTreeIter iter, iter1;

    GtkTreeSelection  *selection = gtk_tree_view_get_selection(cl);
    if ( gtk_tree_selection_get_selected (selection, &model, &iter))
    {
        GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);

        if ( up )
            gtk_tree_path_prev (path);
        else
            gtk_tree_path_next (path);

        if ( gtk_tree_model_get_iter (model, &iter1, path) )
        {
            gtk_list_store_swap( GTK_LIST_STORE(model), &iter, &iter1);
        }
    }
}

void
Preferences::on_btn_color_set(GtkWidget *wdgt, Preferences *pr)
{
    GdkColor color;

#if  GTK_CHECK_VERSION(2,3,0)
    std::string name = gtk_widget_get_name(wdgt);
    std::ostringstream ostr;
    gtk_color_button_get_color(GTK_COLOR_BUTTON(wdgt),&color);
    ostr << '#' << std::setw(2) << std::hex << color.red
                << std::setw(2) << std::hex << color.green
                << std::setw(2) << std::hex << color.blue;

    if (name=="btnHstBg")
    {
        pr->hcolor.bg(ostr.str());
    }
    else if (name=="btnHstFg")
    {
        pr->hcolor.fg(ostr.str());
    }
    else if (name=="btnHstAx")
    {
        pr->hcolor.axis(ostr.str());
    }
    else if (name == "btnTrBg")
    {
        pr->tcolor.bg(ostr.str());
    }
    else if (name == "btnTrFg")
    {
        pr->tcolor.fg(ostr.str());
    }
    else if (name == "btnTrAx")
    {
        pr->tcolor.axis(ostr.str());
    }
    else
    {
        std::cout << "Preferences::on_btn_color_set: this should not happen" << std::endl;
    }
#endif
}