datastreamswidget.cpp

/********************************************************************************
 *  FARSA DataStreamsWidget UI                                                  *
 *  Copyright (C) 2012-2013                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program 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 this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#include "datastreamswidget.h"
#include <QBoxLayout>
#include <QCheckBox>
#include <QPushButton>
#include <QFrame>
#include <QLabel>
#include <QMutexLocker>
#include <QProgressDialog>

namespace farsa {

DataStreamsWidget::DataStreamsWidget( QWidget* parent ) :
    QWidget(parent),
    mutex( QMutex::Recursive ) {

    QVBoxLayout* lay = new QVBoxLayout( this );
    
    // top toolbar
    QHBoxLayout* toolLay = new QHBoxLayout();
    lay->addLayout( toolLay );
    // regular automatic replot checkbox
    QCheckBox* ck = new QCheckBox( "Automatic Update", this );
    toolLay->addWidget( ck );
    ck->setChecked( true );
    connect( ck, SIGNAL(toggled(bool)), this, SLOT(enableAutomaticUpdates(bool)) );
    QPushButton* bt = new QPushButton( "Update Plots", this );
    toolLay->addWidget( bt );
    bt->setEnabled( false );
    bt->setAutoRepeat( true );
    bt->setAutoRepeatDelay( 100 );
    connect( bt, SIGNAL(clicked()), this, SLOT(updatePlots()) );
    connect( ck, SIGNAL(toggled(bool)), bt, SLOT(setDisabled(bool)) );
    bt = new QPushButton( "Dequeue All Data", this );
    toolLay->addWidget( bt );
    connect( bt, SIGNAL(clicked()), this, SLOT(dequeueAllData()) );

    // update the plot at regular intervals
    replotTimer.setInterval( 20 );
    replotTimer.setSingleShot( false );
    replotTimer.start();
    connect( &replotTimer, SIGNAL(timeout()), this, SLOT(updatePlots()) );
}

DataStreamsWidget::~DataStreamsWidget() {
    /* nothing to do */
}

int DataStreamsWidget::addPlot( QString name ) {
    QMutexLocker locker( &mutex );

    QFrame* frame = new QFrame(this);
    frame->setFrameStyle( QFrame::StyledPanel | QFrame::Plain );
    QHBoxLayout* frameLay = new QHBoxLayout( frame );
    QLabel* lb = new QLabel( name+"\nNo Data", frame );
    frameLay->addWidget( lb );
    DataStreamPlot* plot = new DataStreamPlot( frame );
    plot->setMinimumSize( QSize(100,80) );
    plot->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Ignored ) );
    frameLay->addWidget( plot );
    layout()->addWidget( frame );
    plots.append( plot );
    plotNames.append( name );
    plotInfos.append( lb );
    queuedValues.append( QQueue< QVector<float> >() );
    return (plots.size()-1);
}

DataStreamPlot* DataStreamsWidget::getPlot( int plotID ) {
    QMutexLocker locker( &mutex );
    return plots[plotID];
}

int DataStreamsWidget::getNumPlots() {
    QMutexLocker locker( &mutex );
    return plots.size();
}

void DataStreamsWidget::appendDatas( int plotID, QVector<float> values ) {
    QMutexLocker locker( &mutex );
    queuedValues[plotID].enqueue( values );
}

void DataStreamsWidget::updatePlots() {
    QMutexLocker locker( &mutex );
    for( int p=0; p<plots.size(); p++ ) {
        DataStreamPlot* plot = plots[p];
        if ( !queuedValues[p].isEmpty() ) {
            // consume one element of the queuedValues
            QVector<float> values = queuedValues[p].dequeue();
            for( int i=0; i<values.size(); i++ ) {
                plot->appendData( i, values[i] );
            }
        }
        plot->updatePlot();
        plotInfos[p]->setText( QString("%1\n%2 Queued Data")
                                .arg(plotNames[p])
                                .arg(queuedValues[p].size()) );
    }
}

void DataStreamsWidget::enableAutomaticUpdates( bool enable ) {
    if ( enable ) {
        replotTimer.start();
    } else {
        replotTimer.stop();
    }
}

void DataStreamsWidget::dequeueAllData() {
    QMutexLocker locker( &mutex );
    // this operation can take long time
    QProgressDialog progress( "Dequeuing All Pending Data...", "Stop", 0, plots.size(), this );
    
    for( int p=0; p<plots.size(); p++ ) {
        QQueue< QVector<float> > queue = queuedValues[p];
        while( !queue.isEmpty() ) {
            QVector<float> values = queue.dequeue();
            for( int i=0; i<values.size(); i++ ) {
                plots[p]->appendData( i, values[i] );
            }
        }
        progress.setValue(p);
    }
    progress.setValue(plots.size());
}

} // end namespace farsa