qwt_polar_item.cpp

/******************************************************************************
 * QwtPolar Widget Library
 * Copyright (C) 2008   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_polar_plot.h"
#include "qwt_polar_item.h"
#include "qwt_legend.h"
#include "qwt_scale_div.h"
 
#include <qpainter.h>
 
class QwtPolarItem::PrivateData
{
  public:
    PrivateData()
        : plot( NULL )
        , isVisible( true )
        , renderThreadCount( 1 )
        , z( 0.0 )
        , legendIconSize( 8, 8 )
    {
    }
 
    mutable QwtPolarPlot* plot;
 
    bool isVisible;
    QwtPolarItem::ItemAttributes attributes;
    QwtPolarItem::RenderHints renderHints;
    uint renderThreadCount;
 
    double z;
 
    QwtText title;
    QSize legendIconSize;
};
 
QwtPolarItem::QwtPolarItem( const QwtText& title )
{
    m_data = new PrivateData;
    m_data->title = title;
}
 
QwtPolarItem::~QwtPolarItem()
{
    attach( NULL );
    delete m_data;
}
 
void QwtPolarItem::attach( QwtPolarPlot* 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 QwtPolarItem::detach()
{
    attach( NULL );
}
 
int QwtPolarItem::rtti() const
{
    return Rtti_PolarItem;
}
 
QwtPolarPlot* QwtPolarItem::plot() const
{
    return m_data->plot;
}
 
double QwtPolarItem::z() const
{
    return m_data->z;
}
 
void QwtPolarItem::setZ( double z )
{
    if ( m_data->z != z )
    {
        if ( m_data->plot )
            m_data->plot->attachItem( this, false );
 
        m_data->z = z;
 
        if ( m_data->plot )
            m_data->plot->attachItem( this, true );
 
        itemChanged();
    }
}
 
void QwtPolarItem::setTitle( const QString& title )
{
    setTitle( QwtText( title ) );
}
 
void QwtPolarItem::setTitle( const QwtText& title )
{
    if ( m_data->title != title )
    {
        m_data->title = title;
        itemChanged();
    }
}
 
const QwtText& QwtPolarItem::title() const
{
    return m_data->title;
}
 
void QwtPolarItem::setItemAttribute( ItemAttribute attribute, bool on )
{
    if ( bool( m_data->attributes & attribute ) != on )
    {
        if ( on )
            m_data->attributes |= attribute;
        else
            m_data->attributes &= ~attribute;
 
        itemChanged();
    }
}
 
bool QwtPolarItem::testItemAttribute( ItemAttribute attribute ) const
{
    return m_data->attributes & attribute;
}
 
void QwtPolarItem::setRenderHint( RenderHint hint, bool on )
{
    if ( ( ( m_data->renderHints & hint ) != 0 ) != on )
    {
        if ( on )
            m_data->renderHints |= hint;
        else
            m_data->renderHints &= ~hint;
 
        itemChanged();
    }
}
 
bool QwtPolarItem::testRenderHint( RenderHint hint ) const
{
    return ( m_data->renderHints & hint );
}
 
void QwtPolarItem::setRenderThreadCount( uint numThreads )
{
    m_data->renderThreadCount = numThreads;
}
 
uint QwtPolarItem::renderThreadCount() const
{
    return m_data->renderThreadCount;
}
 
void QwtPolarItem::setLegendIconSize( const QSize& size )
{
    if ( m_data->legendIconSize != size )
    {
        m_data->legendIconSize = size;
        legendChanged();
    }
}
 
QSize QwtPolarItem::legendIconSize() const
{
    return m_data->legendIconSize;
}
 
void QwtPolarItem::show()
{
    setVisible( true );
}
 
void QwtPolarItem::hide()
{
    setVisible( false );
}
 
void QwtPolarItem::setVisible( bool on )
{
    if ( on != m_data->isVisible )
    {
        m_data->isVisible = on;
        itemChanged();
    }
}
 
bool QwtPolarItem::isVisible() const
{
    return m_data->isVisible;
}
 
void QwtPolarItem::itemChanged()
{
    if ( m_data->plot )
        m_data->plot->autoRefresh();
}
 
void QwtPolarItem::legendChanged()
{
    if ( testItemAttribute( QwtPolarItem::Legend ) && m_data->plot )
        m_data->plot->updateLegend( this );
}
 
QwtInterval QwtPolarItem::boundingInterval( int scaleId ) const
{
    Q_UNUSED( scaleId );
 
    return QwtInterval(); // invalid
}
 
void QwtPolarItem::updateScaleDiv( const QwtScaleDiv& azimuthScaleDiv,
    const QwtScaleDiv& radialScaleDiv, const QwtInterval& interval )
{
    Q_UNUSED( azimuthScaleDiv );
    Q_UNUSED( radialScaleDiv );
    Q_UNUSED( interval );
}
 
QList< QwtLegendData > QwtPolarItem::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;
}
 
QwtGraphic QwtPolarItem::legendIcon(
    int index, const QSizeF& size ) const
{
    Q_UNUSED( index )
    Q_UNUSED( size )
 
    return QwtGraphic();
}
 
int QwtPolarItem::marginHint() const
{
    return 0;
}