meters/graph.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2003 by Hans Karlsson                                   *
 *   karlsson.h@home.se                                                      *
 *                                                                         *
 *   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.                                   *
 ***************************************************************************/

#include "graph.h"

Graph::Graph(Karamba* k, int x, int y, int w, int h, int nbrPts):
        Meter(k, x, y, w, h), lastValue(0)
{
    nbrPoints = (nbrPts == 0) ? 50 : nbrPts;

    m_minValue = 0;
    m_maxValue = 100;

    fill = false;
    fillColor = m_color;
    scrollDir = SCROLL_RIGHT;
    plotDir = PLOT_UP;
    //prime m_values with a size of nbrPoints and filled with 0's
    m_values.resize(nbrPoints);
    m_values.fill(0);
}

Graph::~Graph()
{}

QColor Graph::getFillColor() const
{
    return fillColor;
}
void Graph::setFillColor(QColor c)
{
    fillColor = c;
    fill = true;
    update();
}

void Graph::shouldFill(bool b)
{
    if (fill != b) {
      fill = b;
      update();
    }
}

bool Graph::shouldFill() const
{
    return fill;
}

int Graph::getValue() const
{
    return lastValue;
}

void Graph::setValue(int v)
{
    //keep lastValue between the bounds
    if (v > m_maxValue) {
        lastValue = m_maxValue;
    } else if (v < m_minValue) {
        lastValue = m_minValue;
    } else {
        lastValue = v;
    }
    m_values.prepend(lastValue);
    if (m_values.count() > nbrPoints) {
        m_values.erase(m_values.end() - 1);
    }
    update();
}

void Graph::setValue(const QString &v)
{
    double d = v.toDouble();
    if (d > 0) {
        d += 0.5;
    } else if (d < 0) {
        d -= 0.5;
    }
    setValue((int)d);
}

void Graph::setScrollDirection(const QString& dir)
{
    if (!dir.isEmpty() && dir.toLower() == "left")
        scrollDir = SCROLL_LEFT;
    else
        scrollDir = SCROLL_RIGHT;
}

QString Graph::getScrollDirection() const
{
    if (scrollDir == SCROLL_LEFT)
        return "LEFT";
    return "RIGHT";
}

void Graph::setPlotDirection(const QString& dir)
{
    if (!dir.isEmpty() && dir.toLower() == "down")
        plotDir = PLOT_DOWN;
    else
        plotDir = PLOT_UP;
}
QString Graph::getPlotDirection() const
{
    if (plotDir == PLOT_DOWN)
        return "DOWN";
    return "UP";
}

void Graph::paint(QPainter *p, const QStyleOptionGraphicsItem *option,
                  QWidget *widget)
{
    Q_UNUSED(option);
    Q_UNUSED(widget);

    if (m_hidden)
        return;

    //might want to fudge the width and height by -1 here
    int width = getWidth();
    int height = getHeight();

    int top = 0;
    int bottom = height;

    if (plotDir == PLOT_DOWN) {
        bottom = 0;
        top = height;
    }

    int n = nbrPoints - 1;

    qreal h_step = ((qreal) width) / n;
    qreal v_step = ((qreal) height * plotDir) / (m_maxValue - m_minValue) * -1; //neg one shows up here to make subtracting from h (bottom) easier later, can just add the two and not worry about order

    QPolygonF polygon;

    for (int k = 0; k <= n;k++) {
        int i = k;
        if (scrollDir == SCROLL_RIGHT) {
            i = n - k;
        }
        qreal raw = m_values.at(i);
        qreal v;
        //some quick shortcuts for edge cases
        if (raw <= m_minValue)
            v = bottom;
        else if (raw >= m_maxValue)
            v = top;
        else
            v = ((raw - m_minValue) * v_step) + bottom; // since the coordinate system is one with 0 at the top and h at the bottom for the default case

        polygon << QPointF(h_step * k, v);
    }

    p->setRenderHint(QPainter::Antialiasing);
    p->setRenderHint(QPainter::SmoothPixmapTransform);
    if (fill) {
        //compute the 0 boundary for the baseline
        qreal baseline = ((-m_minValue) * v_step) + bottom;
        //add "edges" from the baseline to the first and last points of graph
        polygon.insert(0, QPointF(polygon.first().x(), baseline));
        polygon.insert(polygon.end(), QPointF(polygon.last().x(), baseline));

        p->save();
        QBrush tpBrush(fillColor);
        p->setPen(Qt::NoPen);
        p->setBrush(tpBrush);
        p->drawPolygon(polygon);
        p->restore();
        //erase our edges allowing the reuse of this exact polygon
        polygon.erase(polygon.begin());
        polygon.erase(polygon.end() - 1);
    }
    p->setPen(m_color);
    p->drawPolyline(polygon);
}

#include "graph.moc"