valveshuttercontrol.cpp

#include "valveshuttercontrol.h"
#include "ui_valveshuttercontrol.h"
#include "row.h"
#include "errmanager.h"
#include "rpcthread.h"
#include <macros.h>
#include <configuration.h>
#include <elettracolors.h>
#include <QTimer>
#include <QFile>
#include <QMessageBox>
#include <QGridLayout>
#include <QVBoxLayout>
#include <QTWriter>
#include <QCheckBox>
#include <QTWriter>
#include <QtDebug>

ValveShutterControl::ValveShutterControl(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::ValveShutterControl)
{
    ui->setupUi(this);
    ui->progressWidget->setVisible(false);
    QTimer::singleShot(100, this, SLOT(setup()));
}

ValveShutterControl::~ValveShutterControl()
{
    delete ui;
}

void ValveShutterControl::setup()
{
    if(qApp->arguments().count() < 2)
    {
        QMessageBox::information(this, "Usage", QString("%1 configuration_file").arg(qApp->arguments().at(0)));
        exit(EXIT_FAILURE);
    }

    Config::instance()->setStateColor(Tango::OPEN, EColor(Elettra::green));
    Config::instance()->setStateColor(Tango::CLOSE, EColor(Elettra::darkYellow));
    Config::instance()->setStateColor(Tango::FAULT, EColor(Elettra::red));

    foreach(QPushButton *pb, ui->gbValve->findChildren<QPushButton *>())
        connect(pb, SIGNAL(clicked()), this, SLOT(execCmd()));
    foreach(QPushButton *pb, ui->gbShutter->findChildren<QPushButton *>())
        connect(pb, SIGNAL(clicked()), this, SLOT(execCmd()));
    foreach(QPushButton *pb, ui->frameHeader->findChildren<QPushButton *>())
        connect(pb, SIGNAL(clicked()), this, SLOT(execCmd()));
    connect(ui->pbCancelThread, SIGNAL(clicked()), this, SLOT(cancelRpcThread()));

    QVBoxLayout *vb = new QVBoxLayout(ui->table);
    QFile file(qApp->arguments().at(1));
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
        return;

    unsigned linecnt = 0;
    while (!file.atEnd())
    {
        linecnt++;
        QString line = QString(file.readLine()).trimmed();
        if(!line.startsWith('#') && line.count(",") > 0)
        {
            QStringList parts = line.split(",");
            if(parts.size() == 3)
            {
                Row *row = new Row(parts, this);
                connect(row, SIGNAL(selectionChanged(bool,bool)), this, SLOT(rowSelectionChanged(bool,bool)));
                vb->addWidget(row);
            }
            else
                perr("line %d \"%s\" is not valid!", linecnt, qstoc(line));

        }
    }
}

void ValveShutterControl::execCmd()
{
    QObject *sen = sender();
    QString cmd = sen->property("cmd").toString();
    if(cmd == "vlvSelectAll")
        foreach(Row *r, ui->table->findChildren<Row *>())
            r->setValveSelected(true);
    else if(cmd == "vlvDeselectAll")
        foreach(Row *r, ui->table->findChildren<Row *>())
            r->setValveSelected(false);
    else if(cmd == "shSelectAll")
        foreach(Row *r, ui->table->findChildren<Row *>())
            r->setShutterSelected(true);
    else if(cmd == "shDeselectAll")
        foreach(Row *r, ui->table->findChildren<Row *>())
            r->setShutterSelected(false);
    else if(cmd == "vlvOpen" || cmd == "vlvClose")
        cmdValves(cmd.remove("vlv"));
    else if(cmd == "shOpen" || cmd == "shClose")
        cmdShutters(cmd.remove("sh"));

}

void ValveShutterControl::writeProgress(int step, int total)
{
    ui->progressWidget->setVisible(step < total);
    ui->progressBar->setMaximum(total);
    ui->progressBar->setValue(step);
}

void ValveShutterControl::rpcWriteFinished()
{
    RpcThread *th = findChild<RpcThread *>();
    QStringList errors = th->errors();

    if(errors.size())
    {
        ErrManager* errMan = new ErrManager(this);
        errMan->setErrors("RPC", errors);
        errMan->exec();
        delete errMan;
    }
    delete th;
}

void ValveShutterControl::cancelRpcThread()
{
    RpcThread *th = findChild<RpcThread *>();
    if(th)
        th->cancel();
}

void ValveShutterControl::rowSelectionChanged(bool isValve, bool checked)
{
    bool oneChecked = checked;
    QList<Row *> rows = ui->table->findChildren<Row *>();
    Row *r;
    if(isValve)
    {
        for(int i = 0; !checked && i < rows.size(); i++)
        {
            r = rows.at(i);
            oneChecked = r->isValveSelected();
            if(oneChecked)
                break;
        }
        ui->pbOpenValve->setEnabled(oneChecked);
        ui->pbCloseValve->setEnabled(oneChecked);
    }
    else
    {
        for(int i = 0; !checked && i < rows.size(); i++)
        {
            r = rows.at(i);
            oneChecked = r->isShutterSelected();
            if(oneChecked)
                break;
        }
        ui->pbOpenSh->setEnabled(oneChecked);
        ui->pbCloseSh->setEnabled(oneChecked);
    }
}


void ValveShutterControl::cmdValves(const QString& cmd)
{
    QStringList sections_rpc;
    foreach(Row *r, ui->table->findChildren<Row *>())
        if(r->isValveSelected() && !r->isVlvFETango())
            sections_rpc << r->section();

    qDebug() << __FUNCTION__  << "sections rpc " << sections_rpc << cmd;

    RpcThread *rpcThread = new RpcThread(this, sections_rpc, cmd);
    connect(rpcThread, SIGNAL(progress(int,int)), this, SLOT(writeProgress(int,int)));
    connect(rpcThread, SIGNAL(finished()), this, SLOT(rpcWriteFinished()));
    rpcThread->start();

    /* tango VLVFEs */
    QString target;
    foreach(Row *r, ui->table->findChildren<Row *>())
    {
        if(r->isValveSelected() && r->isVlvFETango())
        {
            QTWriter *w = new QTWriter(this);
            w->setAutoDestroy(true);
            target = r->vlvFeSource().section('/',0, 2);
            target += "->" + cmd;
            printf("** executing tango command \"%s\" ***\n", qstoc(target));
            w->setTargets(target);
            w->execute();
        }
    }
}

void ValveShutterControl::cmdShutters(const QString& cmd)
{
    QString targets;
    foreach(Row *r, ui->table->findChildren<Row *>())
        if(r->isShutterSelected())
            targets += r->shutterSource() + "->" + cmd + ";";

    if(targets.isEmpty())
        return;

    QTWriter *w = new QTWriter(this);
    w->setAutoDestroy(true);
    printf("CmdShutters.executing \"%s\"\n", qstoc(targets));
    w->setTargets(targets);
    w->execute();
}