qwt_compass.cpp

Go to the documentation of this file.

/* -*- 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
 *****************************************************************************/

#include "qwt_compass.h"
#include "qwt_compass_rose.h"
#include "qwt_text.h"

#include <qevent.h>
#include <qmap.h>

class QwtCompassScaleDraw::PrivateData
{
public:
    QMap<double, QString> labelMap;
};

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

    enableComponent( QwtAbstractScaleDraw::Backbone, false );
    enableComponent( QwtAbstractScaleDraw::Ticks, false );

    QMap<double, QString> &map = d_data->labelMap;

    map.insert( 0.0, QString::fromLatin1( "N" ) );
    map.insert( 45.0, QString::fromLatin1( "NE" ) );
    map.insert( 90.0, QString::fromLatin1( "E" ) );
    map.insert( 135.0, QString::fromLatin1( "SE" ) );
    map.insert( 180.0, QString::fromLatin1( "S" ) );
    map.insert( 225.0, QString::fromLatin1( "SW" ) );
    map.insert( 270.0, QString::fromLatin1( "W" ) );
    map.insert( 315.0, QString::fromLatin1( "NW" ) );

#if 0
    map.insert( 22.5, QString::fromLatin1( "NNE" ) );
    map.insert( 67.5, QString::fromLatin1( "NEE" ) );
    map.insert( 112.5, QString::fromLatin1( "SEE" ) );
    map.insert( 157.5, QString::fromLatin1( "SSE" ) );
    map.insert( 202.5, QString::fromLatin1( "SSW" ) );
    map.insert( 247.5, QString::fromLatin1( "SWW" ) );
    map.insert( 292.5, QString::fromLatin1( "NWW" ) );
    map.insert( 337.5, QString::fromLatin1( "NNW" ) );
#endif
}

QwtCompassScaleDraw::QwtCompassScaleDraw( const QMap<double, QString> &map )
{
    d_data = new PrivateData;
    d_data->labelMap = map;

    enableComponent( QwtAbstractScaleDraw::Backbone, false );
    enableComponent( QwtAbstractScaleDraw::Ticks, false );
}

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

void QwtCompassScaleDraw::setLabelMap( const QMap<double, QString> &map )
{
    d_data->labelMap = map;
}

QMap<double, QString> QwtCompassScaleDraw::labelMap() const
{
    return d_data->labelMap;
}

QwtText QwtCompassScaleDraw::label( double value ) const
{
    if ( qFuzzyCompare( value + 1.0, 1.0 ) )
        value = 0.0;

    if ( value < 0.0 )
        value += 360.0;

    QMap<double, QString>::const_iterator it =
        d_data->labelMap.constFind( value );

    if ( it != d_data->labelMap.constEnd() )
        return *it;

    return QwtText();
}

class QwtCompass::PrivateData
{
public:
    PrivateData():
        rose( NULL )
    {
    }

    ~PrivateData()
    {
        delete rose;
    }

    QwtCompassRose *rose;
};

QwtCompass::QwtCompass( QWidget* parent ):
    QwtDial( parent )
{
    d_data = new PrivateData;

    setScaleDraw( new QwtCompassScaleDraw() );

    setOrigin( 270.0 );
    setWrapping( true );

    setScaleMaxMajor( 36 );
    setScaleMaxMinor( 10 );

    setScale( 0.0, 360.0 ); // degrees as default
    setTotalSteps( 360 );
}

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


void QwtCompass::drawScaleContents( QPainter *painter,
    const QPointF &center, double radius ) const
{
    QPalette::ColorGroup cg;
    if ( isEnabled() )
        cg = hasFocus() ? QPalette::Active : QPalette::Inactive;
    else
        cg = QPalette::Disabled;

    double north = origin();
    if ( isValid() )
    {
        if ( mode() == RotateScale )
            north -= value();
    }

    const int margin = 4;
    drawRose( painter, center, radius - margin, 360.0 - north,  cg );
}

void QwtCompass::drawRose( QPainter *painter, const QPointF &center,
    double radius, double north, QPalette::ColorGroup cg ) const
{
    if ( d_data->rose )
        d_data->rose->draw( painter, center, radius, north,  cg );
}

void QwtCompass::setRose( QwtCompassRose *rose )
{
    if ( rose != d_data->rose )
    {
        if ( d_data->rose )
            delete d_data->rose;

        d_data->rose = rose;
        update();
    }
}

const QwtCompassRose *QwtCompass::rose() const
{
    return d_data->rose;
}

QwtCompassRose *QwtCompass::rose()
{
    return d_data->rose;
}

void QwtCompass::keyPressEvent( QKeyEvent *kev )
{
    if ( isReadOnly() )
        return;

#if 0
    if ( kev->key() == Key_5 )
    {
        invalidate(); // signal ???
        return;
    }
#endif

    double newValue = value();

    if ( kev->key() >= Qt::Key_1 && kev->key() <= Qt::Key_9 )
    {
        if ( mode() != RotateNeedle || kev->key() == Qt::Key_5 )
            return;

        switch ( kev->key() )
        {
            case Qt::Key_6:
                newValue = 180.0 * 0.0;
                break;
            case Qt::Key_3:
                newValue = 180.0 * 0.25;
                break;
            case Qt::Key_2:
                newValue = 180.0 * 0.5;
                break;
            case Qt::Key_1:
                newValue = 180.0 * 0.75;
                break;
            case Qt::Key_4:
                newValue = 180.0 * 1.0;
                break;
            case Qt::Key_7:
                newValue = 180.0 * 1.25;
                break;
            case Qt::Key_8:
                newValue = 180.0 * 1.5;
                break;
            case Qt::Key_9:
                newValue = 180.0 * 1.75;
                break;
        }
        newValue -= origin();
        setValue( newValue );
    }
    else
    {
        QwtDial::keyPressEvent( kev );
    }
}

#if QWT_MOC_INCLUDE
#include "moc_qwt_compass.cpp"
#endif