/var/www/hormigaproject.com.ar/files/src/mainwindow.cpp

Go to the documentation of this file.

/*
# Hormiga - Software de cálculo programable.
#
# Copyright (C) 2008, 2009 Leonardo Román, Hugo J. Curti, Norma  Ercoli,
# Universidad Nacional del Centro de la Provincia de Buenos Aires
# (UNCPBA)
#
# Este programa es parte de Hormiga.
#
# Hormiga es software libre. Puede redistribuirlo y/o modificarlo
# bajo los términos de la Licencia Pública General de GNU según es
# publicada por la Free Software Foundation, versión 2. Vea el archivo
# COPIA (español, no oficial) o COPYING (inglés, oficial) en directorio
# raíz.
#
# Hormiga se distribuye con la esperanza de que sea útil, pero SIN
# NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL implícita o sin
# garantizar la CONVENIENCIA PARA UN PROPÓSITO PARTICULAR. Véase la
# Licencia Pública General de GNU para más detalles.
#
# Debería haber recibido una copia de la Licencia Pública General junto
# con Hormiga. Si no ha sido así, escriba a la Free Software
# Foundation, Inc., en 675 Mass Ave, Cambridge, MA 02139, EEUU.
# Añada también información sobre cómo contactar con usted mediante
# correo electrónico y postal.
#
# This file is part of Hormiga.
#
# Hormiga is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2
# as published by the Free Software Foundation; see the file COPYING
# in the top directory for details.
#
# Hormiga is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Hormiga; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
# USA
*/

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "stdio.h"

#include <QMessageBox>
#include <QScrollArea>
#include <QComboBox>

#include <qwt_slider.h>
#include <qwt_thermo.h>
#include <qwt_data.h>
/* QwtDataHPlot2D
 * Helper Class for Ploter
 */
    QwtData *   QwtDataHPlot2D::copy () const {
        QwtDataHPlot2D* toRet = new QwtDataHPlot2D( this->fi , QObject::parent(), true );
        toRet->vx = this->vx ;
        toRet->vy = this->vy ;
        toRet->vsize = this->vsize ;
        return toRet ;
    }
    size_t   QwtDataHPlot2D::size () const {
        return this->vsize ;
    }
    double   QwtDataHPlot2D::x (size_t i) const {
        return vx[i] ;
    }
    double   QwtDataHPlot2D::y (size_t i) const {
        return vy[i] ;
    }
    QwtDataHPlot2D::QwtDataHPlot2D ( FunctionInstanceIterator* fi, QObject *parent , bool isCopy )
        : QObject(parent) {
        this->isCloned = isCopy ;
        this->fi = fi ;
        if ( ! isCopy ) {
            size_t s = fi->iterationsCount() ;
            vx = new double[s] ;
            vy = new double[s] ;
            int i = 0 ;
            const double* d = fi->first() ;
            do {
                vx[i] = d[0] ;
                vy[i] = d[1] ;
                i++ ;
            } while ( fi->next() != NULL ) ;
            this->vsize = i ;
        }
    }
    QwtDataHPlot2D::~QwtDataHPlot2D () {
        if ( ! this->isCloned ) {
            delete[] this->vx ;
            delete[] this->vy ;
        }
    }


MainWindow::MainWindow( CoreInterface *core , QWidget *parent )
    : QMainWindow(parent), ui(new Ui::MainWindowClass)
{
    ui->setupUi(this);
    this->currentCapts = NULL ;
    this->currentStep = NULL ;
    this->core = core ;
    QObject::connect( core, SIGNAL( stepCreated( Step* ) ),
                      this, SLOT( addStep( Step* ) ) ) ;
    QObject::connect( ui->stepList,
                      SIGNAL( itemDoubleClicked ( QListWidgetItem* ) ),
                      this, SLOT( executeStep ( QListWidgetItem* ) ) ) ;
    // For Error reports...
    QObject::connect( core, SIGNAL( coreMessage(QString,int)) ,
                      this, SLOT( showMessage(QString,int) ) ) ;
}


void MainWindow::clear ()
{
    this->currentCapts = NULL ;
    this->currentStep = NULL ;
    this->ui->stepList->clear() ;
    inputs.clear() ;
    if ( ui->splitter->widget( 1 ) ) delete ui->splitter->widget( 1 ) ;
}

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


void MainWindow::addStep ( Step *newStep )
{
    /* Este slot se conecta al CORE */
    ui->stepList->addItem( newStep->getName() );
    QObject::connect( newStep, SIGNAL(stateChanged(Step*,Step::state,Step::state)),
                      this, SLOT(changeState(Step*,Step::state,Step::state)) );
    /* The next connection is forced to be Synchronic */
    QObject::connect( newStep,
                      SIGNAL(needInput( Step*, T_CAPTURE_LIST* )),
                      this, SLOT(showCapturesGUI ( Step*, T_CAPTURE_LIST* )),
                      Qt::BlockingQueuedConnection ) ;
    QObject::connect( newStep,
                      SIGNAL( reportOutput(Step*, T_REPORT_LIST*) ),
                      this, SLOT( showReportsGUI(Step*, T_REPORT_LIST*) ),
                      Qt::BlockingQueuedConnection ) ;
}

void MainWindow::changeState( Step* peer , Step::state newState , Step::state oldState )
{
    /* Este slot se conecta a los Steps */
    QListWidgetItem *s = NULL ;
    for ( int i = 0 ; i < ui->stepList->count() ; i ++ ) {
        s = ui->stepList->item(i) ;
        if ( s->text() == peer->getName() ) {
            QBrush b = s->foreground() ;
            switch ( newState ) {
                case Step::NotSatisfied: b.setColor( Qt::lightGray ) ; break ;
                case Step::Satisfied:    b.setColor( Qt::darkBlue ) ; break ;
                case Step::Executing:    b.setColor( Qt::darkRed ) ; break ;
                case Step::Accepted:     b.setColor( Qt::darkGreen ) ; break ;
            }
            s->setForeground( b ) ;
            return ;
        }
    }
}


void MainWindow::showCapturesGUI ( Step* emisor , T_CAPTURE_LIST* captures )
{
    /* Este slot se conecta a los Steps */
    emisor->sleep();
    inputs.clear() ;
    if ( ui->splitter->widget( 1 ) ) delete ui->splitter->widget( 1 ) ;
    QFrame *frame = new QFrame() ;
    QVBoxLayout *vLayout = new QVBoxLayout(frame) ;
    for ( int i = 0 ; i < captures->count() ; i++ )
    {
        Capture *c = captures->at( i ) ;
        QLayout *layout = NULL ;
        switch ( c->getCaptureType() )
        {
            case Capture::CTXT : layout = getCaptureInputTXT( c, frame ) ; break ;
            case Capture::CGUI : layout = getCaptureInputGUI( c, frame ) ; break ;
            case Capture::CIMG : layout = getCRLayoutIMG( (CR_Image*) c , frame ) ; break ;
            case Capture::CSEL : layout = getCRLayoutSEL( (CR_Select*) c, frame, false ) ; break ;
            case Capture::CPLOT : layout = getCRLayoutPLOT( (CR_FunctionIterator*) c , frame ) ; break ;
        }
        vLayout->addLayout( layout ) ;
    }
    QPushButton *okButton = new QPushButton( tr("Ok") , frame ) ;
    vLayout->addWidget( okButton ) ;
    QObject::connect( okButton,
                      SIGNAL( clicked()) ,
                      this, SLOT( acceptCaptures()) ) ;
    QPushButton *printButton = new QPushButton( tr("Print...") , frame ) ;
    vLayout->addWidget( printButton ) ;
    QObject::connect( printButton,
                      SIGNAL( clicked()) ,
                      this, SLOT( print() ) ) ;
    QScrollArea *scrollArea = new QScrollArea ;
    scrollArea->setWidget( frame ) ;
    ui->splitter->addWidget( scrollArea ) ;
    this->currentCapts = captures ;
    this->currentStep = emisor ;
}

QLayout *MainWindow::getCaptureInputGUI( Capture* capture, QFrame *frame )
{
    CaptureGUI *c = (CaptureGUI*) capture ;
    QLabel *label = new QLabel( tr( c->getLabel().toAscii().data() ), frame ) ;

    QwtSlider *slider = new QwtSlider ( frame, Qt::Horizontal, QwtSlider::BottomScale ) ;
    slider->setRange( c->getRange()->getFirst(), c->getRange()->getLast(),
                      c->getRange()->getStep() ) ;
    QLabel *num = new QLabel( frame ) ;
    connect(slider, SIGNAL(valueChanged(double)), num, SLOT(setNum(double)));
    slider->setValue ( c->getValue() ) ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    layout->addWidget ( label ) ;
    layout->addWidget ( slider ) ;
    layout->addWidget ( num ) ;
    this->inputs.append( slider ) ;
    return layout ;
}

QLayout *MainWindow::getCaptureInputTXT( Capture* capture, QFrame *frame )
{
    CaptureTXT *c = (CaptureTXT*) capture ;
    QLabel *label = new QLabel( tr( c->getLabel().toAscii().data() ), frame ) ;
    QLineEdit *lineEdit = new QLineEdit(frame) ;
    lineEdit->setText( QString("%1").arg( c->getValue() ) ) ;
    QDoubleValidator *val = new QDoubleValidator( lineEdit ) ;
    lineEdit->setValidator( val ) ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    layout->addWidget ( label ) ;
    layout->addWidget ( lineEdit ) ;
    this->inputs.append( lineEdit ) ;
    return layout ;
}

void MainWindow::acceptCaptures ()
{
    if ( ! inputs.count() || ! currentCapts ) return ;
    for ( int i = 0 ; i < currentCapts->count() ; i++ )
    {
        Capture* c = currentCapts->at( i ) ;
        bool setOk = false ;
        switch ( c->getCaptureType() )
        {
            case Capture::CTXT : setOk = setCaptureTXT( i ) ; break ;
            case Capture::CGUI : setOk = setCaptureGUI( i ) ; break ;
            case Capture::CIMG : setOk = true ; break ;
            case Capture::CSEL : setOk = setCaptureSEL( i ) ; break ;
            case Capture::CPLOT : setOk = true ; break ;
        }
        if ( ! setOk ) return ;
    }
    currentStep->wakeUp();
    currentStep = NULL ;
    currentCapts = NULL ;
    inputs.clear() ;
    if ( ui->splitter->widget( 1 ) ) delete ui->splitter->widget( 1 ) ;
}

bool MainWindow::setCaptureSEL ( int order )
{
    QComboBox *cb = (QComboBox*) inputs.at( order ) ;
    CR_Select* sel = (CR_Select*)currentCapts->at( order ) ;
    return sel->setValue( cb->currentIndex() ) ;
}

bool MainWindow::setCaptureGUI ( int order )
{
    QwtSlider *sl = (QwtSlider*) inputs.at( order ) ;
    CaptureGUI* c = (CaptureGUI*)currentCapts->at( order ) ;
    return c->setValue( sl->value() ) ;
}

bool MainWindow::setCaptureTXT ( int order )
{
    QLineEdit *le = (QLineEdit*) inputs.at( order ) ;
    if ( ! le->isModified() ) return true ;
    bool convertResult ;
    T_MAGNITUDE v = le->text().toDouble(&convertResult) ;
    CaptureTXT* c = (CaptureTXT*) currentCapts->at( order ) ;
    if ( ! ( convertResult && c->setValue( v ) ) )
    {
        le->setFocus() ;
        le->selectAll() ;
        QErrorMessage msg(this) ;
        msg.setModal( true ) ;
        msg.showMessage( QString( tr("The value '%1' for '%2' is not allowed")
                                  ).arg(v).arg(c->getLabel()) ) ;
        msg.exec() ;
        return false ;
    }
    return true ;
}

void MainWindow::showReportsGUI ( Step* emisor , T_REPORT_LIST* reports )
{
    /* Este slot se conecta a los Steps */
    emisor->sleep();
    if ( ui->splitter->widget( 1 ) ) delete ui->splitter->widget( 1 ) ;
    QFrame *frame = new QFrame() ;
    QVBoxLayout *vLayout = new QVBoxLayout(frame) ;
    for ( int i = 0 ; i < reports->count() ; i++ )
    {
        Report *r = reports->at( i ) ;
        QLayout *layout = NULL ;
        switch ( r->getReportType() )
        {
            case Report::CTXT : layout = getReportOutputTXT( r, frame ) ; break ;
            case Report::CGUI : layout = getReportOutputGUI( r, frame ) ; break ;
            case Report::CIMG : layout = getCRLayoutIMG( (CR_Image*) r , frame ) ; break ;
            case Report::CSEL : layout = getCRLayoutSEL( (CR_Select*) r, frame, true ) ; break ;
            case Report::CPLOT : layout = getCRLayoutPLOT( (CR_FunctionIterator*) r , frame ) ; break ;
        }
        vLayout->addLayout( layout ) ;
    }
    QPushButton *okButton = new QPushButton( tr("Ok") , frame ) ;
    vLayout->addWidget( okButton ) ;
    QObject::connect( okButton,
                      SIGNAL( clicked()) ,
                      this, SLOT( acceptReports() ) ) ;
    QPushButton *printButton = new QPushButton( tr("Print...") , frame ) ;
    vLayout->addWidget( printButton ) ;
    QObject::connect( printButton,
                      SIGNAL( clicked()) ,
                      this, SLOT( print() ) ) ;
    QScrollArea *scrollArea = new QScrollArea ;
    scrollArea->setWidget( frame ) ;
    ui->splitter->addWidget( scrollArea ) ;
    this->currentStep = emisor ;
}

QLayout *MainWindow::getReportOutputTXT( Report* report, QFrame *frame )
{
    ReportTXT *r = (ReportTXT*) report ;
    QLabel *label = new QLabel( tr( r->getLabel().toAscii().data() ), frame ) ;
    QLineEdit *lineEdit = new QLineEdit(frame) ;
    // Representar con 4 digitos o usar notacion exponencial:
    lineEdit->setText( QString("%1").arg( r->getValue() , 0 , 'g' , 4 ) ) ;
    lineEdit->setReadOnly( true ) ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    layout->addWidget ( label ) ;
    layout->addWidget ( lineEdit ) ;
    return ( layout ) ;
}

QLayout *MainWindow::getReportOutputGUI( Report* report, QFrame *frame )
{
    ReportGUI *r = (ReportGUI*) report ;
    QLabel *label = new QLabel( tr( r->getLabel().toAscii().data() ), frame ) ;
    QwtThermo *thermo = new  QwtThermo( frame ) ;
    thermo->setOrientation ( Qt::Horizontal , QwtThermo::BottomScale ) ;
    thermo->setRange( r->getRange()->getFirst(), r->getRange()->getLast() ) ;
    thermo->setValue( r->getValue() ) ;
    QLabel *num = new QLabel( frame ) ;
    num->setNum( r->getValue() ) ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    layout->addWidget ( label ) ;
    layout->addWidget ( thermo ) ;
    layout->addWidget ( num ) ;
    return ( layout ) ;
}

QLayout* MainWindow::getCRLayoutIMG( CR_Image* img, QFrame *frame )
{
    QLabel *label = new QLabel( tr( img->getLabel().toAscii().data() ), frame ) ;
    QLabel *pix = new QLabel( frame ) ;
    QPixmap p ;
    if ( ! p.load( img->getSource() ) )
    {
        QMessageBox::critical ( this, tr("Invalid Image"),
                QString( tr("Invalid Image file: %1") ).arg(img->getSource())
                ) ;
    }
    // For now... it's only a fixed restriction, to ensure you can view it...
    if ( p.width() > 800 || p.height() > 600 )
        p = p.scaled(800,600,Qt::KeepAspectRatio) ;
    pix->setPixmap( p ) ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    layout->addWidget ( label ) ;
    layout->addWidget ( pix ) ;
    inputs.append( pix ) ;
    return ( layout ) ;
}

QLayout* MainWindow::getCRLayoutSEL( CR_Select* sel, QFrame *frame, bool readOnly )
{
    QLabel *label = new QLabel( sel->getLabel() , frame ) ;
    QComboBox *cb = new QComboBox( frame ) ;
    cb->setEditable( false ) ;
    cb->addItems ( *sel->getOptions() ) ;
    cb->setCurrentIndex( sel->getValue() ) ;
    cb->setEnabled( ! readOnly ) ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    layout->addWidget ( label ) ;
    layout->addWidget ( cb ) ;
    inputs.append( cb ) ;
    return ( layout ) ;
}

#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_zoomer.h>
//#include <qwt_plot_magnifier.h>
//#include <qwt_plot_panner.h>
QLayout* MainWindow::getCRLayoutPLOT( CR_FunctionIterator* fi, QFrame *frame )
{
    QwtDataHPlot2D* data = new QwtDataHPlot2D( fi->getIterator() , frame ) ;
    QwtPlot *plot = new QwtPlot(tr( fi->getLabel().toAscii().data() ), frame ) ;
    //QwtPlot *plot = new QwtPlot( ) ;
    QwtPlotCurve *curve = new QwtPlotCurve("Curve 1") ;
    //curve->setRenderHint(QwtPlotItem::RenderAntialiased) ; // Very Slow on zooming :(
    curve->setPen(QPen(Qt::blue)) ; // A colour, to make it a bit beautiful
    curve->setData( *data ) ;
    curve->attach( plot ) ;
    QwtPlotZoomer *zoomer = new QwtPlotZoomer( plot->canvas() ) ;
    //QwtPlotMagnifier *magnifier = new QwtPlotMagnifier( plot->canvas() ) ;
    //QwtPlotPanner *panner = new QwtPlotPanner( plot->canvas() ) ;
    plot->replot() ;
    QHBoxLayout *layout = new QHBoxLayout() ;
    //QLabel *label = new QLabel( tr( fi->getLabel().toAscii().data() ), frame ) ;
    //layout->addWidget ( label ) ;
    layout->addWidget ( plot ) ;
    inputs.append( plot ) ; // nothing to do here ;)
    return ( layout ) ;
}

void MainWindow::acceptReports ()
{
    currentStep->wakeUp();
    currentStep = NULL ;
    if ( ui->splitter->widget( 1 ) ) delete ui->splitter->widget( 1 ) ;
}

void MainWindow::executeStep ( QListWidgetItem *item )
{
    if ( this->currentStep != NULL )
        return ;
    QString name = item->text() ;
    /* Este slot se conecta al widget stepList (doble-click) */
    if ( Step* s = core->getCurrentEnviroment()->getStep( name ) ) {
        //printf ("Ejecutando Step:%s\n",name.toAscii().data() ) ;
        s->start() ;
    } else {
        printf ("Step not found:%s\n",name.toAscii().data() ) ;
    }
    fflush( stdout );
}

void MainWindow::showMessage ( QString msg , int severity )
{
    if ( severity == 2 )
        QMessageBox::critical ( this, tr("Critical Error !"), msg ) ;
}


#include <QFileDialog>
void MainWindow::loadFile ()
{
    QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "" ) ;
    if ( ! fileName.isNull() ) // User was pressed "Cancel" button ?
    {
        this->clear () ;
        core->loadFile( fileName ) ;
    }
}

#include <QPrinter>
#include <QPrintDialog>
#include <QPainter>
void MainWindow::print ()
{
    if ( ui->splitter->widget( 1 ) ==  NULL ) return ;
    QWidget *wg = ((QScrollArea*)ui->splitter->widget( 1 ))->widget() ;
    QPrinter *printer = new QPrinter;
    QPrintDialog *printDialog = new QPrintDialog(printer, this);
    if (printDialog->exec() == QDialog::Accepted) {
        QPainter p(printer);
        QPixmap pm = QPixmap::grabWidget(wg);
        p.drawPixmap(0, 0, pm);
    }
}

void MainWindow::on_action_Load_triggered()
{
    this->loadFile() ;
}

void MainWindow::on_actionAbout_triggered()
{
    QMessageBox::about ( this, tr("About Hormiga"),
         QString("Hormiga Core %1\n%2\n%3")
                        .arg(core->getVersion())
                        .arg(core->getURL())
                        .arg(core->getLicense())) ;
}

#include <QDesktopServices>
#include <QUrl>
void MainWindow::on_action_Home_Page_triggered()
{
    QDesktopServices::openUrl ( QUrl( core->getURL() ) ) ;
}

void MainWindow::on_actionAbout_Qt_triggered()
{
    QMessageBox::aboutQt( this, tr("About Qt") ) ;
}