qwt_plot_item.cpp

Go to the documentation of this file.

/******************************************************************************
 * 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 "qwt_plot_item.h"
#include "qwt_text.h"
#include "qwt_plot.h"
#include "qwt_legend_data.h"
#include "qwt_scale_map.h"
#include "qwt_graphic.h"

#include <qpainter.h>

class QwtPlotItem::PrivateData
{
  public:
    PrivateData()
        : plot( NULL )
        , isVisible( true )
        , renderThreadCount( 1 )
        , z( 0.0 )
        , xAxisId( QwtAxis::XBottom )
        , yAxisId( QwtAxis::YLeft )
        , legendIconSize( 8, 8 )
    {
    }

    mutable QwtPlot* plot;

    bool isVisible;

    QwtPlotItem::ItemAttributes attributes;
    QwtPlotItem::ItemInterests interests;

    QwtPlotItem::RenderHints renderHints;
    uint renderThreadCount;

    double z;

    QwtAxisId xAxisId;
    QwtAxisId yAxisId;

    QwtText title;
    QSize legendIconSize;
};

QwtPlotItem::QwtPlotItem()
{
    m_data = new PrivateData;
}

QwtPlotItem::QwtPlotItem( const QString& title )
{
    m_data = new PrivateData;
    m_data->title = title;
}

QwtPlotItem::QwtPlotItem( const QwtText& title )
{
    m_data = new PrivateData;
    m_data->title = title;
}

QwtPlotItem::~QwtPlotItem()
{
    attach( NULL );
    delete m_data;
}

void QwtPlotItem::attach( QwtPlot* plot )
{
    if ( plot == m_data->plot )
        return;

    if ( m_data->plot )
        m_data->plot->attachItem( this, false );

    m_data->plot = plot;

    if ( m_data->plot )
        m_data->plot->attachItem( this, true );
}

void QwtPlotItem::detach()
{
    attach( NULL );
}

int QwtPlotItem::rtti() const
{
    return Rtti_PlotItem;
}

QwtPlot* QwtPlotItem::plot() const
{
    return m_data->plot;
}

double QwtPlotItem::z() const
{
    return m_data->z;
}

void QwtPlotItem::setZ( double z )
{
    if ( m_data->z != z )
    {
        if ( m_data->plot ) // update the z order
            m_data->plot->attachItem( this, false );

        m_data->z = z;

        if ( m_data->plot )
            m_data->plot->attachItem( this, true );

        itemChanged();
    }
}

void QwtPlotItem::setTitle( const QString& title )
{
    setTitle( QwtText( title ) );
}

void QwtPlotItem::setTitle( const QwtText& title )
{
    if ( m_data->title != title )
    {
        m_data->title = title;

        legendChanged();
#if 0
        itemChanged();
#endif
    }
}

const QwtText& QwtPlotItem::title() const
{
    return m_data->title;
}

void QwtPlotItem::setItemAttribute( ItemAttribute attribute, bool on )
{
    if ( m_data->attributes.testFlag( attribute ) != on )
    {
        if ( on )
            m_data->attributes |= attribute;
        else
            m_data->attributes &= ~attribute;

        if ( attribute == QwtPlotItem::Legend )
        {
            if ( on )
            {
                legendChanged();
            }
            else
            {
                /*
                    In the special case of taking an item from
                    the legend we can't use legendChanged() as
                    it depends on QwtPlotItem::Legend being enabled
                 */
                if ( m_data->plot )
                    m_data->plot->updateLegend( this );
            }
        }

        itemChanged();
    }
}

bool QwtPlotItem::testItemAttribute( ItemAttribute attribute ) const
{
    return m_data->attributes.testFlag( attribute );
}

void QwtPlotItem::setItemInterest( ItemInterest interest, bool on )
{
    if ( m_data->interests.testFlag( interest ) != on )
    {
        if ( on )
            m_data->interests |= interest;
        else
            m_data->interests &= ~interest;

        itemChanged();
    }
}

bool QwtPlotItem::testItemInterest( ItemInterest interest ) const
{
    return m_data->interests.testFlag( interest );
}

void QwtPlotItem::setRenderHint( RenderHint hint, bool on )
{
    if ( m_data->renderHints.testFlag( hint ) != on )
    {
        if ( on )
            m_data->renderHints |= hint;
        else
            m_data->renderHints &= ~hint;

        itemChanged();
    }
}

bool QwtPlotItem::testRenderHint( RenderHint hint ) const
{
    return m_data->renderHints.testFlag( hint );
}

void QwtPlotItem::setRenderThreadCount( uint numThreads )
{
    m_data->renderThreadCount = numThreads;
}

uint QwtPlotItem::renderThreadCount() const
{
    return m_data->renderThreadCount;
}

void QwtPlotItem::setLegendIconSize( const QSize& size )
{
    if ( m_data->legendIconSize != size )
    {
        m_data->legendIconSize = size;
        legendChanged();
    }
}

QSize QwtPlotItem::legendIconSize() const
{
    return m_data->legendIconSize;
}

QwtGraphic QwtPlotItem::legendIcon(
    int index, const QSizeF& size ) const
{
    Q_UNUSED( index )
    Q_UNUSED( size )

    return QwtGraphic();
}

QwtGraphic QwtPlotItem::defaultIcon(
    const QBrush& brush, const QSizeF& size ) const
{
    QwtGraphic icon;
    if ( !size.isEmpty() )
    {
        icon.setDefaultSize( size );

        QRectF r( 0, 0, size.width(), size.height() );

        QPainter painter( &icon );
        painter.fillRect( r, brush );
    }

    return icon;
}

void QwtPlotItem::show()
{
    setVisible( true );
}

void QwtPlotItem::hide()
{
    setVisible( false );
}

void QwtPlotItem::setVisible( bool on )
{
    if ( on != m_data->isVisible )
    {
        m_data->isVisible = on;
        itemChanged();
    }
}

bool QwtPlotItem::isVisible() const
{
    return m_data->isVisible;
}

void QwtPlotItem::itemChanged()
{
    if ( m_data->plot )
        m_data->plot->autoRefresh();
}

void QwtPlotItem::legendChanged()
{
    if ( testItemAttribute( QwtPlotItem::Legend ) && m_data->plot )
        m_data->plot->updateLegend( this );
}

void QwtPlotItem::setAxes( QwtAxisId xAxisId, QwtAxisId yAxisId )
{
    if ( QwtAxis::isXAxis( xAxisId ) )
        m_data->xAxisId = xAxisId;

    if ( QwtAxis::isYAxis( yAxisId ) )
        m_data->yAxisId = yAxisId;

    itemChanged();
}

void QwtPlotItem::setXAxis( QwtAxisId axisId )
{
    if ( QwtAxis::isXAxis( axisId ) )
    {
        m_data->xAxisId = axisId;
        itemChanged();
    }
}

void QwtPlotItem::setYAxis( QwtAxisId axisId )
{
    if ( QwtAxis::isYAxis( axisId ) )
    {
        m_data->yAxisId = axisId;
        itemChanged();
    }
}

QwtAxisId QwtPlotItem::xAxis() const
{
    return m_data->xAxisId;
}

QwtAxisId QwtPlotItem::yAxis() const
{
    return m_data->yAxisId;
}

QRectF QwtPlotItem::boundingRect() const
{
    return QRectF( 1.0, 1.0, -2.0, -2.0 ); // invalid
}

void QwtPlotItem::getCanvasMarginHint( const QwtScaleMap& xMap,
    const QwtScaleMap& yMap, const QRectF& canvasRect,
    double& left, double& top, double& right, double& bottom ) const
{
    Q_UNUSED( xMap );
    Q_UNUSED( yMap );
    Q_UNUSED( canvasRect );

    // use QMargins, when we don't need to support Qt < 4.6 anymore
    left = top = right = bottom = 0.0;
}

QList< QwtLegendData > QwtPlotItem::legendData() const
{
    QwtLegendData data;

    QwtText label = title();
    label.setRenderFlags( label.renderFlags() & Qt::AlignLeft );

    data.setValue( QwtLegendData::TitleRole,
        QVariant::fromValue( label ) );

    const QwtGraphic graphic = legendIcon( 0, legendIconSize() );
    if ( !graphic.isNull() )
    {
        data.setValue( QwtLegendData::IconRole,
            QVariant::fromValue( graphic ) );
    }

    QList< QwtLegendData > list;
    list += data;

    return list;
}

void QwtPlotItem::updateScaleDiv( const QwtScaleDiv& xScaleDiv,
    const QwtScaleDiv& yScaleDiv )
{
    Q_UNUSED( xScaleDiv );
    Q_UNUSED( yScaleDiv );
}

void QwtPlotItem::updateLegend( const QwtPlotItem* item,
    const QList< QwtLegendData >& data )
{
    Q_UNUSED( item );
    Q_UNUSED( data );
}

QRectF QwtPlotItem::scaleRect( const QwtScaleMap& xMap,
    const QwtScaleMap& yMap ) const
{
    return QRectF( xMap.s1(), yMap.s1(),
        xMap.sDist(), yMap.sDist() );
}

QRectF QwtPlotItem::paintRect( const QwtScaleMap& xMap,
    const QwtScaleMap& yMap ) const
{
    const QRectF rect( xMap.p1(), yMap.p1(),
        xMap.pDist(), yMap.pDist() );

    return rect;
}