qwt_polar_plot.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_canvas.h"
#include "qwt_polar_layout.h"
#include "qwt_painter.h"
#include "qwt_scale_engine.h"
#include "qwt_scale_div.h"
#include "qwt_text_label.h"
#include "qwt_round_scale_draw.h"
#include "qwt_legend.h"
#include "qwt_dyngrid_layout.h"
 
#include <qpointer.h>
#include <qpaintengine.h>
#include <qpainter.h>
#include <qevent.h>
 
static inline double qwtDistance(
    const QPointF& p1, const QPointF& p2 )
{
    double dx = p2.x() - p1.x();
    double dy = p2.y() - p1.y();
    return qSqrt( dx * dx + dy * dy );
}
 
namespace
{
    class ScaleData
    {
      public:
        ScaleData()
            : isValid( false )
            , scaleEngine( NULL )
        {
        }
 
        ~ScaleData()
        {
            delete scaleEngine;
        }
 
        bool doAutoScale;
 
        double minValue;
        double maxValue;
        double stepSize;
 
        int maxMajor;
        int maxMinor;
 
        bool isValid;
 
        QwtScaleDiv scaleDiv;
        QwtScaleEngine* scaleEngine;
    };
}
 
class QwtPolarPlot::PrivateData
{
  public:
    QBrush canvasBrush;
 
    bool autoReplot;
 
    QwtPointPolar zoomPos;
    double zoomFactor;
 
    ScaleData scaleData[QwtPolar::ScaleCount];
    QPointer< QwtTextLabel > titleLabel;
    QPointer< QwtPolarCanvas > canvas;
    QPointer< QwtAbstractLegend > legend;
    double azimuthOrigin;
 
    QwtPolarLayout* layout;
};
 
QwtPolarPlot::QwtPolarPlot( QWidget* parent )
    : QFrame( parent )
{
    initPlot( QwtText() );
}
 
QwtPolarPlot::QwtPolarPlot( const QwtText& title, QWidget* parent )
    : QFrame( parent )
{
    initPlot( title );
}
 
QwtPolarPlot::~QwtPolarPlot()
{
    detachItems( QwtPolarItem::Rtti_PolarItem, autoDelete() );
 
    delete m_data->layout;
    delete m_data;
}
 
void QwtPolarPlot::setTitle( const QString& title )
{
    if ( title != m_data->titleLabel->text().text() )
    {
        m_data->titleLabel->setText( title );
        if ( !title.isEmpty() )
            m_data->titleLabel->show();
        else
            m_data->titleLabel->hide();
    }
}
 
void QwtPolarPlot::setTitle( const QwtText& title )
{
    if ( title != m_data->titleLabel->text() )
    {
        m_data->titleLabel->setText( title );
        if ( !title.isEmpty() )
            m_data->titleLabel->show();
        else
            m_data->titleLabel->hide();
    }
}
 
QwtText QwtPolarPlot::title() const
{
    return m_data->titleLabel->text();
}
 
QwtTextLabel* QwtPolarPlot::titleLabel()
{
    return m_data->titleLabel;
}
 
const QwtTextLabel* QwtPolarPlot::titleLabel() const
{
    return m_data->titleLabel;
}
 
void QwtPolarPlot::insertLegend( QwtAbstractLegend* legend,
    QwtPolarPlot::LegendPosition pos, double ratio )
{
    m_data->layout->setLegendPosition( pos, ratio );
 
    if ( legend != m_data->legend )
    {
        if ( m_data->legend && m_data->legend->parent() == this )
            delete m_data->legend;
 
        m_data->legend = legend;
 
        if ( m_data->legend )
        {
            connect( this,
                SIGNAL(legendDataChanged(
                    const QVariant&,const QList<QwtLegendData>&)),
                m_data->legend,
                SLOT(updateLegend(
                    const QVariant&,const QList<QwtLegendData>&))
                );
 
            if ( m_data->legend->parent() != this )
                m_data->legend->setParent( this );
 
            updateLegend();
 
            QwtLegend* lgd = qobject_cast< QwtLegend* >( legend );
            if ( lgd )
            {
                switch ( m_data->layout->legendPosition() )
                {
                    case LeftLegend:
                    case RightLegend:
                    {
                        if ( lgd->maxColumns() == 0     )
                            lgd->setMaxColumns( 1 ); // 1 column: align vertical
                        break;
                    }
                    case TopLegend:
                    case BottomLegend:
                    {
                        lgd->setMaxColumns( 0 ); // unlimited
                        break;
                    }
                    default:
                        break;
                }
            }
 
        }
    }
 
    updateLayout();
}
 
void QwtPolarPlot::updateLegend()
{
    const QwtPolarItemList& itmList = itemList();
    for ( QwtPolarItemIterator it = itmList.begin();
        it != itmList.end(); ++it )
    {
        updateLegend( *it );
    }
}
 
void QwtPolarPlot::updateLegend( const QwtPolarItem* plotItem )
{
    if ( plotItem == NULL )
        return;
 
    QList< QwtLegendData > legendData;
 
    if ( plotItem->testItemAttribute( QwtPolarItem::Legend ) )
        legendData = plotItem->legendData();
 
    const QVariant itemInfo = itemToInfo( const_cast< QwtPolarItem* >( plotItem ) );
    Q_EMIT legendDataChanged( itemInfo, legendData );
}
 
QwtAbstractLegend* QwtPolarPlot::legend()
{
    return m_data->legend;
}
 
const QwtAbstractLegend* QwtPolarPlot::legend() const
{
    return m_data->legend;
}
 
void QwtPolarPlot::setPlotBackground( const QBrush& brush )
{
    if ( brush != m_data->canvasBrush )
    {
        m_data->canvasBrush = brush;
        autoRefresh();
    }
}
 
const QBrush& QwtPolarPlot::plotBackground() const
{
    return m_data->canvasBrush;
}
 
void QwtPolarPlot::setAutoReplot( bool enable )
{
    m_data->autoReplot = enable;
}
 
bool QwtPolarPlot::autoReplot() const
{
    return m_data->autoReplot;
}
 
void QwtPolarPlot::setAutoScale( int scaleId )
{
    if ( scaleId != QwtPolar::ScaleRadius )
        return;
 
    ScaleData& scaleData = m_data->scaleData[scaleId];
    if ( !scaleData.doAutoScale )
    {
        scaleData.doAutoScale = true;
        autoRefresh();
    }
}
 
bool QwtPolarPlot::hasAutoScale( int scaleId ) const
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return false;
 
    return m_data->scaleData[scaleId].doAutoScale;
}
 
void QwtPolarPlot::setScaleMaxMinor( int scaleId, int maxMinor )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return;
 
    maxMinor = qBound( 0, maxMinor, 100 );
 
    ScaleData& scaleData = m_data->scaleData[scaleId];
 
    if ( maxMinor != scaleData.maxMinor )
    {
        scaleData.maxMinor = maxMinor;
        scaleData.isValid = false;
        autoRefresh();
    }
}
 
int QwtPolarPlot::scaleMaxMinor( int scaleId ) const
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return 0;
 
    return m_data->scaleData[scaleId].maxMinor;
}
 
void QwtPolarPlot::setScaleMaxMajor( int scaleId, int maxMajor )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return;
 
    maxMajor = qBound( 1, maxMajor, 10000 );
 
    ScaleData& scaleData = m_data->scaleData[scaleId];
    if ( maxMajor != scaleData.maxMinor )
    {
        scaleData.maxMajor = maxMajor;
        scaleData.isValid = false;
        autoRefresh();
    }
}
 
int QwtPolarPlot::scaleMaxMajor( int scaleId ) const
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return 0;
 
    return m_data->scaleData[scaleId].maxMajor;
}
 
void QwtPolarPlot::setScaleEngine( int scaleId, QwtScaleEngine* scaleEngine )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return;
 
    ScaleData& scaleData = m_data->scaleData[scaleId];
    if ( scaleEngine == NULL || scaleEngine == scaleData.scaleEngine )
        return;
 
    delete scaleData.scaleEngine;
    scaleData.scaleEngine = scaleEngine;
 
    scaleData.isValid = false;
 
    autoRefresh();
}
 
QwtScaleEngine* QwtPolarPlot::scaleEngine( int scaleId )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return NULL;
 
    return m_data->scaleData[scaleId].scaleEngine;
}
 
const QwtScaleEngine* QwtPolarPlot::scaleEngine( int scaleId ) const
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return NULL;
 
    return m_data->scaleData[scaleId].scaleEngine;
}
 
void QwtPolarPlot::setScale( int scaleId,
    double min, double max, double stepSize )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return;
 
    ScaleData& scaleData = m_data->scaleData[scaleId];
 
    scaleData.isValid = false;
 
    scaleData.minValue = min;
    scaleData.maxValue = max;
    scaleData.stepSize = stepSize;
    scaleData.doAutoScale = false;
 
    autoRefresh();
}
 
void QwtPolarPlot::setScaleDiv( int scaleId, const QwtScaleDiv& scaleDiv )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return;
 
    ScaleData& scaleData = m_data->scaleData[scaleId];
 
    scaleData.scaleDiv = scaleDiv;
    scaleData.isValid = true;
    scaleData.doAutoScale = false;
 
    autoRefresh();
}
 
const QwtScaleDiv* QwtPolarPlot::scaleDiv( int scaleId ) const
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return NULL;
 
    return &m_data->scaleData[scaleId].scaleDiv;
}
 
QwtScaleDiv* QwtPolarPlot::scaleDiv( int scaleId )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return NULL;
 
    return &m_data->scaleData[scaleId].scaleDiv;
}
 
void QwtPolarPlot::setAzimuthOrigin( double origin )
{
    origin = ::fmod( origin, 2 * M_PI );
    if ( origin != m_data->azimuthOrigin )
    {
        m_data->azimuthOrigin = origin;
        autoRefresh();
    }
}
 
double QwtPolarPlot::azimuthOrigin() const
{
    return m_data->azimuthOrigin;
}
 
void QwtPolarPlot::zoom( const QwtPointPolar& zoomPos, double zoomFactor )
{
    zoomFactor = qAbs( zoomFactor );
    if ( zoomPos != m_data->zoomPos ||
        zoomFactor != m_data->zoomFactor )
    {
        m_data->zoomPos = zoomPos;
        m_data->zoomFactor = zoomFactor;
        updateLayout();
        autoRefresh();
    }
}
 
void QwtPolarPlot::unzoom()
{
    if ( m_data->zoomFactor != 1.0 || m_data->zoomPos.isValid() )
    {
        m_data->zoomFactor = 1.0;
        m_data->zoomPos = QwtPointPolar();
        autoRefresh();
    }
}
 
QwtPointPolar QwtPolarPlot::zoomPos() const
{
    return m_data->zoomPos;
}
 
double QwtPolarPlot::zoomFactor() const
{
    return m_data->zoomFactor;
}
 
QwtScaleMap QwtPolarPlot::scaleMap( int scaleId ) const
{
    const QRectF pr = plotRect();
    return scaleMap( scaleId, pr.width() / 2.0 );
}
 
QwtScaleMap QwtPolarPlot::scaleMap( int scaleId, const double radius ) const
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return QwtScaleMap();
 
    QwtScaleMap map;
    map.setTransformation( scaleEngine( scaleId )->transformation() );
 
    const QwtScaleDiv* sd = scaleDiv( scaleId );
    map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
 
    if ( scaleId == QwtPolar::Azimuth )
    {
        map.setPaintInterval( m_data->azimuthOrigin,
            m_data->azimuthOrigin + 2 * M_PI );
    }
    else
    {
        map.setPaintInterval( 0.0, radius );
    }
 
    return map;
}
 
bool QwtPolarPlot::event( QEvent* e )
{
    bool ok = QWidget::event( e );
    switch( e->type() )
    {
        case QEvent::LayoutRequest:
        {
            updateLayout();
            break;
        }
        case QEvent::PolishRequest:
        {
            updateLayout();
            replot();
            break;
        }
        default:;
    }
    return ok;
}
 
void QwtPolarPlot::resizeEvent( QResizeEvent* e )
{
    QFrame::resizeEvent( e );
    updateLayout();
}
 
void QwtPolarPlot::initPlot( const QwtText& title )
{
    m_data = new PrivateData;
    m_data->layout = new QwtPolarLayout;
 
    QwtText text( title );
    text.setRenderFlags( Qt::AlignCenter | Qt::TextWordWrap );
 
    m_data->titleLabel = new QwtTextLabel( text, this );
    m_data->titleLabel->setFont( QFont( fontInfo().family(), 14, QFont::Bold ) );
    if ( !text.isEmpty() )
        m_data->titleLabel->show();
    else
        m_data->titleLabel->hide();
 
    m_data->canvas = new QwtPolarCanvas( this );
 
    m_data->autoReplot = false;
    m_data->canvasBrush = QBrush( Qt::white );
 
    for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ )
    {
        ScaleData& scaleData = m_data->scaleData[scaleId];
 
        if ( scaleId == QwtPolar::Azimuth )
        {
            scaleData.minValue = 0.0;
            scaleData.maxValue = 360.0;
            scaleData.stepSize = 30.0;
        }
        else
        {
            scaleData.minValue = 0.0;
            scaleData.maxValue = 1000.0;
            scaleData.stepSize = 0.0;
        }
 
        scaleData.doAutoScale = true;
 
        scaleData.maxMinor = 5;
        scaleData.maxMajor = 8;
 
        scaleData.isValid = false;
 
        scaleData.scaleEngine = new QwtLinearScaleEngine;
    }
    m_data->zoomFactor = 1.0;
    m_data->azimuthOrigin = 0.0;
 
    setSizePolicy( QSizePolicy::MinimumExpanding,
        QSizePolicy::MinimumExpanding );
 
    for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ )
        updateScale( scaleId );
}
 
void QwtPolarPlot::autoRefresh()
{
    if ( m_data->autoReplot )
        replot();
}
 
void QwtPolarPlot::updateLayout()
{
    m_data->layout->activate( this, contentsRect() );
 
    // resize and show the visible widgets
    if ( m_data->titleLabel )
    {
        if ( !m_data->titleLabel->text().isEmpty() )
        {
            m_data->titleLabel->setGeometry( m_data->layout->titleRect().toRect() );
            if ( !m_data->titleLabel->isVisible() )
                m_data->titleLabel->show();
        }
        else
            m_data->titleLabel->hide();
    }
 
    if ( m_data->legend )
    {
        if ( m_data->legend->isEmpty() )
        {
            m_data->legend->hide();
        }
        else
        {
            const QRectF legendRect = m_data->layout->legendRect();
            m_data->legend->setGeometry( legendRect.toRect() );
            m_data->legend->show();
        }
    }
 
    m_data->canvas->setGeometry( m_data->layout->canvasRect().toRect() );
    Q_EMIT layoutChanged();
}
 
void QwtPolarPlot::replot()
{
    bool doAutoReplot = autoReplot();
    setAutoReplot( false );
 
    for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ )
        updateScale( scaleId );
 
    m_data->canvas->invalidateBackingStore();
    m_data->canvas->repaint();
 
    setAutoReplot( doAutoReplot );
}
 
QwtPolarCanvas* QwtPolarPlot::canvas()
{
    return m_data->canvas;
}
 
const QwtPolarCanvas* QwtPolarPlot::canvas() const
{
    return m_data->canvas;
}
 
void QwtPolarPlot::drawCanvas( QPainter* painter,
    const QRectF& canvasRect ) const
{
    const QRectF cr = canvasRect;
    const QRectF pr = plotRect( cr );
 
    const double radius = pr.width() / 2.0;
 
    if ( m_data->canvasBrush.style() != Qt::NoBrush )
    {
        painter->save();
        painter->setPen( Qt::NoPen );
        painter->setBrush( m_data->canvasBrush );
 
        if ( qwtDistance( pr.center(), cr.topLeft() ) < radius &&
            qwtDistance( pr.center(), cr.topRight() ) < radius &&
            qwtDistance( pr.center(), cr.bottomRight() ) < radius &&
            qwtDistance( pr.center(), cr.bottomLeft() ) < radius )
        {
            QwtPainter::drawRect( painter, cr );
        }
        else
        {
            painter->setRenderHint( QPainter::Antialiasing, true );
            QwtPainter::drawEllipse( painter, pr );
        }
        painter->restore();
    }
 
    drawItems( painter,
        scaleMap( QwtPolar::Azimuth, radius ),
        scaleMap( QwtPolar::Radius, radius ),
        pr.center(), radius, canvasRect );
}
 
void QwtPolarPlot::drawItems( QPainter* painter,
    const QwtScaleMap& azimuthMap, const QwtScaleMap& radialMap,
    const QPointF& pole, double radius,
    const QRectF& canvasRect ) const
{
    const QRectF pr = plotRect( canvasRect );
 
    const QwtPolarItemList& itmList = itemList();
    for ( QwtPolarItemIterator it = itmList.begin();
        it != itmList.end(); ++it )
    {
        QwtPolarItem* item = *it;
        if ( item && item->isVisible() )
        {
            painter->save();
 
            // Unfortunately circular clipping slows down
            // painting a lot. So we better try to avoid it.
 
            bool doClipping = false;
            if ( item->rtti() != QwtPolarItem::Rtti_PolarGrid )
            {
                const QwtInterval intv =
                    item->boundingInterval( QwtPolar::Radius );
 
                if ( !intv.isValid() )
                    doClipping = true;
                else
                {
                    if ( radialMap.s1() < radialMap.s2() )
                        doClipping = intv.maxValue() > radialMap.s2();
                    else
                        doClipping = intv.minValue() < radialMap.s2();
                }
            }
 
            if ( doClipping )
            {
                const int margin = item->marginHint();
 
                const QRectF clipRect = pr.adjusted(
                    -margin, -margin, margin, margin );
                if ( !clipRect.contains( canvasRect ) )
                {
                    QRegion clipRegion( clipRect.toRect(), QRegion::Ellipse );
                    painter->setClipRegion( clipRegion, Qt::IntersectClip );
                }
            }
 
            painter->setRenderHint( QPainter::Antialiasing,
                item->testRenderHint( QwtPolarItem::RenderAntialiased ) );
 
            item->draw( painter, azimuthMap, radialMap,
                pole, radius, canvasRect );
 
            painter->restore();
        }
    }
}
 
void QwtPolarPlot::updateScale( int scaleId )
{
    if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount )
        return;
 
    ScaleData& d = m_data->scaleData[scaleId];
 
    double minValue = d.minValue;
    double maxValue = d.maxValue;
    double stepSize = d.stepSize;
 
    if ( scaleId == QwtPolar::ScaleRadius && d.doAutoScale )
    {
        QwtInterval interval;
 
        const QwtPolarItemList& itmList = itemList();
        for ( QwtPolarItemIterator it = itmList.begin();
            it != itmList.end(); ++it )
        {
            const QwtPolarItem* item = *it;
            if ( item->testItemAttribute( QwtPolarItem::AutoScale ) )
                interval |= item->boundingInterval( scaleId );
        }
 
        minValue = interval.minValue();
        maxValue = interval.maxValue();
 
        d.scaleEngine->autoScale( d.maxMajor,
            minValue, maxValue, stepSize );
        d.isValid = false;
    }
 
    if ( !d.isValid )
    {
        d.scaleDiv = d.scaleEngine->divideScale(
            minValue, maxValue, d.maxMajor, d.maxMinor, stepSize );
        d.isValid = true;
    }
 
    const QwtInterval interval = visibleInterval();
 
    const QwtPolarItemList& itmList = itemList();
    for ( QwtPolarItemIterator it = itmList.begin();
        it != itmList.end(); ++it )
    {
        QwtPolarItem* item = *it;
        item->updateScaleDiv( *scaleDiv( QwtPolar::Azimuth ),
            *scaleDiv( QwtPolar::Radius ), interval );
    }
}
 
int QwtPolarPlot::plotMarginHint() const
{
    int margin = 0;
    const QwtPolarItemList& itmList = itemList();
    for ( QwtPolarItemIterator it = itmList.begin();
        it != itmList.end(); ++it )
    {
        QwtPolarItem* item = *it;
        if ( item && item->isVisible() )
        {
            const int hint = item->marginHint();
            if ( hint > margin )
                margin = hint;
        }
    }
    return margin;
}
 
QRectF QwtPolarPlot::plotRect() const
{
    return plotRect( canvas()->contentsRect() );
}
 
QRectF QwtPolarPlot::plotRect( const QRectF& canvasRect ) const
{
    const QwtScaleDiv* sd = scaleDiv( QwtPolar::Radius );
    const QwtScaleEngine* se = scaleEngine( QwtPolar::Radius );
 
    const int margin = plotMarginHint();
    const QRectF cr = canvasRect;
    const int radius = qMin( cr.width(), cr.height() ) / 2 - margin;
 
    QwtScaleMap map;
    map.setTransformation( se->transformation() );
    map.setPaintInterval( 0.0, radius / m_data->zoomFactor );
    map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
 
    double v = map.s1();
    if ( map.s1() <= map.s2() )
        v += m_data->zoomPos.radius();
    else
        v -= m_data->zoomPos.radius();
    v = map.transform( v );
 
    const QPointF off =
        QwtPointPolar( m_data->zoomPos.azimuth(), v ).toPoint();
 
    QPointF center( cr.center().x(), cr.top() + margin + radius );
    center -= QPointF( off.x(), -off.y() );
 
    QRectF rect( 0, 0, 2 * map.p2(), 2 * map.p2() );
    rect.moveCenter( center );
 
    return rect;
}
 
QwtInterval QwtPolarPlot::visibleInterval() const
{
    const QwtScaleDiv* sd = scaleDiv( QwtPolar::Radius );
 
    const QRectF cRect = canvas()->contentsRect();
    const QRectF pRect = plotRect( cRect );
    if ( cRect.contains( pRect ) || !cRect.intersects( pRect ) )
    {
        return QwtInterval( sd->lowerBound(), sd->upperBound() );
    }
 
    const QPointF pole = pRect.center();
    const QRectF scaleRect = pRect & cRect;
 
    const QwtScaleMap map = scaleMap( QwtPolar::Radius );
 
    double dmin = 0.0;
    double dmax = 0.0;
    if ( scaleRect.contains( pole ) )
    {
        dmin = 0.0;
 
        QPointF corners[4];
        corners[0] = scaleRect.bottomRight();
        corners[1] = scaleRect.topRight();
        corners[2] = scaleRect.topLeft();
        corners[3] = scaleRect.bottomLeft();
 
        dmax = 0.0;
        for ( int i = 0; i < 4; i++ )
        {
            const double dist = qwtDistance( pole, corners[i] );
            if ( dist > dmax )
                dmax = dist;
        }
    }
    else
    {
        if ( pole.x() < scaleRect.left() )
        {
            if ( pole.y() < scaleRect.top() )
            {
                dmin = qwtDistance( pole, scaleRect.topLeft() );
                dmax = qwtDistance( pole, scaleRect.bottomRight() );
            }
            else if ( pole.y() > scaleRect.bottom() )
            {
                dmin = qwtDistance( pole, scaleRect.bottomLeft() );
                dmax = qwtDistance( pole, scaleRect.topRight() );
            }
            else
            {
                dmin = scaleRect.left() - pole.x();
                dmax = qMax( qwtDistance( pole, scaleRect.bottomRight() ),
                    qwtDistance( pole, scaleRect.topRight() ) );
            }
        }
        else if ( pole.x() > scaleRect.right() )
        {
            if ( pole.y() < scaleRect.top() )
            {
                dmin = qwtDistance( pole, scaleRect.topRight() );
                dmax = qwtDistance( pole, scaleRect.bottomLeft() );
            }
            else if ( pole.y() > scaleRect.bottom() )
            {
                dmin = qwtDistance( pole, scaleRect.bottomRight() );
                dmax = qwtDistance( pole, scaleRect.topLeft() );
            }
            else
            {
                dmin = pole.x() - scaleRect.right();
                dmax = qMax( qwtDistance( pole, scaleRect.bottomLeft() ),
                    qwtDistance( pole, scaleRect.topLeft() ) );
            }
        }
        else if ( pole.y() < scaleRect.top() )
        {
            dmin = scaleRect.top() - pole.y();
            dmax = qMax( qwtDistance( pole, scaleRect.bottomLeft() ),
                qwtDistance( pole, scaleRect.bottomRight() ) );
        }
        else if ( pole.y() > scaleRect.bottom() )
        {
            dmin = pole.y() - scaleRect.bottom();
            dmax = qMax( qwtDistance( pole, scaleRect.topLeft() ),
                qwtDistance( pole, scaleRect.topRight() ) );
        }
    }
 
    const double radius = pRect.width() / 2.0;
    if ( dmax > radius )
        dmax = radius;
 
    QwtInterval interval;
    interval.setMinValue( map.invTransform( dmin ) );
    interval.setMaxValue( map.invTransform( dmax ) );
 
    return interval;
}
 
QwtPolarLayout* QwtPolarPlot::plotLayout()
{
    return m_data->layout;
}
 
const QwtPolarLayout* QwtPolarPlot::plotLayout() const
{
    return m_data->layout;
}
 
void QwtPolarPlot::attachItem( QwtPolarItem* plotItem, bool on )
{
    if ( on )
        insertItem( plotItem );
    else
        removeItem( plotItem );
 
    Q_EMIT itemAttached( plotItem, on );
 
    if ( plotItem->testItemAttribute( QwtPolarItem::Legend ) )
    {
        // the item wants to be represented on the legend
 
        if ( on )
        {
            updateLegend( plotItem );
        }
        else
        {
            const QVariant itemInfo = itemToInfo( plotItem );
            Q_EMIT legendDataChanged( itemInfo, QList< QwtLegendData >() );
        }
    }
 
    if ( autoReplot() )
        update();
}
 
QVariant QwtPolarPlot::itemToInfo( QwtPolarItem* plotItem ) const
{
    return QVariant::fromValue( plotItem );
}
 
QwtPolarItem* QwtPolarPlot::infoToItem( const QVariant& itemInfo ) const
{
    if ( itemInfo.canConvert< QwtPolarItem* >() )
        return qvariant_cast< QwtPolarItem* >( itemInfo );
 
    return NULL;
}
 
#include "moc_qwt_polar_plot.cpp"