qwt_polar_picker.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_picker.h"
#include "qwt_polar_plot.h"
#include "qwt_polar_canvas.h"
#include "qwt_scale_map.h"
#include "qwt_picker_machine.h"
#include "qwt_point_polar.h"
 
class QwtPolarPicker::PrivateData
{
};
 
QwtPolarPicker::QwtPolarPicker( QwtPolarCanvas* canvas )
    : QwtPicker( canvas )
    , m_data( NULL )
{
}
 
QwtPolarPicker::QwtPolarPicker(
        RubberBand rubberBand, DisplayMode trackerMode, QwtPolarCanvas* canvas )
    : QwtPicker( rubberBand, trackerMode, canvas )
    , m_data( NULL )
{
}
 
QwtPolarPicker::~QwtPolarPicker()
{
}
 
QwtPolarCanvas* QwtPolarPicker::canvas()
{
    return qobject_cast< QwtPolarCanvas* >( parentWidget() );
}
 
const QwtPolarCanvas* QwtPolarPicker::canvas() const
{
    return qobject_cast< const QwtPolarCanvas* >( parentWidget() );
}
 
QwtPolarPlot* QwtPolarPicker::plot()
{
    QwtPolarCanvas* w = canvas();
    if ( w )
        return w->plot();
 
    return NULL;
}
 
const QwtPolarPlot* QwtPolarPicker::plot() const
{
    const QwtPolarCanvas* w = canvas();
    if ( w )
        return w->plot();
 
    return NULL;
}
 
QwtText QwtPolarPicker::trackerText( const QPoint& pos ) const
{
    const QwtPointPolar polarPoint = invTransform( pos );
    return trackerTextPolar( polarPoint );
}
 
QwtText QwtPolarPicker::trackerTextPolar( const QwtPointPolar& pos ) const
{
    const QString text = QString::number( pos.radius(), 'f', 4 )
        + ", " + QString::number( pos.azimuth(), 'f', 4 );
 
    return QwtText( text );
}
 
void QwtPolarPicker::append( const QPoint& pos )
{
    QwtPicker::append( pos );
    Q_EMIT appended( invTransform( pos ) );
}
 
void QwtPolarPicker::move( const QPoint& pos )
{
    QwtPicker::move( pos );
    Q_EMIT moved( invTransform( pos ) );
}
 
bool QwtPolarPicker::end( bool ok )
{
    ok = QwtPicker::end( ok );
    if ( !ok )
        return false;
 
    QwtPolarPlot* plot = QwtPolarPicker::plot();
    if ( !plot )
        return false;
 
    const QPolygon points = selection();
    if ( points.count() == 0 )
        return false;
 
    QwtPickerMachine::SelectionType selectionType =
        QwtPickerMachine::NoSelection;
 
    if ( stateMachine() )
        selectionType = stateMachine()->selectionType();
 
    switch ( selectionType )
    {
        case QwtPickerMachine::PointSelection:
        {
            const QwtPointPolar pos = invTransform( points[0] );
            Q_EMIT selected( pos );
            break;
        }
        case QwtPickerMachine::RectSelection:
        case QwtPickerMachine::PolygonSelection:
        {
            QVector< QwtPointPolar > polarPoints( points.count() );
            for ( int i = 0; i < points.count(); i++ )
                polarPoints[i] = invTransform( points[i] );
 
            Q_EMIT selected( polarPoints );
        }
        default:
            break;
    }
 
    return true;
}
 
QwtPointPolar QwtPolarPicker::invTransform( const QPoint& pos ) const
{
    QwtPointPolar polarPos;
    if ( canvas() == NULL )
        return QwtPointPolar();
 
    return canvas()->invTransform( pos );
}
 
QRect QwtPolarPicker::pickRect() const
{
    const QRect cr = canvas()->contentsRect();
    const QRect pr = plot()->plotRect( cr ).toRect();
 
    return cr & pr;
}
 
QPainterPath QwtPolarPicker::pickArea() const
{
    const QRect cr = canvas()->contentsRect();
 
    QPainterPath crPath;
    crPath.addRect( cr );
 
    QPainterPath prPath;
    prPath.addEllipse( plot()->plotRect( cr ) );
 
    return crPath.intersected( prPath );
}
 
#include "moc_qwt_polar_picker.cpp"