First shot at it

libs/qwt/qwt_color_map.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
- *****************************************************************************/
-
-#include "qwt_color_map.h"
-#include "qwt_math.h"
-#include "qwt_interval.h"
-#include <qnumeric.h>
-
-class QwtLinearColorMap::ColorStops
-{
-public:
-    ColorStops()
-    {
-        _stops.reserve( 256 );
-    }
-
-    void insert( double pos, const QColor &color );
-    QRgb rgb( QwtLinearColorMap::Mode, double pos ) const;
-
-    QVector<double> stops() const;
-
-private:
-
-    class ColorStop
-    {
-    public:
-        ColorStop():
-            pos( 0.0 ),
-            rgb( 0 )
-        {
-        };
-
-        ColorStop( double p, const QColor &c ):
-            pos( p ),
-            rgb( c.rgb() )
-        {
-            r = qRed( rgb );
-            g = qGreen( rgb );
-            b = qBlue( rgb );
-        }
-
-        double pos;
-        QRgb rgb;
-        int r, g, b;
-    };
-
-    inline int findUpper( double pos ) const;
-    QVector<ColorStop> _stops;
-};
-
-void QwtLinearColorMap::ColorStops::insert( double pos, const QColor &color )
-{
-    // Lookups need to be very fast, insertions are not so important.
-    // Anyway, a balanced tree is what we need here. TODO ...
-
-    if ( pos < 0.0 || pos > 1.0 )
-        return;
-
-    int index;
-    if ( _stops.size() == 0 )
-    {
-        index = 0;
-        _stops.resize( 1 );
-    }
-    else
-    {
-        index = findUpper( pos );
-        if ( index == _stops.size() ||
-                qAbs( _stops[index].pos - pos ) >= 0.001 )
-        {
-            _stops.resize( _stops.size() + 1 );
-            for ( int i = _stops.size() - 1; i > index; i-- )
-                _stops[i] = _stops[i-1];
-        }
-    }
-
-    _stops[index] = ColorStop( pos, color );
-}
-
-inline QVector<double> QwtLinearColorMap::ColorStops::stops() const
-{
-    QVector<double> positions( _stops.size() );
-    for ( int i = 0; i < _stops.size(); i++ )
-        positions[i] = _stops[i].pos;
-    return positions;
-}
-
-inline int QwtLinearColorMap::ColorStops::findUpper( double pos ) const
-{
-    int index = 0;
-    int n = _stops.size();
-
-    const ColorStop *stops = _stops.data();
-
-    while ( n > 0 )
-    {
-        const int half = n >> 1;
-        const int middle = index + half;
-
-        if ( stops[middle].pos <= pos )
-        {
-            index = middle + 1;
-            n -= half + 1;
-        }
-        else
-            n = half;
-    }
-
-    return index;
-}
-
-inline QRgb QwtLinearColorMap::ColorStops::rgb(
-    QwtLinearColorMap::Mode mode, double pos ) const
-{
-    if ( pos <= 0.0 )
-        return _stops[0].rgb;
-    if ( pos >= 1.0 )
-        return _stops[ _stops.size() - 1 ].rgb;
-
-    const int index = findUpper( pos );
-    if ( mode == FixedColors )
-    {
-        return _stops[index-1].rgb;
-    }
-    else
-    {
-        const ColorStop &s1 = _stops[index-1];
-        const ColorStop &s2 = _stops[index];
-
-        const double ratio = ( pos - s1.pos ) / ( s2.pos - s1.pos );
-
-        const int r = s1.r + qRound( ratio * ( s2.r - s1.r ) );
-        const int g = s1.g + qRound( ratio * ( s2.g - s1.g ) );
-        const int b = s1.b + qRound( ratio * ( s2.b - s1.b ) );
-
-        return qRgb( r, g, b );
-    }
-}
-
-//! Constructor
-QwtColorMap::QwtColorMap( Format format ):
-    d_format( format )
-{
-}
-
-//! Destructor
-QwtColorMap::~QwtColorMap()
-{
-}
-
-/*!
-   Build and return a color map of 256 colors
-
-   The color table is needed for rendering indexed images in combination
-   with using colorIndex().
-
-   \param interval Range for the values
-   \return A color table, that can be used for a QImage
-*/
-QVector<QRgb> QwtColorMap::colorTable( const QwtInterval &interval ) const
-{
-    QVector<QRgb> table( 256 );
-
-    if ( interval.isValid() )
-    {
-        const double step = interval.width() / ( table.size() - 1 );
-        for ( int i = 0; i < table.size(); i++ )
-            table[i] = rgb( interval, interval.minValue() + step * i );
-    }
-
-    return table;
-}
-
-class QwtLinearColorMap::PrivateData
-{
-public:
-    ColorStops colorStops;
-    QwtLinearColorMap::Mode mode;
-};
-
-/*!
-   Build a color map with two stops at 0.0 and 1.0. The color
-   at 0.0 is Qt::blue, at 1.0 it is Qt::yellow.
-
-   \param format Preferred format of the color map
-*/
-QwtLinearColorMap::QwtLinearColorMap( QwtColorMap::Format format ):
-    QwtColorMap( format )
-{
-    d_data = new PrivateData;
-    d_data->mode = ScaledColors;
-
-    setColorInterval( Qt::blue, Qt::yellow );
-}
-
-/*!
-   Build a color map with two stops at 0.0 and 1.0.
-
-   \param color1 Color used for the minimum value of the value interval
-   \param color2 Color used for the maximum value of the value interval
-   \param format Preferred format for the color map
-*/
-QwtLinearColorMap::QwtLinearColorMap( const QColor &color1,
-        const QColor &color2, QwtColorMap::Format format ):
-    QwtColorMap( format )
-{
-    d_data = new PrivateData;
-    d_data->mode = ScaledColors;
-    setColorInterval( color1, color2 );
-}
-
-//! Destructor
-QwtLinearColorMap::~QwtLinearColorMap()
-{
-    delete d_data;
-}
-
-/*!
-   \brief Set the mode of the color map
-
-   FixedColors means the color is calculated from the next lower
-   color stop. ScaledColors means the color is calculated
-   by interpolating the colors of the adjacent stops.
-
-   \sa mode()
-*/
-void QwtLinearColorMap::setMode( Mode mode )
-{
-    d_data->mode = mode;
-}
-
-/*!
-   \return Mode of the color map
-   \sa setMode()
-*/
-QwtLinearColorMap::Mode QwtLinearColorMap::mode() const
-{
-    return d_data->mode;
-}
-
-/*!
-   Set the color range
-
-   Add stops at 0.0 and 1.0.
-
-   \param color1 Color used for the minimum value of the value interval
-   \param color2 Color used for the maximum value of the value interval
-
-   \sa color1(), color2()
-*/
-void QwtLinearColorMap::setColorInterval(
-    const QColor &color1, const QColor &color2 )
-{
-    d_data->colorStops = ColorStops();
-    d_data->colorStops.insert( 0.0, color1 );
-    d_data->colorStops.insert( 1.0, color2 );
-}
-
-/*!
-   Add a color stop
-
-   The value has to be in the range [0.0, 1.0].
-   F.e. a stop at position 17.0 for a range [10.0,20.0] must be
-   passed as: (17.0 - 10.0) / (20.0 - 10.0)
-
-   \param value Value between [0.0, 1.0]
-   \param color Color stop
-*/
-void QwtLinearColorMap::addColorStop( double value, const QColor& color )
-{
-    if ( value >= 0.0 && value <= 1.0 )
-        d_data->colorStops.insert( value, color );
-}
-
-/*!
-   \return Positions of color stops in increasing order
-*/
-QVector<double> QwtLinearColorMap::colorStops() const
-{
-    return d_data->colorStops.stops();
-}
-
-/*!
-  \return the first color of the color range
-  \sa setColorInterval()
-*/
-QColor QwtLinearColorMap::color1() const
-{
-    return QColor( d_data->colorStops.rgb( d_data->mode, 0.0 ) );
-}
-
-/*!
-  \return the second color of the color range
-  \sa setColorInterval()
-*/
-QColor QwtLinearColorMap::color2() const
-{
-    return QColor( d_data->colorStops.rgb( d_data->mode, 1.0 ) );
-}
-
-/*!
-  Map a value of a given interval into a RGB value
-
-  \param interval Range for all values
-  \param value Value to map into a RGB value
-
-  \return RGB value for value
-*/
-QRgb QwtLinearColorMap::rgb(
-    const QwtInterval &interval, double value ) const
-{
-    if ( qIsNaN(value) )
-        return qRgba(0, 0, 0, 0);
-
-    const double width = interval.width();
-
-    double ratio = 0.0;
-    if ( width > 0.0 )
-        ratio = ( value - interval.minValue() ) / width;
-
-    return d_data->colorStops.rgb( d_data->mode, ratio );
-}
-
-/*!
-  \brief Map a value of a given interval into a color index
-
-  \param interval Range for all values
-  \param value Value to map into a color index
-
-  \return Index, between 0 and 255
-*/
-unsigned char QwtLinearColorMap::colorIndex(
-    const QwtInterval &interval, double value ) const
-{
-    const double width = interval.width();
-
-    if ( qIsNaN(value) || width <= 0.0 || value <= interval.minValue() )
-        return 0;
-
-    if ( value >= interval.maxValue() )
-        return 255;
-
-    const double ratio = ( value - interval.minValue() ) / width;
-
-    unsigned char index;
-    if ( d_data->mode == FixedColors )
-        index = static_cast<unsigned char>( ratio * 255 ); // always floor
-    else
-        index = static_cast<unsigned char>( qRound( ratio * 255 ) );
-
-    return index;
-}
-
-class QwtAlphaColorMap::PrivateData
-{
-public:
-    QColor color;
-    QRgb rgb;
-};
-
-
-/*!
-   Constructor
-   \param color Color of the map
-*/
-QwtAlphaColorMap::QwtAlphaColorMap( const QColor &color ):
-    QwtColorMap( QwtColorMap::RGB )
-{
-    d_data = new PrivateData;
-    d_data->color = color;
-    d_data->rgb = color.rgb() & qRgba( 255, 255, 255, 0 );
-}
-
-//! Destructor
-QwtAlphaColorMap::~QwtAlphaColorMap()
-{
-    delete d_data;
-}
-
-/*!
-   Set the color
-
-   \param color Color
-   \sa color()
-*/
-void QwtAlphaColorMap::setColor( const QColor &color )
-{
-    d_data->color = color;
-    d_data->rgb = color.rgb();
-}
-
-/*!
-  \return the color
-  \sa setColor()
-*/
-QColor QwtAlphaColorMap::color() const
-{
-    return d_data->color;
-}
-
-/*!
-  \brief Map a value of a given interval into a alpha value
-
-  alpha := (value - interval.minValue()) / interval.width();
-
-  \param interval Range for all values
-  \param value Value to map into a RGB value
-  \return RGB value, with an alpha value
-*/
-QRgb QwtAlphaColorMap::rgb( const QwtInterval &interval, double value ) const
-{
-    const double width = interval.width();
-    if ( !qIsNaN(value) && width >= 0.0 )
-    {
-        const double ratio = ( value - interval.minValue() ) / width;
-        int alpha = qRound( 255 * ratio );
-        if ( alpha < 0 )
-            alpha = 0;
-        if ( alpha > 255 )
-            alpha = 255;
-
-        return d_data->rgb | ( alpha << 24 );
-    }
-    return d_data->rgb;
-}
-
-/*!
-  Dummy function, needed to be implemented as it is pure virtual
-  in QwtColorMap. Color indices make no sense in combination with
-  an alpha channel.
-
-  \return Always 0
-*/
-unsigned char QwtAlphaColorMap::colorIndex(
-    const QwtInterval &, double ) const
-{
-    return 0;
-}

libs/qwt/qwt_color_map.h

-/* -*- 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
- *****************************************************************************/
-
-#ifndef QWT_COLOR_MAP_H
-#define QWT_COLOR_MAP_H
-
-#include "qwt_global.h"
-#include "qwt_interval.h"
-#include <qcolor.h>
-#include <qvector.h>
-
-/*!
-  \brief QwtColorMap is used to map values into colors.
-
-  For displaying 3D data on a 2D plane the 3rd dimension is often
-  displayed using colors, like f.e in a spectrogram.
-
-  Each color map is optimized to return colors for only one of the
-  following image formats:
-
-  - QImage::Format_Indexed8\n
-  - QImage::Format_ARGB32\n
-
-  \sa QwtPlotSpectrogram, QwtScaleWidget
-*/
-
-class QWT_EXPORT QwtColorMap
-{
-public:
-    /*!
-        Format for color mapping
-        \sa rgb(), colorIndex(), colorTable()
-    */
-
-    enum Format
-    {
-        //! The map is intended to map into RGB values.
-        RGB,
-
-        /*!
-          The map is intended to map into 8 bit values, that
-          are indices into the color table.
-         */
-        Indexed
-    };
-
-    QwtColorMap( Format = QwtColorMap::RGB );
-    virtual ~QwtColorMap();
-
-    Format format() const;
-
-    /*!
-       Map a value of a given interval into a RGB value.
-
-       \param interval Range for the values
-       \param value Value
-       \return RGB value, corresponding to value
-    */
-    virtual QRgb rgb( const QwtInterval &interval,
-        double value ) const = 0;
-
-    /*!
-       Map a value of a given interval into a color index
-
-       \param interval Range for the values
-       \param value Value
-       \return color index, corresponding to value
-     */
-    virtual unsigned char colorIndex(
-        const QwtInterval &interval, double value ) const = 0;
-
-    QColor color( const QwtInterval &, double value ) const;
-    virtual QVector<QRgb> colorTable( const QwtInterval & ) const;
-
-private:
-    Format d_format;
-};
-
-/*!
-  \brief QwtLinearColorMap builds a color map from color stops.
-
-  A color stop is a color at a specific position. The valid
-  range for the positions is [0.0, 1.0]. When mapping a value
-  into a color it is translated into this interval according to mode().
-*/
-class QWT_EXPORT QwtLinearColorMap: public QwtColorMap
-{
-public:
-    /*!
-       Mode of color map
-       \sa setMode(), mode()
-    */
-    enum Mode
-    {
-        //! Return the color from the next lower color stop
-        FixedColors,
-
-        //! Interpolating the colors of the adjacent stops.
-        ScaledColors
-    };
-
-    QwtLinearColorMap( QwtColorMap::Format = QwtColorMap::RGB );
-    QwtLinearColorMap( const QColor &from, const QColor &to,
-        QwtColorMap::Format = QwtColorMap::RGB );
-
-    virtual ~QwtLinearColorMap();
-
-    void setMode( Mode );
-    Mode mode() const;
-
-    void setColorInterval( const QColor &color1, const QColor &color2 );
-    void addColorStop( double value, const QColor& );
-    QVector<double> colorStops() const;
-
-    QColor color1() const;
-    QColor color2() const;
-
-    virtual QRgb rgb( const QwtInterval &, double value ) const;
-    virtual unsigned char colorIndex(
-        const QwtInterval &, double value ) const;
-
-    class ColorStops;
-
-private:
-    // Disabled copy constructor and operator=
-    QwtLinearColorMap( const QwtLinearColorMap & );
-    QwtLinearColorMap &operator=( const QwtLinearColorMap & );
-
-    class PrivateData;
-    PrivateData *d_data;
-};
-
-/*!
-  \brief QwtAlphaColorMap varies the alpha value of a color
-*/
-class QWT_EXPORT QwtAlphaColorMap: public QwtColorMap
-{
-public:
-    QwtAlphaColorMap( const QColor & = QColor( Qt::gray ) );
-    virtual ~QwtAlphaColorMap();
-
-    void setColor( const QColor & );
-    QColor color() const;
-
-    virtual QRgb rgb( const QwtInterval &, double value ) const;
-
-private:
-    QwtAlphaColorMap( const QwtAlphaColorMap & );
-    QwtAlphaColorMap &operator=( const QwtAlphaColorMap & );
-
-    virtual unsigned char colorIndex(
-        const QwtInterval &, double value ) const;
-
-    class PrivateData;
-    PrivateData *d_data;
-};
-
-
-/*!
-   Map a value into a color
-
-   \param interval Valid interval for values
-   \param value Value
-
-   \return Color corresponding to value
-
-   \warning This method is slow for Indexed color maps. If it is
-            necessary to map many values, its better to get the
-            color table once and find the color using colorIndex().
-*/
-inline QColor QwtColorMap::color(
-    const QwtInterval &interval, double value ) const
-{
-    if ( d_format == RGB )
-    {
-        return QColor( rgb( interval, value ) );
-    }
-    else
-    {
-        const unsigned int index = colorIndex( interval, value );
-        return colorTable( interval )[index]; // slow
-    }
-}
-
-/*!
-   \return Intended format of the color map
-   \sa Format
-*/
-inline QwtColorMap::Format QwtColorMap::format() const
-{
-    return d_format;
-}
-
-#endif

libs/qwt/qwt_column_symbol.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
- *****************************************************************************/
-
-#include "qwt_column_symbol.h"
-#include "qwt_math.h"
-#include "qwt_painter.h"
-#include <qpainter.h>
-#include <qpalette.h>
-
-static void qwtDrawBox( QPainter *p, const QRectF &rect,
-    const QPalette &pal, double lw )
-{
-    if ( lw > 0.0 )
-    {
-        if ( rect.width() == 0.0 )
-        {
-            p->setPen( pal.dark().color() );
-            p->drawLine( rect.topLeft(), rect.bottomLeft() );
-            return;
-        }
-
-        if ( rect.height() == 0.0 )
-        {
-            p->setPen( pal.dark().color() );
-            p->drawLine( rect.topLeft(), rect.topRight() );
-            return;
-        }
-
-        lw = qMin( lw, rect.height() / 2.0 - 1.0 );
-        lw = qMin( lw, rect.width() / 2.0 - 1.0 );
-
-        const QRectF outerRect = rect.adjusted( 0, 0, 1, 1 );
-        QPolygonF polygon( outerRect );
-
-        if ( outerRect.width() > 2 * lw &&
-                outerRect.height() > 2 * lw )
-        {
-            const QRectF innerRect = outerRect.adjusted( lw, lw, -lw, -lw );
-            polygon = polygon.subtracted( innerRect );
-        }
-
-        p->setPen( Qt::NoPen );
-
-        p->setBrush( pal.dark() );
-        p->drawPolygon( polygon );
-    }
-
-    const QRectF windowRect = rect.adjusted( lw, lw, -lw + 1, -lw + 1 );
-    if ( windowRect.isValid() )
-        p->fillRect( windowRect, pal.window() );
-}
-
-static void qwtDrawPanel( QPainter *painter, const QRectF &rect,
-    const QPalette &pal, double lw )
-{
-    if ( lw > 0.0 )
-    {
-        if ( rect.width() == 0.0 )
-        {
-            painter->setPen( pal.window().color() );
-            painter->drawLine( rect.topLeft(), rect.bottomLeft() );
-            return;
-        }
-
-        if ( rect.height() == 0.0 )
-        {
-            painter->setPen( pal.window().color() );
-            painter->drawLine( rect.topLeft(), rect.topRight() );
-            return;
-        }
-
-        lw = qMin( lw, rect.height() / 2.0 - 1.0 );
-        lw = qMin( lw, rect.width() / 2.0 - 1.0 );
-
-        const QRectF outerRect = rect.adjusted( 0, 0, 1, 1 );
-        const QRectF innerRect = outerRect.adjusted( lw, lw, -lw, -lw );
-
-        QPolygonF lines[2];
-
-        lines[0] += outerRect.bottomLeft();
-        lines[0] += outerRect.topLeft();
-        lines[0] += outerRect.topRight();
-        lines[0] += innerRect.topRight();
-        lines[0] += innerRect.topLeft();
-        lines[0] += innerRect.bottomLeft();
-
-        lines[1] += outerRect.topRight();
-        lines[1] += outerRect.bottomRight();
-        lines[1] += outerRect.bottomLeft();
-        lines[1] += innerRect.bottomLeft();
-        lines[1] += innerRect.bottomRight();
-        lines[1] += innerRect.topRight();
-
-        painter->setPen( Qt::NoPen );
-
-        painter->setBrush( pal.light() );
-        painter->drawPolygon( lines[0] );
-        painter->setBrush( pal.dark() );
-        painter->drawPolygon( lines[1] );
-    }
-
-    painter->fillRect( rect.adjusted( lw, lw, -lw + 1, -lw + 1 ), pal.window() );
-}
-
-class QwtColumnSymbol::PrivateData
-{
-public:
-    PrivateData():
-        style( QwtColumnSymbol::Box ),
-        frameStyle( QwtColumnSymbol::Raised ),
-        lineWidth( 2 )
-    {
-        palette = QPalette( Qt::gray );
-    }
-
-    QwtColumnSymbol::Style style;
-    QwtColumnSymbol::FrameStyle frameStyle;
-
-    QPalette palette;
-    int lineWidth;
-};
-
-/*!
-  Constructor
-
-  \param style Style of the symbol
-  \sa setStyle(), style(), Style
-*/
-QwtColumnSymbol::QwtColumnSymbol( Style style )
-{
-    d_data = new PrivateData();
-    d_data->style = style;
-}
-
-//! Destructor
-QwtColumnSymbol::~QwtColumnSymbol()
-{
-    delete d_data;
-}
-
-/*!
-  Specify the symbol style
-
-  \param style Style
-  \sa style(), setPalette()
-*/
-void QwtColumnSymbol::setStyle( Style style )
-{
-    d_data->style = style;
-}
-
-/*!
-  \return Current symbol style
-  \sa setStyle()
-*/
-QwtColumnSymbol::Style QwtColumnSymbol::style() const
-{
-    return d_data->style;
-}
-
-/*!
-  Assign a palette for the symbol
-
-  \param palette Palette
-  \sa palette(), setStyle()
-*/
-void QwtColumnSymbol::setPalette( const QPalette &palette )
-{
-    d_data->palette = palette;
-}
-
-/*!
-  \return Current palette
-  \sa setPalette()
-*/
-const QPalette& QwtColumnSymbol::palette() const
-{
-    return d_data->palette;
-}
-
-/*!
-   Set the frame, that is used for the Box style.
-
-   \param frameStyle Frame style
-   \sa frameStyle(), setLineWidth(), setStyle()
-*/
-void QwtColumnSymbol::setFrameStyle( FrameStyle frameStyle )
-{
-    d_data->frameStyle = frameStyle;
-}
-
-/*!
-  \return Current frame style, that is used for the Box style.
-  \sa setFrameStyle(), lineWidth(), setStyle()
-*/
-QwtColumnSymbol::FrameStyle QwtColumnSymbol::frameStyle() const
-{
-    return d_data->frameStyle;
-}
-
-/*!
-   Set the line width of the frame, that is used for the Box style.
-
-   \param width Width
-   \sa lineWidth(), setFrameStyle()
-*/
-void QwtColumnSymbol::setLineWidth( int width )
-{
-    if ( width < 0 )
-        width = 0;
-
-    d_data->lineWidth = width;
-}
-
-/*!
-  \return Line width of the frame, that is used for the Box style.
-  \sa setLineWidth(), frameStyle(), setStyle()
-*/
-int QwtColumnSymbol::lineWidth() const
-{
-    return d_data->lineWidth;
-}
-
-/*!
-  Draw the symbol depending on its style.
-
-  \param painter Painter
-  \param rect Directed rectangle
-
-  \sa drawBox()
-*/
-void QwtColumnSymbol::draw( QPainter *painter,
-    const QwtColumnRect &rect ) const
-{
-    painter->save();
-
-    switch ( d_data->style )
-    {
-        case QwtColumnSymbol::Box:
-        {
-            drawBox( painter, rect );
-            break;
-        }
-        default:;
-    }
-
-    painter->restore();
-}
-
-/*!
-  Draw the symbol when it is in Box style.
-
-  \param painter Painter
-  \param rect Directed rectangle
-
-  \sa draw()
-*/
-void QwtColumnSymbol::drawBox( QPainter *painter,
-    const QwtColumnRect &rect ) const
-{
-    QRectF r = rect.toRect();
-    if ( QwtPainter::roundingAlignment( painter ) )
-    {
-        r.setLeft( qRound( r.left() ) );
-        r.setRight( qRound( r.right() ) );
-        r.setTop( qRound( r.top() ) );
-        r.setBottom( qRound( r.bottom() ) );
-    }
-
-    switch ( d_data->frameStyle )
-    {
-        case QwtColumnSymbol::Raised:
-        {
-            qwtDrawPanel( painter, r, d_data->palette, d_data->lineWidth );
-            break;
-        }
-        case QwtColumnSymbol::Plain:
-        {
-            qwtDrawBox( painter, r, d_data->palette, d_data->lineWidth );
-            break;
-        }
-        default:
-        {
-            painter->fillRect( r, d_data->palette.window() );
-        }
-    }
-}

libs/qwt/qwt_compass.h

-/* -*- 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
- *****************************************************************************/
-
-#ifndef QWT_COMPASS_H
-#define QWT_COMPASS_H 1
-
-#include "qwt_global.h"
-#include "qwt_dial.h"
-#include "qwt_round_scale_draw.h"
-#include <qstring.h>
-#include <qmap.h>
-
-class QwtCompassRose;
-
-/*!
-  \brief A special scale draw made for QwtCompass
-
-  QwtCompassScaleDraw maps values to strings using
-  a special map, that can be modified by the application
-
-  The default map consists of the labels N, NE, E, SE, S, SW, W, NW.
-
-  \sa QwtCompass
-*/
-class QWT_EXPORT QwtCompassScaleDraw: public QwtRoundScaleDraw
-{
-public:
-    explicit QwtCompassScaleDraw();
-    explicit QwtCompassScaleDraw( const QMap<double, QString> &map );
-
-    void setLabelMap( const QMap<double, QString> &map );
-    QMap<double, QString> labelMap() const;
-
-    virtual QwtText label( double value ) const;
-
-private:
-    QMap<double, QString> d_labelMap;
-};
-
-/*!
-  \brief A Compass Widget
-
-  QwtCompass is a widget to display and enter directions. It consists
-  of a scale, an optional needle and rose.
-
-  \image html dials1.png
-
-  \note The examples/dials example shows how to use QwtCompass.
-*/
-
-class QWT_EXPORT QwtCompass: public QwtDial
-{
-    Q_OBJECT
-
-public:
-    explicit QwtCompass( QWidget* parent = NULL );
-    virtual ~QwtCompass();
-
-    void setRose( QwtCompassRose *rose );
-    const QwtCompassRose *rose() const;
-    QwtCompassRose *rose();
-
-protected:
-    virtual void drawRose( QPainter *, const QPointF &center,
-        double radius, double north, QPalette::ColorGroup ) const;
-
-    virtual void drawScaleContents( QPainter *,
-        const QPointF &center, double radius ) const;
-
-    virtual void keyPressEvent( QKeyEvent * );
-
-private:
-    class PrivateData;
-    PrivateData *d_data;
-};
-
-#endif

libs/qwt/qwt_compat.h

-/* -*- 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
- *****************************************************************************/
-
-#ifndef _QWT_COMPAT_H_
-#define _QWT_COMPAT_H_
-
-#include "qwt_global.h"
-#include "qwt_interval.h"
-#include "qwt_point_3d.h"
-#include <qlist.h>
-#include <qvector.h>
-#include <qpoint.h>
-#include <qsize.h>
-#include <qrect.h>
-#include <qpolygon.h>
-
-// A couple of definition for Qwt5 compatibility
-
-#define qwtMax qMax
-#define qwtMin qMin
-#define qwtAbs qAbs
-#define qwtRound qRound
-
-#define QwtArray QVector
-
-typedef QList<double> QwtValueList;
-typedef QPointF QwtDoublePoint;
-typedef QSizeF QwtDoubleSize;
-typedef QRectF QwtDoubleRect;
-
-typedef QPolygon QwtPolygon;
-typedef QPolygonF QwtPolygonF;
-typedef QwtInterval QwtDoubleInterval;
-typedef QwtPoint3D QwtDoublePoint3D;
-
-#endif