qwt_plot.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>
#if QT_VERSION < 0x040000
#include <qguardedptr.h>
#include <qfocusdata.h>
#else
#include <qpointer.h>
#include <qpaintengine.h>
#endif
#include <qapplication.h>
#include <qevent.h>
#include "qwt_plot.h"
#include "qwt_plot_dict.h"
#include "qwt_plot_layout.h"
#include "qwt_rect.h"
#include "qwt_scale_widget.h"
#include "qwt_scale_engine.h"
#include "qwt_text_label.h"
#include "qwt_legend.h"
#include "qwt_dyngrid_layout.h"
#include "qwt_plot_canvas.h"
#include "qwt_paint_buffer.h"

class QwtPlot::PrivateData
{
public:
#if QT_VERSION < 0x040000
    QGuardedPtr<QwtTextLabel> lblTitle;
    QGuardedPtr<QwtPlotCanvas> canvas;
    QGuardedPtr<QwtLegend> legend;
#else
    QPointer<QwtTextLabel> lblTitle;
    QPointer<QwtPlotCanvas> canvas;
    QPointer<QwtLegend> legend;
#endif
    QwtPlotLayout *layout;

    bool autoReplot;
};

QwtPlot::QwtPlot(QWidget *parent):
    QFrame(parent)
{
    initPlot(QwtText());
}

QwtPlot::QwtPlot(const QwtText &title, QWidget *parent):
    QFrame(parent)
{
    initPlot(title);
}

#if QT_VERSION < 0x040000

QwtPlot::QwtPlot(QWidget *parent, const char *name):
    QFrame(parent, name)
{   
    initPlot(QwtText());
}   
#endif


QwtPlot::~QwtPlot()
{
    detachItems(QwtPlotItem::Rtti_PlotItem, autoDelete());

    delete d_data->layout;
    deleteAxesData();
    delete d_data;
}

void QwtPlot::initPlot(const QwtText &title)
{
    d_data = new PrivateData;

#if QT_VERSION < 0x040000
    setWFlags(Qt::WNoAutoErase);
#endif 

    d_data->layout = new QwtPlotLayout;

    d_data->autoReplot = false;

    d_data->lblTitle = new QwtTextLabel(title, this);
    d_data->lblTitle->setFont(QFont(fontInfo().family(), 14, QFont::Bold));

    QwtText text(title);
    int flags = Qt::AlignCenter;
#if QT_VERSION < 0x040000
    flags |= Qt::WordBreak | Qt::ExpandTabs;
#else
    flags |= Qt::TextWordWrap;
#endif
    text.setRenderFlags(flags);
    d_data->lblTitle->setText(text);

    d_data->legend = NULL;

    initAxesData();

    d_data->canvas = new QwtPlotCanvas(this);
    d_data->canvas->setFrameStyle(QFrame::Panel|QFrame::Sunken);
    d_data->canvas->setLineWidth(2);
    d_data->canvas->setMidLineWidth(0);

    updateTabOrder();

    setSizePolicy(QSizePolicy::MinimumExpanding, 
        QSizePolicy::MinimumExpanding);
}

bool QwtPlot::event(QEvent *e)
{
    bool ok = QFrame::event(e);
    switch(e->type())
    {
#if QT_VERSION < 0x040000
        case QEvent::LayoutHint:
#else
        case QEvent::LayoutRequest:
#endif
            updateLayout();
            break;
#if QT_VERSION >= 0x040000
        case QEvent::PolishRequest:
            polish();
            break;
#endif
        default:;
    }
    return ok;
}

void QwtPlot::autoRefresh()
{
    if (d_data->autoReplot)
        replot();
}

void QwtPlot::setAutoReplot(bool tf)
{
    d_data->autoReplot = tf;
}

bool QwtPlot::autoReplot() const
{
    return d_data->autoReplot; 
}

void QwtPlot::setTitle(const QString &t)
{
    if ( t != d_data->lblTitle->text().text() )
    {
        d_data->lblTitle->setText(t);
        updateLayout();
    }
}

void QwtPlot::setTitle(const QwtText &t)
{
    if ( t != d_data->lblTitle->text() )
    {
        d_data->lblTitle->setText(t);
        updateLayout();
    }
}

QwtText QwtPlot::title() const
{
    return d_data->lblTitle->text();
}

QwtPlotLayout *QwtPlot::plotLayout()
{
    return d_data->layout;
}

const QwtPlotLayout *QwtPlot::plotLayout() const
{
    return d_data->layout;
}

QwtTextLabel *QwtPlot::titleLabel()
{
    return d_data->lblTitle;
}

const QwtTextLabel *QwtPlot::titleLabel() const
{
    return d_data->lblTitle;
}

QwtLegend *QwtPlot::legend()
{ 
    return d_data->legend;
}   

const QwtLegend *QwtPlot::legend() const
{ 
    return d_data->legend;
}   


QwtPlotCanvas *QwtPlot::canvas()
{ 
    return d_data->canvas;
}   

const QwtPlotCanvas *QwtPlot::canvas() const
{ 
    return d_data->canvas;
}

void QwtPlot::polish()
{
    replot();

#if QT_VERSION < 0x040000
    QFrame::polish();
#endif
}

QSize QwtPlot::sizeHint() const
{
    int dw = 0;
    int dh = 0;
    for ( int axisId = 0; axisId < axisCnt; axisId++ )
    {
        if ( axisEnabled(axisId) )
        {   
            const int niceDist = 40;
            const QwtScaleWidget *scaleWidget = axisWidget(axisId);
            const QwtScaleDiv &scaleDiv = scaleWidget->scaleDraw()->scaleDiv();
            const int majCnt = scaleDiv.ticks(QwtScaleDiv::MajorTick).count();

            if ( axisId == yLeft || axisId == yRight )
            {
                int hDiff = (majCnt - 1) * niceDist 
                    - scaleWidget->minimumSizeHint().height();
                if ( hDiff > dh )
                    dh = hDiff;
            }
            else
            {
                int wDiff = (majCnt - 1) * niceDist 
                    - scaleWidget->minimumSizeHint().width();
                if ( wDiff > dw )
                    dw = wDiff;
            }
        }
    }
    return minimumSizeHint() + QSize(dw, dh);
}

QSize QwtPlot::minimumSizeHint() const
{
    QSize hint = d_data->layout->minimumSizeHint(this);
    hint += QSize(2 * frameWidth(), 2 * frameWidth());

    return hint;
}

void QwtPlot::resizeEvent(QResizeEvent *e)
{
    QFrame::resizeEvent(e);
    updateLayout();
}

void QwtPlot::replot()
{
    bool doAutoReplot = autoReplot();
    setAutoReplot(false);

    updateAxes();

    /*
      Maybe the layout needs to be updated, because of changed
      axes labels. We need to process them here before painting
      to avoid that scales and canvas get out of sync.
     */
#if QT_VERSION >= 0x040000
    QApplication::sendPostedEvents(this, QEvent::LayoutRequest);
#else
    QApplication::sendPostedEvents(this, QEvent::LayoutHint);
#endif

    QwtPlotCanvas &canvas = *d_data->canvas;

    canvas.invalidatePaintCache();

    /*
      In case of cached or packed painting the canvas
      is repainted completely and doesn't need to be erased.
     */
    const bool erase = 
        !canvas.testPaintAttribute(QwtPlotCanvas::PaintPacked) 
        && !canvas.testPaintAttribute(QwtPlotCanvas::PaintCached);

#if QT_VERSION >= 0x040000
    const bool noBackgroundMode = canvas.testAttribute(Qt::WA_NoBackground);
    if ( !erase && !noBackgroundMode )
        canvas.setAttribute(Qt::WA_NoBackground, true);

    canvas.repaint(canvas.contentsRect());

    if ( !erase && !noBackgroundMode )
        canvas.setAttribute(Qt::WA_NoBackground, false);
#else
    canvas.repaint(canvas.contentsRect(), erase);
#endif

    setAutoReplot(doAutoReplot);
}

void QwtPlot::updateLayout()
{
    d_data->layout->activate(this, contentsRect());

    //
    // resize and show the visible widgets
    //
    if (!d_data->lblTitle->text().isEmpty())
    {
        d_data->lblTitle->setGeometry(d_data->layout->titleRect());
        if (!d_data->lblTitle->isVisible())
            d_data->lblTitle->show();
    }
    else
        d_data->lblTitle->hide();

    for (int axisId = 0; axisId < axisCnt; axisId++ )
    {
        if (axisEnabled(axisId) )
        {
            axisWidget(axisId)->setGeometry(d_data->layout->scaleRect(axisId));

            if ( axisId == xBottom || axisId == xTop )
            {
                QRegion r(d_data->layout->scaleRect(axisId));
                if ( axisEnabled(yLeft) )
                    r = r.subtract(QRegion(d_data->layout->scaleRect(yLeft)));
                if ( axisEnabled(yRight) )
                    r = r.subtract(QRegion(d_data->layout->scaleRect(yRight)));
                r.translate(-d_data->layout->scaleRect(axisId).x(), 
                    -d_data->layout->scaleRect(axisId).y());

                axisWidget(axisId)->setMask(r);
            }
            if (!axisWidget(axisId)->isVisible())
                axisWidget(axisId)->show();
        }
        else
            axisWidget(axisId)->hide();
    }

    if ( d_data->legend && 
        d_data->layout->legendPosition() != ExternalLegend )
    {
        if (d_data->legend->itemCount() > 0)
        {
            d_data->legend->setGeometry(d_data->layout->legendRect());
            d_data->legend->show();
        }
        else
            d_data->legend->hide();
    }

    d_data->canvas->setGeometry(d_data->layout->canvasRect());
}

void QwtPlot::updateTabOrder()
{
#if QT_VERSION >= 0x040000
    using namespace Qt; // QWidget::NoFocus/Qt::NoFocus
#else
    if ( d_data->canvas->focusPolicy() == NoFocus )
        return;
#endif
    if ( d_data->legend.isNull()  
        || d_data->layout->legendPosition() == ExternalLegend
        || d_data->legend->legendItems().count() == 0 )
    {
        return;
    }

    // Depending on the position of the legend the 
    // tab order will be changed that the canvas is
    // next to the last legend item, or before
    // the first one. 

    const bool canvasFirst = 
        d_data->layout->legendPosition() == QwtPlot::BottomLegend ||
        d_data->layout->legendPosition() == QwtPlot::RightLegend;

    QWidget *previous = NULL; 

    QWidget *w;
#if QT_VERSION >= 0x040000
    w = d_data->canvas;
    while ( ( w = w->nextInFocusChain() ) != d_data->canvas )
#else
    if ( focusData() == NULL )
        return;

    while ( focusData()->next() != d_data->canvas );
    while ( (w = focusData()->next()) != d_data->canvas )
#endif
    {
        bool isLegendItem = false;
        if ( w->focusPolicy() != NoFocus 
            && w->parent() && w->parent() == d_data->legend->contentsWidget() )
        {
            isLegendItem = true;
        }

        if ( canvasFirst )
        {
            if ( isLegendItem )
                break;

            previous = w;
        }
        else
        {
            if ( isLegendItem )
                previous = w;
            else
            {
                if ( previous )
                    break;
            }
        }
    }

    if ( previous && previous != d_data->canvas)
        setTabOrder(previous, d_data->canvas);
}

void QwtPlot::drawCanvas(QPainter *painter)
{
    QwtScaleMap maps[axisCnt];
    for ( int axisId = 0; axisId < axisCnt; axisId++ )
        maps[axisId] = canvasMap(axisId);

    drawItems(painter, 
        d_data->canvas->contentsRect(), maps, QwtPlotPrintFilter());
}

void QwtPlot::drawItems(QPainter *painter, const QRect &rect, 
        const QwtScaleMap map[axisCnt], 
        const QwtPlotPrintFilter &pfilter) const
{
    painter->save();

    const QwtPlotItemList& itmList = itemList();
    for ( QwtPlotItemIterator it = itmList.begin();
        it != itmList.end(); ++it )
    {
        QwtPlotItem *item = *it;
        if ( item && item->isVisible() )
        {
            if ( !(pfilter.options() & QwtPlotPrintFilter::PrintGrid)
                && item->rtti() == QwtPlotItem::Rtti_PlotGrid )
            {
                continue;
            }

#if QT_VERSION >= 0x040000
            painter->setRenderHint(QPainter::Antialiasing,
                item->testRenderHint(QwtPlotItem::RenderAntialiased) );
#endif

            item->draw(painter, 
                map[item->xAxis()], map[item->yAxis()],
                rect);
        }
    }

    painter->restore();
}

QwtScaleMap QwtPlot::canvasMap(int axisId) const
{
    QwtScaleMap map;
    if ( !d_data->canvas )
        return map;

    map.setTransformation(axisScaleEngine(axisId)->transformation());

    const QwtScaleDiv *sd = axisScaleDiv(axisId);
    map.setScaleInterval(sd->lBound(), sd->hBound());

    if ( axisEnabled(axisId) )
    {
        const QwtScaleWidget *s = axisWidget(axisId);
        if ( axisId == yLeft || axisId == yRight )
        {
            int y = s->y() + s->startBorderDist() - d_data->canvas->y();
            int h = s->height() - s->startBorderDist() - s->endBorderDist();
            map.setPaintInterval(y + h - 1, y);
        }
        else
        {
            int x = s->x() + s->startBorderDist() - d_data->canvas->x();
            int w = s->width() - s->startBorderDist() - s->endBorderDist();
            map.setPaintInterval(x, x + w - 1);
        }
    }
    else
    {
        const int margin = plotLayout()->canvasMargin(axisId);

        const QRect &canvasRect = d_data->canvas->contentsRect();
        if ( axisId == yLeft || axisId == yRight )
        {
            map.setPaintInterval(canvasRect.bottom() - margin, 
                canvasRect.top() + margin);
        }
        else
        {
            map.setPaintInterval(canvasRect.left() + margin, 
                canvasRect.right() - margin);
        }
    }
    return map;
}

void QwtPlot::setMargin(int margin)
{
    if ( margin < 0 )
        margin = 0;

    if ( margin != d_data->layout->margin() )
    {
        d_data->layout->setMargin(margin);
        updateLayout();
    }
}

int QwtPlot::margin() const
{
    return d_data->layout->margin();
}

void QwtPlot::setCanvasBackground(const QColor &c)
{
    QPalette p = d_data->canvas->palette();

    for ( int i = 0; i < QPalette::NColorGroups; i++ )
    {
#if QT_VERSION < 0x040000
        p.setColor((QPalette::ColorGroup)i, QColorGroup::Background, c);
#else
        p.setColor((QPalette::ColorGroup)i, QPalette::Background, c);
#endif
    }

    canvas()->setPalette(p);
}

const QColor & QwtPlot::canvasBackground() const
{
#if QT_VERSION < 0x040000
    return canvas()->palette().color(
        QPalette::Normal, QColorGroup::Background);
#else
    return canvas()->palette().color(
        QPalette::Normal, QPalette::Background);
#endif
}

void QwtPlot::setCanvasLineWidth(int w)
{
    canvas()->setLineWidth(w);
    updateLayout();
}
 
int QwtPlot::canvasLineWidth() const
{ 
    return canvas()->lineWidth();
}

bool QwtPlot::axisValid(int axisId)
{
    return ((axisId >= QwtPlot::yLeft) && (axisId < QwtPlot::axisCnt));
}

void QwtPlot::legendItemClicked()
{
    if ( d_data->legend && sender()->isWidgetType() )
    {
        QwtPlotItem *plotItem = d_data->legend->find((QWidget *)sender());
        if ( plotItem )
            emit legendClicked(plotItem);
    }
}

void QwtPlot::legendItemChecked(bool on)
{
    if ( d_data->legend && sender()->isWidgetType() )
    {
        QwtPlotItem *plotItem = d_data->legend->find((QWidget *)sender());
        if ( plotItem )
            emit legendChecked(plotItem, on);
    }
}

void QwtPlot::clear()
{
    detachItems(QwtPlotItem::Rtti_PlotCurve);
    detachItems(QwtPlotItem::Rtti_PlotMarker);
}

void QwtPlot::insertLegend(QwtLegend *legend, 
    QwtPlot::LegendPosition pos, double ratio)
{
    d_data->layout->setLegendPosition(pos, ratio);

    if ( legend != d_data->legend )
    {
        if ( d_data->legend && d_data->legend->parent() == this )
            delete d_data->legend;

        d_data->legend = legend;

        if ( d_data->legend )
        {
            if ( pos != ExternalLegend )
            {
                if ( d_data->legend->parent() != this )
                {
#if QT_VERSION < 0x040000
                    d_data->legend->reparent(this, QPoint(0, 0));
#else
                    d_data->legend->setParent(this);
#endif
                }
            }

            const QwtPlotItemList& itmList = itemList();
            for ( QwtPlotItemIterator it = itmList.begin();
                it != itmList.end(); ++it )
            {
                (*it)->updateLegend(d_data->legend);
            }

            QLayout *l = d_data->legend->contentsWidget()->layout();
            if ( l && l->inherits("QwtDynGridLayout") )
            {
                QwtDynGridLayout *tl = (QwtDynGridLayout *)l;
                switch(d_data->layout->legendPosition())
                {
                    case LeftLegend:
                    case RightLegend:
                        tl->setMaxCols(1); // 1 column: align vertical
                        break;
                    case TopLegend:
                    case BottomLegend:
                        tl->setMaxCols(0); // unlimited
                        break;
                    case ExternalLegend:
                        break;
                }
            }
        }
        updateTabOrder();
    }

    updateLayout();
}

---