qwt_polar_item.cpp

Go to the documentation of this file.

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * 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 )
{
    d_data = new PrivateData;
    d_data->title = title;
}

QwtPolarItem::~QwtPolarItem()
{
    attach( NULL );
    delete d_data;
}

void QwtPolarItem::attach( QwtPolarPlot *plot )
{
    if ( plot == d_data->plot )
        return;

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

    d_data->plot = plot;

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

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

int QwtPolarItem::rtti() const
{
    return Rtti_PolarItem;
}

QwtPolarPlot *QwtPolarItem::plot() const
{
    return d_data->plot;
}

double QwtPolarItem::z() const
{
    return d_data->z;
}

void QwtPolarItem::setZ( double z )
{
    if ( d_data->z != z )
    {
        if ( d_data->plot )
            d_data->plot->attachItem( this, false );

        d_data->z = z;

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

        itemChanged();
    }
}

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

void QwtPolarItem::setTitle( const QwtText &title )
{
    if ( d_data->title != title )
    {
        d_data->title = title;
        itemChanged();
    }
}

const QwtText &QwtPolarItem::title() const
{
    return d_data->title;
}

void QwtPolarItem::setItemAttribute( ItemAttribute attribute, bool on )
{
    if ( bool( d_data->attributes & attribute ) != on )
    {
        if ( on )
            d_data->attributes |= attribute;
        else
            d_data->attributes &= ~attribute;

        itemChanged();
    }
}

bool QwtPolarItem::testItemAttribute( ItemAttribute attribute ) const
{
    return d_data->attributes & attribute;
}

void QwtPolarItem::setRenderHint( RenderHint hint, bool on )
{
    if ( ( ( d_data->renderHints & hint ) != 0 ) != on )
    {
        if ( on )
            d_data->renderHints |= hint;
        else
            d_data->renderHints &= ~hint;

        itemChanged();
    }
}

bool QwtPolarItem::testRenderHint( RenderHint hint ) const
{
    return ( d_data->renderHints & hint );
}

void QwtPolarItem::setRenderThreadCount( uint numThreads )
{
    d_data->renderThreadCount = numThreads;
}

uint QwtPolarItem::renderThreadCount() const
{
    return d_data->renderThreadCount;
}

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

QSize QwtPolarItem::legendIconSize() const
{
    return d_data->legendIconSize;
}

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

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

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

bool QwtPolarItem::isVisible() const
{
    return d_data->isVisible;
}

void QwtPolarItem::itemChanged()
{
    if ( d_data->plot )
        d_data->plot->autoRefresh();
}

void QwtPolarItem::legendChanged()
{
    if ( testItemAttribute( QwtPolarItem::Legend ) && d_data->plot )
        d_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;
}