qwt_round_scale_draw.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_round_scale_draw.h"
#include "qwt_painter.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_text.h"
#include "qwt_math.h"
 
#include <qpainter.h>
 
class QwtRoundScaleDraw::PrivateData
{
  public:
    PrivateData()
        : center( 50.0, 50.0 )
        , radius( 50.0 )
        , startAngle( -135.0 )
        , endAngle( 135.0 )
    {
    }
 
    QPointF center;
    double radius;
 
    double startAngle;
    double endAngle;
};
 
QwtRoundScaleDraw::QwtRoundScaleDraw()
{
    m_data = new QwtRoundScaleDraw::PrivateData;
 
    setRadius( 50 );
    scaleMap().setPaintInterval( m_data->startAngle, m_data->endAngle );
}
 
QwtRoundScaleDraw::~QwtRoundScaleDraw()
{
    delete m_data;
}
 
void QwtRoundScaleDraw::setRadius( double radius )
{
    m_data->radius = radius;
}
 
double QwtRoundScaleDraw::radius() const
{
    return m_data->radius;
}
 
void QwtRoundScaleDraw::moveCenter( const QPointF& center )
{
    m_data->center = center;
}
 
QPointF QwtRoundScaleDraw::center() const
{
    return m_data->center;
}
 
void QwtRoundScaleDraw::setAngleRange( double angle1, double angle2 )
{
#if 0
    angle1 = qBound( -360.0, angle1, 360.0 );
    angle2 = qBound( -360.0, angle2, 360.0 );
#endif
 
    m_data->startAngle = angle1;
    m_data->endAngle = angle2;
 
    if ( m_data->startAngle == m_data->endAngle )
    {
        m_data->startAngle -= 1;
        m_data->endAngle += 1;
    }
 
    scaleMap().setPaintInterval( m_data->startAngle, m_data->endAngle );
}
 
void QwtRoundScaleDraw::drawLabel( QPainter* painter, double value ) const
{
    const double tval = scaleMap().transform( value );
    if ( ( tval >= m_data->startAngle + 360.0 )
        || ( tval <= m_data->startAngle - 360.0 ) )
    {
        return;
    }
 
    const QwtText label = tickLabel( painter->font(), value );
    if ( label.isEmpty() )
        return;
 
    double radius = m_data->radius;
    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) ||
        hasComponent( QwtAbstractScaleDraw::Backbone ) )
    {
        radius += spacing();
    }
 
    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
        radius += tickLength( QwtScaleDiv::MajorTick );
 
    const QSizeF sz = label.textSize( painter->font() );
    const double arc = qwtRadians( tval );
 
    const double x = m_data->center.x() +
        ( radius + sz.width() / 2.0 ) * std::sin( arc );
    const double y = m_data->center.y() -
        ( radius + sz.height() / 2.0 ) * std::cos( arc );
 
    const QRectF r( x - sz.width() / 2, y - sz.height() / 2,
        sz.width(), sz.height() );
    label.draw( painter, r );
}
 
void QwtRoundScaleDraw::drawTick( QPainter* painter, double value, double len ) const
{
    if ( len <= 0 )
        return;
 
    const double tval = scaleMap().transform( value );
 
    const double cx = m_data->center.x();
    const double cy = m_data->center.y();
    const double radius = m_data->radius;
 
    if ( ( tval < m_data->startAngle + 360.0 )
        && ( tval > m_data->startAngle - 360.0 ) )
    {
        const double arc = qwtRadians( tval );
 
        const double sinArc = std::sin( arc );
        const double cosArc = std::cos( arc );
 
        const double x1 = cx + radius * sinArc;
        const double x2 = cx + ( radius + len ) * sinArc;
        const double y1 = cy - radius * cosArc;
        const double y2 = cy - ( radius + len ) * cosArc;
 
        QwtPainter::drawLine( painter, x1, y1, x2, y2 );
    }
}
 
void QwtRoundScaleDraw::drawBackbone( QPainter* painter ) const
{
    const double deg1 = scaleMap().p1();
    const double deg2 = scaleMap().p2();
 
    const int a1 = qRound( qwtMinF( deg1, deg2 ) - 90 );
    const int a2 = qRound( qwtMaxF( deg1, deg2 ) - 90 );
 
    const double radius = m_data->radius;
    const double x = m_data->center.x() - radius;
    const double y = m_data->center.y() - radius;
 
    painter->drawArc( QRectF( x, y, 2 * radius, 2 * radius ),
        -a2 * 16, ( a2 - a1 + 1 ) * 16 );          // counterclockwise
}
 
double QwtRoundScaleDraw::extent( const QFont& font ) const
{
    double d = 0.0;
 
    if ( hasComponent( QwtAbstractScaleDraw::Labels ) )
    {
        const QwtScaleDiv& sd = scaleDiv();
        const QList< double >& ticks = sd.ticks( QwtScaleDiv::MajorTick );
        for ( int i = 0; i < ticks.count(); i++ )
        {
            const double value = ticks[i];
            if ( !sd.contains( value ) )
                continue;
 
            const double tval = scaleMap().transform( value );
            if ( ( tval < m_data->startAngle + 360 )
                && ( tval > m_data->startAngle - 360 ) )
            {
                const QwtText label = tickLabel( font, value );
                if ( label.isEmpty() )
                    continue;
 
                const double arc = qwtRadians( tval );
 
                const QSizeF sz = label.textSize( font );
                const double off = qMax( sz.width(), sz.height() );
 
                double x = off * std::sin( arc );
                double y = off * std::cos( arc );
 
                const double dist = std::sqrt( x * x + y * y );
                if ( dist > d )
                    d = dist;
            }
        }
    }
 
    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
    {
        d += maxTickLength();
    }
 
    if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
    {
        d += qwtMaxF( penWidthF(), 1.0 );
    }
 
    if ( hasComponent( QwtAbstractScaleDraw::Labels ) &&
        ( hasComponent( QwtAbstractScaleDraw::Ticks ) ||
        hasComponent( QwtAbstractScaleDraw::Backbone ) ) )
    {
        d += spacing();
    }
 
    d = qwtMaxF( d, minimumExtent() );
 
    return d;
}