qwt_thermo.cpp

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/

#include <qpainter.h>
#include <qevent.h>
#include <qstyle.h>
#include <qpixmap.h>
#include <qdrawutil.h>
#include "qwt_math.h"
#include "qwt_scale_engine.h"
#include "qwt_scale_draw.h"
#include "qwt_scale_map.h"
#include "qwt_paint_buffer.h"
#include "qwt_thermo.h"

class QwtThermo::PrivateData
{
public:
    PrivateData():
        fillBrush(Qt::black),
        alarmBrush(Qt::white),
        orientation(Qt::Vertical),
        scalePos(QwtThermo::LeftScale),
        borderWidth(2),
        scaleDist(3),
        thermoWidth(10),
        minValue(0.0),
        maxValue(1.0),
        value(0.0),
        alarmLevel(0.0),
        alarmEnabled(false)
    {
        map.setScaleInterval(minValue, maxValue);
    }

    QwtScaleMap map;
    QRect thermoRect;
    QBrush fillBrush;
    QBrush alarmBrush;

    Qt::Orientation orientation;
    ScalePos scalePos;
    int borderWidth;
    int scaleDist;
    int thermoWidth;

    double minValue;
    double maxValue;
    double value;
    double alarmLevel;
    bool alarmEnabled;
};

QwtThermo::QwtThermo(QWidget *parent): 
    QWidget(parent)
{
    initThermo();
}

#if QT_VERSION < 0x040000

QwtThermo::QwtThermo(QWidget *parent, const char *name): 
    QWidget(parent, name)
{
    initThermo();
}
#endif

void QwtThermo::initThermo()
{
#if QT_VERSION < 0x040000
    setWFlags(Qt::WNoAutoErase);
#endif
    d_data = new PrivateData;
    setRange(d_data->minValue, d_data->maxValue, false);

    QSizePolicy policy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
    if (d_data->orientation == Qt::Vertical) 
        policy.transpose();

    setSizePolicy(policy);
    
#if QT_VERSION >= 0x040000
    setAttribute(Qt::WA_WState_OwnSizePolicy, false);
#else
    clearWState( WState_OwnSizePolicy );
#endif
}

QwtThermo::~QwtThermo()
{
    delete d_data;
}

void QwtThermo::setMaxValue(double v) 
{ 
    setRange(d_data->minValue, v); 
}

double QwtThermo::maxValue() const 
{ 
    return d_data->maxValue; 
}

void QwtThermo::setMinValue(double v) 
{ 
    setRange(v, d_data->maxValue); 
}

double QwtThermo::minValue() const 
{ 
    return d_data->minValue; 
}

void QwtThermo::setValue(double v)
{
    if (d_data->value != v)
    {
        d_data->value = v;
        update();
    }
}

double QwtThermo::value() const 
{ 
    return d_data->value; 
}

void QwtThermo::setScaleDraw(QwtScaleDraw *scaleDraw)
{
    setAbstractScaleDraw(scaleDraw);
}

const QwtScaleDraw *QwtThermo::scaleDraw() const
{
    return (QwtScaleDraw *)abstractScaleDraw();
}

QwtScaleDraw *QwtThermo::scaleDraw() 
{
    return (QwtScaleDraw *)abstractScaleDraw();
}

void QwtThermo::paintEvent(QPaintEvent *e)
{
    // Use double-buffering
    const QRect &ur = e->rect();
    if ( ur.isValid() )
    {
#if QT_VERSION < 0x040000
        QwtPaintBuffer paintBuffer(this, ur);
        draw(paintBuffer.painter(), ur);
#else
        QPainter painter(this);
        draw(&painter, ur);
#endif
    }
}

void QwtThermo::draw(QPainter *p, const QRect& ur)
{
    if ( !d_data->thermoRect.contains(ur) )
    {
        if (d_data->scalePos != NoScale)
        {
#if QT_VERSION < 0x040000
            scaleDraw()->draw(p, colorGroup());
#else
            scaleDraw()->draw(p, palette());
#endif
        }

        qDrawShadePanel(p,
            d_data->thermoRect.x() - d_data->borderWidth,
            d_data->thermoRect.y() - d_data->borderWidth,
            d_data->thermoRect.width() + 2*d_data->borderWidth,
            d_data->thermoRect.height() + 2*d_data->borderWidth,
#if QT_VERSION < 0x040000
            colorGroup(), 
#else
            palette(), 
#endif
            true, d_data->borderWidth,0);
    }
    drawThermo(p);
}

void QwtThermo::resizeEvent(QResizeEvent *)
{
    layoutThermo( false );
}

void QwtThermo::layoutThermo( bool update_geometry )
{
    QRect r = rect();
    int mbd = 0;
    if ( d_data->scalePos != NoScale )
    {
        int d1, d2;
        scaleDraw()->getBorderDistHint(font(), d1, d2);
        mbd = qwtMax(d1, d2);
    }

    if ( d_data->orientation == Qt::Horizontal )
    {
        switch ( d_data->scalePos )
        {
            case TopScale:
            {
                d_data->thermoRect.setRect(
                    r.x() + mbd + d_data->borderWidth,
                    r.y() + r.height()
                    - d_data->thermoWidth - 2*d_data->borderWidth,
                    r.width() - 2*(d_data->borderWidth + mbd),
                    d_data->thermoWidth);
                scaleDraw()->setAlignment(QwtScaleDraw::TopScale);
                scaleDraw()->move( d_data->thermoRect.x(),
                    d_data->thermoRect.y() - d_data->borderWidth 
                        - d_data->scaleDist);
                scaleDraw()->setLength(d_data->thermoRect.width());
                break;
            }

            case BottomScale:
            case NoScale: // like Bottom but without scale
            default:   // inconsistent orientation and scale position
                       // Mapping between values and pixels requires
                       // initialization of the scale geometry
            {
                d_data->thermoRect.setRect(
                    r.x() + mbd + d_data->borderWidth,
                    r.y() + d_data->borderWidth,
                    r.width() - 2*(d_data->borderWidth + mbd),
                    d_data->thermoWidth);
                scaleDraw()->setAlignment(QwtScaleDraw::BottomScale);
                scaleDraw()->move(
                    d_data->thermoRect.x(),
                    d_data->thermoRect.y() + d_data->thermoRect.height()
                        + d_data->borderWidth + d_data->scaleDist );
                scaleDraw()->setLength(d_data->thermoRect.width());
                break;
            }
        }
        d_data->map.setPaintInterval(d_data->thermoRect.x(),
            d_data->thermoRect.x() + d_data->thermoRect.width() - 1);
    }
    else // Qt::Vertical
    {
        switch ( d_data->scalePos )
        {
            case RightScale:
            {
                d_data->thermoRect.setRect(
                    r.x() + d_data->borderWidth,
                    r.y() + mbd + d_data->borderWidth,
                    d_data->thermoWidth,
                    r.height() - 2*(d_data->borderWidth + mbd));
                scaleDraw()->setAlignment(QwtScaleDraw::RightScale);
                scaleDraw()->move(
                    d_data->thermoRect.x() + d_data->thermoRect.width()
                        + d_data->borderWidth + d_data->scaleDist,
                    d_data->thermoRect.y());
                scaleDraw()->setLength(d_data->thermoRect.height());
                break;
            }

            case LeftScale:
            case NoScale: // like Left but without scale
            default:   // inconsistent orientation and scale position
                       // Mapping between values and pixels requires
                       // initialization of the scale geometry
            {
                d_data->thermoRect.setRect(
                    r.x() + r.width() - 2*d_data->borderWidth - d_data->thermoWidth,
                    r.y() + mbd + d_data->borderWidth,
                    d_data->thermoWidth,
                    r.height() - 2*(d_data->borderWidth + mbd));
                scaleDraw()->setAlignment(QwtScaleDraw::LeftScale);
                scaleDraw()->move(
                    d_data->thermoRect.x() - d_data->scaleDist 
                        - d_data->borderWidth,
                    d_data->thermoRect.y() );
                scaleDraw()->setLength(d_data->thermoRect.height());
                break;
            }
        }
        d_data->map.setPaintInterval(
            d_data->thermoRect.y() + d_data->thermoRect.height() - 1,
            d_data->thermoRect.y());
    }
    if ( update_geometry )
    {
        updateGeometry();
        update();
    }
}

void QwtThermo::setOrientation(Qt::Orientation o, ScalePos s)
{
    if ( o == d_data->orientation && s == d_data->scalePos )
        return;

    switch(o)
    {
        case Qt::Horizontal:
        {
            if ((s == NoScale) || (s == BottomScale) || (s == TopScale))
                d_data->scalePos = s;
            else
                d_data->scalePos = NoScale;
            break;
        }
        case Qt::Vertical:
        {
            if ((s == NoScale) || (s == LeftScale) || (s == RightScale))
                d_data->scalePos = s;
            else
                d_data->scalePos = NoScale;
            break;
        }
    }

    if ( o != d_data->orientation )
    {
#if QT_VERSION >= 0x040000
        if ( !testAttribute(Qt::WA_WState_OwnSizePolicy) )
#else
        if ( !testWState( WState_OwnSizePolicy ) )
#endif
        {
            QSizePolicy sp = sizePolicy();
            sp.transpose();
            setSizePolicy(sp);

#if QT_VERSION >= 0x040000
            setAttribute(Qt::WA_WState_OwnSizePolicy, false);
#else
            clearWState( WState_OwnSizePolicy );
#endif
        }
    }

    d_data->orientation = o;
    layoutThermo();
}

void QwtThermo::setScalePosition(ScalePos s)
{
    if ((s == BottomScale) || (s == TopScale))
        setOrientation(Qt::Horizontal, s);
    else if ((s == LeftScale) || (s == RightScale))
        setOrientation(Qt::Vertical, s);
    else
        setOrientation(d_data->orientation, NoScale);
}

QwtThermo::ScalePos QwtThermo::scalePosition() const
{
    return d_data->scalePos;
}

void QwtThermo::fontChange(const QFont &f)
{
    QWidget::fontChange( f );
    layoutThermo();
}

void QwtThermo::scaleChange()
{
    update();
    layoutThermo();
}

void QwtThermo::drawThermo(QPainter *p)
{
    int alarm  = 0, taval = 0;

    QRect fRect;
    QRect aRect;
    QRect bRect;

    int inverted = ( d_data->maxValue < d_data->minValue );

    //
    //  Determine if value exceeds alarm threshold.
    //  Note: The alarm value is allowed to lie
    //        outside the interval (minValue, maxValue).
    //
    if (d_data->alarmEnabled)
    {
        if (inverted)
        {
            alarm = ((d_data->alarmLevel >= d_data->maxValue)
                 && (d_data->alarmLevel <= d_data->minValue)
                 && (d_data->value >= d_data->alarmLevel));
        
        }
        else
        {
            alarm = (( d_data->alarmLevel >= d_data->minValue)
                 && (d_data->alarmLevel <= d_data->maxValue)
                 && (d_data->value >= d_data->alarmLevel));
        }
    }

    //
    //  transform values
    //
    int tval = transform(d_data->value);

    if (alarm)
       taval = transform(d_data->alarmLevel);

    //
    //  calculate recangles
    //
    if ( d_data->orientation == Qt::Horizontal )
    {
        if (inverted)
        {
            bRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
                  tval - d_data->thermoRect.x(),
                  d_data->thermoRect.height());
        
            if (alarm)
            {
                aRect.setRect(tval, d_data->thermoRect.y(),
                      taval - tval + 1,
                      d_data->thermoRect.height());
                fRect.setRect(taval + 1, d_data->thermoRect.y(),
                      d_data->thermoRect.x() + d_data->thermoRect.width() - (taval + 1),
                      d_data->thermoRect.height());
            }
            else
            {
                fRect.setRect(tval, d_data->thermoRect.y(),
                      d_data->thermoRect.x() + d_data->thermoRect.width() - tval,
                      d_data->thermoRect.height());
            }
        }
        else
        {
            bRect.setRect(tval + 1, d_data->thermoRect.y(),
                  d_data->thermoRect.width() - (tval + 1 - d_data->thermoRect.x()),
                  d_data->thermoRect.height());
        
            if (alarm)
            {
                aRect.setRect(taval, d_data->thermoRect.y(),
                      tval - taval + 1,
                      d_data->thermoRect.height());
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
                      taval - d_data->thermoRect.x(),
                      d_data->thermoRect.height());
            }
            else
            {
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
                      tval - d_data->thermoRect.x() + 1,
                      d_data->thermoRect.height());
            }
        
        }
    }
    else // Qt::Vertical
    {
        if (tval < d_data->thermoRect.y())
            tval = d_data->thermoRect.y();
        else 
        {
            if (tval > d_data->thermoRect.y() + d_data->thermoRect.height())
                tval = d_data->thermoRect.y() + d_data->thermoRect.height();
        }

        if (inverted)
        {
            bRect.setRect(d_data->thermoRect.x(), tval + 1,
            d_data->thermoRect.width(),
            d_data->thermoRect.height() - (tval + 1 - d_data->thermoRect.y()));

            if (alarm)
            {
                aRect.setRect(d_data->thermoRect.x(), taval,
                    d_data->thermoRect.width(),
                    tval - taval + 1);
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
                    d_data->thermoRect.width(),
                taval - d_data->thermoRect.y());
            }
            else
            {
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
                    d_data->thermoRect.width(),
                    tval - d_data->thermoRect.y() + 1);
            }
        }
        else
        {
            bRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
            d_data->thermoRect.width(),
            tval - d_data->thermoRect.y());
            if (alarm)
            {
                aRect.setRect(d_data->thermoRect.x(),tval,
                    d_data->thermoRect.width(),
                    taval - tval + 1);
                fRect.setRect(d_data->thermoRect.x(),taval + 1,
                    d_data->thermoRect.width(),
                    d_data->thermoRect.y() + d_data->thermoRect.height() - (taval + 1));
            }
            else
            {
                fRect.setRect(d_data->thermoRect.x(),tval,
                    d_data->thermoRect.width(),
                d_data->thermoRect.y() + d_data->thermoRect.height() - tval);
            }
        }
    }

    //
    // paint thermometer
    //
    const QColor bgColor =
#if QT_VERSION < 0x040000
        colorGroup().color(QColorGroup::Background);
#else
        palette().color(QPalette::Background);
#endif
    p->fillRect(bRect, bgColor);

    if (alarm)
       p->fillRect(aRect, d_data->alarmBrush);

    p->fillRect(fRect, d_data->fillBrush);
}

void QwtThermo::setBorderWidth(int w)
{
    if ((w >= 0) && (w < (qwtMin(d_data->thermoRect.width(), 
        d_data->thermoRect.height()) + d_data->borderWidth) / 2  - 1))
    {
        d_data->borderWidth = w;
        layoutThermo();
    }
}

int QwtThermo::borderWidth() const
{
    return d_data->borderWidth;
}

void QwtThermo::setRange(double vmin, double vmax, bool logarithmic)
{
    d_data->minValue = vmin;
    d_data->maxValue = vmax;

    if ( logarithmic )
        setScaleEngine(new QwtLog10ScaleEngine);
    else
        setScaleEngine(new QwtLinearScaleEngine);

    /*
      There are two different maps, one for the scale, the other
      for the values. This is confusing and will be changed
      in the future. TODO ...
     */

    d_data->map.setTransformation(scaleEngine()->transformation());
    d_data->map.setScaleInterval(d_data->minValue, d_data->maxValue);

    if (autoScale())
        rescale(d_data->minValue, d_data->maxValue);

    layoutThermo();
}

void QwtThermo::setFillBrush(const QBrush& brush)
{
    d_data->fillBrush = brush;
    update();
}

const QBrush& QwtThermo::fillBrush() const
{
    return d_data->fillBrush;
}

void QwtThermo::setFillColor(const QColor &c)
{
    d_data->fillBrush.setColor(c);
    update();
}

const QColor &QwtThermo::fillColor() const
{
    return d_data->fillBrush.color();
}

void QwtThermo::setAlarmBrush(const QBrush& brush)
{
    d_data->alarmBrush = brush;
    update();
}

const QBrush& QwtThermo::alarmBrush() const
{
    return d_data->alarmBrush;
}

void QwtThermo::setAlarmColor(const QColor &c)
{
    d_data->alarmBrush.setColor(c);
    update();
}

const QColor &QwtThermo::alarmColor() const
{
    return d_data->alarmBrush.color();
}

void QwtThermo::setAlarmLevel(double v)
{
    d_data->alarmLevel = v;
    d_data->alarmEnabled = 1;
    update();
}

double QwtThermo::alarmLevel() const
{
    return d_data->alarmLevel;
}

void QwtThermo::setPipeWidth(int w)
{
    if (w > 0)
    {
        d_data->thermoWidth = w;
        layoutThermo();
    }
}

int QwtThermo::pipeWidth() const
{
    return d_data->thermoWidth;
}


void QwtThermo::setMargin(int)
{
}


void QwtThermo::setAlarmEnabled(bool tf)
{
    d_data->alarmEnabled = tf;
    update();
}

bool QwtThermo::alarmEnabled() const
{
    return d_data->alarmEnabled;
}

QSize QwtThermo::sizeHint() const
{
    return minimumSizeHint();
}

QSize QwtThermo::minimumSizeHint() const
{
    int w = 0, h = 0;

    if ( d_data->scalePos != NoScale )
    {
        const int sdExtent = scaleDraw()->extent( QPen(), font() );
        const int sdLength = scaleDraw()->minLength( QPen(), font() );

        w = sdLength;
        h = d_data->thermoWidth + sdExtent + 
            d_data->borderWidth + d_data->scaleDist;

    }
    else // no scale
    {
        w = 200;
        h = d_data->thermoWidth;
    }

    if ( d_data->orientation == Qt::Vertical )
        qSwap(w, h);

    w += 2 * d_data->borderWidth;
    h += 2 * d_data->borderWidth;

    return QSize( w, h );
}

int QwtThermo::transform(double value) const
{
    const double min = qwtMin(d_data->map.s1(), d_data->map.s2());
    const double max = qwtMax(d_data->map.s1(), d_data->map.s2());

    if ( value > max )
        value = max;
    if ( value < min )
        value = min;

    return d_data->map.transform(value);
}

---