simpleplot.cpp

/******************************************************************************
*
*   This file is part of Cardio Curves.
*   Copyright (C) 2009 Jan Gunnar Andreassen
*   Copyright (C) 2009 Lars Magne Engedal
*
*   Cardio Curves is free software: you can redistribute it and/or modify
*   it under the terms of the GNU Lesser General Public License as published
*   by the Free Software Foundation, either version 2.1 of the License, or
*   (at your option) any later version.
*
*   Cardio Cruves 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 Lesser General Public License for more details.
*
*   You should have received a copy of the GNU Lesser General Public License
*   along with Cardio Curves.  If not, see <http://www.gnu.org/licenses/>.
*
*   Developer contact:
*       (janislazzaroni at users.sourceforge.net)
*       (engedal at users.sourceforge.net )
******************************************************************************/

#include <QtDebug>
#include <QPainter>
#include <QMouseEvent>
#include <QPoint>
#include <QDateTime>

#include <qwt_scale_map.h>
#include <qwt_plot_curve.h>
#include <qwt_symbol.h>

#include "datahandler.h"
#include "simpleplot.h"

SimplePlot::SimplePlot(int linesize,
    QPointF lineAxis,
    const QDateTime &startstamp,
    QWidget *parent)
        : QWidget(parent)
{
    d_valid = false;
    samplesprCurve = linesize;

    xMap = new QwtScaleMap;
    yMap = new QwtScaleMap;
    d_lineaxisbounds = lineAxis;

    setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
    setFocusPolicy(Qt::StrongFocus);
    setMouseTracking(true);

    d_deltax = d_deltay = 1;

    shadowRect.setLeft(0);
    shadowRect.setTop(0);
    setCursor(QCursor(Qt::BlankCursor));
    markerVisible = false;
    curvesStartTime = startstamp;
}

SimplePlot::~SimplePlot()
{
    delete xMap;
    delete yMap;
    qDeleteAll(curves);
    curves.clear();
}

void SimplePlot::initCurves(int curvecount)
{
    if (!d_valid)
    {
        curveCount = curvecount;
        createCurves();
    }
    else
    {
        if (curveCount != curvecount)
        {
            // flush and recreate
        }
    }
}

void SimplePlot::setData(const double *x,
    const QVector<QVector<double> > &vYData)
{
    if (d_valid)
    {
        for (int i = 0; i < vYData.size(); i++)
        {
            curves[i]->setRawData(x, vYData[i].constData(), samplesprCurve);
        }
        shadowRect.setLeft(0);
        shadowRect.setTop(0);
        update();
    }
}

void SimplePlot::createCurves()
{
    //from 0.0 to 30.0 seconds..
    xMap->setScaleInterval(0.0, 30.0);
    yMap->setScaleInterval(d_lineaxisbounds.x(), d_lineaxisbounds.y());

    QwtSymbol sym;

    sym.setPen(QColor(Qt::black));
    sym.setSize(5);

    QwtPlotCurve *c = NULL;

    for (int i = 0; i < curveCount; i++)
    {
        c = new QwtPlotCurve;
        c->setSymbol(sym);
        c->setStyle(QwtPlotCurve::Lines);

        curves.push_back(c);
    }
    d_valid = true;
}

void SimplePlot::drawContents(QPainter *painter)
{
    int deltay, i;

    QRect r = contentsRect();

    deltay = r.height() / curveCount - 1;

    d_deltay = deltay;
    d_deltax = (double)samplesprCurve / (double)r.width();

    markerRect.setWidth((int)(d_samplebounds.y() / d_deltax));
    markerRect.setHeight(d_deltay);
    shadowRect.setWidth(markerRect.width());
    shadowRect.setHeight(markerRect.height());

    r.setHeight(deltay);

    QDateTime temp = curvesStartTime;
    QString format("hh:mm:ss");

    painter->drawText(r, Qt::AlignHCenter, QString("CHANNEL 1"));
    for (i = 0; i < curveCount; i++)
    {
        painter->drawText(r,
            Qt::AlignLeft | Qt::AlignTop,
            temp.toString(format));

        if (curves[i]->dataSize() != 0)
        {
            xMap->setPaintInterval(r.left(), r.right());
            yMap->setPaintInterval(r.bottom(), r.top());

            curves[i]->draw(painter, *xMap, *yMap, r);

            shiftDown(r, deltay);
        }
        temp = temp.addSecs(DataHandler::secondsprLine);
    }
}

void SimplePlot::drawMarker(QPainter *painter)
{
    painter->setPen(palette().dark().color());
    painter->drawRect(markerRect);
}

void SimplePlot::drawShadow(QPainter *painter)
{
    painter->setPen(palette().background().color());
    painter->setBrush(Qt::DiagCrossPattern);
    painter->drawRect(shadowRect);
}

void SimplePlot::paintEvent(QPaintEvent *event)
{
    QWidget::paintEvent(event);

    if (d_valid)
    {
        QPainter painter(this);
        painter.setClipRect(contentsRect());
        drawContents(&painter);
        if (markerVisible)
        {
            drawMarker(&painter);
        }
        drawShadow(&painter);
    }
}

void SimplePlot::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton)
    {
        int segment = event->y() / d_deltay;
        segment = qBound(0, segment, curveCount - 1);
        int sample = (int)(event->x() * d_deltax);

        qDebug() << "Segment:" << segment << "Sample:" << sample;
        sample = qBound(0, sample, samplesprCurve - d_samplebounds.y() - 1);
        qDebug() << "qbound sample:" << sample;
        int xadjusted = (int)(sample / d_deltax);
        QRect r = contentsRect();
        shiftDown(r, d_deltay * segment);
        shadowRect.setLeft(xadjusted);
        shadowRect.setTop(r.top());
        emit valueClicked(segment, sample);
        update();
    }
}

void SimplePlot::mouseMoveEvent(QMouseEvent *event)
{
    QRect r = contentsRect();
    int segment = event->y() / d_deltay;
    segment = qBound(0, segment, curveCount - 1);
    shiftDown(r, d_deltay * segment);
    int sample = (int)(event->x() * d_deltax);
    sample = qBound(0, sample, samplesprCurve - d_samplebounds.y() - 1);
    int xadjusted = (int)(sample / d_deltax);
    markerRect.setLeft(xadjusted);
    markerRect.setTop(r.top());
    update();
}

void SimplePlot::enterEvent(QEvent *event)
{
    markerVisible = true;
    QWidget::enterEvent(event);
    update();
}

void SimplePlot::leaveEvent(QEvent *event)
{
    markerVisible = false;
    QWidget::leaveEvent(event);
    update();
}

---