qwt_plot_item.cpp

/******************************************************************************
 * 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;
}