Merge remote-tracking branch 'upstream/master' into hil_quad

QGCExternalLibs.pri

@@ -320,7 +320,9 @@ INCLUDEPATH += \
 #
 # [REQUIRED] QWT plotting library dependency. Provides plotting capabilities.
 #
-include(libs/qwt/qwt.pri)
+include(libs/qwt.pri)
+DEPENDPATH += libs/qwt
+INCLUDEPATH += libs/qwt
 
 #
 # [REQUIRED] QSerialPort library. Provides serial port wrapper library.

libs/README.md

+This folder contains the various required libraries for QGC to compile. They are distributed with the codebase to ease development.
+
+# Qwt
+Qt Widgets for Technical Applications
+Version: 6.1
+Source obtained: `svn checkout svn://svn.code.sf.net/p/qwt/code/branches/qwt-6.1 qwt`
+
+Contents of `/libs/qwt` is the contents of the `/src` directory from the Qwt repository.
+qwt.pri file is custom made to compile all necessary Qwt code in with QGC.

libs/qwt.pri

+######################################################################
+# Automatically generated by qmake (2.01a) Wed Feb 10 11:43:43 2010
+######################################################################
+
+QWTSRCDIR = libs/qwt
+DEPENDPATH += $$QWTSRCDIR
+INCLUDEPATH += $$QWTSRCDIR
+
+# Input
+HEADERS += $$QWTSRCDIR/qwt.h \
+           $$QWTSRCDIR/qwt_abstract_legend.h \
+           $$QWTSRCDIR/qwt_abstract_scale.h \
+           $$QWTSRCDIR/qwt_abstract_scale_draw.h \
+           $$QWTSRCDIR/qwt_abstract_slider.h \
+           $$QWTSRCDIR/qwt_analog_clock.h \
+           $$QWTSRCDIR/qwt_arrow_button.h \
+           $$QWTSRCDIR/qwt_clipper.h \
+           $$QWTSRCDIR/qwt_color_map.h \
+           $$QWTSRCDIR/qwt_compass.h \
+           $$QWTSRCDIR/qwt_compass_rose.h \
+           $$QWTSRCDIR/qwt_counter.h \
+           $$QWTSRCDIR/qwt_curve_fitter.h \
+           $$QWTSRCDIR/qwt_dial.h \
+           $$QWTSRCDIR/qwt_dial_needle.h \
+           $$QWTSRCDIR/qwt_dyngrid_layout.h \
+           $$QWTSRCDIR/qwt_event_pattern.h \
+           $$QWTSRCDIR/qwt_global.h \
+           $$QWTSRCDIR/qwt_graphic.h \
+           $$QWTSRCDIR/qwt_interval.h \
+           $$QWTSRCDIR/qwt_knob.h \
+           $$QWTSRCDIR/qwt_legend.h \
+           $$QWTSRCDIR/qwt_legend_data.h \
+           $$QWTSRCDIR/qwt_legend_label.h \
+           $$QWTSRCDIR/qwt_magnifier.h \
+           $$QWTSRCDIR/qwt_math.h \
+           $$QWTSRCDIR/qwt_null_paintdevice.h \
+           $$QWTSRCDIR/qwt_painter.h \
+           $$QWTSRCDIR/qwt_painter_command.h \
+           $$QWTSRCDIR/qwt_panner.h \
+           $$QWTSRCDIR/qwt_picker.h \
+           $$QWTSRCDIR/qwt_picker_machine.h \
+           $$QWTSRCDIR/qwt_pixel_matrix.h \
+           $$QWTSRCDIR/qwt_plot.h \
+           $$QWTSRCDIR/qwt_plot_canvas.h \
+           $$QWTSRCDIR/qwt_plot_curve.h \
+           $$QWTSRCDIR/qwt_plot_dict.h \
+           $$QWTSRCDIR/qwt_plot_grid.h \
+           $$QWTSRCDIR/qwt_plot_item.h \
+           $$QWTSRCDIR/qwt_plot_layout.h \
+           $$QWTSRCDIR/qwt_plot_magnifier.h \
+           $$QWTSRCDIR/qwt_plot_marker.h \
+           $$QWTSRCDIR/qwt_plot_panner.h \
+           $$QWTSRCDIR/qwt_plot_picker.h \
+           $$QWTSRCDIR/qwt_plot_rasteritem.h \
+           $$QWTSRCDIR/qwt_plot_scaleitem.h \
+           $$QWTSRCDIR/qwt_plot_seriesitem.h \
+           $$QWTSRCDIR/qwt_plot_spectrogram.h \
+           $$QWTSRCDIR/qwt_plot_svgitem.h \
+           $$QWTSRCDIR/qwt_plot_zoomer.h \
+           $$QWTSRCDIR/qwt_point_mapper.h \
+           $$QWTSRCDIR/qwt_point_data.h \
+           $$QWTSRCDIR/qwt_raster_data.h \
+           $$QWTSRCDIR/qwt_round_scale_draw.h \
+           $$QWTSRCDIR/qwt_scale_div.h \
+           $$QWTSRCDIR/qwt_scale_draw.h \
+           $$QWTSRCDIR/qwt_scale_engine.h \
+           $$QWTSRCDIR/qwt_scale_map.h \
+           $$QWTSRCDIR/qwt_scale_widget.h \
+           $$QWTSRCDIR/qwt_series_data.h \
+           $$QWTSRCDIR/qwt_slider.h \
+           $$QWTSRCDIR/qwt_spline.h \
+           $$QWTSRCDIR/qwt_symbol.h \
+           $$QWTSRCDIR/qwt_text.h \
+           $$QWTSRCDIR/qwt_text_engine.h \
+           $$QWTSRCDIR/qwt_text_label.h \
+           $$QWTSRCDIR/qwt_thermo.h \
+           $$QWTSRCDIR/qwt_transform.h \
+           $$QWTSRCDIR/qwt_wheel.h \
+           $$QWTSRCDIR/qwt_widget_overlay.h
+SOURCES += $$QWTSRCDIR/qwt_abstract_legend.cpp \
+           $$QWTSRCDIR/qwt_abstract_scale.cpp \
+           $$QWTSRCDIR/qwt_abstract_scale_draw.cpp \
+           $$QWTSRCDIR/qwt_abstract_slider.cpp \
+           $$QWTSRCDIR/qwt_analog_clock.cpp \
+           $$QWTSRCDIR/qwt_arrow_button.cpp \
+           $$QWTSRCDIR/qwt_clipper.cpp \
+           $$QWTSRCDIR/qwt_color_map.cpp \
+           $$QWTSRCDIR/qwt_compass.cpp \
+           $$QWTSRCDIR/qwt_compass_rose.cpp \
+           $$QWTSRCDIR/qwt_counter.cpp \
+           $$QWTSRCDIR/qwt_curve_fitter.cpp \
+           $$QWTSRCDIR/qwt_dial.cpp \
+           $$QWTSRCDIR/qwt_dial_needle.cpp \
+           $$QWTSRCDIR/qwt_dyngrid_layout.cpp \
+           $$QWTSRCDIR/qwt_event_pattern.cpp \
+           $$QWTSRCDIR/qwt_graphic.cpp \
+           $$QWTSRCDIR/qwt_interval.cpp \
+           $$QWTSRCDIR/qwt_knob.cpp \
+           $$QWTSRCDIR/qwt_legend.cpp \
+           $$QWTSRCDIR/qwt_legend_data.cpp \
+           $$QWTSRCDIR/qwt_legend_label.cpp \
+           $$QWTSRCDIR/qwt_magnifier.cpp \
+           $$QWTSRCDIR/qwt_math.cpp \
+           $$QWTSRCDIR/qwt_null_paintdevice.cpp \
+           $$QWTSRCDIR/qwt_painter.cpp \
+           $$QWTSRCDIR/qwt_painter_command.cpp \
+           $$QWTSRCDIR/qwt_panner.cpp \
+           $$QWTSRCDIR/qwt_picker.cpp \
+           $$QWTSRCDIR/qwt_picker_machine.cpp \
+           $$QWTSRCDIR/qwt_pixel_matrix.cpp \
+           $$QWTSRCDIR/qwt_plot.cpp \
+           $$QWTSRCDIR/qwt_plot_axis.cpp \
+           $$QWTSRCDIR/qwt_plot_canvas.cpp \
+           $$QWTSRCDIR/qwt_plot_curve.cpp \
+           $$QWTSRCDIR/qwt_plot_dict.cpp \
+           $$QWTSRCDIR/qwt_plot_grid.cpp \
+           $$QWTSRCDIR/qwt_plot_item.cpp \
+           $$QWTSRCDIR/qwt_plot_layout.cpp \
+           $$QWTSRCDIR/qwt_plot_magnifier.cpp \
+           $$QWTSRCDIR/qwt_plot_marker.cpp \
+           $$QWTSRCDIR/qwt_plot_panner.cpp \
+           $$QWTSRCDIR/qwt_plot_picker.cpp \
+           $$QWTSRCDIR/qwt_plot_rasteritem.cpp \
+           $$QWTSRCDIR/qwt_plot_scaleitem.cpp \
+           $$QWTSRCDIR/qwt_plot_seriesitem.cpp \
+           $$QWTSRCDIR/qwt_plot_spectrogram.cpp \
+           $$QWTSRCDIR/qwt_plot_svgitem.cpp \
+           $$QWTSRCDIR/qwt_plot_xml.cpp \
+           $$QWTSRCDIR/qwt_plot_zoomer.cpp \
+           $$QWTSRCDIR/qwt_point_mapper.cpp \
+           $$QWTSRCDIR/qwt_point_data.cpp \
+           $$QWTSRCDIR/qwt_raster_data.cpp \
+           $$QWTSRCDIR/qwt_round_scale_draw.cpp \
+           $$QWTSRCDIR/qwt_scale_div.cpp \
+           $$QWTSRCDIR/qwt_scale_draw.cpp \
+           $$QWTSRCDIR/qwt_scale_engine.cpp \
+           $$QWTSRCDIR/qwt_scale_map.cpp \
+           $$QWTSRCDIR/qwt_scale_widget.cpp \
+           $$QWTSRCDIR/qwt_series_data.cpp \
+           $$QWTSRCDIR/qwt_slider.cpp \
+           $$QWTSRCDIR/qwt_spline.cpp \
+           $$QWTSRCDIR/qwt_symbol.cpp \
+           $$QWTSRCDIR/qwt_text.cpp \
+           $$QWTSRCDIR/qwt_text_engine.cpp \
+           $$QWTSRCDIR/qwt_text_label.cpp \
+           $$QWTSRCDIR/qwt_thermo.cpp \
+           $$QWTSRCDIR/qwt_transform.cpp \
+           $$QWTSRCDIR/qwt_wheel.cpp \
+           $$QWTSRCDIR/qwt_widget_overlay.cpp

libs/qwt/qwt_abstract_legend.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_abstract_legend.h"
+
+/*!
+  Constructor
+
+  \param parent Parent widget
+*/
+QwtAbstractLegend::QwtAbstractLegend( QWidget *parent ):
+    QFrame( parent )
+{
+}
+
+//! Destructor
+QwtAbstractLegend::~QwtAbstractLegend()
+{
+}
+
+/*!
+   Return the extent, that is needed for elements to scroll
+   the legend ( usually scrollbars ),
+
+   \param orientation Orientation
+   \return Extent of the corresponding scroll element
+*/
+int QwtAbstractLegend::scrollExtent( Qt::Orientation orientation ) const
+{
+    Q_UNUSED( orientation );
+    return 0;
+}

libs/qwt/qwt_abstract_legend.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_ABSTRACT_LEGEND_H
+#define QWT_ABSTRACT_LEGEND_H
+
+#include "qwt_global.h"
+#include "qwt_legend_data.h"
+#include <qframe.h>
+#include <qlist.h>
+
+class QVariant;
+
+/*!
+  \brief Abstract base class for legend widgets
+
+  Legends, that need to be under control of the QwtPlot layout system
+  need to be derived from QwtAbstractLegend. 
+
+  \note Other type of legends can be implemented by connecting to
+        the QwtPlot::legendDataChanged() signal. But as these legends
+        are unknown to the plot layout system the layout code
+        ( on screen and for QwtPlotRenderer ) need to be organized
+        in application code.
+
+  \sa QwtLegend
+ */
+class QWT_EXPORT QwtAbstractLegend : public QFrame
+{
+    Q_OBJECT
+
+public:
+    explicit QwtAbstractLegend( QWidget *parent = NULL );
+    virtual ~QwtAbstractLegend();
+
+    /*!
+      Render the legend into a given rectangle.
+
+      \param painter Painter
+      \param rect Bounding rectangle
+      \param fillBackground When true, fill rect with the widget background 
+
+      \sa renderLegend() is used by QwtPlotRenderer
+    */
+    virtual void renderLegend( QPainter *painter, 
+        const QRectF &rect, bool fillBackground ) const = 0;
+
+    //! \return True, when no plot item is inserted
+    virtual bool isEmpty() const = 0;
+
+    virtual int scrollExtent( Qt::Orientation ) const;
+
+public Q_SLOTS:
+
+    /*!
+      \brief Update the entries for a plot item
+
+      \param itemInfo Info about an item
+      \param data List of legend entry attributes for the  item
+     */
+    virtual void updateLegend( const QVariant &itemInfo, 
+        const QList<QwtLegendData> &data ) = 0;
+};
+
+#endif 

libs/qwt/qwt_abstract_scale.cpp

@@ -7,26 +7,27 @@
  * modify it under the terms of the Qwt License, Version 1.0
  *****************************************************************************/
 
+#include "qwt_abstract_scale.h"
 #include "qwt_scale_engine.h"
 #include "qwt_scale_draw.h"
 #include "qwt_scale_div.h"
 #include "qwt_scale_map.h"
-#include "qwt_double_interval.h"
-#include "qwt_abstract_scale.h"
+#include "qwt_interval.h"
 
 class QwtAbstractScale::PrivateData
 {
 public:
     PrivateData():
-        maxMajor(5),
-        maxMinor(3),
-        stepSize(0.0),
-        autoScale(true) {
-        scaleEngine = new QwtLinearScaleEngine;
+        maxMajor( 5 ),
+        maxMinor( 3 ),
+        stepSize( 0.0 )
+    {
+        scaleEngine = new QwtLinearScaleEngine();
         scaleDraw = new QwtScaleDraw();
     }
 
-    ~PrivateData() {
+    ~PrivateData()
+    {
         delete scaleEngine;
         delete scaleDraw;
     }
@@ -37,21 +38,25 @@ public:
     int maxMajor;
     int maxMinor;
     double stepSize;
-
-    bool autoScale;
 };
 
 /*!
   Constructor
 
+  \param parent Parent widget
+
   Creates a default QwtScaleDraw and a QwtLinearScaleEngine.
-  Autoscaling is enabled, and the stepSize is initialized by 0.0.
+  The initial scale boundaries are set to [ 0.0, 100.0 ]
+
+  The scaleStepSize() is initialized to 0.0, scaleMaxMajor() to 5
+  and scaleMaxMajor to 3.
 */
 
-QwtAbstractScale::QwtAbstractScale()
+QwtAbstractScale::QwtAbstractScale( QWidget *parent ):
+    QWidget( parent )
 {
     d_data = new PrivateData;
-    rescale(0.0, 100.0);
+    rescale( 0.0, 100.0, d_data->stepSize );
 }
 
 //! Destructor
@@ -61,138 +66,166 @@ QwtAbstractScale::~QwtAbstractScale()
 }
 
 /*!
-  \brief Specify a scale.
+  Set the lower bound of the scale
 
-  Disable autoscaling and define a scale by an interval and a step size
+  \param value Lower bound
 
-  \param vmin lower limit of the scale interval
-  \param vmax upper limit of the scale interval
-  \param stepSize major step size
-  \sa setAutoScale()
+  \sa lowerBound(), setScale(), setUpperBound()
+  \note For inverted scales the lower bound 
+        is greater than the upper bound
 */
-void QwtAbstractScale::setScale(double vmin, double vmax, double stepSize)
+void QwtAbstractScale::setLowerBound( double value )
 {
-    d_data->autoScale = false;
-    d_data->stepSize = stepSize;
+    setScale( value, upperBound() );
+}
 
-    rescale(vmin, vmax, stepSize);
+/*!
+  \return Lower bound of the scale
+  \sa setLowerBound(), setScale(), upperBound()
+*/
+double QwtAbstractScale::lowerBound() const
+{
+    return d_data->scaleDraw->scaleDiv().lowerBound();
 }
 
 /*!
-  \brief Specify a scale.
+  Set the upper bound of the scale
 
-  Disable autoscaling and define a scale by an interval and a step size
+  \param value Upper bound
 
-  \param interval Interval
-  \param stepSize major step size
-  \sa setAutoScale()
+  \sa upperBound(), setScale(), setLowerBound()
+  \note For inverted scales the lower bound 
+        is greater than the upper bound
 */
-void QwtAbstractScale::setScale(const QwtDoubleInterval &interval,
-                                double stepSize)
+void QwtAbstractScale::setUpperBound( double value )
 {
-    setScale(interval.minValue(), interval.maxValue(), stepSize);
+    setScale( lowerBound(), value );
 }
 
+/*!
+  \return Upper bound of the scale
+  \sa setUpperBound(), setScale(), lowerBound()
+*/
+double QwtAbstractScale::upperBound() const
+{
+    return d_data->scaleDraw->scaleDiv().upperBound();
+}
 
 /*!
   \brief Specify a scale.
 
-  Disable autoscaling and define a scale by a scale division
+  Define a scale by an interval 
 
-  \param scaleDiv Scale division
-  \sa setAutoScale()
+  The ticks are calculated using scaleMaxMinor(), 
+  scaleMaxMajor() and scaleStepSize().
+
+  \param lowerBound lower limit of the scale interval
+  \param upperBound upper limit of the scale interval
+
+  \note For inverted scales the lower bound 
+        is greater than the upper bound
 */
-void QwtAbstractScale::setScale(const QwtScaleDiv &scaleDiv)
+void QwtAbstractScale::setScale( double lowerBound, double upperBound )
 {
-    d_data->autoScale = false;
-
-    if (scaleDiv != d_data->scaleDraw->scaleDiv()) {
-        d_data->scaleDraw->setScaleDiv(scaleDiv);
-        scaleChange();
-    }
+    rescale( lowerBound, upperBound, d_data->stepSize );
 }
 
 /*!
-  Recalculate the scale division and update the scale draw.
+  \brief Specify a scale.
 
-  \param vmin Lower limit of the scale interval
-  \param vmax Upper limit of the scale interval
-  \param stepSize Major step size
+  Define a scale by an interval
 
-  \sa scaleChange()
+  The ticks are calculated using scaleMaxMinor(), 
+  scaleMaxMajor() and scaleStepSize().
+
+  \param interval Interval
 */
-void QwtAbstractScale::rescale(double vmin, double vmax, double stepSize)
+void QwtAbstractScale::setScale( const QwtInterval &interval )
 {
-    const QwtScaleDiv scaleDiv = d_data->scaleEngine->divideScale(
-                                     vmin, vmax, d_data->maxMajor, d_data->maxMinor, stepSize);
-
-    if ( scaleDiv != d_data->scaleDraw->scaleDiv() ) {
-        d_data->scaleDraw->setTransformation(
-            d_data->scaleEngine->transformation());
-        d_data->scaleDraw->setScaleDiv(scaleDiv);
-        scaleChange();
-    }
+    setScale( interval.minValue(), interval.maxValue() );
 }
 
 /*!
-  \brief Advise the widget to control the scale range internally.
+  \brief Specify a scale.
 
-  Autoscaling is on by default.
-  \sa setScale(), autoScale()
+  scaleMaxMinor(), scaleMaxMajor() and scaleStepSize() and have no effect.
+
+  \param scaleDiv Scale division
+  \sa setAutoScale()
 */
-void QwtAbstractScale::setAutoScale()
+void QwtAbstractScale::setScale( const QwtScaleDiv &scaleDiv )
 {
-    if (!d_data->autoScale) {
-        d_data->autoScale = true;
+    if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
+    {
+#if 1
+        if ( d_data->scaleEngine )
+        {
+            d_data->scaleDraw->setTransformation(
+                d_data->scaleEngine->transformation() );
+        }
+#endif
+
+        d_data->scaleDraw->setScaleDiv( scaleDiv );
+
         scaleChange();
     }
 }
 
-/*!
-  \return \c true if autoscaling is enabled
-*/
-bool QwtAbstractScale::autoScale() const
-{
-    return d_data->autoScale;
-}
-
 /*!
   \brief Set the maximum number of major tick intervals.
 
   The scale's major ticks are calculated automatically such that
   the number of major intervals does not exceed ticks.
+
   The default value is 5.
-  \param ticks maximal number of major ticks.
-  \sa QwtAbstractScaleDraw
+
+  \param ticks Maximal number of major ticks.
+
+  \sa scaleMaxMajor(), setScaleMaxMinor(),
+      setScaleStepSize(), QwtScaleEngine::divideInterval()
 */
-void QwtAbstractScale::setScaleMaxMajor(int ticks)
+void QwtAbstractScale::setScaleMaxMajor( int ticks )
 {
-    if (ticks != d_data->maxMajor) {
+    if ( ticks != d_data->maxMajor )
+    {
         d_data->maxMajor = ticks;
         updateScaleDraw();
     }
 }
 
+/*!
+  \return Maximal number of major tick intervals
+  \sa setScaleMaxMajor(), scaleMaxMinor()
+*/
+int QwtAbstractScale::scaleMaxMajor() const
+{
+    return d_data->maxMajor;
+}
+
 /*!
   \brief Set the maximum number of minor tick intervals
 
   The scale's minor ticks are calculated automatically such that
   the number of minor intervals does not exceed ticks.
   The default value is 3.
-  \param ticks
-  \sa QwtAbstractScaleDraw
+
+  \param ticks Maximal number of minor ticks.
+
+  \sa scaleMaxMajor(), setScaleMaxMinor(),
+      setScaleStepSize(), QwtScaleEngine::divideInterval()
 */
-void QwtAbstractScale::setScaleMaxMinor(int ticks)
+void QwtAbstractScale::setScaleMaxMinor( int ticks )
 {
-    if ( ticks != d_data->maxMinor) {
+    if ( ticks != d_data->maxMinor )
+    {
         d_data->maxMinor = ticks;
         updateScaleDraw();
     }
 }
 
 /*!
-  \return Max. number of minor tick intervals
-  The default value is 3.
+  \return Maximal number of minor tick intervals
+  \sa setScaleMaxMinor(), scaleMaxMajor()
 */
 int QwtAbstractScale::scaleMaxMinor() const
 {
@@ -200,27 +233,52 @@ int QwtAbstractScale::scaleMaxMinor() const
 }
 
 /*!
-  \return Max. number of major tick intervals
-  The default value is 5.
+   \brief Set the step size used for calculating a scale division
+
+   The step size is hint for calculating the intervals for
+   the major ticks of the scale. A value of 0.0 is interpreted
+   as no hint.
+
+   \param stepSize Hint for the step size of the scale
+
+   \sa scaleStepSize(), QwtScaleEngine::divideScale()
+
+   \note Position and distance between the major ticks also
+         depends on scaleMaxMajor().
 */
-int QwtAbstractScale::scaleMaxMajor() const
+void QwtAbstractScale::setScaleStepSize( double stepSize )
 {
-    return d_data->maxMajor;
+    if ( stepSize != d_data->stepSize )
+    {
+        d_data->stepSize = stepSize;
+        updateScaleDraw();
+    }
+}
+
+/*!
+  \return Hint for the step size of the scale
+  \sa setScaleStepSize(), QwtScaleEngine::divideScale()
+*/
+double QwtAbstractScale::scaleStepSize() const
+{
+    return d_data->stepSize;
 }
 
 /*!
   \brief Set a scale draw
 
   scaleDraw has to be created with new and will be deleted in
-  ~QwtAbstractScale or the next call of setAbstractScaleDraw.
+  the destructor or the next call of setAbstractScaleDraw().
+
+  \sa abstractScaleDraw()
 */
-void QwtAbstractScale::setAbstractScaleDraw(QwtAbstractScaleDraw *scaleDraw)
+void QwtAbstractScale::setAbstractScaleDraw( QwtAbstractScaleDraw *scaleDraw )
 {
     if ( scaleDraw == NULL || scaleDraw == d_data->scaleDraw )
         return;
 
     if ( d_data->scaleDraw != NULL )
-        scaleDraw->setScaleDiv(d_data->scaleDraw->scaleDiv());
+        scaleDraw->setScaleDiv( d_data->scaleDraw->scaleDiv() );
 
     delete d_data->scaleDraw;
     d_data->scaleDraw = scaleDraw;
@@ -244,32 +302,27 @@ const QwtAbstractScaleDraw *QwtAbstractScale::abstractScaleDraw() const
     return d_data->scaleDraw;
 }
 
-void QwtAbstractScale::updateScaleDraw()
-{
-    rescale( d_data->scaleDraw->scaleDiv().lBound(),
-             d_data->scaleDraw->scaleDiv().hBound(), d_data->stepSize);
-}
-
 /*!
   \brief Set a scale engine
 
-  The scale engine is responsible for calculating the scale division,
-  and in case of auto scaling how to align the scale.
+  The scale engine is responsible for calculating the scale division
+  and provides a transformation between scale and widget coordinates.
 
   scaleEngine has to be created with new and will be deleted in
-  ~QwtAbstractScale or the next call of setScaleEngine.
+  the destructor or the next call of setScaleEngine.
 */
-void QwtAbstractScale::setScaleEngine(QwtScaleEngine *scaleEngine)
+void QwtAbstractScale::setScaleEngine( QwtScaleEngine *scaleEngine )
 {
-    if ( scaleEngine != NULL && scaleEngine != d_data->scaleEngine ) {
+    if ( scaleEngine != NULL && scaleEngine != d_data->scaleEngine )
+    {
         delete d_data->scaleEngine;
         d_data->scaleEngine = scaleEngine;
     }
 }
 
 /*!
-    \return Scale engine
-    \sa setScaleEngine()
+  \return Scale engine
+  \sa setScaleEngine()
 */
 const QwtScaleEngine *QwtAbstractScale::scaleEngine() const
 {
@@ -277,8 +330,8 @@ const QwtScaleEngine *QwtAbstractScale::scaleEngine() const
 }
 
 /*!
-    \return Scale engine
-    \sa setScaleEngine()
+  \return Scale engine
+  \sa setScaleEngine()
 */
 QwtScaleEngine *QwtAbstractScale::scaleEngine()
 {
@@ -286,18 +339,111 @@ QwtScaleEngine *QwtAbstractScale::scaleEngine()
 }
 
 /*!
-  \brief Notify changed scale
+  \return Scale boundaries and positions of the ticks
 
-  Dummy empty implementation, intended to be overloaded by derived classes
-*/
-void QwtAbstractScale::scaleChange()
+  The scale division might have been assigned explicitly
+  or calculated implicitly by rescale(). 
+ */
+const QwtScaleDiv &QwtAbstractScale::scaleDiv() const
 {
+    return d_data->scaleDraw->scaleDiv();
 }
 
 /*!
-   \return abstractScaleDraw()->scaleMap()
-*/
+  \return Map to translate between scale and widget coordinates
+ */
 const QwtScaleMap &QwtAbstractScale::scaleMap() const
 {
     return d_data->scaleDraw->scaleMap();
 }
+
+/*!
+  Translate a scale value into a widget coordinate
+
+  \param value Scale value 
+  \return Corresponding widget coordinate for value
+  \sa scaleMap(), invTransform()
+ */
+int QwtAbstractScale::transform( double value ) const
+{
+    return qRound( d_data->scaleDraw->scaleMap().transform( value ) );
+}
+
+/*!
+  Translate a widget coordinate into a scale value
+
+  \param value Widget coordinate
+  \return Corresponding scale coordinate for value
+  \sa scaleMap(), transform()
+ */
+double QwtAbstractScale::invTransform( int value ) const
+{
+    return d_data->scaleDraw->scaleMap().invTransform( value );
+}
+
+/*!
+  \return True, when the scale is increasing in opposite direction
+          to the widget coordinates
+ */
+bool QwtAbstractScale::isInverted() const
+{
+    return d_data->scaleDraw->scaleMap().isInverting();
+}
+
+/*!
+  \return The boundary with the smaller value
+  \sa maximum(), lowerBound(), upperBound()
+ */
+double QwtAbstractScale::minimum() const
+{
+    return qMin( d_data->scaleDraw->scaleDiv().lowerBound(),
+        d_data->scaleDraw->scaleDiv().upperBound() );
+}
+
+/*!
+  \return The boundary with the larger value
+  \sa minimum(), lowerBound(), upperBound()
+ */
+double QwtAbstractScale::maximum() const
+{
+    return qMax( d_data->scaleDraw->scaleDiv().lowerBound(),
+        d_data->scaleDraw->scaleDiv().upperBound() );
+}
+
+//! Notify changed scale
+void QwtAbstractScale::scaleChange()
+{
+}
+
+/*!
+  Recalculate the scale division and update the scale.
+
+  \param lowerBound Lower limit of the scale interval
+  \param upperBound Upper limit of the scale interval
+  \param stepSize Major step size
+
+  \sa scaleChange()
+*/
+void QwtAbstractScale::rescale( 
+    double lowerBound, double upperBound, double stepSize )
+{
+    const QwtScaleDiv scaleDiv = d_data->scaleEngine->divideScale(
+        lowerBound, upperBound, d_data->maxMajor, d_data->maxMinor, stepSize );
+
+    if ( scaleDiv != d_data->scaleDraw->scaleDiv() )
+    {
+#if 1
+        d_data->scaleDraw->setTransformation(
+            d_data->scaleEngine->transformation() );
+#endif
+
+        d_data->scaleDraw->setScaleDiv( scaleDiv );
+        scaleChange();
+    }
+}
+
+void QwtAbstractScale::updateScaleDraw()
+{
+    rescale( d_data->scaleDraw->scaleDiv().lowerBound(),
+        d_data->scaleDraw->scaleDiv().upperBound(), d_data->stepSize );
+}

libs/qwt/qwt_abstract_scale.h

@@ -11,50 +11,85 @@
 #define QWT_ABSTRACT_SCALE_H
 
 #include "qwt_global.h"
+#include <qwidget.h>
 
 class QwtScaleEngine;
 class QwtAbstractScaleDraw;
 class QwtScaleDiv;
 class QwtScaleMap;
-class QwtDoubleInterval;
+class QwtInterval;
 
 /*!
-  \brief An abstract base class for classes containing a scale
+  \brief An abstract base class for widgets having a scale
 
-  QwtAbstractScale is used to provide classes with a QwtScaleDraw,
-  and a QwtScaleDiv. The QwtScaleDiv might be set explicitely
-  or calculated by a QwtScaleEngine.
+  The scale of an QwtAbstractScale is determined by a QwtScaleDiv
+  definition, that contains the boundaries and the ticks of the scale.
+  The scale is painted using a QwtScaleDraw object.
+
+  The scale division might be assigned explicitly - but usually
+  it is calculated from the boundaries using a QwtScaleEngine. 
+
+  The scale engine also decides the type of transformation of the scale 
+  ( linear, logarithmic ... ).
 */
 
-class QWT_EXPORT QwtAbstractScale
+class QWT_EXPORT QwtAbstractScale: public QWidget
 {
+    Q_OBJECT
+
+    Q_PROPERTY( double lowerBound READ lowerBound WRITE setLowerBound )
+    Q_PROPERTY( double upperBound READ upperBound WRITE setUpperBound )
+
+    Q_PROPERTY( int scaleMaxMajor READ scaleMaxMajor WRITE setScaleMaxMajor )
+    Q_PROPERTY( int scaleMaxMinor READ scaleMaxMinor WRITE setScaleMaxMinor )
+
+    Q_PROPERTY( double scaleStepSize READ scaleStepSize WRITE setScaleStepSize )
+
 public:
-    QwtAbstractScale();
+    QwtAbstractScale( QWidget *parent = NULL );
     virtual ~QwtAbstractScale();
 
-    void setScale(double vmin, double vmax, double step = 0.0);
-    void setScale(const QwtDoubleInterval &, double step = 0.0);
-    void setScale(const QwtScaleDiv &s);
+    void setScale( double lowerBound, double upperBound );
+    void setScale( const QwtInterval & );
+    void setScale( const QwtScaleDiv & );
+
+    const QwtScaleDiv& scaleDiv() const;
 
-    void setAutoScale();
-    bool autoScale() const;
+    void setLowerBound( double value );
+    double lowerBound() const;
 
-    void setScaleMaxMajor( int ticks);
+    void setUpperBound( double value );
+    double upperBound() const;
+
+    void setScaleStepSize( double stepSize );
+    double scaleStepSize() const;
+
+    void setScaleMaxMajor( int ticks );
     int scaleMaxMinor() const;
 
-    void setScaleMaxMinor( int ticks);
+    void setScaleMaxMinor( int ticks );
     int scaleMaxMajor() const;
 
-    void setScaleEngine(QwtScaleEngine *);
+    void setScaleEngine( QwtScaleEngine * );
     const QwtScaleEngine *scaleEngine() const;
     QwtScaleEngine *scaleEngine();
 
+    int transform( double ) const;
+    double invTransform( int ) const;
+
+    bool isInverted() const;
+
+    double minimum() const;
+    double maximum() const;
+
     const QwtScaleMap &scaleMap() const;
 
 protected:
-    void rescale(double vmin, double vmax, double step = 0.0);
+    void rescale( double lowerBound, 
+        double upperBound, double stepSize );
+
+    void setAbstractScaleDraw( QwtAbstractScaleDraw * );
 
-    void setAbstractScaleDraw(QwtAbstractScaleDraw *);
     const QwtAbstractScaleDraw *abstractScaleDraw() const;
     QwtAbstractScaleDraw *abstractScaleDraw();
 

libs/qwt/qwt_abstract_scale_draw.cpp

@@ -7,39 +7,43 @@
  * modify it under the terms of the Qwt License, Version 1.0
  *****************************************************************************/
 
-// vim: expandtab
-
-#include <qpainter.h>
-#include <qpalette.h>
-#include <qmap.h>
-#include <qlocale.h>
+#include "qwt_abstract_scale_draw.h"
 #include "qwt_math.h"
 #include "qwt_text.h"
 #include "qwt_painter.h"
 #include "qwt_scale_map.h"
-#include "qwt_scale_draw.h"
+#include <qpainter.h>
+#include <qpalette.h>
+#include <qmap.h>
+#include <qlocale.h>
 
 class QwtAbstractScaleDraw::PrivateData
 {
 public:
     PrivateData():
-        components(Backbone | Ticks | Labels),
-        spacing(4),
-        minExtent(0) {
-        tickLength[QwtScaleDiv::MinorTick] = 4;
-        tickLength[QwtScaleDiv::MediumTick] = 6;
-        tickLength[QwtScaleDiv::MajorTick] = 8;
+        spacing( 4.0 ),
+        penWidth( 0 ),
+        minExtent( 0.0 )
+    {
+        components = QwtAbstractScaleDraw::Backbone 
+            | QwtAbstractScaleDraw::Ticks 
+            | QwtAbstractScaleDraw::Labels;
+
+        tickLength[QwtScaleDiv::MinorTick] = 4.0;
+        tickLength[QwtScaleDiv::MediumTick] = 6.0;
+        tickLength[QwtScaleDiv::MajorTick] = 8.0;
     }
 
-    int components;
+    ScaleComponents components;
 
     QwtScaleMap map;
-    QwtScaleDiv scldiv;
+    QwtScaleDiv scaleDiv;
 
-    int spacing;
-    int tickLength[QwtScaleDiv::NTickTypes];
+    double spacing;
+    double tickLength[QwtScaleDiv::NTickTypes];
+    int penWidth;
 
-    int minExtent;
+    double minExtent;
 
     QMap<double, QwtText> labelCache;
 };
@@ -56,23 +60,11 @@ QwtAbstractScaleDraw::QwtAbstractScaleDraw()
     d_data = new QwtAbstractScaleDraw::PrivateData;
 }
 
-//! Copy constructor
-QwtAbstractScaleDraw::QwtAbstractScaleDraw(const QwtAbstractScaleDraw &other)
-{
-    d_data = new QwtAbstractScaleDraw::PrivateData(*other.d_data);
-}
-
 //! Destructor
 QwtAbstractScaleDraw::~QwtAbstractScaleDraw()
 {
     delete d_data;
 }
-//! Assignment operator
-QwtAbstractScaleDraw &QwtAbstractScaleDraw::operator=(const QwtAbstractScaleDraw &other)
-{
-    *d_data = *other.d_data;
-    return *this;
-}
 
 /*!
   En/Disable a component of the scale
@@ -80,10 +72,10 @@ QwtAbstractScaleDraw &QwtAbstractScaleDraw::operator=(const QwtAbstractScaleDraw
   \param component Scale component
   \param enable On/Off
 
-  \sa QwtAbstractScaleDraw::hasComponent
+  \sa hasComponent()
 */
 void QwtAbstractScaleDraw::enableComponent(
-    ScaleComponent component, bool enable)
+    ScaleComponent component, bool enable )
 {
     if ( enable )
         d_data->components |= component;
@@ -93,21 +85,24 @@ void QwtAbstractScaleDraw::enableComponent(
 
 /*!
   Check if a component is enabled
-  \sa QwtAbstractScaleDraw::enableComponent
+
+  \param component Component type
+  \return true, when component is enabled
+  \sa enableComponent()
 */
-bool QwtAbstractScaleDraw::hasComponent(ScaleComponent component) const
+bool QwtAbstractScaleDraw::hasComponent( ScaleComponent component ) const
 {
-    return (d_data->components & component);
+    return ( d_data->components & component );
 }
 
 /*!
   Change the scale division
-  \param sd New scale division
+  \param scaleDiv New scale division
 */
-void QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &sd)
+void QwtAbstractScaleDraw::setScaleDiv( const QwtScaleDiv &scaleDiv )
 {
-    d_data->scldiv = sd;
-    d_data->map.setScaleInterval(sd.lBound(), sd.hBound());
+    d_data->scaleDiv = scaleDiv;
+    d_data->map.setScaleInterval( scaleDiv.lowerBound(), scaleDiv.upperBound() );
     d_data->labelCache.clear();
 }
 
@@ -116,13 +111,13 @@ void QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &sd)
   \param transformation New scale transformation
 */
 void QwtAbstractScaleDraw::setTransformation(
-    QwtScaleTransformation *transformation)
+    QwtTransform *transformation )
 {
-    d_data->map.setTransformation(transformation);
+    d_data->map.setTransformation( transformation );
 }
 
 //! \return Map how to translate between scale and pixel values
-const QwtScaleMap &QwtAbstractScaleDraw::map() const
+const QwtScaleMap &QwtAbstractScaleDraw::scaleMap() const
 {
     return d_data->map;
 }
@@ -136,22 +131,31 @@ QwtScaleMap &QwtAbstractScaleDraw::scaleMap()
 //! \return scale division
 const QwtScaleDiv& QwtAbstractScaleDraw::scaleDiv() const
 {
-    return d_data->scldiv;
+    return d_data->scaleDiv;
 }
 
-#if QT_VERSION < 0x040000
 /*!
-  \brief Draw the scale
+  \brief Specify the width of the scale pen
+  \param width Pen width
+  \sa penWidth()
+*/
+void QwtAbstractScaleDraw::setPenWidth( int width )
+{
+    if ( width < 0 )
+        width = 0;
 
-  \param painter    The painter
+    if ( width != d_data->penWidth )
+        d_data->penWidth = width;
+}
 
-  \param colorGroup Color group, text color is used for the labels,
-                    foreground color for ticks and backbone
+/*!
+    \return Scale pen width
+    \sa setPenWidth()
 */
-void QwtAbstractScaleDraw::draw(QPainter *painter,
-                                const QColorGroup& colorGroup) const
-
-#else
+int QwtAbstractScaleDraw::penWidth() const
+{
+    return d_data->penWidth;
+}
 
 /*!
   \brief Draw the scale
@@ -161,70 +165,75 @@ void QwtAbstractScaleDraw::draw(QPainter *painter,
   \param palette    Palette, text color is used for the labels,
                     foreground color for ticks and backbone
 */
-void QwtAbstractScaleDraw::draw(QPainter *painter,
-                                const QPalette& palette) const
-#endif
+void QwtAbstractScaleDraw::draw( QPainter *painter,
+    const QPalette& palette ) const
 {
-    if ( hasComponent(QwtAbstractScaleDraw::Labels) ) {
-        painter->save();
+    painter->save();
 
-#if QT_VERSION < 0x040000
-        painter->setPen(colorGroup.text()); // ignore pen style
-#else
-        painter->setPen(palette.color(QPalette::Text)); // ignore pen style
-#endif
+    QPen pen = painter->pen();
+    pen.setWidth( d_data->penWidth );
+    pen.setCosmetic( false );
+    painter->setPen( pen );
 
-        const QwtValueList &majorTicks =
-            d_data->scldiv.ticks(QwtScaleDiv::MajorTick);
+    if ( hasComponent( QwtAbstractScaleDraw::Labels ) )
+    {
+        painter->save();
+        painter->setPen( palette.color( QPalette::Text ) ); // ignore pen style
+
+        const QList<double> &majorTicks =
+            d_data->scaleDiv.ticks( QwtScaleDiv::MajorTick );
 
-        for (int i = 0; i < (int)majorTicks.count(); i++) {
+        for ( int i = 0; i < majorTicks.count(); i++ )
+        {
             const double v = majorTicks[i];
-            if ( d_data->scldiv.contains(v) )
-                drawLabel(painter, majorTicks[i]);
+            if ( d_data->scaleDiv.contains( v ) )
+                drawLabel( painter, v );
         }
 
         painter->restore();
     }
 
-    if ( hasComponent(QwtAbstractScaleDraw::Ticks) ) {
+    if ( hasComponent( QwtAbstractScaleDraw::Ticks ) )
+    {
         painter->save();
 
         QPen pen = painter->pen();
-#if QT_VERSION < 0x040000
-        pen.setColor(colorGroup.foreground());
-#else
-        pen.setColor(palette.color(QPalette::Foreground));
-#endif
-        painter->setPen(pen);
+        pen.setColor( palette.color( QPalette::WindowText ) );
+        pen.setCapStyle( Qt::FlatCap );
+
+        painter->setPen( pen );
 
         for ( int tickType = QwtScaleDiv::MinorTick;
-                tickType < QwtScaleDiv::NTickTypes; tickType++ ) {
-            const QwtValueList &ticks = d_data->scldiv.ticks(tickType);
-            for (int i = 0; i < (int)ticks.count(); i++) {
+            tickType < QwtScaleDiv::NTickTypes; tickType++ )
+        {
+            const QList<double> &ticks = d_data->scaleDiv.ticks( tickType );
+            for ( int i = 0; i < ticks.count(); i++ )
+            {
                 const double v = ticks[i];
-                if ( d_data->scldiv.contains(v) )
-                    drawTick(painter, v, d_data->tickLength[tickType]);
+                if ( d_data->scaleDiv.contains( v ) )
+                    drawTick( painter, v, d_data->tickLength[tickType] );
             }
         }
 
         painter->restore();
     }
 
-    if ( hasComponent(QwtAbstractScaleDraw::Backbone) ) {
+    if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
+    {
         painter->save();
 
         QPen pen = painter->pen();
-#if QT_VERSION < 0x040000
-        pen.setColor(colorGroup.foreground());
-#else
-        pen.setColor(palette.color(QPalette::Foreground));
-#endif
-        painter->setPen(pen);
+        pen.setColor( palette.color( QPalette::WindowText ) );
+        pen.setCapStyle( Qt::FlatCap );
+
+        painter->setPen( pen );
 
-        drawBackbone(painter);
+        drawBackbone( painter );
 
         painter->restore();
     }
+
+    painter->restore();
 }
 
 /*!
@@ -235,9 +244,9 @@ void QwtAbstractScaleDraw::draw(QPainter *painter,
 
   \param spacing Spacing
 
-  \sa QwtAbstractScaleDraw::spacing
+  \sa spacing()
 */
-void QwtAbstractScaleDraw::setSpacing(int spacing)
+void QwtAbstractScaleDraw::setSpacing( double spacing )
 {
     if ( spacing < 0 )
         spacing = 0;
@@ -251,9 +260,10 @@ void QwtAbstractScaleDraw::setSpacing(int spacing)
   The spacing is the distance between ticks and labels.
   The default spacing is 4 pixels.
 
-  \sa QwtAbstractScaleDraw::setSpacing
+  \return Spacing
+  \sa setSpacing()
 */
-int QwtAbstractScaleDraw::spacing() const
+double QwtAbstractScaleDraw::spacing() const
 {
     return d_data->spacing;
 }
@@ -261,7 +271,7 @@ int QwtAbstractScaleDraw::spacing() const
 /*!
   \brief Set a minimum for the extent
 
-  The extent is calculated from the coomponents of the
+  The extent is calculated from the components of the
   scale draw. In situations, where the labels are
   changing and the layout depends on the extent (f.e scrolling
   a scale), setting an upper limit as minimum extent will
@@ -271,19 +281,20 @@ int QwtAbstractScaleDraw::spacing() const
 
   \sa extent(), minimumExtent()
 */
-void QwtAbstractScaleDraw::setMinimumExtent(int minExtent)
+void QwtAbstractScaleDraw::setMinimumExtent( double minExtent )
 {
-    if ( minExtent < 0 )
-        minExtent = 0;
+    if ( minExtent < 0.0 )
+        minExtent = 0.0;
 
     d_data->minExtent = minExtent;
 }
 
 /*!
   Get the minimum extent
+  \return Minimum extent
   \sa extent(), setMinimumExtent()
 */
-int QwtAbstractScaleDraw::minimumExtent() const
+double QwtAbstractScaleDraw::minimumExtent() const
 {
     return d_data->minExtent;
 }
@@ -297,33 +308,33 @@ int QwtAbstractScaleDraw::minimumExtent() const
   \warning the length is limited to [0..1000]
 */
 void QwtAbstractScaleDraw::setTickLength(
-    QwtScaleDiv::TickType tickType, int length)
+    QwtScaleDiv::TickType tickType, double length )
 {
     if ( tickType < QwtScaleDiv::MinorTick ||
-            tickType > QwtScaleDiv::MajorTick ) {
+        tickType > QwtScaleDiv::MajorTick )
+    {
         return;
     }
 
-    if ( length < 0 )
-        length = 0;
+    if ( length < 0.0 )
+        length = 0.0;
 
-    const int maxTickLen = 1000;
+    const double maxTickLen = 1000.0;
     if ( length > maxTickLen )
-        length = 1000;
+        length = maxTickLen;
 
     d_data->tickLength[tickType] = length;
 }
 
 /*!
-    Return the length of the ticks
-
-    \sa QwtAbstractScaleDraw::setTickLength,
-        QwtAbstractScaleDraw::majTickLength
+    \return Length of the ticks
+    \sa setTickLength(), maxTickLength()
 */
-int QwtAbstractScaleDraw::tickLength(QwtScaleDiv::TickType tickType) const
+double QwtAbstractScaleDraw::tickLength( QwtScaleDiv::TickType tickType ) const
 {
     if ( tickType < QwtScaleDiv::MinorTick ||
-            tickType > QwtScaleDiv::MajorTick ) {
+        tickType > QwtScaleDiv::MajorTick )
+    {
         return 0;
     }
 
@@ -331,27 +342,34 @@ int QwtAbstractScaleDraw::tickLength(QwtScaleDiv::TickType tickType) const
 }
 
 /*!
-   The same as QwtAbstractScaleDraw::tickLength(QwtScaleDiv::MajorTick).
+   \return Length of the longest tick
+
+   Useful for layout calculations
+   \sa tickLength(), setTickLength()
 */
-int QwtAbstractScaleDraw::majTickLength() const
+double QwtAbstractScaleDraw::maxTickLength() const
 {
-    return d_data->tickLength[QwtScaleDiv::MajorTick];
+    double length = 0.0;
+    for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
+        length = qMax( length, d_data->tickLength[i] );
+
+    return length;
 }
 
 /*!
   \brief Convert a value into its representing label
 
   The value is converted to a plain text using
-  QLocale::system().toString(value).
+  QLocale().toString(value).
   This method is often overloaded by applications to have individual
   labels.
 
   \param value Value
   \return Label string.
 */
-QwtText QwtAbstractScaleDraw::label(double value) const
+QwtText QwtAbstractScaleDraw::label( double value ) const
 {
-    return QLocale::system().toString(value);
+    return QLocale().toString( value );
 }
 
 /*!
@@ -368,28 +386,29 @@ QwtText QwtAbstractScaleDraw::label(double value) const
    \return Tick label
 */
 const QwtText &QwtAbstractScaleDraw::tickLabel(
-    const QFont &font, double value) const
+    const QFont &font, double value ) const
 {
-    QMap<double, QwtText>::const_iterator it = d_data->labelCache.find(value);
-    if ( it == d_data->labelCache.end() ) {
-        QwtText lbl = label(value);
-        lbl.setRenderFlags(0);
-        lbl.setLayoutAttribute(QwtText::MinimumLayout);
+    QMap<double, QwtText>::const_iterator it = d_data->labelCache.find( value );
+    if ( it == d_data->labelCache.end() )
+    {
+        QwtText lbl = label( value );
+        lbl.setRenderFlags( 0 );
+        lbl.setLayoutAttribute( QwtText::MinimumLayout );
 
-        (void)lbl.textSize(font); // initialize the internal cache
+        ( void )lbl.textSize( font ); // initialize the internal cache
 
-        it = d_data->labelCache.insert(value, lbl);
+        it = d_data->labelCache.insert( value, lbl );
     }
 
-    return (*it);
+    return ( *it );
 }
 
 /*!
-   Invalidate the cache used by QwtAbstractScaleDraw::tickLabel
+   Invalidate the cache used by tickLabel()
 
    The cache is invalidated, when a new QwtScaleDiv is set. If
    the labels need to be changed. while the same QwtScaleDiv is set,
-   QwtAbstractScaleDraw::invalidateCache needs to be called manually.
+   invalidateCache() needs to be called manually.
 */
 void QwtAbstractScaleDraw::invalidateCache()
 {

libs/qwt/qwt_abstract_scale_draw.h

@@ -14,15 +14,10 @@
 #include "qwt_scale_div.h"
 #include "qwt_text.h"
 
-
-#if QT_VERSION < 0x040000
-class QColorGroup;
-#else
 class QPalette;
-#endif
 class QPainter;
 class QFont;
-class QwtScaleTransformation;
+class QwtTransform;
 class QwtScaleMap;
 
 /*!
@@ -31,8 +26,7 @@ class QwtScaleMap;
   QwtAbstractScaleDraw can be used to draw linear or logarithmic scales.
 
   After a scale division has been specified as a QwtScaleDiv object
-  using QwtAbstractScaleDraw::setScaleDiv(const QwtScaleDiv &s),
-  the scale can be drawn with the QwtAbstractScaleDraw::draw() member.
+  using setScaleDiv(), the scale can be drawn with the draw() member.
 */
 class QWT_EXPORT QwtAbstractScaleDraw
 {
@@ -40,66 +34,66 @@ public:
 
     /*!
        Components of a scale
+       \sa enableComponent(), hasComponent
+    */
+    enum ScaleComponent
+    {
+        //! Backbone = the line where the ticks are located
+        Backbone = 0x01,
 
-       - Backbone
-       - Ticks
-       - Labels
-
-       \sa QwtAbstractScaleDraw::enableComponent,
-           QwtAbstractScaleDraw::hasComponent
-        */
+        //! Ticks
+        Ticks = 0x02,
 
-    enum ScaleComponent {
-        Backbone = 1,
-        Ticks = 2,
-        Labels = 4
+        //! Labels
+        Labels = 0x04
     };
 
+    //! Scale components
+    typedef QFlags<ScaleComponent> ScaleComponents;
+
     QwtAbstractScaleDraw();
-    QwtAbstractScaleDraw( const QwtAbstractScaleDraw & );
     virtual ~QwtAbstractScaleDraw();
 
-    QwtAbstractScaleDraw &operator=(const QwtAbstractScaleDraw &);
-
-    void setScaleDiv(const QwtScaleDiv &s);
+    void setScaleDiv( const QwtScaleDiv &s );
     const QwtScaleDiv& scaleDiv() const;
 
-    void setTransformation(QwtScaleTransformation *);
-    const QwtScaleMap &map() const;
+    void setTransformation( QwtTransform * );
+    const QwtScaleMap &scaleMap() const;
+    QwtScaleMap &scaleMap();
 
-    void enableComponent(ScaleComponent, bool enable = true);
-    bool hasComponent(ScaleComponent) const;
+    void enableComponent( ScaleComponent, bool enable = true );
+    bool hasComponent( ScaleComponent ) const;
 
-    void setTickLength(QwtScaleDiv::TickType, int length);
-    int tickLength(QwtScaleDiv::TickType) const;
-    int majTickLength() const;
+    void setTickLength( QwtScaleDiv::TickType, double length );
+    double tickLength( QwtScaleDiv::TickType ) const;
+    double maxTickLength() const;
 
-    void setSpacing(int margin);
-    int spacing() const;
+    void setSpacing( double margin );
+    double spacing() const;
 
-#if QT_VERSION < 0x040000
-    virtual void draw(QPainter *, const QColorGroup &) const;
-#else
-    virtual void draw(QPainter *, const QPalette &) const;
-#endif
+    void setPenWidth( int width );
+    int penWidth() const;
+
+    virtual void draw( QPainter *, const QPalette & ) const;
 
-    virtual QwtText label(double) const;
+    virtual QwtText label( double ) const;
 
     /*!
       Calculate the extent
 
-      The extent is the distcance from the baseline to the outermost
+      The extent is the distance from the baseline to the outermost
       pixel of the scale draw in opposite to its orientation.
       It is at least minimumExtent() pixels.
 
+      \param font Font used for drawing the tick labels
+      \return Number of pixels
+
       \sa setMinimumExtent(), minimumExtent()
     */
-    virtual int extent(const QPen &, const QFont &) const = 0;
+    virtual double extent( const QFont &font ) const = 0;
 
-    void setMinimumExtent(int);
-    int minimumExtent() const;
-
-    QwtScaleMap &scaleMap();
+    void setMinimumExtent( double );
+    double minimumExtent() const;
 
 protected:
     /*!
@@ -107,11 +101,11 @@ protected:
 
        \param painter Painter
        \param value Value of the tick
-       \param len Lenght of the tick
+       \param len Length of the tick
 
        \sa drawBackbone(), drawLabel()
     */
-    virtual void drawTick(QPainter *painter, double value, int len) const = 0;
+    virtual void drawTick( QPainter *painter, double value, double len ) const = 0;
 
     /*!
       Draws the baseline of the scale
@@ -119,7 +113,7 @@ protected:
 
       \sa drawTick(), drawLabel()
     */
-    virtual void drawBackbone(QPainter *painter) const = 0;
+    virtual void drawBackbone( QPainter *painter ) const = 0;
 
     /*!
         Draws the label for a major scale tick
@@ -127,19 +121,21 @@ protected:
         \param painter Painter
         \param value Value
 
-        \sa drawTick, drawBackbone
+        \sa drawTick(), drawBackbone()
     */
-    virtual void drawLabel(QPainter *painter, double value) const = 0;
+    virtual void drawLabel( QPainter *painter, double value ) const = 0;
 
     void invalidateCache();
-    const QwtText &tickLabel(const QFont &, double value) const;
+    const QwtText &tickLabel( const QFont &, double value ) const;
 
 private:
-    int operator==(const QwtAbstractScaleDraw &) const;
-    int operator!=(const QwtAbstractScaleDraw &) const;
+    QwtAbstractScaleDraw( const QwtAbstractScaleDraw & );
+    QwtAbstractScaleDraw &operator=( const QwtAbstractScaleDraw & );
 
     class PrivateData;
     PrivateData *d_data;
 };
 
+Q_DECLARE_OPERATORS_FOR_FLAGS( QwtAbstractScaleDraw::ScaleComponents )
+
 #endif

libs/qwt/qwt_abstract_slider.h

@@ -10,112 +10,95 @@
 #ifndef QWT_ABSTRACT_SLIDER_H
 #define QWT_ABSTRACT_SLIDER_H
 
-#include <qwidget.h>
 #include "qwt_global.h"
-#include "qwt_double_range.h"
+#include "qwt_abstract_scale.h"
 
 /*!
-  \brief An abstract base class for slider widgets
-
-  QwtAbstractSlider is a base class for
-  slider widgets. It handles mouse events
-  and updates the slider's value accordingly. Derived classes
-  only have to implement the getValue() and
-  getScrollMode() members, and should react to a
-  valueChange(), which normally requires repainting.
+  \brief An abstract base class for slider widgets with a scale
+
+  A slider widget displays a value according to a scale.
+  The class is designed as a common super class for widgets like 
+  QwtKnob, QwtDial and QwtSlider.
+
+  When the slider is nor readOnly() its value can be modified 
+  by keyboard, mouse and wheel inputs. 
+
+  The range of the slider is divided into a number of steps from
+  which the value increments according to user inputs depend. 
+  Only for linear scales the number of steps correspond with
+  a fixed step size.
 */
 
-class QWT_EXPORT QwtAbstractSlider : public QWidget, public QwtDoubleRange
+class QWT_EXPORT QwtAbstractSlider: public QwtAbstractScale
 {
     Q_OBJECT
+
+    Q_PROPERTY( double value READ value WRITE setValue )
+
+    Q_PROPERTY( uint totalSteps READ totalSteps WRITE setTotalSteps )
+    Q_PROPERTY( uint singleSteps READ singleSteps WRITE setSingleSteps )
+    Q_PROPERTY( uint pageSteps READ pageSteps WRITE setPageSteps )
+    Q_PROPERTY( bool stepAlignment READ stepAlignment WRITE setStepAlignment )
+
     Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly )
-    Q_PROPERTY( bool valid READ isValid WRITE setValid )
-    Q_PROPERTY( double mass READ mass WRITE setMass )
-#ifndef Q_MOC_RUN // Qt3 moc
-#define QWT_PROPERTY Q_PROPERTY
-    Q_PROPERTY( Orientation orientation
-                READ orientation WRITE setOrientation )
-#else // Qt4 moc
-// MOC_SKIP_BEGIN
-    Q_PROPERTY( Qt::Orientation orientation
-                READ orientation WRITE setOrientation )
-// MOC_SKIP_END
-#endif
+    Q_PROPERTY( bool tracking READ isTracking WRITE setTracking )
+    Q_PROPERTY( bool wrapping READ wrapping WRITE setWrapping )
+
+    Q_PROPERTY( bool invertedControls READ invertedControls WRITE setInvertedControls )
 
 public:
-    /*!
-      Scroll mode
-      \sa getScrollMode()
-     */
-    enum ScrollMode {
-        ScrNone,
-        ScrMouse,
-        ScrTimer,
-        ScrDirect,
-        ScrPage
-    };
-
-    explicit QwtAbstractSlider(Qt::Orientation, QWidget *parent = NULL);
+    explicit QwtAbstractSlider( QWidget *parent = NULL );
     virtual ~QwtAbstractSlider();
 
-    void setUpdateTime(int t);
-    void stopMoving();
-    void setTracking(bool enable);
+    void setValid( bool );
+    bool isValid() const;
 
-    virtual void setMass(double val);
-    virtual double mass() const;
+    double value() const;
 
-#if QT_VERSION >= 0x040000
-    virtual void setOrientation(Qt::Orientation o);
-    Qt::Orientation orientation() const;
-#else
-    virtual void setOrientation(Orientation o);
-    Orientation orientation() const;
-#endif
+    void setWrapping( bool );
+    bool wrapping() const;
 
-    bool isReadOnly() const;
+    void setTotalSteps( uint );
+    uint totalSteps() const;
 
-    /*
-        Wrappers for QwtDblRange::isValid/QwtDblRange::setValid made
-        to be available as Q_PROPERTY in the designer.
-    */
+    void setSingleSteps( uint );
+    uint singleSteps() const;
 
-    /*!
-      \sa QwtDblRange::isValid
-    */
-    bool isValid() const {
-        return QwtDoubleRange::isValid();
-    }
+    void setPageSteps( uint );
+    uint pageSteps() const;
 
-    /*!
-      \sa QwtDblRange::isValid
-    */
-    void setValid(bool valid) {
-        QwtDoubleRange::setValid(valid);
-    }
+    void setStepAlignment( bool ); 
+    bool stepAlignment() const;
 
-public slots:
-    virtual void setValue(double val);
-    virtual void fitValue(double val);
-    virtual void incValue(int steps);
+    void setTracking( bool );
+    bool isTracking() const;
+
+    void setReadOnly( bool );
+    bool isReadOnly() const;
 
-    virtual void setReadOnly(bool);
+    void setInvertedControls( bool );
+    bool invertedControls() const;
 
-signals:
+public Q_SLOTS:
+    void setValue( double val );
+
+Q_SIGNALS:
 
     /*!
       \brief Notify a change of value.
 
-      In the default setting
-      (tracking enabled), this signal will be emitted every
-      time the value changes ( see setTracking() ).
-      \param value new value
+      When tracking is enabled (default setting), 
+      this signal will be emitted every time the value changes. 
+
+      \param value New value
+
+      \sa setTracking(), sliderMoved()
     */
-    void valueChanged(double value);
+    void valueChanged( double value );
 
     /*!
       This signal is emitted when the user presses the
-      movable part of the slider (start ScrMouse Mode).
+      movable part of the slider.
     */
     void sliderPressed();
 
@@ -123,70 +106,59 @@ signals:
       This signal is emitted when the user releases the
       movable part of the slider.
     */
-
     void sliderReleased();
+
     /*!
       This signal is emitted when the user moves the
       slider with the mouse.
-      \param value new value
+
+      \param value New value
+
+      \sa valueChanged()
     */
-    void sliderMoved(double value);
+    void sliderMoved( double value );
 
 protected:
-    virtual void setPosition(const QPoint &);
-    virtual void valueChange();
-
-    virtual void timerEvent(QTimerEvent *e);
-    virtual void mousePressEvent(QMouseEvent *e);
-    virtual void mouseReleaseEvent(QMouseEvent *e);
-    virtual void mouseMoveEvent(QMouseEvent *e);
-    virtual void keyPressEvent(QKeyEvent *e);
-    virtual void wheelEvent(QWheelEvent *e);
+    virtual void mousePressEvent( QMouseEvent * );
+    virtual void mouseReleaseEvent( QMouseEvent * );
+    virtual void mouseMoveEvent( QMouseEvent * );
+    virtual void keyPressEvent( QKeyEvent * );
+    virtual void wheelEvent( QWheelEvent * );
 
     /*!
-      \brief Determine the value corresponding to a specified poind
+      \brief Determine what to do when the user presses a mouse button.
+
+      \param pos Mouse position
 
-      This is an abstract virtual function which is called when
-      the user presses or releases a mouse button or moves the
-      mouse. It has to be implemented by the derived class.
-      \param p point
+      \retval True, when pos is a valid scroll position
+      \sa scrolledTo()
     */
-    virtual double getValue(const QPoint & p) = 0;
+    virtual bool isScrollPosition( const QPoint &pos ) const = 0;
+
     /*!
-      \brief Determine what to do when the user presses a mouse button.
+      \brief Determine the value for a new position of the
+             movable part of the slider
 
-      This function is abstract and has to be implemented by derived classes.
-      It is called on a mousePress event. The derived class can determine
-      what should happen next in dependence of the position where the mouse
-      was pressed by returning scrolling mode and direction. QwtAbstractSlider
-      knows the following modes:<dl>
-      <dt>QwtAbstractSlider::ScrNone
-      <dd>Scrolling switched off. Don't change the value.
-      <dt>QwtAbstractSlider::ScrMouse
-      <dd>Change the value while the user keeps the
-          button pressed and moves the mouse.
-      <dt>QwtAbstractSlider::ScrTimer
-      <dd>Automatic scrolling. Increment the value
-          in the specified direction as long as
-      the user keeps the button pressed.
-      <dt>QwtAbstractSlider::ScrPage
-      <dd>Automatic scrolling. Same as ScrTimer, but
-          increment by page size.</dl>
-
-      \param p point where the mouse was pressed
-      \retval scrollMode The scrolling mode
-      \retval direction  direction: 1, 0, or -1.
+      \param pos Mouse position
+
+      \return Value for the mouse position
+      \sa isScrollPosition()
     */
-    virtual void getScrollMode( const QPoint &p,
-                                int &scrollMode, int &direction) = 0;
+    virtual double scrolledTo( const QPoint &pos ) const = 0;
+
+    void incrementValue( int numSteps );
 
-    void setMouseOffset(double);
-    double mouseOffset() const;
+    virtual void scaleChange();
+
+protected:
+    virtual void sliderChange();
 
-    int scrollMode() const;
+    double incrementedValue( 
+        double value, int stepCount ) const;
 
 private:
-    void buttonReleased();
+    double alignedValue( double ) const;
+    double boundedValue( double ) const;
 
     class PrivateData;
     PrivateData *d_data;

libs/qwt/qwt_analog_clock.cpp

@@ -8,69 +8,94 @@
  *****************************************************************************/
 
 #include "qwt_analog_clock.h"
+#include "qwt_round_scale_draw.h"
+#include <qmath.h>
+#include <qlocale.h>
 
-/*!
-  Constructor
-  \param parent Parent widget
-*/
-QwtAnalogClock::QwtAnalogClock(QWidget *parent):
-    QwtDial(parent)
+class QwtAnalogClockScaleDraw: public QwtRoundScaleDraw
 {
-    initClock();
-}
+public:
+    QwtAnalogClockScaleDraw()
+    {
+        setSpacing( 8 );
+
+        enableComponent( QwtAbstractScaleDraw::Backbone, false );
+
+        setTickLength( QwtScaleDiv::MinorTick, 2 );
+        setTickLength( QwtScaleDiv::MediumTick, 4 );
+        setTickLength( QwtScaleDiv::MajorTick, 8 );
+
+        setPenWidth( 1 );
+    }
+
+    virtual QwtText label( double value ) const
+    {
+        if ( qFuzzyCompare( value + 1.0, 1.0 ) )
+            value = 60.0 * 60.0 * 12.0;
+
+        return QLocale().toString( qRound( value / ( 60.0 * 60.0 ) ) );
+    }
+};
 
-#if QT_VERSION < 0x040000
 /*!
   Constructor
   \param parent Parent widget
-  \param name Object name
 */
-QwtAnalogClock::QwtAnalogClock(QWidget* parent, const char *name):
-    QwtDial(parent, name)
+QwtAnalogClock::QwtAnalogClock( QWidget *parent ):
+    QwtDial( parent )
 {
-    initClock();
-}
-#endif
+    setWrapping( true );
+    setReadOnly( true );
 
-void QwtAnalogClock::initClock()
-{
-    setWrapping(true);
-    setReadOnly(true);
+    setOrigin( 270.0 );
+    setScaleDraw( new QwtAnalogClockScaleDraw() );
+
+    setTotalSteps( 60 );
+
+    const int secondsPerHour = 60.0 * 60.0; 
 
-    setOrigin(270.0);
-    setRange(0.0, 60.0 * 60.0 * 12.0); // seconds
-    setScale(-1, 5, 60.0 * 60.0);
+    QList<double> majorTicks;
+    QList<double> minorTicks;
 
-    setScaleOptions(ScaleTicks | ScaleLabel);
-    setScaleTicks(1, 0, 8);
-    scaleDraw()->setSpacing(8);
+    for ( int i = 0; i < 12; i++ )
+    {
+        majorTicks += i * secondsPerHour;
 
-    QColor knobColor =
-#if QT_VERSION < 0x040000
-        palette().color(QPalette::Active, QColorGroup::Text);
-#else
-        palette().color(QPalette::Active, QPalette::Text);
-#endif
-    knobColor = knobColor.dark(120);
+        for ( int j = 1; j < 5; j++ )
+            minorTicks += i * secondsPerHour + j * secondsPerHour / 5.0;
+    }
+
+    QwtScaleDiv scaleDiv;
+    scaleDiv.setInterval( 0.0, 12.0 * secondsPerHour );
+    scaleDiv.setTicks( QwtScaleDiv::MajorTick, majorTicks );
+    scaleDiv.setTicks( QwtScaleDiv::MinorTick, minorTicks );
+    setScale( scaleDiv );
+
+    QColor knobColor = palette().color( QPalette::Active, QPalette::Text );
+    knobColor = knobColor.dark( 120 );
 
     QColor handColor;
     int width;
 
-    for ( int i = 0; i < NHands; i++ ) {
-        if ( i == SecondHand ) {
+    for ( int i = 0; i < NHands; i++ )
+    {
+        if ( i == SecondHand )
+        {
             width = 2;
-            handColor = knobColor.dark(120);
-        } else {
+            handColor = knobColor.dark( 120 );
+        }
+        else
+        {
             width = 8;
             handColor = knobColor;
         }
 
         QwtDialSimpleNeedle *hand = new QwtDialSimpleNeedle(
-            QwtDialSimpleNeedle::Arrow, true, handColor, knobColor);
-        hand->setWidth(width);
+            QwtDialSimpleNeedle::Arrow, true, handColor, knobColor );
+        hand->setWidth( width );
 
         d_hand[i] = NULL;
-        setHand((Hand)i, hand);
+        setHand( static_cast<Hand>( i ), hand );
     }
 }
 
@@ -82,24 +107,25 @@ QwtAnalogClock::~QwtAnalogClock()
 }
 
 /*!
-  Nop method, use setHand instead
-  \sa QwtAnalogClock::setHand
+  Nop method, use setHand() instead
+  \sa setHand()
 */
-void QwtAnalogClock::setNeedle(QwtDialNeedle *)
+void QwtAnalogClock::setNeedle( QwtDialNeedle * )
 {
     // no op
     return;
 }
 
 /*!
-   Set a clockhand
+   Set a clock hand
    \param hand Specifies the type of hand
    \param needle Hand
-   \sa QwtAnalogClock::hand()
+   \sa hand()
 */
-void QwtAnalogClock::setHand(Hand hand, QwtDialNeedle *needle)
+void QwtAnalogClock::setHand( Hand hand, QwtDialNeedle *needle )
 {
-    if ( hand >= 0 || hand < NHands ) {
+    if ( hand >= 0 && hand < NHands )
+    {
         delete d_hand[hand];
         d_hand[hand] = needle;
     }
@@ -108,9 +134,9 @@ void QwtAnalogClock::setHand(Hand hand, QwtDialNeedle *needle)
 /*!
   \return Clock hand
   \param hd Specifies the type of hand
-  \sa QwtAnalogClock::setHand
+  \sa setHand()
 */
-QwtDialNeedle *QwtAnalogClock::hand(Hand hd)
+QwtDialNeedle *QwtAnalogClock::hand( Hand hd )
 {
     if ( hd < 0 || hd >= NHands )
         return NULL;
@@ -121,81 +147,75 @@ QwtDialNeedle *QwtAnalogClock::hand(Hand hd)
 /*!
   \return Clock hand
   \param hd Specifies the type of hand
-  \sa QwtAnalogClock::setHand
+  \sa setHand()
 */
-const QwtDialNeedle *QwtAnalogClock::hand(Hand hd) const
+const QwtDialNeedle *QwtAnalogClock::hand( Hand hd ) const
 {
-    return ((QwtAnalogClock *)this)->hand(hd);
+    return const_cast<QwtAnalogClock *>( this )->hand( hd );
 }
 
 /*!
   \brief Set the current time
-
-  This is the same as QwtAnalogClock::setTime(), but Qt < 3.0
-  can't handle default parameters for slots.
 */
 void QwtAnalogClock::setCurrentTime()
 {
-    setTime(QTime::currentTime());
+    setTime( QTime::currentTime() );
 }
 
 /*!
   Set a time
   \param time Time to display
 */
-void QwtAnalogClock::setTime(const QTime &time)
-{
-    if ( time.isValid() ) {
-        setValue((time.hour() % 12) * 60.0 * 60.0
-                 + time.minute() * 60.0 + time.second());
-    } else
-        setValid(false);
-}
-
-/*!
-  Find the scale label for a given value
-
-  \param value Value
-  \return Label
-*/
-QwtText QwtAnalogClock::scaleLabel(double value) const
+void QwtAnalogClock::setTime( const QTime &time )
 {
-    if ( value == 0.0 )
-        value = 60.0 * 60.0 * 12.0;
-
-    return QString::number(int(value / (60.0 * 60.0)));
+    if ( time.isValid() )
+    {
+        setValue( ( time.hour() % 12 ) * 60.0 * 60.0
+            + time.minute() * 60.0 + time.second() );
+    }
+    else
+        setValid( false );
 }
 
 /*!
   \brief Draw the needle
 
-  A clock has no single needle but three hands instead. drawNeedle
+  A clock has no single needle but three hands instead. drawNeedle()
   translates value() into directions for the hands and calls
   drawHand().
 
   \param painter Painter
   \param center Center of the clock
   \param radius Maximum length for the hands
-  \param direction Dummy, not used.
-  \param cg ColorGroup
+  \param dir Dummy, not used.
+  \param colorGroup ColorGroup
 
-  \sa QwtAnalogClock::drawHand()
+  \sa drawHand()
 */
-void QwtAnalogClock::drawNeedle(QPainter *painter, const QPoint &center,
-                                int radius, double, QPalette::ColorGroup cg) const
+void QwtAnalogClock::drawNeedle( QPainter *painter, const QPointF &center,
+    double radius, double dir, QPalette::ColorGroup colorGroup ) const
 {
-    if ( isValid() ) {
-        const double hours = value() / (60.0 * 60.0);
-        const double minutes = (value() - (int)hours * 60.0 * 60.0) / 60.0;
-        const double seconds = value() - (int)hours * 60.0 * 60.0
-                               - (int)minutes * 60.0;
-
-        drawHand(painter, HourHand, center, radius,
-                 360.0 - (origin() + 360.0 * hours / 12.0), cg);
-        drawHand(painter, MinuteHand, center, radius,
-                 360.0 - (origin() + 360.0 * minutes / 60.0), cg);
-        drawHand(painter, SecondHand, center, radius,
-                 360.0 - (origin() + 360.0 * seconds / 60.0), cg);
+    Q_UNUSED( dir );
+
+    if ( isValid() )
+    {
+        const double hours = value() / ( 60.0 * 60.0 );
+        const double minutes = 
+            ( value() - qFloor(hours) * 60.0 * 60.0 ) / 60.0;
+        const double seconds = value() - qFloor(hours) * 60.0 * 60.0
+            - qFloor(minutes) * 60.0;
+
+        double angle[NHands];
+        angle[HourHand] = 360.0 * hours / 12.0;
+        angle[MinuteHand] = 360.0 * minutes / 60.0;
+        angle[SecondHand] = 360.0 * seconds / 60.0;
+
+        for ( int hand = 0; hand < NHands; hand++ )
+        {
+            const double d = 360.0 - angle[hand] - origin();
+            drawHand( painter, static_cast<Hand>( hand ), 
+                center, radius, d, colorGroup );
+        }
     }
 }
 
@@ -209,15 +229,16 @@ void QwtAnalogClock::drawNeedle(QPainter *painter, const QPoint &center,
   \param direction Direction of the hand in degrees, counter clockwise
   \param cg ColorGroup
 */
-void QwtAnalogClock::drawHand(QPainter *painter, Hand hd,
-                              const QPoint &center, int radius, double direction,
-                              QPalette::ColorGroup cg) const
+void QwtAnalogClock::drawHand( QPainter *painter, Hand hd,
+    const QPointF &center, double radius, double direction,
+    QPalette::ColorGroup cg ) const
 {
-    const QwtDialNeedle *needle = hand(hd);
-    if ( needle ) {
+    const QwtDialNeedle *needle = hand( hd );
+    if ( needle )
+    {
         if ( hd == HourHand )
-            radius = qRound(0.8 * radius);
+            radius = qRound( 0.8 * radius );
 
-        needle->draw(painter, center, radius, direction, cg);
+        needle->draw( painter, center, radius, direction, cg );
     }
 }

libs/qwt/qwt_analog_clock.h

@@ -10,10 +10,10 @@
 #ifndef QWT_ANALOG_CLOCK_H
 #define QWT_ANALOG_CLOCK_H
 
-#include <qdatetime.h>
 #include "qwt_global.h"
 #include "qwt_dial.h"
 #include "qwt_dial_needle.h"
+#include <qdatetime.h>
 
 /*!
   \brief An analog clock
@@ -21,7 +21,8 @@
   \image html analogclock.png
 
   \par Example
-  \verbatim #include <qwt_analog_clock.h>
+  \code 
+  #include <qwt_analog_clock.h>
 
   QwtAnalogClock *clock = new QwtAnalogClock(...);
   clock->scaleDraw()->setPenWidth(3);
@@ -34,10 +35,7 @@
   timer->connect(timer, SIGNAL(timeout()), clock, SLOT(setCurrentTime()));
   timer->start(1000);
 
-  \endverbatim
-
-  Qwt is missing a set of good looking hands.
-  Contributions are very welcome.
+  \endcode
 
   \note The examples/dials example shows how to use QwtAnalogClock.
 */
@@ -51,41 +49,43 @@ public:
         Hand type
         \sa setHand(), hand()
     */
-
-    enum Hand {
+    enum Hand
+    {
+        //! Needle displaying the seconds
         SecondHand,
+
+        //! Needle displaying the minutes
         MinuteHand,
+
+        //! Needle displaying the hours
         HourHand,
 
+        //! Number of needles
         NHands
     };
 
-    explicit QwtAnalogClock(QWidget* parent = NULL);
-#if QT_VERSION < 0x040000
-    explicit QwtAnalogClock(QWidget* parent, const char *name);
-#endif
+    explicit QwtAnalogClock( QWidget* parent = NULL );
     virtual ~QwtAnalogClock();
 
-    virtual void setHand(Hand, QwtDialNeedle *);
-    const QwtDialNeedle *hand(Hand) const;
-    QwtDialNeedle *hand(Hand);
+    void setHand( Hand, QwtDialNeedle * );
 
-public slots:
+    const QwtDialNeedle *hand( Hand ) const;
+    QwtDialNeedle *hand( Hand );
+
+public Q_SLOTS:
     void setCurrentTime();
-    void setTime(const QTime & = QTime::currentTime());
+    void setTime( const QTime & );
 
 protected:
-    virtual QwtText scaleLabel(double) const;
-
-    virtual void drawNeedle(QPainter *, const QPoint &,
-                            int radius, double direction, QPalette::ColorGroup) const;
+    virtual void drawNeedle( QPainter *, const QPointF &,
+        double radius, double direction, QPalette::ColorGroup ) const;
 
-    virtual void drawHand(QPainter *, Hand, const QPoint &,
-                          int radius, double direction, QPalette::ColorGroup) const;
+    virtual void drawHand( QPainter *, Hand, const QPointF &,
+        double radius, double direction, QPalette::ColorGroup ) const;
 
 private:
-    virtual void setNeedle(QwtDialNeedle *);
-    void initClock();
+    // use setHand instead
+    void setNeedle( QwtDialNeedle * );
 
     QwtDialNeedle *d_hand[NHands];
 };

libs/qwt/qwt_arrow_button.cpp

@@ -7,12 +7,13 @@
  * modify it under the terms of the Qwt License, Version 1.0
  *****************************************************************************/
 
+#include "qwt_arrow_button.h"
+#include "qwt_math.h"
 #include <qpainter.h>
 #include <qstyle.h>
+#include <qstyleoption.h>
 #include <qevent.h>
-#include "qwt_math.h"
-#include "qwt_polygon.h"
-#include "qwt_arrow_button.h"
+#include <qapplication.h>
 
 static const int MaxNum = 3;
 static const int Margin = 2;
@@ -25,56 +26,53 @@ public:
     Qt::ArrowType arrowType;
 };
 
-
-#if QT_VERSION >= 0x040000
-#include <qstyleoption.h>
-static QStyleOptionButton styleOpt(const QwtArrowButton* btn)
+static QStyleOptionButton styleOpt( const QwtArrowButton* btn )
 {
     QStyleOptionButton option;
-    option.init(btn);
+    option.init( btn );
     option.features = QStyleOptionButton::None;
-    if (btn->isFlat())
+    if ( btn->isFlat() )
         option.features |= QStyleOptionButton::Flat;
-    if (btn->menu())
+    if ( btn->menu() )
         option.features |= QStyleOptionButton::HasMenu;
-    if (btn->autoDefault() || btn->isDefault())
+    if ( btn->autoDefault() || btn->isDefault() )
         option.features |= QStyleOptionButton::AutoDefaultButton;
-    if (btn->isDefault())
+    if ( btn->isDefault() )
         option.features |= QStyleOptionButton::DefaultButton;
-    if (btn->isDown())
+    if ( btn->isDown() )
         option.state |= QStyle::State_Sunken;
-    if (!btn->isFlat() && !btn->isDown())
+    if ( !btn->isFlat() && !btn->isDown() )
         option.state |= QStyle::State_Raised;
 
     return option;
 }
-#endif
 
 /*!
   \param num Number of arrows
-  \param arrowType see Qt::ArowType in the Qt docs.
+  \param arrowType see Qt::ArrowType in the Qt docs.
   \param parent Parent widget
 */
-QwtArrowButton::QwtArrowButton(int num,
-                               Qt::ArrowType arrowType, QWidget *parent):
-    QPushButton(parent)
+QwtArrowButton::QwtArrowButton( int num,
+        Qt::ArrowType arrowType, QWidget *parent ):
+    QPushButton( parent )
 {
     d_data = new PrivateData;
-    d_data->num = qwtLim(num, 1, MaxNum);
+    d_data->num = qBound( 1, num, MaxNum );
     d_data->arrowType = arrowType;
 
-    setAutoRepeat(true);
-    setAutoDefault(false);
-
-    switch(d_data->arrowType) {
-    case Qt::LeftArrow:
-    case Qt::RightArrow:
-        setSizePolicy(QSizePolicy::Expanding,
-                      QSizePolicy::Fixed);
-        break;
-    default:
-        setSizePolicy(QSizePolicy::Fixed,
-                      QSizePolicy::Expanding);
+    setAutoRepeat( true );
+    setAutoDefault( false );
+
+    switch ( d_data->arrowType )
+    {
+        case Qt::LeftArrow:
+        case Qt::RightArrow:
+            setSizePolicy( QSizePolicy::Expanding,
+                QSizePolicy::Fixed );
+            break;
+        default:
+            setSizePolicy( QSizePolicy::Fixed,
+                QSizePolicy::Expanding );
     }
 }
 
@@ -102,60 +100,51 @@ int QwtArrowButton::num() const
 }
 
 /*!
-  \return the bounding rect for the label
+  \return the bounding rectangle for the label
 */
 QRect QwtArrowButton::labelRect() const
 {
     const int m = Margin;
 
     QRect r = rect();
-    r.setRect(r.x() + m, r.y() + m,
-              r.width() - 2 * m, r.height() - 2 * m);
-
-    if ( isDown() ) {
-        int ph, pv;
-#if QT_VERSION < 0x040000
-        ph = style().pixelMetric(
-                 QStyle::PM_ButtonShiftHorizontal, this);
-        pv = style().pixelMetric(
-                 QStyle::PM_ButtonShiftVertical, this);
-        r.moveBy(ph, pv);
-#else
-        QStyleOptionButton option = styleOpt(this);
-        ph = style()->pixelMetric(
-                 QStyle::PM_ButtonShiftHorizontal, &option, this);
-        pv = style()->pixelMetric(
-                 QStyle::PM_ButtonShiftVertical, &option, this);
-        r.translate(ph, pv);
-#endif
+    r.setRect( r.x() + m, r.y() + m,
+        r.width() - 2 * m, r.height() - 2 * m );
+
+    if ( isDown() )
+    {
+        QStyleOptionButton option = styleOpt( this );
+        const int ph = style()->pixelMetric(
+            QStyle::PM_ButtonShiftHorizontal, &option, this );
+        const int pv = style()->pixelMetric(
+            QStyle::PM_ButtonShiftVertical, &option, this );
+
+        r.translate( ph, pv );
     }
 
     return r;
 }
 
-#if QT_VERSION >= 0x040000
 /*!
    Paint event handler
    \param event Paint event
 */
-void QwtArrowButton::paintEvent(QPaintEvent *event)
+void QwtArrowButton::paintEvent( QPaintEvent *event )
 {
-    QPushButton::paintEvent(event);
-    QPainter painter(this);
-    drawButtonLabel(&painter);
+    QPushButton::paintEvent( event );
+    QPainter painter( this );
+    drawButtonLabel( &painter );
 }
-#endif
 
 /*!
   \brief Draw the button label
 
   \param painter Painter
-  \sa The Qt Manual on QPushButton
+  \sa The Qt Manual for QPushButton
 */
-void QwtArrowButton::drawButtonLabel(QPainter *painter)
+void QwtArrowButton::drawButtonLabel( QPainter *painter )
 {
     const bool isVertical = d_data->arrowType == Qt::UpArrow ||
-                            d_data->arrowType == Qt::DownArrow;
+        d_data->arrowType == Qt::DownArrow;
 
     const QRect r = labelRect();
     QSize boundingSize = labelRect().size();
@@ -163,32 +152,36 @@ void QwtArrowButton::drawButtonLabel(QPainter *painter)
         boundingSize.transpose();
 
     const int w =
-        (boundingSize.width() - (MaxNum - 1) * Spacing) / MaxNum;
+        ( boundingSize.width() - ( MaxNum - 1 ) * Spacing ) / MaxNum;
 
-    QSize arrow = arrowSize(Qt::RightArrow,
-                            QSize(w, boundingSize.height()));
+    QSize arrow = arrowSize( Qt::RightArrow,
+        QSize( w, boundingSize.height() ) );
 
     if ( isVertical )
         arrow.transpose();
 
     QRect contentsSize; // aligned rect where to paint all arrows
-    if ( d_data->arrowType == Qt::LeftArrow || d_data->arrowType == Qt::RightArrow ) {
-        contentsSize.setWidth(d_data->num * arrow.width()
-                              + (d_data->num - 1) * Spacing);
-        contentsSize.setHeight(arrow.height());
-    } else {
-        contentsSize.setWidth(arrow.width());
-        contentsSize.setHeight(d_data->num * arrow.height()
-                               + (d_data->num - 1) * Spacing);
+    if ( d_data->arrowType == Qt::LeftArrow || d_data->arrowType == Qt::RightArrow )
+    {
+        contentsSize.setWidth( d_data->num * arrow.width()
+            + ( d_data->num - 1 ) * Spacing );
+        contentsSize.setHeight( arrow.height() );
+    }
+    else
+    {
+        contentsSize.setWidth( arrow.width() );
+        contentsSize.setHeight( d_data->num * arrow.height()
+            + ( d_data->num - 1 ) * Spacing );
     }
 
-    QRect arrowRect(contentsSize);
-    arrowRect.moveCenter(r.center());
-    arrowRect.setSize(arrow);
+    QRect arrowRect( contentsSize );
+    arrowRect.moveCenter( r.center() );
+    arrowRect.setSize( arrow );
 
     painter->save();
-    for (int i = 0; i < d_data->num; i++) {
-        drawArrow(painter, arrowRect, d_data->arrowType);
+    for ( int i = 0; i < d_data->num; i++ )
+    {
+        drawArrow( painter, arrowRect, d_data->arrowType );
 
         int dx = 0;
         int dy = 0;
@@ -198,77 +191,66 @@ void QwtArrowButton::drawButtonLabel(QPainter *painter)
         else
             dx = arrow.width() + Spacing;
 
-#if QT_VERSION >= 0x040000
-        arrowRect.translate(dx, dy);
-#else
-        arrowRect.moveBy(dx, dy);
-#endif
+        arrowRect.translate( dx, dy );
     }
     painter->restore();
 
-    if ( hasFocus() ) {
-#if QT_VERSION >= 0x040000
+    if ( hasFocus() )
+    {
         QStyleOptionFocusRect option;
-        option.init(this);
-        option.backgroundColor = palette().color(QPalette::Background);
-
-        style()->drawPrimitive(QStyle::PE_FrameFocusRect,
-                               &option, painter, this);
-#else
-        const QRect focusRect =
-            style().subRect(QStyle::SR_PushButtonFocusRect, this);
-        style().drawPrimitive(QStyle::PE_FocusRect, painter,
-                              focusRect, colorGroup());
-#endif
+        option.init( this );
+        option.backgroundColor = palette().color( QPalette::Window );
+
+        style()->drawPrimitive( QStyle::PE_FrameFocusRect,
+            &option, painter, this );
     }
 }
 
 /*!
-    Draw an arrow int a bounding rect
+    Draw an arrow int a bounding rectangle
 
     \param painter Painter
     \param r Rectangle where to paint the arrow
     \param arrowType Arrow type
 */
-void QwtArrowButton::drawArrow(QPainter *painter,
-                               const QRect &r, Qt::ArrowType arrowType) const
+void QwtArrowButton::drawArrow( QPainter *painter,
+    const QRect &r, Qt::ArrowType arrowType ) const
 {
-    QwtPolygon pa(3);
-
-    switch(arrowType) {
-    case Qt::UpArrow:
-        pa.setPoint(0, r.bottomLeft());
-        pa.setPoint(1, r.bottomRight());
-        pa.setPoint(2, r.center().x(), r.top());
-        break;
-    case Qt::DownArrow:
-        pa.setPoint(0, r.topLeft());
-        pa.setPoint(1, r.topRight());
-        pa.setPoint(2, r.center().x(), r.bottom());
-        break;
-    case Qt::RightArrow:
-        pa.setPoint(0, r.topLeft());
-        pa.setPoint(1, r.bottomLeft());
-        pa.setPoint(2, r.right(), r.center().y());
-        break;
-    case Qt::LeftArrow:
-        pa.setPoint(0, r.topRight());
-        pa.setPoint(1, r.bottomRight());
-        pa.setPoint(2, r.left(), r.center().y());
-        break;
-    default:
-        break;
+    QPolygon pa( 3 );
+
+    switch ( arrowType )
+    {
+        case Qt::UpArrow:
+            pa.setPoint( 0, r.bottomLeft() );
+            pa.setPoint( 1, r.bottomRight() );
+            pa.setPoint( 2, r.center().x(), r.top() );
+            break;
+        case Qt::DownArrow:
+            pa.setPoint( 0, r.topLeft() );
+            pa.setPoint( 1, r.topRight() );
+            pa.setPoint( 2, r.center().x(), r.bottom() );
+            break;
+        case Qt::RightArrow:
+            pa.setPoint( 0, r.topLeft() );
+            pa.setPoint( 1, r.bottomLeft() );
+            pa.setPoint( 2, r.right(), r.center().y() );
+            break;
+        case Qt::LeftArrow:
+            pa.setPoint( 0, r.topRight() );
+            pa.setPoint( 1, r.bottomRight() );
+            pa.setPoint( 2, r.left(), r.center().y() );
+            break;
+        default:
+            break;
     }
 
     painter->save();
-#if QT_VERSION < 0x040000
-    painter->setPen(colorGroup().buttonText());
-    painter->setBrush(colorGroup().brush(QColorGroup::ButtonText));
-#else
-    painter->setPen(palette().color(QPalette::ButtonText));
-    painter->setBrush(palette().brush(QPalette::ButtonText));
-#endif
-    painter->drawPolygon(pa);
+
+    painter->setRenderHint( QPainter::Antialiasing, true );
+    painter->setPen( Qt::NoPen );
+    painter->setBrush( palette().brush( QPalette::ButtonText ) );
+    painter->drawPolygon( pa );
+
     painter->restore();
 }
 
@@ -277,7 +259,8 @@ void QwtArrowButton::drawArrow(QPainter *painter,
 */
 QSize QwtArrowButton::sizeHint() const
 {
-    return minimumSizeHint();
+    const QSize hint = minimumSizeHint();
+    return hint.expandedTo( QApplication::globalStrut() );
 }
 
 /*!
@@ -285,43 +268,34 @@ QSize QwtArrowButton::sizeHint() const
 */
 QSize QwtArrowButton::minimumSizeHint() const
 {
-    const QSize asz = arrowSize(Qt::RightArrow, QSize());
+    const QSize asz = arrowSize( Qt::RightArrow, QSize() );
 
     QSize sz(
-        2 * Margin + (MaxNum - 1) * Spacing + MaxNum * asz.width(),
+        2 * Margin + ( MaxNum - 1 ) * Spacing + MaxNum * asz.width(),
         2 * Margin + asz.height()
     );
 
     if ( d_data->arrowType == Qt::UpArrow || d_data->arrowType == Qt::DownArrow )
         sz.transpose();
 
-#if QT_VERSION >= 0x040000
     QStyleOption styleOption;
-    styleOption.init(this);
-
-    const QSize hsz = style()->sizeFromContents(QStyle::CT_PushButton,
-                      &styleOption, sz, this);
-#if QT_VERSION < 0x040300
-    if ( hsz.width() != 80 ) // avoid a bug in the Cleanlooks style
-#endif
-        sz = hsz;
+    styleOption.init( this );
 
-#else
-    sz = style().sizeFromContents(QStyle::CT_PushButton, this, sz);
-#endif
+    sz = style()->sizeFromContents( QStyle::CT_PushButton,
+        &styleOption, sz, this );
 
     return sz;
 }
 
 /*!
-   Calculate the size for a arrow that fits into a rect of a given size
+   Calculate the size for a arrow that fits into a rectangle of a given size
 
    \param arrowType Arrow type
    \param boundingSize Bounding size
    \return Size of the arrow
 */
-QSize QwtArrowButton::arrowSize(Qt::ArrowType arrowType,
-                                const QSize &boundingSize) const
+QSize QwtArrowButton::arrowSize( Qt::ArrowType arrowType,
+    const QSize &boundingSize ) const
 {
     QSize bs = boundingSize;
     if ( arrowType == Qt::UpArrow || arrowType == Qt::DownArrow )
@@ -329,17 +303,18 @@ QSize QwtArrowButton::arrowSize(Qt::ArrowType arrowType,
 
     const int MinLen = 2;
     const QSize sz = bs.expandedTo(
-                         QSize(MinLen, 2 * MinLen - 1)); // minimum
+        QSize( MinLen, 2 * MinLen - 1 ) ); // minimum
 
     int w = sz.width();
     int h = 2 * w - 1;
 
-    if ( h > sz.height() ) {
+    if ( h > sz.height() )
+    {
         h = sz.height();
-        w = (h + 1) / 2;
+        w = ( h + 1 ) / 2;
     }
 
-    QSize arrSize(w, h);
+    QSize arrSize( w, h );
     if ( arrowType == Qt::UpArrow || arrowType == Qt::DownArrow )
         arrSize.transpose();
 
@@ -349,10 +324,10 @@ QSize QwtArrowButton::arrowSize(Qt::ArrowType arrowType,
 /*!
   \brief autoRepeat for the space keys
 */
-void QwtArrowButton::keyPressEvent(QKeyEvent *e)
+void QwtArrowButton::keyPressEvent( QKeyEvent *event )
 {
-    if ( e->isAutoRepeat() && e->key() == Qt::Key_Space )
-        emit clicked();
+    if ( event->isAutoRepeat() && event->key() == Qt::Key_Space )
+        Q_EMIT clicked();
 
-    QPushButton::keyPressEvent(e);
+    QPushButton::keyPressEvent( event );
 }

libs/qwt/qwt_arrow_button.h

@@ -10,8 +10,8 @@
 #ifndef QWT_ARROW_BUTTON_H
 #define QWT_ARROW_BUTTON_H
 
-#include <qpushbutton.h>
 #include "qwt_global.h"
+#include <qpushbutton.h>
 
 /*!
   \brief Arrow Button
@@ -23,7 +23,7 @@
 class QWT_EXPORT QwtArrowButton : public QPushButton
 {
 public:
-    explicit QwtArrowButton (int num, Qt::ArrowType, QWidget *parent = NULL);
+    explicit QwtArrowButton ( int num, Qt::ArrowType, QWidget *parent = NULL );
     virtual ~QwtArrowButton();
 
     Qt::ArrowType arrowType() const;
@@ -33,18 +33,16 @@ public:
     virtual QSize minimumSizeHint() const;
 
 protected:
-#if QT_VERSION >= 0x040000
-    virtual void paintEvent(QPaintEvent *event);
-#endif
+    virtual void paintEvent( QPaintEvent *event );
 
-    virtual void drawButtonLabel(QPainter *p);
-    virtual void drawArrow(QPainter *,
-                           const QRect &, Qt::ArrowType) const;
+    virtual void drawButtonLabel( QPainter *p );
+    virtual void drawArrow( QPainter *,
+        const QRect &, Qt::ArrowType ) const;
     virtual QRect labelRect() const;
-    virtual QSize arrowSize(Qt::ArrowType,
-                            const QSize &boundingSize) const;
+    virtual QSize arrowSize( Qt::ArrowType,
+        const QSize &boundingSize ) const;
 
-    virtual void keyPressEvent(QKeyEvent *);
+    virtual void keyPressEvent( QKeyEvent * );
 
 private:
     class PrivateData;

libs/qwt/qwt_clipper.h

@@ -11,27 +11,30 @@
 #define QWT_CLIPPER_H
 
 #include "qwt_global.h"
-#include "qwt_array.h"
-#include "qwt_polygon.h"
-#include "qwt_double_rect.h"
-#include "qwt_double_interval.h"
+#include "qwt_interval.h"
+#include <qpolygon.h>
+#include <qvector.h>
 
 class QRect;
+class QRectF;
 
 /*!
-  \brief Some clipping algos
+  \brief Some clipping algorithms
 */
 
 class QWT_EXPORT QwtClipper
 {
 public:
-    static QwtPolygon clipPolygon(const QRect &, const QwtPolygon &);
-    static QwtPolygonF clipPolygonF(const QwtDoubleRect &, const QwtPolygonF &);
+    static QPolygon clipPolygon( const QRect &, 
+        const QPolygon &, bool closePolygon = false );
+    static QPolygon clipPolygon( const QRectF &, 
+        const QPolygon &, bool closePolygon = false );
 
-#if QT_VERSION >= 0x040000
-    static QwtArray<QwtDoubleInterval> clipCircle(
-        const QwtDoubleRect &, const QwtDoublePoint &, double radius);
-#endif
+    static QPolygonF clipPolygonF( const QRectF &, 
+        const QPolygonF &, bool closePolygon = false );
+
+    static QVector<QwtInterval> clipCircle(
+        const QRectF &, const QPointF &, double radius );
 };
 
 #endif