qwt_plot_picker.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_picker.h"
#include "qwt_plot.h"
#include "qwt_text.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_picker_machine.h"
 
class QwtPlotPicker::PrivateData
{
  public:
    PrivateData():
        xAxisId( -1 ),
        yAxisId( -1 )
    {
    }
 
    QwtAxisId xAxisId;
    QwtAxisId yAxisId;
};
 
QwtPlotPicker::QwtPlotPicker( QWidget* canvas )
    : QwtPicker( canvas )
{
    m_data = new PrivateData;
 
    if ( !canvas )
        return;
 
    const QwtPlot* plot = QwtPlotPicker::plot();
    // attach axes
 
    using namespace QwtAxis;
 
    int xAxis = XBottom;
    if ( !plot->isAxisVisible( XBottom ) && plot->isAxisVisible( XTop ) )
        xAxis = XTop;
 
    int yAxis = YLeft;
    if ( !plot->isAxisVisible( YLeft ) && plot->isAxisVisible( YRight ) )
        yAxis = YRight;
 
    setAxes( xAxis, yAxis );
}
 
QwtPlotPicker::QwtPlotPicker( QwtAxisId xAxisId, QwtAxisId yAxisId, QWidget* canvas )
    : QwtPicker( canvas )
{
    m_data = new PrivateData;
    m_data->xAxisId = xAxisId;
    m_data->yAxisId = yAxisId;
}
 
QwtPlotPicker::QwtPlotPicker( QwtAxisId xAxisId, QwtAxisId yAxisId,
        RubberBand rubberBand, DisplayMode trackerMode, QWidget* canvas )
    : QwtPicker( rubberBand, trackerMode, canvas )
{
    m_data = new PrivateData;
    m_data->xAxisId = xAxisId;
    m_data->yAxisId = yAxisId;
}
 
QwtPlotPicker::~QwtPlotPicker()
{
    delete m_data;
}
 
QWidget* QwtPlotPicker::canvas()
{
    return parentWidget();
}
 
const QWidget* QwtPlotPicker::canvas() const
{
    return parentWidget();
}
 
QwtPlot* QwtPlotPicker::plot()
{
    QWidget* w = canvas();
    if ( w )
        w = w->parentWidget();
 
    return qobject_cast< QwtPlot* >( w );
}
 
const QwtPlot* QwtPlotPicker::plot() const
{
    const QWidget* w = canvas();
    if ( w )
        w = w->parentWidget();
 
    return qobject_cast< const QwtPlot* >( w );
}
 
QRectF QwtPlotPicker::scaleRect() const
{
    QRectF rect;
 
    if ( plot() )
    {
        const QwtScaleDiv& xs = plot()->axisScaleDiv( xAxis() );
        const QwtScaleDiv& ys = plot()->axisScaleDiv( yAxis() );
 
        rect = QRectF( xs.lowerBound(), ys.lowerBound(),
            xs.range(), ys.range() );
        rect = rect.normalized();
    }
 
    return rect;
}
 
void QwtPlotPicker::setAxes( QwtAxisId xAxisId, QwtAxisId yAxisId )
{
    const QwtPlot* plt = plot();
    if ( !plt )
        return;
 
    if ( xAxisId != m_data->xAxisId || yAxisId != m_data->yAxisId )
    {
        m_data->xAxisId = xAxisId;
        m_data->yAxisId = yAxisId;
    }
}
 
QwtAxisId QwtPlotPicker::xAxis() const
{
    return m_data->xAxisId;
}
 
QwtAxisId QwtPlotPicker::yAxis() const
{
    return m_data->yAxisId;
}
 
QwtText QwtPlotPicker::trackerText( const QPoint& pos ) const
{
    if ( plot() == NULL )
        return QwtText();
 
    return trackerTextF( invTransform( pos ) );
}
 
QwtText QwtPlotPicker::trackerTextF( const QPointF& pos ) const
{
    QString text;
 
    switch ( rubberBand() )
    {
        case HLineRubberBand:
            text = QString::number( pos.y(), 'f', 4 );
            break;
        case VLineRubberBand:
            text = QString::number( pos.x(), 'f', 4 );
            break;
        default:
            text = QString::number( pos.x(), 'f', 4 )
                + ", " + QString::number( pos.y(), 'f', 4 );
    }
    return QwtText( text );
}
 
void QwtPlotPicker::append( const QPoint& pos )
{
    QwtPicker::append( pos );
    Q_EMIT appended( invTransform( pos ) );
}
 
void QwtPlotPicker::move( const QPoint& pos )
{
    QwtPicker::move( pos );
    Q_EMIT moved( invTransform( pos ) );
}
 
bool QwtPlotPicker::end( bool ok )
{
    ok = QwtPicker::end( ok );
    if ( !ok )
        return false;
 
    QwtPlot* plot = QwtPlotPicker::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 QPointF pos = invTransform( points.first() );
            Q_EMIT selected( pos );
            break;
        }
        case QwtPickerMachine::RectSelection:
        {
            if ( points.count() >= 2 )
            {
                const QPoint p1 = points.first();
                const QPoint p2 = points.last();
 
                const QRect rect = QRect( p1, p2 ).normalized();
                Q_EMIT selected( invTransform( rect ) );
            }
            break;
        }
        case QwtPickerMachine::PolygonSelection:
        {
            QVector< QPointF > dpa( points.count() );
            for ( int i = 0; i < points.count(); i++ )
                dpa[i] = invTransform( points[i] );
 
            Q_EMIT selected( dpa );
        }
        default:
            break;
    }
 
    return true;
}
 
QRectF QwtPlotPicker::invTransform( const QRect& rect ) const
{
    const QwtScaleMap xMap = plot()->canvasMap( xAxis() );
    const QwtScaleMap yMap = plot()->canvasMap( yAxis() );
 
    return QwtScaleMap::invTransform( xMap, yMap, rect );
}
 
QRect QwtPlotPicker::transform( const QRectF& rect ) const
{
    const QwtScaleMap xMap = plot()->canvasMap( xAxis() );
    const QwtScaleMap yMap = plot()->canvasMap( yAxis() );
 
    return QwtScaleMap::transform( xMap, yMap, rect ).toRect();
}
 
QPointF QwtPlotPicker::invTransform( const QPoint& pos ) const
{
    const QwtScaleMap xMap = plot()->canvasMap( xAxis() );
    const QwtScaleMap yMap = plot()->canvasMap( yAxis() );
 
    return QPointF(
        xMap.invTransform( pos.x() ),
        yMap.invTransform( pos.y() )
        );
}
 
QPoint QwtPlotPicker::transform( const QPointF& pos ) const
{
    const QwtScaleMap xMap = plot()->canvasMap( xAxis() );
    const QwtScaleMap yMap = plot()->canvasMap( yAxis() );
 
    const QPointF p( xMap.transform( pos.x() ), yMap.transform( pos.y() ) );
 
    return p.toPoint();
}
 
#include "moc_qwt_plot_picker.cpp"