qwt_round_scale_draw.cpp

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * 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
 *****************************************************************************/

// vim: expandtab

#include <math.h>
#include <qpen.h>
#include <qpainter.h>
#include <qfontmetrics.h>
#include "qwt_painter.h"
#include "qwt_scale_div.h"
#include "qwt_scale_map.h"
#include "qwt_round_scale_draw.h"

class QwtRoundScaleDraw::PrivateData
{
public:
    PrivateData():
        center(50, 50),
        radius(50),
        minAngle(-135 * 16),
        maxAngle(135 * 16)
    {
    }

    QPoint center;
    int radius; 

    int minAngle;
    int maxAngle;
};

QwtRoundScaleDraw::QwtRoundScaleDraw()
{
    d_data = new QwtRoundScaleDraw::PrivateData;

    setRadius(50);
    scaleMap().setPaintInterval(d_data->minAngle, d_data->maxAngle);
}

QwtRoundScaleDraw::QwtRoundScaleDraw(const QwtRoundScaleDraw &other):
    QwtAbstractScaleDraw(other)
{
    d_data = new QwtRoundScaleDraw::PrivateData(*other.d_data);
}


QwtRoundScaleDraw::~QwtRoundScaleDraw()
{
    delete d_data;
}

QwtRoundScaleDraw &QwtRoundScaleDraw::operator=(const QwtRoundScaleDraw &other)
{
    *(QwtAbstractScaleDraw*)this = (const QwtAbstractScaleDraw &)other;
    *d_data = *other.d_data;
    return *this;
}

void QwtRoundScaleDraw::setRadius(int radius)
{
    d_data->radius = radius;
}

int QwtRoundScaleDraw::radius() const
{
    return d_data->radius;
}

void QwtRoundScaleDraw::moveCenter(const QPoint &center)
{
    d_data->center = center;
}

QPoint QwtRoundScaleDraw::center() const
{
    return d_data->center;
}

void QwtRoundScaleDraw::setAngleRange(double angle1, double angle2)
{
    angle1 = qwtLim(angle1, -360.0, 360.0);
    angle2 = qwtLim(angle2, -360.0, 360.0);

    int amin = qRound(qwtMin(angle1, angle2) * 16.0);
    int amax = qRound(qwtMax(angle1, angle2) * 16.0); 
 
    if (amin == amax)
    {
        amin -= 1;
        amax += 1;
    }
 
    d_data->minAngle = amin;
    d_data->maxAngle = amax;
    scaleMap().setPaintInterval(d_data->minAngle, d_data->maxAngle);
}

void QwtRoundScaleDraw::drawLabel(QPainter *painter, double value) const
{
    const QwtText label = tickLabel(painter->font(), value);
    if ( label.isEmpty() )
        return; 

    const int tval = map().transform(value);
    if ((tval > d_data->minAngle + 359 * 16)
        || (tval < d_data->minAngle - 359 * 16))
    {
       return; 
    }

    double radius = d_data->radius;
    if ( hasComponent(QwtAbstractScaleDraw::Ticks) ||
        hasComponent(QwtAbstractScaleDraw::Backbone) )
    {
        radius += spacing();
    }

    if ( hasComponent(QwtAbstractScaleDraw::Ticks) )
        radius += majTickLength();

    const QSize sz = label.textSize(painter->font());
    const double arc = tval / 16.0 / 360.0 * 2 * M_PI;

    const int x = d_data->center.x() +
        qRound((radius + sz.width() / 2.0) * sin(arc));
    const int y = d_data->center.y() -
        qRound( (radius + sz.height() / 2.0) * cos(arc));

    const QRect r(x - sz.width() / 2, y - sz.height() / 2,
        sz.width(), sz.height() );
    label.draw(painter, r);
}

void QwtRoundScaleDraw::drawTick(QPainter *painter, double value, int len) const
{
    if ( len <= 0 )
        return;

    const int tval = map().transform(value);

    const int cx = d_data->center.x();
    const int cy = d_data->center.y();
    const int radius = d_data->radius;

    if ((tval <= d_data->minAngle + 359 * 16)
        || (tval >= d_data->minAngle - 359 * 16))
    {
        const double arc = double(tval) / 16.0 * M_PI / 180.0;

        const double sinArc = sin(arc);
        const double cosArc = cos(arc);

        const int x1 = qRound( cx + radius * sinArc );
        const int x2 = qRound( cx + (radius + len) * sinArc );
        const int y1 = qRound( cy - radius * cosArc );
        const int y2 = qRound( cy - (radius + len) * cosArc );

        QwtPainter::drawLine(painter, x1, y1, x2, y2);
    }
}

void QwtRoundScaleDraw::drawBackbone(QPainter *painter) const
{
    const int a1 = qRound(qwtMin(map().p1(), map().p2()) - 90 * 16);
    const int a2 = qRound(qwtMax(map().p1(), map().p2()) - 90 * 16);

    const int radius = d_data->radius;
    const int x = d_data->center.x() - radius;
    const int y = d_data->center.y() - radius;

    painter->drawArc(x, y, 2 * radius, 2 * radius,
        -a2, a2 - a1 + 1);           // counterclockwise
}

int QwtRoundScaleDraw::extent(const QPen &pen, const QFont &font) const
{
    int d = 0;

    if ( hasComponent(QwtAbstractScaleDraw::Labels) )
    {
        const QwtScaleDiv &sd = scaleDiv();
        const QwtValueList &ticks = sd.ticks(QwtScaleDiv::MajorTick);
        for (uint i = 0; i < (uint)ticks.count(); i++)
        {
            const double value = ticks[i];
            if ( !sd.contains(value) )
                continue;

            const QwtText label = tickLabel(font, value);
            if ( label.isEmpty() )
                continue;
                
            const int tval = map().transform(value);
            if ((tval < d_data->minAngle + 360 * 16)
                && (tval > d_data->minAngle - 360 * 16))
            {
                const double arc = tval / 16.0 / 360.0 * 2 * M_PI;

                const QSize sz = label.textSize(font);
                const double off = qwtMax(sz.width(), sz.height());

                double x = off * sin(arc);
                double y = off * cos(arc);

                const int dist = (int)ceil(sqrt(x * x + y * y) + 1 );
                if ( dist > d )
                    d = dist;
            }
        }
    }

    if ( hasComponent(QwtAbstractScaleDraw::Ticks) )
    {
        d += majTickLength();
    }

    if ( hasComponent(QwtAbstractScaleDraw::Backbone) )
    {
        const int pw = qwtMax( 1, pen.width() );  // penwidth can be zero
        d += pw;
    }

    if ( hasComponent(QwtAbstractScaleDraw::Labels) &&
        ( hasComponent(QwtAbstractScaleDraw::Ticks) || 
            hasComponent(QwtAbstractScaleDraw::Backbone) ) )
    {
        d += spacing();
    }

    d = qwtMax(d, minimumExtent());

    return d;
}

---