Changeset 8127 for trunk/BNC – RTCM-Ntrip

trunk/BNC/qwt/qwt.h

r4271	r8127
18	18	namespace Qwt
19	19	{
20		};
	20	}
21	21
22	22	#endif

trunk/BNC/qwt/qwt.pro

-              r5182
+              r8127
 CONFIG -= debug
 CONFIG += release
+###DEFINES += QWT_NO_SVG
+QT += svg
+QWT_CONFIG = QwtPlot QwtWidgets QwtSvg
 OBJECTS_DIR = .obj
 MOC_DIR     = .moc
+HEADERS += \
+    qwt.h \
+    qwt_abstract_scale_draw.h \
+    qwt_interval_symbol.h \
+    qwt_clipper.h \
+    qwt_color_map.h \
+    qwt_compat.h \
+    qwt_column_symbol.h \
+    qwt_interval.h \
+    qwt_dyngrid_layout.h \
+    qwt_global.h \
+    qwt_math.h \
+    qwt_magnifier.h \
+    qwt_null_paintdevice.h \
+    qwt_painter.h \
+    qwt_panner.h \
+    qwt_picker.h \
+    qwt_picker_machine.h \
+    qwt_point_3d.h \
+    qwt_point_polar.h \
+    qwt_round_scale_draw.h \
+    qwt_scale_div.h \
+    qwt_scale_draw.h \
+    qwt_scale_engine.h \
+    qwt_scale_map.h \
+    qwt_spline.h \
+    qwt_symbol.h \
+    qwt_system_clock.h \
+    qwt_text_engine.h \
+    qwt_text_label.h \
+    qwt_text.h \
+    qwt_curve_fitter.h \
+    qwt_event_pattern.h \
+    qwt_legend.h \
+    qwt_legend_item.h \
+    qwt_legend_itemmanager.h \
+    qwt_plot.h \
+    qwt_plot_renderer.h \
+    qwt_plot_curve.h \
+    qwt_plot_dict.h \
+    qwt_plot_directpainter.h \
+    qwt_plot_grid.h \
+    qwt_plot_histogram.h \
+    qwt_plot_item.h \
+    qwt_plot_intervalcurve.h \
+    qwt_plot_layout.h \
+    qwt_plot_marker.h \
+    qwt_plot_rasteritem.h \
+    qwt_plot_spectrogram.h \
+    qwt_plot_spectrocurve.h \
+    qwt_plot_scaleitem.h \
+    qwt_plot_seriesitem.h \
+    qwt_plot_canvas.h \
+    qwt_plot_panner.h \
+    qwt_plot_picker.h \
+    qwt_plot_zoomer.h \
+    qwt_plot_magnifier.h \
+    qwt_plot_rescaler.h \
+    qwt_raster_data.h \
+    qwt_matrix_raster_data.h \
+    qwt_sampling_thread.h \
+    qwt_series_data.h \
+    qwt_scale_widget.h \
+    qwt_plot_svgitem.h
+SOURCES += \
+    qwt_abstract_scale_draw.cpp \
+    qwt_interval_symbol.cpp \
+    qwt_clipper.cpp \
+    qwt_color_map.cpp \
+    qwt_column_symbol.cpp \
+    qwt_interval.cpp \
+    qwt_dyngrid_layout.cpp \
+    qwt_math.cpp \
+    qwt_magnifier.cpp \
+    qwt_panner.cpp \
+    qwt_null_paintdevice.cpp \
+    qwt_painter.cpp \
+    qwt_picker.cpp \
+    qwt_round_scale_draw.cpp \
+    qwt_scale_div.cpp \
+    qwt_scale_draw.cpp \
+    qwt_scale_map.cpp \
+    qwt_spline.cpp \
+    qwt_text_engine.cpp \
+    qwt_text_label.cpp \
+    qwt_text.cpp \
+    qwt_event_pattern.cpp \
+    qwt_picker_machine.cpp \
+    qwt_point_3d.cpp \
+    qwt_point_polar.cpp \
+    qwt_scale_engine.cpp \
+    qwt_symbol.cpp \
+    qwt_system_clock.cpp \
+    qwt_curve_fitter.cpp \
+    qwt_legend.cpp \
+    qwt_legend_item.cpp \
+    qwt_plot.cpp \
+    qwt_plot_renderer.cpp \
+    qwt_plot_xml.cpp \
+    qwt_plot_axis.cpp \
+    qwt_plot_curve.cpp \
+    qwt_plot_dict.cpp \
+    qwt_plot_directpainter.cpp \
+    qwt_plot_grid.cpp \
+    qwt_plot_histogram.cpp \
+    qwt_plot_item.cpp \
+    qwt_plot_intervalcurve.cpp \
+    qwt_plot_spectrogram.cpp \
+    qwt_plot_spectrocurve.cpp \
+    qwt_plot_scaleitem.cpp \
+    qwt_plot_seriesitem.cpp \
+    qwt_plot_marker.cpp \
+    qwt_plot_layout.cpp \
+    qwt_plot_canvas.cpp \
+    qwt_plot_panner.cpp \
+    qwt_plot_rasteritem.cpp \
+    qwt_plot_picker.cpp \
+    qwt_plot_zoomer.cpp \
+    qwt_plot_magnifier.cpp \
+    qwt_plot_rescaler.cpp \
+    qwt_raster_data.cpp \
+    qwt_matrix_raster_data.cpp \
+    qwt_sampling_thread.cpp \
+    qwt_series_data.cpp \
+    qwt_scale_widget.cpp \
+    qwt_plot_svgitem.cpp
+include ( src.pri )

trunk/BNC/qwt/qwt_abstract_scale_draw.cpp

-              r4271
+              r8127
     QwtScaleMap map;
     QwtScaleDiv scldiv;
+    QwtScaleDiv scaleDiv;
     double spacing;
 …
 /*!
   Check if a component is enabled
+  \param component Component type
+  \return true, when component is enabled
   \sa enableComponent()
 */
 …
 /*!
   Change the scale division
   \param sd New scale division
 */
 void QwtAbstractScaleDraw::setScaleDiv( const QwtScaleDiv &sd )
+{
     d_data->scldiv = sd;
     d_data->map.setScaleInterval( sd.lowerBound(), sd.upperBound() );
+  \param scaleDiv New scale division
+*/
+void QwtAbstractScaleDraw::setScaleDiv( const QwtScaleDiv &scaleDiv )
+{
+    d_data->scaleDiv = scaleDiv;
+    d_data->map.setScaleInterval( scaleDiv.lowerBound(), scaleDiv.upperBound() );
     d_data->labelCache.clear();
+}
 …
 */
 void QwtAbstractScaleDraw::setTransformation(
     QwtScaleTransformation *transformation )
+    QwtTransform *transformation )
+{
     d_data->map.setTransformation( transformation );
 …
 const QwtScaleDiv& QwtAbstractScaleDraw::scaleDiv() const
+{
     return d_data->scldiv;
+    return d_data->scaleDiv;
+}
 …
         const QList<double> &majorTicks =
             d_data->scldiv.ticks( QwtScaleDiv::MajorTick );
+            d_data->scaleDiv.ticks( QwtScaleDiv::MajorTick );
         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 );
+        }
 …
             tickType < QwtScaleDiv::NTickTypes; tickType++ )
+        {
+            const QList<double> &ticks = d_data->scldiv.ticks( tickType );
+            const double tickLen = d_data->tickLength[tickType];
+            if ( tickLen <= 0.0 )
+                continue;
+            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, tickLen );
+            }
+        }
 …
   The default spacing is 4 pixels.
+  \return Spacing
   \sa setSpacing()
 */
 …
   \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
 …
 /*!
   Get the minimum extent
+  \return Minimum extent
   \sa extent(), setMinimumExtent()
 */
 …
 /*!
+    Return the length of the ticks
+    \return Length of the ticks
     \sa setTickLength(), maxTickLength()
 */
 …
   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.
 …
 /*!
    Invalidate the cache used by QwtAbstractScaleDraw::tickLabel
+   Invalidate the cache used by tickLabel()
    The cache is invalidated, when a new QwtScaleDiv is set. If

trunk/BNC/qwt/qwt_abstract_scale_draw.h

-              r4271
+              r8127
 class QPainter;
 class QFont;
 class QwtScaleTransformation;
+class QwtTransform;
 class QwtScaleMap;
 …
   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
 …
     const QwtScaleDiv& scaleDiv() const;
     void setTransformation( QwtScaleTransformation * );
+    void setTransformation( QwtTransform * );
     const QwtScaleMap &scaleMap() const;
     QwtScaleMap &scaleMap();
 …
       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 double extent( const QFont & ) const = 0;
+    virtual double extent( const QFont &font ) const = 0;
     void setMinimumExtent( double );
 …
        \param painter Painter
        \param value Value of the tick
        \param len Lenght of the tick
+       \param len Length of the tick
        \sa drawBackbone(), drawLabel()

trunk/BNC/qwt/qwt_clipper.cpp

-              r4271
+              r8127
 #include "qwt_point_polar.h"
 #include <qrect.h>
+#include <string.h>
+#include <stdlib.h>
 #if QT_VERSION < 0x040601
 …
+    {
         double dy = ( p1.y() - p2.y() ) / double( p1.x() - p2.x() );
         return Point( d_x1, ( Value ) ( p2.y() + ( d_x1 - p2.x() ) * dy ) );
+        return Point( d_x1, static_cast< Value >( p2.y() + ( d_x1 - p2.x() ) * dy ) );
+    }
 private:
 …
+    {
         double dy = ( p1.y() - p2.y() ) / double( p1.x() - p2.x() );
         return Point( d_x2, ( Value ) ( p2.y() + ( d_x2 - p2.x() ) * dy ) );
+        return Point( d_x2, static_cast<Value>( p2.y() + ( d_x2 - p2.x() ) * dy ) );
+    }
 …
+    {
         double dx = ( p1.x() - p2.x() ) / double( p1.y() - p2.y() );
         return Point( ( Value )( p2.x() + ( d_y1 - p2.y() ) * dx ), d_y1 );
+        return Point( static_cast<Value>( p2.x() + ( d_y1 - p2.y() ) * dx ), d_y1 );
+    }
 …
+    {
         double dx = ( p1.x() - p2.x() ) / double( p1.y() - p2.y() );
         return Point( ( Value )( p2.x() + ( d_y2 - p2.y() ) * dx ), d_y2 );
+        return Point( static_cast<Value>( p2.x() + ( d_y2 - p2.y() ) * dx ), d_y2 );
+    }
 …
+    {
         if ( m_buffer )
             qFree( m_buffer );
+            ::free( m_buffer );
+    }
 …
         m_size = numPoints;
         qMemCopy( m_buffer, points, m_size * sizeof( Point ) );
+        ::memcpy( m_buffer, points, m_size * sizeof( Point ) );
+    }
 …
             m_capacity *= 2;
         m_buffer = ( Point * ) qRealloc(
             m_buffer, m_capacity * sizeof( Point ) );
+        m_buffer = static_cast<Point *>(
+            ::realloc( m_buffer, m_capacity * sizeof( Point ) ) );
+    }
 …
         Polygon p;
         p.resize( points1.size() );
         qMemCopy( p.data(), points1.data(), points1.size() * sizeof( Point ) );
+        ::memcpy( p.data(), points1.data(), points1.size() * sizeof( Point ) );
         return p;
 …
     QList<QPointF> points;
     for ( int edge = 0; edge < NEdges; edge++ )
         points += cuttingPoints( ( Edge )edge, pos, radius );
+        points += cuttingPoints( static_cast<Edge>(edge), pos, radius );
     QVector<QwtInterval> intv;
 …
 */
 QPolygon QwtClipper::clipPolygon(
+    const QRectF &clipRect, const QPolygon &polygon, bool closePolygon )
+{
+    const int minX = qCeil( clipRect.left() );
+    const int maxX = qFloor( clipRect.right() );
+    const int minY = qCeil( clipRect.top() );
+    const int maxY = qFloor( clipRect.bottom() );
+    const QRect r( minX, minY, maxX - minX, maxY - minY );
+    QwtPolygonClipper<QPolygon, QRect, QPoint, int> clipper( r );
+    return clipper.clipPolygon( polygon, closePolygon );
+}
+/*!
+   Sutherland-Hodgman polygon clipping
+   \param clipRect Clip rectangle
+   \param polygon Polygon
+   \param closePolygon True, when the polygon is closed
+   \return Clipped polygon
+*/
+QPolygon QwtClipper::clipPolygon(
     const QRect &clipRect, const QPolygon &polygon, bool closePolygon )
+{
 …
    Circle clipping
    clipCircle() devides a circle into intervals of angles representing arcs
+   clipCircle() divides a circle into intervals of angles representing arcs
    of the circle. When the circle is completely inside the clip rectangle
    an interval [0.0, 2 * M_PI] is returned.

trunk/BNC/qwt/qwt_clipper.h

-              r4271
+              r8127
 /*!
   \brief Some clipping algos
+  \brief Some clipping algorithms
 */
 …
     static QPolygon clipPolygon( const QRect &,
         const QPolygon &, bool closePolygon = false );
+    static QPolygon clipPolygon( const QRectF &,
+        const QPolygon &, bool closePolygon = false );
     static QPolygonF clipPolygonF( const QRectF &,
         const QPolygonF &, bool closePolygon = false );

trunk/BNC/qwt/qwt_color_map.cpp

-              r4271
+              r8127
+{
 public:
+    ColorStops()
+    {
+        _stops.reserve( 256 );
+    ColorStops():
+        d_doAlpha( false )
+    {
+        d_stops.reserve( 256 );
+    }
 …
         ColorStop( double p, const QColor &c ):
             pos( p ),
             rgb( c.rgb() )
+            rgb( c.rgba() )
+        {
             r = qRed( rgb );
             g = qGreen( rgb );
             b = qBlue( rgb );
+            a = qAlpha( rgb );
+            /*
+                when mapping a value to rgb we will have to calcualate:
+                   - const int v = int( ( s1.v0 + ratio * s1.vStep ) + 0.5 );
+                Thus adding 0.5 ( for rounding ) can be done in advance
+             */
+            r0 = r + 0.5;
+            g0 = g + 0.5;
+            b0 = b + 0.5;
+            a0 = a + 0.5;
+            rStep = gStep = bStep = aStep = 0.0;
+            posStep = 0.0;
+        }
+        void updateSteps( const ColorStop &nextStop )
+        {
+            rStep = nextStop.r - r;
+            gStep = nextStop.g - g;
+            bStep = nextStop.b - b;
+            aStep = nextStop.a - a;
+            posStep = nextStop.pos - pos;
+        }
         double pos;
         QRgb rgb;
+        int r, g, b;
+        int r, g, b, a;
+        // precalculated values
+        double rStep, gStep, bStep, aStep;
+        double r0, g0, b0, a0;
+        double posStep;
     };
     inline int findUpper( double pos ) const;
+    QVector<ColorStop> _stops;
+    QVector<ColorStop> d_stops;
+    bool d_doAlpha;
 };
 …
     int index;
     if ( _stops.size() == 0 )
+    if ( d_stops.size() == 0 )
+    {
         index = 0;
         _stops.resize( 1 );
+        d_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 );
+        if ( index == d_stops.size() ||
+                qAbs( d_stops[index].pos - pos ) >= 0.001 )
+        {
+            d_stops.resize( d_stops.size() + 1 );
+            for ( int i = d_stops.size() - 1; i > index; i-- )
+                d_stops[i] = d_stops[i-1];
+        }
+    }
+    d_stops[index] = ColorStop( pos, color );
+    if ( color.alpha() != 255 )
+        d_doAlpha = true;
+    if ( index > 0 )
+        d_stops[index-1].updateSteps( d_stops[index] );
+    if ( index < d_stops.size() - 1 )
+        d_stops[index].updateSteps( d_stops[index+1] );
+}
 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;
+    QVector<double> positions( d_stops.size() );
+    for ( int i = 0; i < d_stops.size(); i++ )
+        positions[i] = d_stops[i].pos;
     return positions;
+}
 …
+{
     int index = 0;
     int n = _stops.size();
     const ColorStop *stops = _stops.data();
+    int n = d_stops.size();
+    const ColorStop *stops = d_stops.data();
     while ( n > 0 )
 …
+{
     if ( pos <= 0.0 )
         return _stops[0].rgb;
+        return d_stops[0].rgb;
     if ( pos >= 1.0 )
         return _stops[ _stops.size() - 1 ].rgb;
+        return d_stops[ d_stops.size() - 1 ].rgb;
     const int index = findUpper( pos );
     if ( mode == FixedColors )
+    {
         return _stops[index-1].rgb;
+        return d_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 );
+        const ColorStop &s1 = d_stops[index-1];
+        const double ratio = ( pos - s1.pos ) / ( s1.posStep );
+        const int r = int( s1.r0 + ratio * s1.rStep );
+        const int g = int( s1.g0 + ratio * s1.gStep );
+        const int b = int( s1.b0 + ratio * s1.bStep );
+        if ( d_doAlpha )
+        {
+            if ( s1.aStep )
+            {
+                const int a = int( s1.a0 + ratio * s1.aStep );
+                return qRgba( r, g, b, a );
+            }
+            else
+            {
+                return qRgba( r, g, b, s1.a );
+            }
+        }
+        else
+        {
+            return qRgb( r, g, b );
+        }
+    }
+}
 …
    \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 of the coor map
+   \param format Preferred format for the color map
 */
 QwtLinearColorMap::QwtLinearColorMap( const QColor &color1,
 …
 /*!
    Return all positions of color stops in increasing order
+   \return Positions of color stops in increasing order
 */
 QVector<double> QwtLinearColorMap::colorStops() const
 …
 /*!
   Map a value of a given interval into a rgb value
+  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
+  \param value Value to map into a RGB value
+  \return RGB value for value
 */
 QRgb QwtLinearColorMap::rgb(
 …
+{
     if ( qIsNaN(value) )
         return qRgba(0, 0, 0, 0);
+        return 0u;
     const double width = interval.width();
+    double ratio = 0.0;
+    if ( width > 0.0 )
+        ratio = ( value - interval.minValue() ) / width;
+    if ( width <= 0.0 )
+        return 0u;
+    const double ratio = ( value - interval.minValue() ) / width;
     return d_data->colorStops.rgb( d_data->mode, ratio );
+}
 /*!
   Map a value of a given interval into a color index, between 0 and 255
+  \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(
 …
     if ( value >= interval.maxValue() )
         return ( unsigned char )255;
+        return 255;
     const double ratio = ( value - interval.minValue() ) / width;
 …
     unsigned char index;
     if ( d_data->mode == FixedColors )
         index = ( unsigned char )( ratio * 255 ); // always floor
+        index = static_cast<unsigned char>( ratio * 255 ); // always floor
     else
         index = ( unsigned char )qRound( ratio * 255 );
+        index = static_cast<unsigned char>( ratio * 255 + 0.5 );
     return index;
 …
     QColor color;
     QRgb rgb;
+    QRgb rgbMax;
 };
 …
+{
     d_data = new PrivateData;
+    setColor( color );
+}
+//! 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() & 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();
+    d_data->rgbMax = d_data->rgb | ( 255 << 24 );
+}
 …
   \param interval Range for all values
   \param value Value to map into a rgb value
   \return rgb value, with an alpha value
+  \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
+{
+    if ( qIsNaN(value) )
+        return 0u;
     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;
+    if ( width <= 0.0 )
+        return 0u;
+    if ( value <= interval.minValue() )
+        return d_data->rgb;
+    if ( value >= interval.maxValue() )
+        return d_data->rgbMax;
+    const double ratio = ( value - interval.minValue() ) / width;
+    return d_data->rgb | ( qRound( 255 * ratio ) << 24 );
+}

trunk/BNC/qwt/qwt_color_map.h

-              r4271
+              r8127
     enum Format
+    {
         //! The map is intended to map into QRgb values.
+        //! The map is intended to map into RGB values.
         RGB,
 …
     /*!
+       Map a value of a given interval into a rgb value.
+       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
+       \return RGB value, corresponding to value
     */
     virtual QRgb rgb( const QwtInterval &interval,
 …
     /*!
        Map a value of a given interval into a color index
        \param interval Range for the values
        \param value Value
 …
 /*!
   \brief QwtAlphaColorMap variies the alpha value of a color
+  \brief QwtAlphaColorMap varies the alpha value of a color
 */
 class QWT_EXPORT QwtAlphaColorMap: public QwtColorMap
 …
     if ( d_format == RGB )
+    {
         return QColor( rgb( interval, value ) );
+        return QColor::fromRgba( rgb( interval, value ) );
+    }
     else

trunk/BNC/qwt/qwt_column_symbol.cpp

-              r4271
+              r8127
 #include "qwt_column_symbol.h"
 #include "qwt_math.h"
-#include "qwt_text.h"
 #include "qwt_painter.h"
 #include <qpainter.h>
 #include <qpalette.h>
 static void drawBox( QPainter *p, const QRectF &rect,
+static void qwtDrawBox( QPainter *p, const QRectF &rect,
     const QPalette &pal, double lw )
+{
 …
+}
 static void drawPanel( QPainter *painter, const QRectF &rect,
+static void qwtDrawPanel( QPainter *painter, const QRectF &rect,
     const QPalette &pal, double lw )
+{
 …
     QPalette palette;
-    QwtText label;
     int lineWidth;
 };
 …
         case QwtColumnSymbol::Raised:
+        {
             ::drawPanel( painter, r, d_data->palette, d_data->lineWidth );
+            qwtDrawPanel( painter, r, d_data->palette, d_data->lineWidth );
             break;
+        }
         case QwtColumnSymbol::Plain:
+        {
             ::drawBox( painter, r, d_data->palette, d_data->lineWidth );
+            qwtDrawBox( painter, r, d_data->palette, d_data->lineWidth );
             break;
+        }

trunk/BNC/qwt/qwt_column_symbol.h

r4271	r8127
23	23
24	24	/*!
25		\brief Directed rectangle representing bounding rectangle und orientation
	25	\brief Directed rectangle representing bounding rectangle and orientation
26	26	of a column.
27	27	*/

trunk/BNC/qwt/qwt_compat.h

r4271	r8127
12	12
13	13	#include "qwt_global.h"
	14	#include "qwt_interval.h"
	15	#include "qwt_point_3d.h"
14	16	#include <qlist.h>
15	17	#include <qvector.h>

trunk/BNC/qwt/qwt_curve_fitter.cpp

-              r4271
+              r8127
 public:
     PrivateData():
+        tolerance( 1.0 )
+        tolerance( 1.0 ),
+        chunkSize( 0 )
+    {
+    }
     double tolerance;
+    uint chunkSize;
 };
 …
  Assign the tolerance
  The tolerance is the maximum distance, that is accaptable
+ The tolerance is the maximum distance, that is acceptable
  between the original curve and the smoothed curve.
 …
 /*!
+ Limit the number of points passed to a run of the algorithm
+ The runtime of the Douglas Peucker algorithm increases non linear
+ with the number of points. For a chunk size > 0 the polygon
+ is split into pieces passed to the algorithm one by one.
+ \param numPoints Maximum for the number of points passed to the algorithm
+ \sa chunkSize()
+*/
+void QwtWeedingCurveFitter::setChunkSize( uint numPoints )
+{
+    if ( numPoints > 0 )
+        numPoints = qMax( numPoints, 3U );
+    d_data->chunkSize = numPoints;
+}
+/*!
+  \return Maximum for the number of points passed to a run
+          of the algorithm - or 0, when unlimited
+  \sa setChunkSize()
+*/
+uint QwtWeedingCurveFitter::chunkSize() const
+{
+    return d_data->chunkSize;
+}
+/*!
   \param points Series of data points
   \return Curve points
 …
 QPolygonF QwtWeedingCurveFitter::fitCurve( const QPolygonF &points ) const
+{
+    QPolygonF fittedPoints;
+    if ( d_data->chunkSize == 0 )
+    {
+        fittedPoints = simplify( points );
+    }
+    else
+    {
+        for ( int i = 0; i < points.size(); i += d_data->chunkSize )
+        {
+            const QPolygonF p = points.mid( i, d_data->chunkSize );
+            fittedPoints += simplify( p );
+        }
+    }
+    return fittedPoints;
+}
+QPolygonF QwtWeedingCurveFitter::simplify( const QPolygonF &points ) const
+{
+    const double toleranceSqr = d_data->tolerance * d_data->tolerance;
     QStack<Line> stack;
     stack.reserve( 500 );
 …
     QVector<bool> usePoint( nPoints, false );
-    double distToSegment;
     stack.push( Line( 0, nPoints - 1 ) );
 …
         const double unitVecY = ( vecLength != 0.0 ) ? vecY / vecLength : 0.0;
         double maxDist = 0.0;
+        double maxDistSqr = 0.0;
         int nVertexIndexMaxDistance = r.from + 1;
         for ( int i = r.from + 1; i < r.to; i++ )
 …
             const double fromVecX = p[i].x() - p[r.from].x();
             const double fromVecY = p[i].y() - p[r.from].y();
+            const double fromVecLength =
+                qSqrt( fromVecX * fromVecX + fromVecY * fromVecY );
+            double distToSegmentSqr;
             if ( fromVecX * unitVecX + fromVecY * unitVecY < 0.0 )
+            {
+                distToSegment = fromVecLength;
+            }
+            if ( fromVecX * unitVecX + fromVecY * unitVecY < 0.0 )
+            {
+                distToSegment = fromVecLength;
+                distToSegmentSqr = fromVecX * fromVecX + fromVecY * fromVecY;
+            }
             else
 …
                 const double toVecX = p[i].x() - p[r.to].x();
                 const double toVecY = p[i].y() - p[r.to].y();
+                const double toVecLength = qSqrt( toVecX * toVecX + toVecY * toVecY );
+                const double toVecLength = toVecX * toVecX + toVecY * toVecY;
                 const double s = toVecX * ( -unitVecX ) + toVecY * ( -unitVecY );
                 if ( s < 0.0 )
+                    distToSegment = toVecLength;
+                {
+                    distToSegmentSqr = toVecLength;
+                }
                 else
+                {
                     distToSegment = qSqrt( qFabs( toVecLength * toVecLength - s * s ) );
+                    distToSegmentSqr = qFabs( toVecLength - s * s );
+                }
+            }
             if ( maxDist < distToSegment )
+            if ( maxDistSqr < distToSegmentSqr )
+            {
                 maxDist = distToSegment;
+                maxDistSqr = distToSegmentSqr;
                 nVertexIndexMaxDistance = i;
+            }
+        }
         if ( maxDist <= d_data->tolerance )
+        if ( maxDistSqr <= toleranceSqr )
+        {
             usePoint[r.from] = true;
 …
+    }
+    int cnt = 0;
+    QPolygonF stripped( nPoints );
+    QPolygonF stripped;
     for ( int i = 0; i < nPoints; i++ )
+    {
         if ( usePoint[i] )
             stripped[cnt++] = p[i];
+    }
+    stripped.resize( cnt );
+            stripped += p[i];
+    }
     return stripped;
+}

trunk/BNC/qwt/qwt_curve_fitter.h

-              r4271
+              r8127
   smoothed curve.
+  The runtime of the algorithm increases non linear ( worst case O( n*n ) )
+  and might be very slow for huge polygons. To avoid performance issues
+  it might be useful to split the polygon ( setChunkSize() ) and to run the algorithm
+  for these smaller parts. The disadvantage of having no interpolation
+  at the borders is for most use cases irrelevant.
   The smoothed curve consists of a subset of the points that defined the
   original curve.
 …
     double tolerance() const;
+    void setChunkSize( uint );
+    uint chunkSize() const;
     virtual QPolygonF fitCurve( const QPolygonF & ) const;
 private:
+    virtual QPolygonF simplify( const QPolygonF & ) const;
     class Line;

trunk/BNC/qwt/qwt_dyngrid_layout.cpp

-              r4271
+              r8127
 #include "qwt_dyngrid_layout.h"
 #include "qwt_math.h"
 #include <qwidget.h>
+#include <qvector.h>
 #include <qlist.h>
 …
     mutable QList<QLayoutItem*> itemList;
     uint maxCols;
+    uint maxColumns;
     uint numRows;
     uint numCols;
+    uint numColumns;
     Qt::Orientations expanding;
 …
+{
     d_data = new QwtDynGridLayout::PrivateData;
     d_data->maxCols = d_data->numRows = d_data->numCols = 0;
+    d_data->maxColumns = d_data->numRows = d_data->numColumns = 0;
     d_data->expanding = 0;
+}
 …
 /*!
   Limit the number of columns.
+  \param maxCols upper limit, 0 means unlimited
+  \sa maxCols()
+*/
+void QwtDynGridLayout::setMaxCols( uint maxCols )
+{
+    d_data->maxCols = maxCols;
+}
+/*!
+  Return the upper limit for the number of columns.
+  \param maxColumns upper limit, 0 means unlimited
+  \sa maxColumns()
+*/
+void QwtDynGridLayout::setMaxColumns( uint maxColumns )
+{
+    d_data->maxColumns = maxColumns;
+}
+/*!
+  \brief Return the upper limit for the number of columns.
 means unlimited, what is the default.
+  \sa setMaxCols()
+*/
+uint QwtDynGridLayout::maxCols() const
+{
+    return d_data->maxCols;
+}
+//! Adds item to the next free position.
+  \return Upper limit for the number of columns
+  \sa setMaxColumns()
+*/
+uint QwtDynGridLayout::maxColumns() const
+{
+    return d_data->maxColumns;
+}
+/*!
+  \brief Add an item to the next free position.
+  \param item Layout item
+ */
 void QwtDynGridLayout::addItem( QLayoutItem *item )
+{
 …
   \return true if this layout is empty.
 */
 bool QwtDynGridLayout::isEmpty() const
+{
 …
   \return number of layout items
 */
 uint QwtDynGridLayout::itemCount() const
+{
 …
 /*!
   Find the item at a spcific index
+  Find the item at a specific index
   \param index Index
+  \return Item at a specific index
   \sa takeAt()
 */
 …
 /*!
   Find the item at a spcific index and remove it from the layout
+  Find the item at a specific index and remove it from the layout
   \param index Index
+  \return Layout item, removed from the layout
   \sa itemAt()
 */
 …
 /*!
+  Returns whether this layout can make use of more space than sizeHint().
+  \brief Returns whether this layout can make use of more space than sizeHint().
   A value of Qt::Vertical or Qt::Horizontal means that it wants to grow in only
   one dimension, while Qt::Vertical | Qt::Horizontal means that it wants
   to grow in both dimensions.
+  \return Orientations, where the layout expands
   \sa setExpandingDirections()
 */
 …
 /*!
   Reorganizes columns and rows and resizes managed widgets within
   the rectangle rect.
+  Reorganizes columns and rows and resizes managed items within
+  a rectangle.
   \param rect Layout geometry
 …
         return;
     d_data->numCols = columnsForWidth( rect.width() );
     d_data->numRows = itemCount() / d_data->numCols;
     if ( itemCount() % d_data->numCols )
+    d_data->numColumns = columnsForWidth( rect.width() );
+    d_data->numRows = itemCount() / d_data->numColumns;
+    if ( itemCount() % d_data->numColumns )
         d_data->numRows++;
     QList<QRect> itemGeometries = layoutItems( rect, d_data->numCols );
+    QList<QRect> itemGeometries = layoutItems( rect, d_data->numColumns );
     int index = 0;
 …
         it != d_data->itemList.end(); ++it )
+    {
+        QWidget *w = ( *it )->widget();
+        if ( w )
+        {
+            w->setGeometry( itemGeometries[index] );
+            index++;
+        }
+    }
+}
+/*!
+  Calculate the number of columns for a given width. It tries to
+  use as many columns as possible (limited by maxCols())
+        ( *it )->setGeometry( itemGeometries[index] );
+        index++;
+    }
+}
+/*!
+  \brief Calculate the number of columns for a given width.
+  The calculation tries to use as many columns as possible
+  ( limited by maxColumns() )
   \param width Available width for all columns
+  \sa maxCols(), setMaxCols()
+*/
+  \return Number of columns for a given width
+  \sa maxColumns(), setMaxColumns()
+*/
 uint QwtDynGridLayout::columnsForWidth( int width ) const
+{
 …
         return 0;
+    const int maxCols = ( d_data->maxCols > 0 ) ? d_data->maxCols : itemCount();
+    if ( maxRowWidth( maxCols ) <= width )
+        return maxCols;
+    for ( int numCols = 2; numCols <= maxCols; numCols++ )
+    {
+        const int rowWidth = maxRowWidth( numCols );
+    uint maxColumns = itemCount();
+    if ( d_data->maxColumns > 0 )
+        maxColumns = qMin( d_data->maxColumns, maxColumns );
+    if ( maxRowWidth( maxColumns ) <= width )
+        return maxColumns;
+    for ( uint numColumns = 2; numColumns <= maxColumns; numColumns++ )
+    {
+        const int rowWidth = maxRowWidth( numColumns );
         if ( rowWidth > width )
             return numCols - 1;
+            return numColumns - 1;
+    }
 …
   columns.
   \param numCols Given number of columns
+  \param numColumns Given number of columns
   \param itemWidth Array of the width hints for all items
 */
 int QwtDynGridLayout::maxRowWidth( int numCols ) const
+int QwtDynGridLayout::maxRowWidth( int numColumns ) const
+{
     int col;
     QVector<int> colWidth( numCols );
     for ( col = 0; col < numCols; col++ )
+    QVector<int> colWidth( numColumns );
+    for ( col = 0; col < numColumns; col++ )
         colWidth[col] = 0;
 …
         index < d_data->itemSizeHints.count(); index++ )
+    {
         col = index % numCols;
+        col = index % numColumns;
         colWidth[col] = qMax( colWidth[col],
             d_data->itemSizeHints[int( index )].width() );
+    }
     int rowWidth = 2 * margin() + ( numCols - 1 ) * spacing();
     for ( col = 0; col < numCols; col++ )
+    int rowWidth = 2 * margin() + ( numColumns - 1 ) * spacing();
+    for ( col = 0; col < numColumns; col++ )
         rowWidth += colWidth[col];
 …
 /*!
   Calculate the geometries of the layout items for a layout
   with numCols columns and a given rect.
+  with numColumns columns and a given rectangle.
   \param rect Rect where to place the items
   \param numCols Number of columns
+  \param numColumns Number of columns
   \return item geometries
 */
 QList<QRect> QwtDynGridLayout::layoutItems( const QRect &rect,
     uint numCols ) const
+    uint numColumns ) const
+{
     QList<QRect> itemGeometries;
     if ( numCols == 0 || isEmpty() )
+    if ( numColumns == 0 || isEmpty() )
         return itemGeometries;
     uint numRows = itemCount() / numCols;
     if ( numRows % itemCount() )
+    uint numRows = itemCount() / numColumns;
+    if ( numColumns % itemCount() )
         numRows++;
+    if ( numRows == 0 )
+        return itemGeometries;
     QVector<int> rowHeight( numRows );
     QVector<int> colWidth( numCols );
     layoutGrid( numCols, rowHeight, colWidth );
+    QVector<int> colWidth( numColumns );
+    layoutGrid( numColumns, rowHeight, colWidth );
     bool expandH, expandV;
 …
     if ( expandH || expandV )
         stretchGrid( rect, numCols, rowHeight, colWidth );
     const int maxCols = d_data->maxCols;
     d_data->maxCols = numCols;
+        stretchGrid( rect, numColumns, rowHeight, colWidth );
+    const int maxColumns = d_data->maxColumns;
+    d_data->maxColumns = numColumns;
     const QRect alignedRect = alignmentRect( rect );
     d_data->maxCols = maxCols;
+    d_data->maxColumns = maxColumns;
     const int xOffset = expandH ? 0 : alignedRect.x();
     const int yOffset = expandV ? 0 : alignedRect.y();
     QVector<int> colX( numCols );
+    QVector<int> colX( numColumns );
     QVector<int> rowY( numRows );
 …
     rowY[0] = yOffset + margin();
     for ( int r = 1; r < ( int )numRows; r++ )
+    for ( uint r = 1; r < numRows; r++ )
         rowY[r] = rowY[r-1] + rowHeight[r-1] + xySpace;
     colX[0] = xOffset + margin();
     for ( int c = 1; c < ( int )numCols; c++ )
+    for ( uint c = 1; c < numColumns; c++ )
         colX[c] = colX[c-1] + colWidth[c-1] + xySpace;
 …
     for ( int i = 0; i < itemCount; i++ )
+    {
         const int row = i / numCols;
         const int col = i % numCols;
+        const int row = i / numColumns;
+        const int col = i % numColumns;
         QRect itemGeometry( colX[col], rowY[row],
 …
 /*!
   Calculate the dimensions for the columns and rows for a grid
   of numCols columns.
   \param numCols Number of columns.
+  of numColumns columns.
+  \param numColumns Number of columns.
   \param rowHeight Array where to fill in the calculated row heights.
   \param colWidth Array where to fill in the calculated column widths.
 */
 void QwtDynGridLayout::layoutGrid( uint numCols,
+void QwtDynGridLayout::layoutGrid( uint numColumns,
     QVector<int>& rowHeight, QVector<int>& colWidth ) const
+{
     if ( numCols <= 0 )
+    if ( numColumns <= 0 )
         return;
 …
         d_data->updateLayoutCache();
+    for ( uint index = 0;
+        index < ( uint )d_data->itemSizeHints.count(); index++ )
+    {
+        const int row = index / numCols;
+        const int col = index % numCols;
+    for ( int index = 0; index < d_data->itemSizeHints.count(); index++ )
+    {
+        const int row = index / numColumns;
+        const int col = index % numColumns;
         const QSize &size = d_data->itemSizeHints[int( index )];
 …
 /*!
   \return true: QwtDynGridLayout implements heightForWidth.
+  \return true: QwtDynGridLayout implements heightForWidth().
   \sa heightForWidth()
 */
 …
 /*!
   \return The preferred height for this layout, given the width w.
+  \return The preferred height for this layout, given a width.
   \sa hasHeightForWidth()
 */
 …
         return 0;
     const uint numCols = columnsForWidth( width );
     uint numRows = itemCount() / numCols;
     if ( itemCount() % numCols )
+    const uint numColumns = columnsForWidth( width );
+    uint numRows = itemCount() / numColumns;
+    if ( itemCount() % numColumns )
         numRows++;
     QVector<int> rowHeight( numRows );
     QVector<int> colWidth( numCols );
     layoutGrid( numCols, rowHeight, colWidth );
+    QVector<int> colWidth( numColumns );
+    layoutGrid( numColumns, rowHeight, colWidth );
     int h = 2 * margin() + ( numRows - 1 ) * spacing();
     for ( int row = 0; row < ( int )numRows; row++ )
+    for ( uint row = 0; row < numRows; row++ )
         h += rowHeight[row];
 …
   rect. Rows and columns are stretched with the same factor.
+  \param rect Bounding rectangle
+  \param numColumns Number of columns
+  \param rowHeight Array to be filled with the calculated row heights
+  \param colWidth Array to be filled with the calculated column widths
   \sa setExpanding(), expanding()
 */
 void QwtDynGridLayout::stretchGrid( const QRect &rect,
     uint numCols, QVector<int>& rowHeight, QVector<int>& colWidth ) const
+{
     if ( numCols == 0 || isEmpty() )
+    uint numColumns, QVector<int>& rowHeight, QVector<int>& colWidth ) const
+{
+    if ( numColumns == 0 || isEmpty() )
         return;
 …
     if ( expandH )
+    {
         int xDelta = rect.width() - 2 * margin() - ( numCols - 1 ) * spacing();
         for ( int col = 0; col < ( int )numCols; col++ )
+        int xDelta = rect.width() - 2 * margin() - ( numColumns - 1 ) * spacing();
+        for ( uint col = 0; col < numColumns; col++ )
             xDelta -= colWidth[col];
         if ( xDelta > 0 )
+        {
             for ( int col = 0; col < ( int )numCols; col++ )
+            for ( uint col = 0; col < numColumns; col++ )
+            {
                 const int space = xDelta / ( numCols - col );
+                const int space = xDelta / ( numColumns - col );
                 colWidth[col] += space;
                 xDelta -= space;
 …
     if ( expandV )
+    {
         uint numRows = itemCount() / numCols;
         if ( itemCount() % numCols )
+        uint numRows = itemCount() / numColumns;
+        if ( itemCount() % numColumns )
             numRows++;
         int yDelta = rect.height() - 2 * margin() - ( numRows - 1 ) * spacing();
         for ( int row = 0; row < ( int )numRows; row++ )
+        for ( uint row = 0; row < numRows; row++ )
             yDelta -= rowHeight[row];
         if ( yDelta > 0 )
+        {
             for ( int row = 0; row < ( int )numRows; row++ )
+            for ( uint row = 0; row < numRows; row++ )
+            {
                 const int space = yDelta / ( numRows - row );
 …
 /*!
    Return the size hint. If maxCols() > 0 it is the size for
    a grid with maxCols() columns, otherwise it is the size for
+   Return the size hint. If maxColumns() > 0 it is the size for
+   a grid with maxColumns() columns, otherwise it is the size for
    a grid with only one row.
+   \sa maxCols(), setMaxCols()
+   \return Size hint
+   \sa maxColumns(), setMaxColumns()
 */
 QSize QwtDynGridLayout::sizeHint() const
 …
         return QSize();
+    const uint numCols = ( d_data->maxCols > 0 ) ? d_data->maxCols : itemCount();
+    uint numRows = itemCount() / numCols;
+    if ( itemCount() % numCols )
+    uint numColumns = itemCount();
+    if ( d_data->maxColumns > 0 )
+        numColumns = qMin( d_data->maxColumns, numColumns );
+    uint numRows = itemCount() / numColumns;
+    if ( itemCount() % numColumns )
         numRows++;
     QVector<int> rowHeight( numRows );
     QVector<int> colWidth( numCols );
     layoutGrid( numCols, rowHeight, colWidth );
+    QVector<int> colWidth( numColumns );
+    layoutGrid( numColumns, rowHeight, colWidth );
     int h = 2 * margin() + ( numRows - 1 ) * spacing();
     for ( int row = 0; row < ( int )numRows; row++ )
+    for ( uint row = 0; row < numRows; row++ )
         h += rowHeight[row];
     int w = 2 * margin() + ( numCols - 1 ) * spacing();
     for ( int col = 0; col < ( int )numCols; col++ )
+    int w = 2 * margin() + ( numColumns - 1 ) * spacing();
+    for ( uint col = 0; col < numColumns; col++ )
         w += colWidth[col];
 …
 /*!
   \return Number of rows of the current layout.
   \sa numCols()
+  \sa numColumns()
   \warning The number of rows might change whenever the geometry changes
 */
 …
   \warning The number of columns might change whenever the geometry changes
 */
 uint QwtDynGridLayout::numCols() const
+{
     return d_data->numCols;
+}
+uint QwtDynGridLayout::numColumns() const
+{
+    return d_data->numColumns;
+}

trunk/BNC/qwt/qwt_dyngrid_layout.h

-              r4271
+              r8127
   QwtDynGridLayout takes the space it gets, divides it up into rows and
   columns, and puts each of the widgets it manages into the correct cell(s).
   It lays out as many number of columns as possible (limited by maxCols()).
+  It lays out as many number of columns as possible (limited by maxColumns()).
 */
 …
     virtual void invalidate();
     void setMaxCols( uint maxCols );
     uint maxCols() const;
+    void setMaxColumns( uint maxCols );
+    uint maxColumns() const;
     uint numRows () const;
     uint numCols () const;
+    uint numColumns () const;
     virtual void addItem( QLayoutItem * );

trunk/BNC/qwt/qwt_event_pattern.cpp

-              r4271
+              r8127
 void QwtEventPattern::initMousePattern( int numButtons )
+{
-    const int altButton = Qt::AltModifier;
-    const int controlButton = Qt::ControlModifier;
-    const int shiftButton = Qt::ShiftModifier;
     d_mousePattern.resize( MousePatternCount );
 …
+        {
             setMousePattern( MouseSelect1, Qt::LeftButton );
             setMousePattern( MouseSelect2, Qt::LeftButton, controlButton );
             setMousePattern( MouseSelect3, Qt::LeftButton, altButton );
+            setMousePattern( MouseSelect2, Qt::LeftButton, Qt::ControlModifier );
+            setMousePattern( MouseSelect3, Qt::LeftButton, Qt::AltModifier );
             break;
+        }
 …
             setMousePattern( MouseSelect1, Qt::LeftButton );
             setMousePattern( MouseSelect2, Qt::RightButton );
             setMousePattern( MouseSelect3, Qt::LeftButton, altButton );
+            setMousePattern( MouseSelect3, Qt::LeftButton, Qt::AltModifier );
             break;
+        }
 …
+        }
+    }
+    for ( int i = 0; i < 3; i++ )
+    {
+        setMousePattern( MouseSelect4 + i,
+                         d_mousePattern[MouseSelect1 + i].button,
+                         d_mousePattern[MouseSelect1 + i].state | shiftButton );
+    }
+    setMousePattern( MouseSelect4, d_mousePattern[MouseSelect1].button,
+        d_mousePattern[MouseSelect1].modifiers | Qt::ShiftModifier );
+    setMousePattern( MouseSelect5, d_mousePattern[MouseSelect2].button,
+        d_mousePattern[MouseSelect2].modifiers | Qt::ShiftModifier );
+    setMousePattern( MouseSelect6, d_mousePattern[MouseSelect3].button,
+        d_mousePattern[MouseSelect3].modifiers | Qt::ShiftModifier );
+}
 …
   \param pattern Index of the pattern
   \param button Button
   \param state State
+  \param modifiers Keyboard modifiers
   \sa QMouseEvent
 */
+void QwtEventPattern::setMousePattern( uint pattern, int button, int state )
+{
+    if ( pattern < ( uint )d_mousePattern.count() )
+void QwtEventPattern::setMousePattern( MousePatternCode pattern,
+    Qt::MouseButton button, Qt::KeyboardModifiers modifiers )
+{
+    if ( pattern >= 0 && pattern < MousePatternCount )
+    {
         d_mousePattern[int( pattern )].button = button;
         d_mousePattern[int( pattern )].state = state;
+        d_mousePattern[ pattern ].button = button;
+        d_mousePattern[ pattern ].modifiers = modifiers;
+    }
+}
 …
   \param pattern Index of the pattern
   \param key Key
   \param state State
+  \param modifiers Keyboard modifiers
   \sa QKeyEvent
 */
+void QwtEventPattern::setKeyPattern( uint pattern, int key, int state )
+{
+    if ( pattern < ( uint )d_keyPattern.count() )
+void QwtEventPattern::setKeyPattern( KeyPatternCode pattern,
+    int key, Qt::KeyboardModifiers modifiers )
+{
+    if ( pattern >= 0 && pattern < KeyPatternCount )
+    {
         d_keyPattern[int( pattern )].key = key;
         d_keyPattern[int( pattern )].state = state;
+        d_keyPattern[ pattern ].key = key;
+        d_keyPattern[ pattern ].modifiers = modifiers;
+    }
+}
 …
+}
 //! Return mouse patterns
+//! \return Mouse pattern
 const QVector<QwtEventPattern::MousePattern> &
 QwtEventPattern::mousePattern() const
 …
+}
 //! Return key patterns
+//! \return Key pattern
 const QVector<QwtEventPattern::KeyPattern> &
 QwtEventPattern::keyPattern() const
 …
+}
 //! Return ,ouse patterns
+//! \return Mouse pattern
 QVector<QwtEventPattern::MousePattern> &QwtEventPattern::mousePattern()
+{
 …
+}
 //! Return Key patterns
+//! \return Key pattern
 QVector<QwtEventPattern::KeyPattern> &QwtEventPattern::keyPattern()
+{
 …
   are set.
   \param pattern Index of the event pattern
+  \param code Index of the event pattern
   \param event Mouse event
   \return true if matches
 …
   \sa keyMatch()
 */
 bool QwtEventPattern::mouseMatch( uint pattern,
+bool QwtEventPattern::mouseMatch( MousePatternCode code,
     const QMouseEvent *event ) const
+{
+    bool ok = false;
+    if ( event && pattern < ( uint )d_mousePattern.count() )
+        ok = mouseMatch( d_mousePattern[int( pattern )], event );
+    return ok;
+    if ( code >= 0 && code < MousePatternCount )
+        return mouseMatch( d_mousePattern[ code ], event );
+    return false;
+}
 …
     const QMouseEvent *event ) const
+{
     if ( event->button() != pattern.button )
+    if ( event == NULL )
         return false;
+    const bool matched =
+        ( event->modifiers() & Qt::KeyboardModifierMask ) ==
+            ( int )( pattern.state & Qt::KeyboardModifierMask );
+    return matched;
+    const MousePattern mousePattern( event->button(), event->modifiers() );
+    return mousePattern == pattern;
+}
 …
   are set.
   \param pattern Index of the event pattern
+  \param code Index of the event pattern
   \param event Key event
   \return true if matches
 …
   \sa mouseMatch()
 */
 bool QwtEventPattern::keyMatch( uint pattern,
+bool QwtEventPattern::keyMatch( KeyPatternCode code,
     const QKeyEvent *event ) const
+{
+    bool ok = false;
+    if ( event && pattern < ( uint )d_keyPattern.count() )
+        ok = keyMatch( d_keyPattern[int( pattern )], event );
+    return ok;
+    if ( code >= 0 && code < KeyPatternCount )
+        return keyMatch( d_keyPattern[ code ], event );
+    return false;
+}
 …
     const KeyPattern &pattern, const QKeyEvent *event ) const
+{
     if ( event->key() != pattern.key )
+    if ( event == NULL )
         return false;
+    const bool matched =
+        ( event->modifiers() & Qt::KeyboardModifierMask ) ==
+            ( int )( pattern.state & Qt::KeyboardModifierMask );
+    return matched;
+}
+    const KeyPattern keyPattern( event->key(), event->modifiers() );
+    return keyPattern == pattern;
+}

trunk/BNC/qwt/qwt_event_pattern.h

-              r4271
+              r8127
       \brief Symbolic mouse input codes
+      The default initialization for 3 button mice is:
+      - MouseSelect1\n
+        Qt::LeftButton
+      - MouseSelect2\n
+        Qt::RightButton
+      - MouseSelect3\n
+        Qt::MidButton
+      - MouseSelect4\n
+        Qt::LeftButton + Qt::ShiftButton
+      - MouseSelect5\n
+        Qt::RightButton + Qt::ShiftButton
+      - MouseSelect6\n
+        Qt::MidButton + Qt::ShiftButton
+      The default initialization for 2 button mice is:
+      - MouseSelect1\n
+        Qt::LeftButton
+      - MouseSelect2\n
+        Qt::RightButton
+      - MouseSelect3\n
+        Qt::LeftButton + Qt::AltButton
+      - MouseSelect4\n
+        Qt::LeftButton + Qt::ShiftButton
+      - MouseSelect5\n
+        Qt::RightButton + Qt::ShiftButton
+      - MouseSelect6\n
+        Qt::LeftButton + Qt::AltButton + Qt::ShiftButton
+      The default initialization for 1 button mice is:
+      - MouseSelect1\n
+        Qt::LeftButton
+      - MouseSelect2\n
+        Qt::LeftButton + Qt::ControlButton
+      - MouseSelect3\n
+        Qt::LeftButton + Qt::AltButton
+      - MouseSelect4\n
+        Qt::LeftButton + Qt::ShiftButton
+      - MouseSelect5\n
+        Qt::LeftButton + Qt::ControlButton + Qt::ShiftButton
+      - MouseSelect6\n
+        Qt::LeftButton + Qt::AltButton + Qt::ShiftButton
+      \sa initMousePattern()
+      QwtEventPattern implements 3 different settings for
+      mice with 1, 2, or 3 buttons that can be activated
+      using initMousePattern(). The default setting is for
+button mice.
+      Individual settings can be configured using setMousePattern().
+      \sa initMousePattern(), setMousePattern(), setKeyPattern()
     */
     enum MousePatternCode
+    {
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton
+          - Qt::LeftButton
+          - Qt::LeftButton
+         */
         MouseSelect1,
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton + Qt::ControlModifier
+          - Qt::RightButton
+          - Qt::RightButton
+         */
         MouseSelect2,
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton + Qt::AltModifier
+          - Qt::LeftButton + Qt::AltModifier
+          - Qt::MidButton
+         */
         MouseSelect3,
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton + Qt::ShiftModifier
+          - Qt::LeftButton + Qt::ShiftModifier
+          - Qt::LeftButton + Qt::ShiftModifier
+         */
         MouseSelect4,
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton + Qt::ControlButton | Qt::ShiftModifier
+          - Qt::RightButton + Qt::ShiftModifier
+          - Qt::RightButton + Qt::ShiftModifier
+         */
         MouseSelect5,
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton + Qt::AltModifier + Qt::ShiftModifier
+          - Qt::LeftButton + Qt::AltModifier | Qt::ShiftModifier
+          - Qt::MidButton + Qt::ShiftModifier
+         */
         MouseSelect6,
+        //! Number of mouse patterns
         MousePatternCount
     };
 …
       \brief Symbolic keyboard input codes
+      Default initialization:
+      - KeySelect1\n
+        Qt::Key_Return
+      - KeySelect2\n
+        Qt::Key_Space
+      - KeyAbort\n
+        Qt::Key_Escape
+      - KeyLeft\n
+        Qt::Key_Left
+      - KeyRight\n
+        Qt::Key_Right
+      - KeyUp\n
+        Qt::Key_Up
+      - KeyDown\n
+        Qt::Key_Down
+      - KeyUndo\n
+        Qt::Key_Minus
+      - KeyRedo\n
+        Qt::Key_Plus
+      - KeyHome\n
+        Qt::Key_Escape
+      Individual settings can be configured using setKeyPattern()
+      \sa setKeyPattern(), setMousePattern()
     */
     enum KeyPatternCode
+    {
+        //! Qt::Key_Return
         KeySelect1,
+        //! Qt::Key_Space
         KeySelect2,
+        //! Qt::Key_Escape
         KeyAbort,
+        //! Qt::Key_Left
         KeyLeft,
+        //! Qt::Key_Right
         KeyRight,
+        //! Qt::Key_Up
         KeyUp,
+        //! Qt::Key_Down
         KeyDown,
+        //! Qt::Key_Plus
         KeyRedo,
+        //! Qt::Key_Minus
         KeyUndo,
+        //! Qt::Key_Escape
         KeyHome,
+        //! Number of key patterns
         KeyPatternCount
     };
 …
     public:
         //! Constructor
+        MousePattern( int btn = Qt::NoButton, int st = Qt::NoButton )
+        MousePattern( Qt::MouseButton btn = Qt::NoButton,
+                Qt::KeyboardModifiers modifierCodes = Qt::NoModifier ):
+            button( btn ),
+            modifiers( modifierCodes )
+        {
-            button = btn;
-            state = st;
+        }
         //! Button code
         int button;
         //! State
         int state;
+        //! Button
+        Qt::MouseButton button;
+        //! Keyboard modifier
+        Qt::KeyboardModifiers modifiers;
     };
 …
     public:
         //! Constructor
+        KeyPattern( int k = 0, int st = Qt::NoButton )
+        KeyPattern( int keyCode = Qt::Key_unknown,
+                Qt::KeyboardModifiers modifierCodes = Qt::NoModifier ):
+            key( keyCode ),
+            modifiers( modifierCodes )
+        {
-            key = k;
-            state = st;
+        }
 …
         int key;
         //! State
         int state;
+        //! Modifiers
+        Qt::KeyboardModifiers modifiers;
     };
 …
     void initKeyPattern();
+    void setMousePattern( uint pattern, int button, int state = Qt::NoButton );
+    void setKeyPattern( uint pattern, int key, int state = Qt::NoButton );
+    void setMousePattern( MousePatternCode, Qt::MouseButton button,
+        Qt::KeyboardModifiers = Qt::NoModifier );
+    void setKeyPattern( KeyPatternCode, int keyCode,
+        Qt::KeyboardModifiers modifierCodes = Qt::NoModifier );
     void setMousePattern( const QVector<MousePattern> & );
 …
     QVector<KeyPattern> &keyPattern();
     bool mouseMatch( uint pattern, const QMouseEvent * ) const;
     bool keyMatch( uint pattern, const QKeyEvent * ) const;
+    bool mouseMatch( MousePatternCode, const QMouseEvent * ) const;
+    bool keyMatch( KeyPatternCode, const QKeyEvent * ) const;
 protected:
 …
     QwtEventPattern::MousePattern  b2 )
+{
     return b1.button == b2.button && b1.state == b2.state;
+    return b1.button == b2.button && b1.modifiers == b2.modifiers;
+}
 …
    QwtEventPattern::KeyPattern  b2 )
+{
     return b1.key == b2.key && b1.state == b2.state;
+    return b1.key == b2.key && b1.modifiers == b2.modifiers;
+}

trunk/BNC/qwt/qwt_global.h

-              r4271
+              r8127
 // QWT_VERSION is (major << 16) + (minor << 8) + patch.
+#define QWT_VERSION       0x060001
+#define QWT_VERSION_STR   "6.0.1"
+#if defined(Q_WS_WIN) || defined(Q_WS_S60)
+#define QWT_VERSION       0x060104
+#define QWT_VERSION_STR   "6.1.4"
 #if defined(_MSC_VER) /* MSVC Compiler */
 /* template-class specialization 'identifier' is already instantiated */
 #pragma warning(disable: 4660)
+/* inherits via dominance */
+#pragma warning(disable: 4250)
 #endif // _MSC_VER
 …
 #if defined(QWT_MAKEDLL)     // create a Qwt DLL library
+#define QWT_EXPORT  __declspec(dllexport)
+#define QWT_TEMPLATEDLL
+#define QWT_EXPORT Q_DECL_EXPORT
 #else                        // use a Qwt DLL library
 #define QWT_EXPORT  __declspec(dllimport)
+#define QWT_EXPORT Q_DECL_IMPORT
 #endif
 #endif // QWT_DLL
-#endif // Q_WS_WIN || Q_WS_S60
 #ifndef QWT_EXPORT
 …
 #endif
-// #define QWT_NO_COMPAT 1 // disable withdrawn functionality
 #endif

trunk/BNC/qwt/qwt_interval.cpp

-              r4271
+              r8127
 /*!
    \brief Normalize the limits of the interval
    If maxValue() < minValue() the limits will be inverted.
    \return Normalized interval
    \sa isValid(), inverted()
+  \brief Normalize the limits of the interval
+  If maxValue() < minValue() the limits will be inverted.
+  \return Normalized interval
+  \sa isValid(), inverted()
 */
 QwtInterval QwtInterval::normalized() const
 …
 /*!
    Invert the limits of the interval
    \return Inverted interval
    \sa normalized()
+  Invert the limits of the interval
+  \return Inverted interval
+  \sa normalized()
 */
 QwtInterval QwtInterval::inverted() const
 …
+}
+//! Intersect 2 intervals
+/*!
+  \brief Intersect 2 intervals
+  \param other Interval to be intersect with
+  \return Intersection
+ */
 QwtInterval QwtInterval::intersect( const QwtInterval &other ) const
+{
 …
+}
+//! Unites this interval with the given interval.
+QwtInterval& QwtInterval::operator|=( const QwtInterval & interval )
+{
+    *this = *this | interval;
+/*!
+  \brief Unite this interval with the given interval.
+  \param other Interval to be united with
+  \return This interval
+ */
+QwtInterval& QwtInterval::operator|=( const QwtInterval &other )
+{
+    *this = *this | other;
     return *this;
+}
+//! Intersects this interval with the given interval.
+QwtInterval& QwtInterval::operator&=( const QwtInterval & interval )
+{
+    *this = *this & interval;
+/*!
+  \brief Intersect this interval with the given interval.
+  \param other Interval to be intersected with
+  \return This interval
+ */
+QwtInterval& QwtInterval::operator&=( const QwtInterval &other )
+{
+    *this = *this & other;
     return *this;
+}
 /*!
+   Test if two intervals overlap
+  \brief Test if two intervals overlap
+  \param other Interval
+  \return True, when the intervals are intersecting
 */
 bool QwtInterval::intersects( const QwtInterval &other ) const
 …
 /*!
    Adjust the limit that is closer to value, so that value becomes
    the center of the interval.
    \param value Center
    \return Interval with value as center
+  Adjust the limit that is closer to value, so that value becomes
+  the center of the interval.
+  \param value Center
+  \return Interval with value as center
 */
 QwtInterval QwtInterval::symmetrize( double value ) const
 …
 /*!
    Limit the interval, keeping the border modes
    \param lowerBound Lower limit
    \param upperBound Upper limit
    \return Limited interval
+  Limit the interval, keeping the border modes
+  \param lowerBound Lower limit
+  \param upperBound Upper limit
+  \return Limited interval
 */
 QwtInterval QwtInterval::limited( double lowerBound, double upperBound ) const
 …
 /*!
+   Extend the interval
+   If value is below minValue, value becomes the lower limit.
+   If value is above maxValue, value becomes the upper limit.
+   extend has no effect for invalid intervals
+   \param value Value
+   \sa isValid()
+  \brief Extend the interval
+  If value is below minValue(), value becomes the lower limit.
+  If value is above maxValue(), value becomes the upper limit.
+  extend() has no effect for invalid intervals
+  \param value Value
+  \return extended interval
+  \sa isValid()
 */
 QwtInterval QwtInterval::extend( double value ) const
 …
 /*!
    Extend an interval
    \param value Value
    \return Reference of the extended interval
    \sa extend()
+  Extend an interval
+  \param value Value
+  \return Reference of the extended interval
+  \sa extend()
 */
 QwtInterval& QwtInterval::operator|=( double value )

trunk/BNC/qwt/qwt_interval.h

-              r4271
+              r8127
 #include "qwt_global.h"
+#include <qmetatype.h>
 #ifndef QT_NO_DEBUG_STREAM
 #include <qdebug.h>
 …
 /*!
-   Return the width of an interval
-   The width of invalid intervals is 0.0, otherwise the result is
-   maxValue() - minValue().
-   \sa isValid()
-*/
-inline double QwtInterval::width() const
+{
-    return isValid() ? ( d_maxValue - d_minValue ) : 0.0;
+}
-/*!
-   Intersection of two intervals
-   \sa intersect()
-*/
-inline QwtInterval QwtInterval::operator&(
-    const QwtInterval &interval ) const
+{
-    return intersect( interval );
+}
-/*!
-   Union of two intervals
-   \sa unite()
-*/
-inline QwtInterval QwtInterval::operator|(
-    const QwtInterval &interval ) const
+{
-    return unite( interval );
+}
-//! Compare two intervals
-inline bool QwtInterval::operator==( const QwtInterval &other ) const
+{
-    return ( d_minValue == other.d_minValue ) &&
-           ( d_maxValue == other.d_maxValue ) &&
-           ( d_borderFlags == other.d_borderFlags );
+}
-//! Compare two intervals
-inline bool QwtInterval::operator!=( const QwtInterval &other ) const
+{
-    return ( !( *this == other ) );
+}
-/*!
-   Extend an interval
-   \param value Value
-   \return Extended interval
-   \sa extend()
-*/
-inline QwtInterval QwtInterval::operator|( double value ) const
+{
-    return extend( value );
+}
-//! \return true, if isValid() && (minValue() >= maxValue())
-inline bool QwtInterval::isNull() const
+{
-    return isValid() && d_minValue >= d_maxValue;
+}
-/*!
    A interval is valid when minValue() <= maxValue().
    In case of QwtInterval::ExcludeBorders it is true
    when minValue() < maxValue()
+   \return True, when the interval is valid
 */
 inline bool QwtInterval::isValid() const
 …
 /*!
+   \brief Return the width of an interval
+   The width of invalid intervals is 0.0, otherwise the result is
+   maxValue() - minValue().
+   \return Interval width
+   \sa isValid()
+*/
+inline double QwtInterval::width() const
+{
+    return isValid() ? ( d_maxValue - d_minValue ) : 0.0;
+}
+/*!
+   \brief Intersection of two intervals
+   \param other Interval to intersect with
+   \return Intersection of this and other
+   \sa intersect()
+*/
+inline QwtInterval QwtInterval::operator&(
+    const QwtInterval &other ) const
+{
+    return intersect( other );
+}
+/*!
+   Union of two intervals
+   \param other Interval to unite with
+   \return Union of this and other
+   \sa unite()
+*/
+inline QwtInterval QwtInterval::operator|(
+    const QwtInterval &other ) const
+{
+    return unite( other );
+}
+/*!
+   \brief Compare two intervals
+   \param other Interval to compare with
+   \return True, when this and other are equal
+*/
+inline bool QwtInterval::operator==( const QwtInterval &other ) const
+{
+    return ( d_minValue == other.d_minValue ) &&
+           ( d_maxValue == other.d_maxValue ) &&
+           ( d_borderFlags == other.d_borderFlags );
+}
+/*!
+   \brief Compare two intervals
+   \param other Interval to compare with
+   \return True, when this and other are not equal
+*/
+inline bool QwtInterval::operator!=( const QwtInterval &other ) const
+{
+    return ( !( *this == other ) );
+}
+/*!
+   Extend an interval
+   \param value Value
+   \return Extended interval
+   \sa extend()
+*/
+inline QwtInterval QwtInterval::operator|( double value ) const
+{
+    return extend( value );
+}
+//! \return true, if isValid() && (minValue() >= maxValue())
+inline bool QwtInterval::isNull() const
+{
+    return isValid() && d_minValue >= d_maxValue;
+}
+/*!
   Invalidate the interval
 …
 Q_DECLARE_OPERATORS_FOR_FLAGS( QwtInterval::BorderFlags )
+Q_DECLARE_METATYPE( QwtInterval )
 #ifndef QT_NO_DEBUG_STREAM

trunk/BNC/qwt/qwt_interval_symbol.cpp

-              r4271
+              r8127
 #if QT_VERSION < 0x040601
 #define qAtan2(y, x) ::atan2(y, x)
+#define qFastSin(x) qSin(x)
+#define qFastCos(x) qCos(x)
 #endif
 …
+{
     return d_data->brush;
+}
+/*!
+  Build and assign a pen
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtIntervalSymbol::setPen( const QColor &color,
+    qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
 …
                     double dw2 = sw / 2.0;
                     const double cx = qCos( angle ) * dw2;
                     const double sy = qSin( angle ) * dw2;
+                    const double cx = qFastCos( angle ) * dw2;
+                    const double sy = qFastSin( angle ) * dw2;
                     QwtPainter::drawLine( painter,
 …
                     double dw2 = sw / 2.0;
                     const int cx = qCos( angle ) * dw2;
                     const int sy = qSin( angle ) * dw2;
+                    const double cx = qFastCos( angle ) * dw2;
+                    const double sy = qFastSin( angle ) * dw2;
                     QPolygonF polygon;

trunk/BNC/qwt/qwt_interval_symbol.h

r4271	r8127
69	69	const QBrush& brush() const;
70	70
	71	void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
71	72	void setPen( const QPen & );
72	73	const QPen& pen() const;

trunk/BNC/qwt/qwt_legend.cpp

-              r4271
+              r8127
 #include "qwt_legend.h"
+#include "qwt_legend_itemmanager.h"
+#include "qwt_legend_item.h"
+#include "qwt_legend_label.h"
 #include "qwt_dyngrid_layout.h"
 #include "qwt_math.h"
+#include "qwt_plot_item.h"
+#include "qwt_painter.h"
 #include <qapplication.h>
-#include <qmap.h>
 #include <qscrollbar.h>
 #include <qscrollarea.h>
+#include <qpainter.h>
+#include <qstyle.h>
+#include <qstyleoption.h>
+class QwtLegendMap
+{
+public:
+    inline bool isEmpty() const { return d_entries.isEmpty(); }
+    void insert( const QVariant &, const QList<QWidget *> & );
+    void remove( const QVariant & );
+    void removeWidget( const QWidget * );
+    QList<QWidget *> legendWidgets( const QVariant & ) const;
+    QVariant itemInfo( const QWidget * ) const;
+private:
+    // we don't know anything about itemInfo and therefore don't have
+    // any key that can be used for a map or hashtab.
+    // But a simple linear list is o.k. here, as we will never have
+    // more than a few entries.
+    class Entry
+    {
+    public:
+        QVariant itemInfo;
+        QList<QWidget *> widgets;
+    };
+    QList< Entry > d_entries;
+};
+void QwtLegendMap::insert( const QVariant &itemInfo,
+    const QList<QWidget *> &widgets )
+{
+    for ( int i = 0; i < d_entries.size(); i++ )
+    {
+        Entry &entry = d_entries[i];
+        if ( entry.itemInfo == itemInfo )
+        {
+            entry.widgets = widgets;
+            return;
+        }
+    }
+    Entry newEntry;
+    newEntry.itemInfo = itemInfo;
+    newEntry.widgets = widgets;
+    d_entries += newEntry;
+}
+void QwtLegendMap::remove( const QVariant &itemInfo )
+{
+    for ( int i = 0; i < d_entries.size(); i++ )
+    {
+        Entry &entry = d_entries[i];
+        if ( entry.itemInfo == itemInfo )
+        {
+            d_entries.removeAt( i );
+            return;
+        }
+    }
+}
+void QwtLegendMap::removeWidget( const QWidget *widget )
+{
+    QWidget *w = const_cast<QWidget *>( widget );
+    for ( int i = 0; i < d_entries.size(); i++ )
+        d_entries[ i ].widgets.removeAll( w );
+}
+QVariant QwtLegendMap::itemInfo( const QWidget *widget ) const
+{
+    if ( widget != NULL )
+    {
+        QWidget *w = const_cast<QWidget *>( widget );
+        for ( int i = 0; i < d_entries.size(); i++ )
+        {
+            const Entry &entry = d_entries[i];
+            if ( entry.widgets.indexOf( w ) >= 0 )
+                return entry.itemInfo;
+        }
+    }
+    return QVariant();
+}
+QList<QWidget *> QwtLegendMap::legendWidgets( const QVariant &itemInfo ) const
+{
+    if ( itemInfo.isValid() )
+    {
+        for ( int i = 0; i < d_entries.size(); i++ )
+        {
+            const Entry &entry = d_entries[i];
+            if ( entry.itemInfo == itemInfo )
+                return entry.widgets;
+        }
+    }
+    return QList<QWidget *>();
+}
 class QwtLegend::PrivateData
+{
 public:
+    class LegendMap
+    {
+    public:
+        void insert( const QwtLegendItemManager *, QWidget * );
+        void remove( const QwtLegendItemManager * );
+        void remove( QWidget * );
+        void clear();
+        uint count() const;
+        inline const QWidget *find( const QwtLegendItemManager * ) const;
+        inline QWidget *find( const QwtLegendItemManager * );
+        inline const QwtLegendItemManager *find( const QWidget * ) const;
+        inline QwtLegendItemManager *find( const QWidget * );
+        const QMap<QWidget *, const QwtLegendItemManager *> &widgetMap() const;
+        QMap<QWidget *, const QwtLegendItemManager *> &widgetMap();
+    private:
+        QMap<QWidget *, const QwtLegendItemManager *> d_widgetMap;
+        QMap<const QwtLegendItemManager *, QWidget *> d_itemMap;
+    };
+    QwtLegend::LegendItemMode itemMode;
+    LegendMap map;
+    PrivateData():
+        itemMode( QwtLegendData::ReadOnly ),
+        view( NULL )
+    {
+    }
+    QwtLegendData::Mode itemMode;
+    QwtLegendMap itemMap;
     class LegendView;
 …
         QScrollArea( parent )
+    {
-        setFocusPolicy( Qt::NoFocus );
         contentsWidget = new QWidget( this );
         contentsWidget->setObjectName( "QwtLegendViewContents" );
 …
+    }
+    virtual bool viewportEvent( QEvent *e )
+    {
+        bool ok = QScrollArea::viewportEvent( e );
+        if ( e->type() == QEvent::Resize )
+        {
+            QEvent event( QEvent::LayoutRequest );
+            QApplication::sendEvent( contentsWidget, &event );
+    virtual bool event( QEvent *event )
+    {
+        if ( event->type() == QEvent::PolishRequest )
+        {
+            setFocusPolicy( Qt::NoFocus );
+        }
+        if ( event->type() == QEvent::Resize )
+        {
+            // adjust the size to en/disable the scrollbars
+            // before QScrollArea adjusts the viewport size
+            const QRect cr = contentsRect();
+            int w = cr.width();
+            int h = contentsWidget->heightForWidth( cr.width() );
+            if ( h > w )
+            {
+                w -= verticalScrollBar()->sizeHint().width();
+                h = contentsWidget->heightForWidth( w );
+            }
+            contentsWidget->resize( w, h );
+        }
+        return QScrollArea::event( event );
+    }
+    virtual bool viewportEvent( QEvent *event )
+    {
+        bool ok = QScrollArea::viewportEvent( event );
+        if ( event->type() == QEvent::Resize )
+        {
+            layoutContents();
+        }
         return ok;
 …
+    }
+    void layoutContents()
+    {
+        const QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
+            contentsWidget->layout() );
+        if ( tl == NULL )
+            return;
+        const QSize visibleSize = viewport()->contentsRect().size();
+        const int minW = int( tl->maxItemWidth() ) + 2 * tl->margin();
+        int w = qMax( visibleSize.width(), minW );
+        int h = qMax( tl->heightForWidth( w ), visibleSize.height() );
+        const int vpWidth = viewportSize( w, h ).width();
+        if ( w > vpWidth )
+        {
+            w = qMax( vpWidth, minW );
+            h = qMax( tl->heightForWidth( w ), visibleSize.height() );
+        }
+        contentsWidget->resize( w, h );
+    }
     QWidget *contentsWidget;
 };
-void QwtLegend::PrivateData::LegendMap::insert(
-    const QwtLegendItemManager *item, QWidget *widget )
+{
-    d_itemMap.insert( item, widget );
-    d_widgetMap.insert( widget, item );
+}
-void QwtLegend::PrivateData::LegendMap::remove( const QwtLegendItemManager *item )
+{
-    QWidget *widget = d_itemMap[item];
-    d_itemMap.remove( item );
-    d_widgetMap.remove( widget );
+}
-void QwtLegend::PrivateData::LegendMap::remove( QWidget *widget )
+{
-    const QwtLegendItemManager *item = d_widgetMap[widget];
-    d_itemMap.remove( item );
-    d_widgetMap.remove( widget );
+}
-void QwtLegend::PrivateData::LegendMap::clear()
+{
-    /*
-       We can't delete the widgets in the following loop, because
-       we would get ChildRemoved events, changing d_itemMap, while
-       we are iterating.
-     */
-    QList<const QWidget *> widgets;
-    QMap<const QwtLegendItemManager *, QWidget *>::const_iterator it;
-    for ( it = d_itemMap.begin(); it != d_itemMap.end(); ++it )
-        widgets.append( it.value() );
-    d_itemMap.clear();
-    d_widgetMap.clear();
-    for ( int i = 0; i < widgets.size(); i++ )
-        delete widgets[i];
+}
-uint QwtLegend::PrivateData::LegendMap::count() const
+{
-    return d_itemMap.count();
+}
-inline const QWidget *QwtLegend::PrivateData::LegendMap::find(
-    const QwtLegendItemManager *item ) const
+{
-    if ( !d_itemMap.contains( item ) )
-        return NULL;
-    return d_itemMap[item];
+}
-inline QWidget *QwtLegend::PrivateData::LegendMap::find(
-    const QwtLegendItemManager *item )
+{
-    if ( !d_itemMap.contains( item ) )
-        return NULL;
-    return d_itemMap[item];
+}
-inline const QwtLegendItemManager *QwtLegend::PrivateData::LegendMap::find(
-    const QWidget *widget ) const
+{
-    QWidget *w = const_cast<QWidget *>( widget );
-    if ( !d_widgetMap.contains( w ) )
-        return NULL;
-    return d_widgetMap[w];
+}
-inline QwtLegendItemManager *QwtLegend::PrivateData::LegendMap::find(
-    const QWidget *widget )
+{
-    QWidget *w = const_cast<QWidget *>( widget );
-    if ( !d_widgetMap.contains( w ) )
-        return NULL;
-    return const_cast<QwtLegendItemManager *>( d_widgetMap[w] );
+}
-inline const QMap<QWidget *, const QwtLegendItemManager *> &
-QwtLegend::PrivateData::LegendMap::widgetMap() const
+{
-    return d_widgetMap;
+}
-inline QMap<QWidget *, const QwtLegendItemManager *> &
-QwtLegend::PrivateData::LegendMap::widgetMap()
+{
-    return d_widgetMap;
+}
 /*!
   Constructor
   \param parent Parent widget
 */
 QwtLegend::QwtLegend( QWidget *parent ):
     QFrame( parent )
+    QwtAbstractLegend( parent )
+{
     setFrameStyle( NoFrame );
     d_data = new QwtLegend::PrivateData;
-    d_data->itemMode = QwtLegend::ReadOnlyItem;
     d_data->view = new QwtLegend::PrivateData::LegendView( this );
 …
+}
+//! \sa LegendItemMode
+void QwtLegend::setItemMode( LegendItemMode mode )
+/*!
+  \brief Set the maximum number of entries in a row
+  F.e when the maximum is set to 1 all items are aligned
+  vertically. 0 means unlimited
+  \param numColums Maximum number of entries in a row
+  \sa maxColumns(), QwtDynGridLayout::setMaxColumns()
+ */
+void QwtLegend::setMaxColumns( uint numColums )
+{
+    QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
+        d_data->view->contentsWidget->layout() );
+    if ( tl )
+        tl->setMaxColumns( numColums );
+}
+/*!
+  \return Maximum number of entries in a row
+  \sa setMaxColumns(), QwtDynGridLayout::maxColumns()
+ */
+uint QwtLegend::maxColumns() const
+{
+    uint maxCols = 0;
+    const QwtDynGridLayout *tl = qobject_cast<const QwtDynGridLayout *>(
+        d_data->view->contentsWidget->layout() );
+    if ( tl )
+        maxCols = tl->maxColumns();
+    return maxCols;
+}
+/*!
+  \brief Set the default mode for legend labels
+  Legend labels will be constructed according to the
+  attributes in a QwtLegendData object. When it doesn't
+  contain a value for the QwtLegendData::ModeRole the
+  label will be initialized with the default mode of the legend.
+  \param mode Default item mode
+  \sa itemMode(), QwtLegendData::value(), QwtPlotItem::legendData()
+  \note Changing the mode doesn't have any effect on existing labels.
+ */
+void QwtLegend::setDefaultItemMode( QwtLegendData::Mode mode )
+{
     d_data->itemMode = mode;
+}
+//! \sa LegendItemMode
+QwtLegend::LegendItemMode QwtLegend::itemMode() const
+/*!
+  \return Default item mode
+  \sa setDefaultItemMode()
+*/
+QwtLegendData::Mode QwtLegend::defaultItemMode() const
+{
     return d_data->itemMode;
 …
 /*!
   The contents widget is the only child of the viewport of
   the internal QScrollArea  and the parent widget of all legend items.
+  the internal QScrollArea and the parent widget of all legend items.
   \return Container widget of the legend items
 …
 /*!
   The contents widget is the only child of the viewport of
   the internal QScrollArea  and the parent widget of all legend items.
+  the internal QScrollArea and the parent widget of all legend items.
   \return Container widget of the legend items
 …
 /*!
+  Insert a new item for a plot item
+  \param plotItem Plot item
+  \param legendItem New legend item
+  \note The parent of item will be changed to contentsWidget()
+*/
+void QwtLegend::insert( const QwtLegendItemManager *plotItem, QWidget *legendItem )
+{
+    if ( legendItem == NULL || plotItem == NULL )
+        return;
+    QWidget *contentsWidget = d_data->view->contentsWidget;
+    if ( legendItem->parent() != contentsWidget )
+        legendItem->setParent( contentsWidget );
+    legendItem->show();
+    d_data->map.insert( plotItem, legendItem );
+    layoutContents();
+    if ( contentsWidget->layout() )
+    {
+        contentsWidget->layout()->addWidget( legendItem );
+  \brief Update the entries for an item
+  \param itemInfo Info for an item
+  \param data List of legend entry attributes for the item
+ */
+void QwtLegend::updateLegend( const QVariant &itemInfo,
+    const QList<QwtLegendData> &data )
+{
+    QList<QWidget *> widgetList = legendWidgets( itemInfo );
+    if ( widgetList.size() != data.size() )
+    {
+        QLayout *contentsLayout = d_data->view->contentsWidget->layout();
+        while ( widgetList.size() > data.size() )
+        {
+            QWidget *w = widgetList.takeLast();
+            contentsLayout->removeWidget( w );
+            // updates might be triggered by signals from the legend widget
+            // itself. So we better don't delete it here.
+            w->hide();
+            w->deleteLater();
+        }
+        for ( int i = widgetList.size(); i < data.size(); i++ )
+        {
+            QWidget *widget = createWidget( data[i] );
+            if ( contentsLayout )
+                contentsLayout->addWidget( widget );
+            if ( isVisible() )
+            {
+                // QLayout does a delayed show, with the effect, that
+                // the size hint will be wrong, when applications
+                // call replot() right after changing the list
+                // of plot items. So we better do the show now.
+                widget->setVisible( true );
+            }
+            widgetList += widget;
+        }
+        if ( widgetList.isEmpty() )
+        {
+            d_data->itemMap.remove( itemInfo );
+        }
+        else
+        {
+            d_data->itemMap.insert( itemInfo, widgetList );
+        }
+        updateTabOrder();
+    }
+    for ( int i = 0; i < data.size(); i++ )
+        updateWidget( widgetList[i], data[i] );
+}
+/*!
+  \brief Create a widget to be inserted into the legend
+  The default implementation returns a QwtLegendLabel.
+  \param data Attributes of the legend entry
+  \return Widget representing data on the legend
+  \note updateWidget() will called soon after createWidget()
+        with the same attributes.
+ */
+QWidget *QwtLegend::createWidget( const QwtLegendData &data ) const
+{
+    Q_UNUSED( data );
+    QwtLegendLabel *label = new QwtLegendLabel();
+    label->setItemMode( defaultItemMode() );
+    connect( label, SIGNAL( clicked() ), SLOT( itemClicked() ) );
+    connect( label, SIGNAL( checked( bool ) ), SLOT( itemChecked( bool ) ) );
+    return label;
+}
+/*!
+  \brief Update the widget
+  \param widget Usually a QwtLegendLabel
+  \param data Attributes to be displayed
+  \sa createWidget()
+  \note When widget is no QwtLegendLabel updateWidget() does nothing.
+ */
+void QwtLegend::updateWidget( QWidget *widget, const QwtLegendData &data )
+{
+    QwtLegendLabel *label = qobject_cast<QwtLegendLabel *>( widget );
+    if ( label )
+    {
+        label->setData( data );
+        if ( !data.value( QwtLegendData::ModeRole ).isValid() )
+        {
+            // use the default mode, when there is no specific
+            // hint from the legend data
+            label->setItemMode( defaultItemMode() );
+        }
+    }
+}
+void QwtLegend::updateTabOrder()
+{
+    QLayout *contentsLayout = d_data->view->contentsWidget->layout();
+    if ( contentsLayout )
+    {
         // set tab focus chain
         QWidget *w = NULL;
         for ( int i = 0; i < contentsWidget->layout()->count(); i++ )
+        {
             QLayoutItem *item = contentsWidget->layout()->itemAt( i );
+        for ( int i = 0; i < contentsLayout->count(); i++ )
+        {
+            QLayoutItem *item = contentsLayout->itemAt( i );
             if ( w && item->widget() )
                 QWidget::setTabOrder( w, item->widget() );
 …
+        }
+    }
-    if ( parentWidget() && parentWidget()->layout() == NULL )
+    {
-        /*
-           updateGeometry() doesn't post LayoutRequest in certain
-           situations, like when we are hidden. But we want the
-           parent widget notified, so it can show/hide the legend
-           depending on its items.
-         */
-        QApplication::postEvent( parentWidget(),
-            new QEvent( QEvent::LayoutRequest ) );
+    }
+}
-/*!
-  Find the widget that represents a plot item
-  \param plotItem Plot item
-  \return Widget on the legend, or NULL
-*/
-QWidget *QwtLegend::find( const QwtLegendItemManager *plotItem ) const
+{
-    return d_data->map.find( plotItem );
+}
-/*!
-  Find the widget that represents a plot item
-  \param legendItem Legend item
-  \return Widget on the legend, or NULL
-*/
-QwtLegendItemManager *QwtLegend::find( const QWidget *legendItem ) const
+{
-    return d_data->map.find( legendItem );
+}
-/*!
-   Find the corresponding item for a plotItem and remove it
-   from the item list.
-   \param plotItem Plot item
-*/
-void QwtLegend::remove( const QwtLegendItemManager *plotItem )
+{
-    QWidget *legendItem = d_data->map.find( plotItem );
-    d_data->map.remove( legendItem );
-    delete legendItem;
+}
-//! Remove all items.
-void QwtLegend::clear()
+{
-    bool doUpdate = updatesEnabled();
-    if ( doUpdate )
-        setUpdatesEnabled( false );
-    d_data->map.clear();
-    if ( doUpdate )
-        setUpdatesEnabled( true );
-    update();
+}
 …
 /*!
   \return The preferred height, for the width w.
+  \return The preferred height, for a width.
   \param width Width
 */
 …
+}
-/*!
-  Adjust contents widget and item layout to the size of the viewport().
-*/
-void QwtLegend::layoutContents()
+{
-    const QSize visibleSize =
-        d_data->view->viewport()->contentsRect().size();
-    const QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
-        d_data->view->contentsWidget->layout() );
-    if ( tl )
+    {
-        const int minW = int( tl->maxItemWidth() ) + 2 * tl->margin();
-        int w = qMax( visibleSize.width(), minW );
-        int h = qMax( tl->heightForWidth( w ), visibleSize.height() );
-        const int vpWidth = d_data->view->viewportSize( w, h ).width();
-        if ( w > vpWidth )
+        {
-            w = qMax( vpWidth, minW );
-            h = qMax( tl->heightForWidth( w ), visibleSize.height() );
+        }
-        d_data->view->contentsWidget->resize( w, h );
+    }
+}
 /*!
 …
   \param object Object to be filtered
   \param event Event
+  \return Forwarded to QwtAbstractLegend::eventFilter()
 */
 bool QwtLegend::eventFilter( QObject *object, QEvent *event )
 …
+                {
                     QWidget *w = static_cast< QWidget * >( ce->child() );
                     d_data->map.remove( w );
+                    d_data->itemMap.removeWidget( w );
+                }
                 break;
 …
             case QEvent::LayoutRequest:
+            {
+                layoutContents();
+                d_data->view->layoutContents();
+                if ( parentWidget() && parentWidget()->layout() == NULL )
+                {
+                    /*
+                       We want the parent widget ( usually QwtPlot ) to recalculate
+                       its layout, when the contentsWidget has changed. But
+                       because of the scroll view we have to forward the LayoutRequest
+                       event manually.
+                       We don't use updateGeometry() because it doesn't post LayoutRequest
+                       events when the legend is hidden. But we want the
+                       parent widget notified, so it can show/hide the legend
+                       depending on its items.
+                     */
+                    QApplication::postEvent( parentWidget(),
+                        new QEvent( QEvent::LayoutRequest ) );
+                }
                 break;
+            }
 …
+    }
+    return QFrame::eventFilter( object, event );
+}
+//! Return true, if there are no legend items.
+    return QwtAbstractLegend::eventFilter( object, event );
+}
+/*!
+  Called internally when the legend has been clicked on.
+  Emits a clicked() signal.
+*/
+void QwtLegend::itemClicked()
+{
+    QWidget *w = qobject_cast<QWidget *>( sender() );
+    if ( w )
+    {
+        const QVariant itemInfo = d_data->itemMap.itemInfo( w );
+        if ( itemInfo.isValid() )
+        {
+            const QList<QWidget *> widgetList =
+                d_data->itemMap.legendWidgets( itemInfo );
+            const int index = widgetList.indexOf( w );
+            if ( index >= 0 )
+                Q_EMIT clicked( itemInfo, index );
+        }
+    }
+}
+/*!
+  Called internally when the legend has been checked
+  Emits a checked() signal.
+*/
+void QwtLegend::itemChecked( bool on )
+{
+    QWidget *w = qobject_cast<QWidget *>( sender() );
+    if ( w )
+    {
+        const QVariant itemInfo = d_data->itemMap.itemInfo( w );
+        if ( itemInfo.isValid() )
+        {
+            const QList<QWidget *> widgetList =
+                d_data->itemMap.legendWidgets( itemInfo );
+            const int index = widgetList.indexOf( w );
+            if ( index >= 0 )
+                Q_EMIT checked( itemInfo, on, index );
+        }
+    }
+}
+/*!
+  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 - not by QwtLegend itself
+*/
+void QwtLegend::renderLegend( QPainter *painter,
+    const QRectF &rect, bool fillBackground ) const
+{
+    if ( d_data->itemMap.isEmpty() )
+        return;
+    if ( fillBackground )
+    {
+        if ( autoFillBackground() ||
+            testAttribute( Qt::WA_StyledBackground ) )
+        {
+            QwtPainter::drawBackgound( painter, rect, this );
+        }
+    }
+    const QwtDynGridLayout *legendLayout =
+        qobject_cast<QwtDynGridLayout *>( contentsWidget()->layout() );
+    if ( legendLayout == NULL )
+        return;
+    int left, right, top, bottom;
+    getContentsMargins( &left, &top, &right, &bottom );
+    QRect layoutRect;
+    layoutRect.setLeft( qCeil( rect.left() ) + left );
+    layoutRect.setTop( qCeil( rect.top() ) + top );
+    layoutRect.setRight( qFloor( rect.right() ) - right );
+    layoutRect.setBottom( qFloor( rect.bottom() ) - bottom );
+    uint numCols = legendLayout->columnsForWidth( layoutRect.width() );
+    QList<QRect> itemRects =
+        legendLayout->layoutItems( layoutRect, numCols );
+    int index = 0;
+    for ( int i = 0; i < legendLayout->count(); i++ )
+    {
+        QLayoutItem *item = legendLayout->itemAt( i );
+        QWidget *w = item->widget();
+        if ( w )
+        {
+            painter->save();
+            painter->setClipRect( itemRects[index], Qt::IntersectClip );
+            renderItem( painter, w, itemRects[index], fillBackground );
+            index++;
+            painter->restore();
+        }
+    }
+}
+/*!
+  Render a legend entry into a given rectangle.
+  \param painter Painter
+  \param widget Widget representing a legend entry
+  \param rect Bounding rectangle
+  \param fillBackground When true, fill rect with the widget background
+  \note When widget is not derived from QwtLegendLabel renderItem
+        does nothing beside the background
+*/
+void QwtLegend::renderItem( QPainter *painter,
+    const QWidget *widget, const QRectF &rect, bool fillBackground ) const
+{
+    if ( fillBackground )
+    {
+        if ( widget->autoFillBackground() ||
+            widget->testAttribute( Qt::WA_StyledBackground ) )
+        {
+            QwtPainter::drawBackgound( painter, rect, widget );
+        }
+    }
+    const QwtLegendLabel *label = qobject_cast<const QwtLegendLabel *>( widget );
+    if ( label )
+    {
+        // icon
+        const QwtGraphic &icon = label->data().icon();
+        const QSizeF sz = icon.defaultSize();
+        const QRectF iconRect( rect.x() + label->margin(),
+            rect.center().y() - 0.5 * sz.height(),
+            sz.width(), sz.height() );
+        icon.render( painter, iconRect, Qt::KeepAspectRatio );
+        // title
+        QRectF titleRect = rect;
+        titleRect.setX( iconRect.right() + 2 * label->spacing() );
+        painter->setFont( label->font() );
+        painter->setPen( label->palette().color( QPalette::Text ) );
+        const_cast< QwtLegendLabel *>( label )->drawText( painter, titleRect );
+    }
+}
+/*!
+  \return List of widgets associated to a item
+  \param itemInfo Info about an item
+  \sa legendWidget(), itemInfo(), QwtPlot::itemToInfo()
+ */
+QList<QWidget *> QwtLegend::legendWidgets( const QVariant &itemInfo ) const
+{
+    return d_data->itemMap.legendWidgets( itemInfo );
+}
+/*!
+  \return First widget in the list of widgets associated to an item
+  \param itemInfo Info about an item
+  \sa itemInfo(), QwtPlot::itemToInfo()
+  \note Almost all types of items have only one widget
+*/
+QWidget *QwtLegend::legendWidget( const QVariant &itemInfo ) const
+{
+    const QList<QWidget *> list = d_data->itemMap.legendWidgets( itemInfo );
+    if ( list.isEmpty() )
+        return NULL;
+    return list[0];
+}
+/*!
+  Find the item that is associated to a widget
+  \param widget Widget on the legend
+  \return Associated item info
+  \sa legendWidget()
+ */
+QVariant QwtLegend::itemInfo( const QWidget *widget ) const
+{
+    return d_data->itemMap.itemInfo( widget );
+}
+//! \return True, when no item is inserted
 bool QwtLegend::isEmpty() const
+{
+    return d_data->map.count() == 0;
+}
+//! Return the number of legend items.
+uint QwtLegend::itemCount() const
+{
+    return d_data->map.count();
+}
+//! Return a list of all legend items
+QList<QWidget *> QwtLegend::legendItems() const
+{
+    const QMap<QWidget *, const QwtLegendItemManager *> &map =
+        d_data->map.widgetMap();
+    QList<QWidget *> list;
+    QMap<QWidget *, const QwtLegendItemManager *>::const_iterator it;
+    for ( it = map.begin(); it != map.end(); ++it )
+        list += it.key();
+    return list;
+}
+    return d_data->itemMap.isEmpty();
+}
+/*!
+    Return the extent, that is needed for the scrollbars
+    \param orientation Orientation (
+    \return The width of the vertical scrollbar for Qt::Horizontal and v.v.
+ */
+int QwtLegend::scrollExtent( Qt::Orientation orientation ) const
+{
+    int extent = 0;
+    if ( orientation == Qt::Horizontal )
+        extent = verticalScrollBar()->sizeHint().width();
+    else
+        extent = horizontalScrollBar()->sizeHint().height();
+    return extent;
+}

trunk/BNC/qwt/qwt_legend.h

-              r4271
+              r8127
 #include "qwt_global.h"
 #include <qframe.h>
 #include <qlist.h>
+#include "qwt_abstract_legend.h"
+#include <qvariant.h>
 class QScrollBar;
-class QwtLegendItemManager;
 /*!
 …
   The QwtLegend widget is a tabular arrangement of legend items. Legend
   items might be any type of widget, but in general they will be
   a QwtLegendItem.
+  a QwtLegendLabel.
   \sa QwtLegendItem, QwtLegendItemManager QwtPlot
+  \sa QwtLegendLabel, QwtPlotItem, QwtPlot
 */
 class QWT_EXPORT QwtLegend : public QFrame
+class QWT_EXPORT QwtLegend : public QwtAbstractLegend
+{
     Q_OBJECT
 public:
-    /*!
-      \brief Interaction mode for the legend items
-       The default is QwtLegend::ReadOnlyItem.
-       \sa setItemMode(), itemMode(), QwtLegendItem::IdentifierMode
-           QwtLegendItem::clicked(), QwtLegendItem::checked(),
-           QwtPlot::legendClicked(), QwtPlot::legendChecked()
-     */
-    enum LegendItemMode
+    {
-        //! The legend item is not interactive, like a label
-        ReadOnlyItem,
-        //! The legend item is clickable, like a push button
-        ClickableItem,
-        //! The legend item is checkable, like a checkable button
-        CheckableItem
-    };
     explicit QwtLegend( QWidget *parent = NULL );
     virtual ~QwtLegend();
+    void setItemMode( LegendItemMode );
+    LegendItemMode itemMode() const;
+    void setMaxColumns( uint numColums );
+    uint maxColumns() const;
+    void setDefaultItemMode( QwtLegendData::Mode );
+    QwtLegendData::Mode defaultItemMode() const;
     QWidget *contentsWidget();
     const QWidget *contentsWidget() const;
     void insert( const QwtLegendItemManager *, QWidget * );
     void remove( const QwtLegendItemManager * );
+    QWidget *legendWidget( const QVariant &  ) const;
+    QList<QWidget *> legendWidgets( const QVariant & ) const;
+    QWidget *find( const QwtLegendItemManager * ) const;
+    QwtLegendItemManager *find( const QWidget * ) const;
+    virtual QList<QWidget *> legendItems() const;
+    void clear();
+    bool isEmpty() const;
+    uint itemCount() const;
+    QVariant itemInfo( const QWidget * ) const;
     virtual bool eventFilter( QObject *, QEvent * );
 …
     QScrollBar *verticalScrollBar() const;
+    virtual void renderLegend( QPainter *,
+        const QRectF &, bool fillBackground ) const;
+    virtual void renderItem( QPainter *,
+        const QWidget *, const QRectF &, bool fillBackground ) const;
+    virtual bool isEmpty() const;
+    virtual int scrollExtent( Qt::Orientation ) const;
+Q_SIGNALS:
+    /*!
+      A signal which is emitted when the user has clicked on
+      a legend label, which is in QwtLegendData::Clickable mode.
+      \param itemInfo Info for the item item of the
+                      selected legend item
+      \param index Index of the legend label in the list of widgets
+                   that are associated with the plot item
+      \note clicks are disabled as default
+      \sa setDefaultItemMode(), defaultItemMode(), QwtPlot::itemToInfo()
+     */
+    void clicked( const QVariant &itemInfo, int index );
+    /*!
+      A signal which is emitted when the user has clicked on
+      a legend label, which is in QwtLegendData::Checkable mode
+      \param itemInfo Info for the item of the
+                      selected legend label
+      \param index Index of the legend label in the list of widgets
+                   that are associated with the plot item
+      \param on True when the legend label is checked
+      \note clicks are disabled as default
+      \sa setDefaultItemMode(), defaultItemMode(), QwtPlot::itemToInfo()
+     */
+    void checked( const QVariant &itemInfo, bool on, int index );
+public Q_SLOTS:
+    virtual void updateLegend( const QVariant &,
+        const QList<QwtLegendData> & );
+protected Q_SLOTS:
+    void itemClicked();
+    void itemChecked( bool );
 protected:
+    virtual void layoutContents();
+    virtual QWidget *createWidget( const QwtLegendData & ) const;
+    virtual void updateWidget( QWidget *widget, const QwtLegendData &data );
 private:
+    void updateTabOrder();
     class PrivateData;
     PrivateData *d_data;

trunk/BNC/qwt/qwt_magnifier.cpp

-              r4271
+              r8127
         isEnabled( false ),
         wheelFactor( 0.9 ),
         wheelButtonState( Qt::NoButton ),
+        wheelModifiers( Qt::NoModifier ),
         mouseFactor( 0.95 ),
         mouseButton( Qt::RightButton ),
         mouseButtonState( Qt::NoButton ),
+        mouseButtonModifiers( Qt::NoModifier ),
         keyFactor( 0.9 ),
         zoomInKey( Qt::Key_Plus ),
+        zoomInKeyModifiers( Qt::NoModifier ),
         zoomOutKey( Qt::Key_Minus ),
-        zoomInKeyModifiers( Qt::NoModifier ),
         zoomOutKeyModifiers( Qt::NoModifier ),
         mousePressed( false )
 …
     double wheelFactor;
     int wheelButtonState;
+    Qt::KeyboardModifiers wheelModifiers;
     double mouseFactor;
+    int mouseButton;
+    int mouseButtonState;
+    Qt::MouseButton mouseButton;
+    Qt::KeyboardModifiers mouseButtonModifiers;
     double keyFactor;
     int zoomInKey;
+    Qt::KeyboardModifiers zoomInKeyModifiers;
     int zoomOutKey;
+    int zoomInKeyModifiers;
+    int zoomOutKeyModifiers;
+    Qt::KeyboardModifiers  zoomOutKeyModifiers;
     bool mousePressed;
 …
    The wheel factor defines the ratio between the current range
    on the parent widget and the zoomed range for each step of the wheel.
+   Use values > 1 for magnification (i.e. 2.0) and values < 1 for
+   scaling down (i.e. 1/2.0 = 0.5). You can use this feature for
+   inverting the direction of the wheel.
    The default value is 0.9.
 …
 /*!
    Assign a mandatory button state for zooming in/out using the wheel.
    The default button state is Qt::NoButton.
    \param buttonState Button state
    \sa wheelButtonState()
 */
 void QwtMagnifier::setWheelButtonState( int buttonState )
+{
     d_data->wheelButtonState = buttonState;
+}
 /*!
    \return Wheel button state
    \sa setWheelButtonState()
 */
 int QwtMagnifier::wheelButtonState() const
+{
     return d_data->wheelButtonState;
+   Assign keyboard modifiers for zooming in/out using the wheel.
+   The default modifiers are Qt::NoModifiers.
+   \param modifiers Keyboard modifiers
+   \sa wheelModifiers()
+*/
+void QwtMagnifier::setWheelModifiers( Qt::KeyboardModifiers modifiers )
+{
+    d_data->wheelModifiers = modifiers;
+}
+/*!
+   \return Wheel modifiers
+   \sa setWheelModifiers()
+*/
+Qt::KeyboardModifiers QwtMagnifier::wheelModifiers() const
+{
+    return d_data->wheelModifiers;
+}
 …
    \param button Button
+   \param buttonState Button state
+   \param modifiers Keyboard modifiers
    \sa getMouseButton()
 */
+void QwtMagnifier::setMouseButton( int button, int buttonState )
+void QwtMagnifier::setMouseButton(
+    Qt::MouseButton button, Qt::KeyboardModifiers modifiers )
+{
     d_data->mouseButton = button;
     d_data->mouseButtonState = buttonState;
+    d_data->mouseButtonModifiers = modifiers;
+}
 //! \sa setMouseButton()
 void QwtMagnifier::getMouseButton(
     int &button, int &buttonState ) const
+    Qt::MouseButton &button, Qt::KeyboardModifiers &modifiers ) const
+{
     button = d_data->mouseButton;
     buttonState = d_data->mouseButtonState;
+    modifiers = d_data->mouseButtonModifiers;
+}
 …
    \sa getZoomInKey(), setZoomOutKey()
 */
+void QwtMagnifier::setZoomInKey( int key, int modifiers )
+void QwtMagnifier::setZoomInKey( int key,
+    Qt::KeyboardModifiers modifiers )
+{
     d_data->zoomInKey = key;
 …
+}
+//! \sa setZoomInKey()
+void QwtMagnifier::getZoomInKey( int &key, int &modifiers ) const
+/*!
+   \brief Retrieve the settings of the zoom in key
+   \param key Key code, see Qt::Key
+   \param modifiers Keyboard modifiers
+   \sa setZoomInKey()
+*/
+void QwtMagnifier::getZoomInKey( int &key,
+    Qt::KeyboardModifiers &modifiers ) const
+{
     key = d_data->zoomInKey;
 …
    \sa getZoomOutKey(), setZoomOutKey()
 */
+void QwtMagnifier::setZoomOutKey( int key, int modifiers )
+void QwtMagnifier::setZoomOutKey( int key,
+    Qt::KeyboardModifiers modifiers )
+{
     d_data->zoomOutKey = key;
 …
+}
+//! \sa setZoomOutKey()
+void QwtMagnifier::getZoomOutKey( int &key, int &modifiers ) const
+/*!
+   \brief Retrieve the settings of the zoom out key
+   \param key Key code, see Qt::Key
+   \param modifiers Keyboard modifiers
+   \sa setZoomOutKey()
+*/
+void QwtMagnifier::getZoomOutKey( int &key,
+    Qt::KeyboardModifiers &modifiers ) const
+{
     key = d_data->zoomOutKey;
 …
   \brief Event filter
+  When isEnabled() the mouse events of the observed widget are filtered.
+  When isEnabled() is true, the mouse events of the
+  observed widget are filtered.
   \param object Object to be filtered
   \param event Event
+  \return Forwarded to QObject::eventFilter()
   \sa widgetMousePressEvent(), widgetMouseReleaseEvent(),
 …
             case QEvent::MouseButtonPress:
+            {
                 widgetMousePressEvent( ( QMouseEvent * )event );
+                widgetMousePressEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::MouseMove:
+            {
                 widgetMouseMoveEvent( ( QMouseEvent * )event );
+                widgetMouseMoveEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::MouseButtonRelease:
+            {
                 widgetMouseReleaseEvent( ( QMouseEvent * )event );
+                widgetMouseReleaseEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::Wheel:
+            {
                 widgetWheelEvent( ( QWheelEvent * )event );
+                widgetWheelEvent( static_cast<QWheelEvent *>( event ) );
                 break;
+            }
             case QEvent::KeyPress:
+            {
                 widgetKeyPressEvent( ( QKeyEvent * )event );
+                widgetKeyPressEvent( static_cast<QKeyEvent *>( event ) );
                 break;
+            }
             case QEvent::KeyRelease:
+            {
                 widgetKeyReleaseEvent( ( QKeyEvent * )event );
+                widgetKeyReleaseEvent( static_cast<QKeyEvent *>( event ) );
                 break;
+            }
 …
 void QwtMagnifier::widgetMousePressEvent( QMouseEvent *mouseEvent )
+{
+    if ( ( mouseEvent->button() != d_data->mouseButton)
+        || parentWidget() == NULL )
+    {
+    if ( parentWidget() == NULL )
         return;
+    }
+    if ( ( mouseEvent->modifiers() & Qt::KeyboardModifierMask ) !=
+        ( int )( d_data->mouseButtonState & Qt::KeyboardModifierMask ) )
+    if ( ( mouseEvent->button() != d_data->mouseButton ) ||
+        ( mouseEvent->modifiers() != d_data->mouseButtonModifiers ) )
+    {
         return;
 …
     d_data->hasMouseTracking = parentWidget()->hasMouseTracking();
     parentWidget()->setMouseTracking( true );
     d_data->mousePos = mouseEvent->pos();
 …
 void QwtMagnifier::widgetWheelEvent( QWheelEvent *wheelEvent )
+{
+    if ( ( wheelEvent->modifiers() & Qt::KeyboardModifierMask ) !=
+        ( int )( d_data->wheelButtonState & Qt::KeyboardModifierMask ) )
+    if ( wheelEvent->modifiers() != d_data->wheelModifiers )
+    {
         return;
 …
          */
         double f = qPow( d_data->wheelFactor,
             qAbs( wheelEvent->delta() / 120 ) );
+            qAbs( wheelEvent->delta() / 120.0 ) );
         if ( wheelEvent->delta() > 0 )
 …
 void QwtMagnifier::widgetKeyPressEvent( QKeyEvent *keyEvent )
+{
+    const int key = keyEvent->key();
+    const int state = keyEvent->modifiers();
+    if ( key == d_data->zoomInKey &&
+        state == d_data->zoomInKeyModifiers )
+    if ( keyEvent->key() == d_data->zoomInKey &&
+        keyEvent->modifiers() == d_data->zoomInKeyModifiers )
+    {
         rescale( d_data->keyFactor );
+    }
     else if ( key == d_data->zoomOutKey &&
         state == d_data->zoomOutKeyModifiers )
+    else if ( keyEvent->key() == d_data->zoomOutKey &&
+        keyEvent->modifiers() == d_data->zoomOutKeyModifiers )
+    {
         rescale( 1.0 / d_data->keyFactor );
 …
 QWidget *QwtMagnifier::parentWidget()
+{
+    if ( parent()->inherits( "QWidget" ) )
+        return ( QWidget * )parent();
+    return NULL;
+    return qobject_cast<QWidget *>( parent() );
+}
 …
 const QWidget *QwtMagnifier::parentWidget() const
+{
+    if ( parent()->inherits( "QWidget" ) )
+        return ( const QWidget * )parent();
+    return NULL;
+}
+    return qobject_cast<const QWidget *>( parent() );
+}

trunk/BNC/qwt/qwt_magnifier.h

-              r4271
+              r8127
     double mouseFactor() const;
     void setMouseButton( int button, int buttonState = Qt::NoButton );
     void getMouseButton( int &button, int &buttonState ) const;
+    void setMouseButton( Qt::MouseButton, Qt::KeyboardModifiers = Qt::NoModifier );
+    void getMouseButton( Qt::MouseButton &, Qt::KeyboardModifiers & ) const;
     // mouse wheel
 …
     double wheelFactor() const;
     void setWheelButtonState( int buttonState );
     int wheelButtonState() const;
+    void setWheelModifiers( Qt::KeyboardModifiers );
+    Qt::KeyboardModifiers wheelModifiers() const;
     // keyboard
 …
     double keyFactor() const;
     void setZoomInKey( int key, int modifiers );
     void getZoomInKey( int &key, int &modifiers ) const;
+    void setZoomInKey( int key, Qt::KeyboardModifiers = Qt::NoModifier );
+    void getZoomInKey( int &key, Qt::KeyboardModifiers & ) const;
     void setZoomOutKey( int key, int modifiers );
     void getZoomOutKey( int &key, int &modifiers ) const;
+    void setZoomOutKey( int key, Qt::KeyboardModifiers = Qt::NoModifier );
+    void getZoomOutKey( int &key, Qt::KeyboardModifiers & ) const;
     virtual bool eventFilter( QObject *, QEvent * );

trunk/BNC/qwt/qwt_math.cpp

-              r4271
+              r8127
     return rv;
+}
+/*!
+  \brief Normalize an angle to be int the range [0.0, 2 * PI[
+  \param radians Angle in radians
+  \return Normalized angle in radians
+*/
+double qwtNormalizeRadians( double radians )
+{
+    double a = ::fmod( radians, 2.0 * M_PI );
+    if ( a < 0.0 )
+        a += 2.0 * M_PI;
+    return a;
+}
+/*!
+  \brief Normalize an angle to be int the range [0.0, 360.0[
+  \param radians Angle in degrees
+  \return Normalized angle in degrees
+*/
+double qwtNormalizeDegrees( double degrees )
+{
+    double a = ::fmod( degrees, 360.0 );
+    if ( a < 0.0 )
+        a += 360.0;
+    return a;
+}

trunk/BNC/qwt/qwt_math.h

-              r4271
+              r8127
 #endif
-#include <qpoint.h>
 #include <qmath.h>
 #include "qwt_global.h"
+#ifndef LOG10_2
+#define LOG10_2     0.30102999566398119802  /* log10(2) */
+#endif
+#ifndef LOG10_3
+#define LOG10_3     0.47712125471966243540  /* log10(3) */
+#endif
+#ifndef LOG10_5
+#define LOG10_5     0.69897000433601885749  /* log10(5) */
+#endif
+#ifndef M_2PI
+#define M_2PI       6.28318530717958623200  /* 2 pi */
+#ifndef M_PI_2
+// For Qt <= 4.8.4 M_PI_2 is not known by MinGW-w64
+// when compiling with -std=c++11
+#define M_PI_2 (1.57079632679489661923)
 #endif
 #ifndef LOG_MIN
 //! Mininum value for logarithmic scales
+//! Minimum value for logarithmic scales
 #define LOG_MIN 1.0e-100
 #endif
 …
 #endif
-#ifndef M_E
-#define M_E            2.7182818284590452354   /* e */
-#endif
-#ifndef M_LOG2E
-#define M_LOG2E 1.4426950408889634074   /* log_2 e */
-#endif
-#ifndef M_LOG10E
-#define M_LOG10E    0.43429448190325182765  /* log_10 e */
-#endif
-#ifndef M_LN2
-#define M_LN2       0.69314718055994530942  /* log_e 2 */
-#endif
-#ifndef M_LN10
-#define M_LN10         2.30258509299404568402  /* log_e 10 */
-#endif
-#ifndef M_PI
-#define M_PI        3.14159265358979323846  /* pi */
-#endif
-#ifndef M_PI_2
-#define M_PI_2      1.57079632679489661923  /* pi/2 */
-#endif
-#ifndef M_PI_4
-#define M_PI_4      0.78539816339744830962  /* pi/4 */
-#endif
-#ifndef M_1_PI
-#define M_1_PI      0.31830988618379067154  /* 1/pi */
-#endif
-#ifndef M_2_PI
-#define M_2_PI      0.63661977236758134308  /* 2/pi */
-#endif
-#ifndef M_2_SQRTPI
-#define M_2_SQRTPI  1.12837916709551257390  /* 2/sqrt(pi) */
-#endif
-#ifndef M_SQRT2
-#define M_SQRT2 1.41421356237309504880  /* sqrt(2) */
-#endif
-#ifndef M_SQRT1_2
-#define M_SQRT1_2   0.70710678118654752440  /* 1/sqrt(2) */
-#endif
 QWT_EXPORT double qwtGetMin( const double *array, int size );
 QWT_EXPORT double qwtGetMax( const double *array, int size );
+QWT_EXPORT double qwtNormalizeRadians( double radians );
+QWT_EXPORT double qwtNormalizeDegrees( double degrees );
 /*!
 …
+}
+//! Like qRound, but without converting the result to an int
+inline double qwtRoundF(double d)
+{
+    return ::floor( d + 0.5 );
+//! Approximation of arc tangent ( error below 0,005 radians )
+inline double qwtFastAtan( double x )
+{
+    if ( x < -1.0 )
+        return -M_PI_2 - x / ( x * x + 0.28 );
+    if ( x > 1.0 )
+        return M_PI_2 - x / ( x * x + 0.28 );
+    return x / ( 1.0 + x * x * 0.28 );
+}
+//! Like qFloor, but without converting the result to an int
+inline double qwtFloorF(double d)
+{
+    return ::floor( d );
+//! Approximation of arc tangent ( error below 0,005 radians )
+inline double qwtFastAtan2( double y, double x )
+{
+    if ( x > 0 )
+        return qwtFastAtan( y / x );
+    if ( x < 0 )
+    {
+        const double d = qwtFastAtan( y / x );
+        return ( y >= 0 ) ? d + M_PI : d - M_PI;
+    }
+    if ( y < 0.0 )
+        return -M_PI_2;
+    if ( y > 0.0 )
+        return M_PI_2;
+    return 0.0;
+}
+//! Like qCeil, but without converting the result to an int
+inline double qwtCeilF(double d)
+{
+    return ::ceil( d );
+//! Translate degrees into radians
+inline double qwtRadians( double degrees )
+{
+    return degrees * M_PI / 180.0;
+}
+//! Translate radians into degrees
+inline double qwtDegrees( double degrees )
+{
+    return degrees * 180.0 / M_PI;
+}

trunk/BNC/qwt/qwt_matrix_raster_data.cpp

-              r4271
+              r8127
+    }
     inline double value(size_t row, size_t col) const
+    inline double value(int row, int col) const
+    {
         return values.data()[ row * numColumns + col ];
 …
     QVector<double> values;
     size_t numColumns;
     size_t numRows;
+    int numColumns;
+    int numRows;
     double dx;
 …
    \sa resampleMode(), value()
 */
 void QwtMatrixRasterData::setResampleMode(ResampleMode mode)
+void QwtMatrixRasterData::setResampleMode( ResampleMode mode )
+{
     d_data->resampleMode = mode;
 …
 */
 void QwtMatrixRasterData::setValueMatrix(
     const QVector<double> &values, size_t numColumns )
+    const QVector<double> &values, int numColumns )
+{
     d_data->values = values;
     d_data->numColumns = numColumns;
+    d_data->numColumns = qMax( numColumns, 0 );
     update();
+}
 …
 /*!
+  \brief Change a single value in the matrix
+  \param row Row index
+  \param col Column index
+  \param value New value
+  \sa value(), setValueMatrix()
+*/
+void QwtMatrixRasterData::setValue( int row, int col, double value )
+{
+    if ( row >= 0 && row < d_data->numRows &&
+        col >= 0 && col < d_data->numColumns )
+    {
+        const int index = row * d_data->numColumns + col;
+        d_data->values.data()[ index ] = value;
+    }
+}
+/*!
    \return Number of columns of the value matrix
    \sa valueMatrix(), numRows(), setValueMatrix()
 */
 size_t QwtMatrixRasterData::numColumns() const
+int QwtMatrixRasterData::numColumns() const
+{
     return d_data->numColumns;
 …
    \sa valueMatrix(), numColumns(), setValueMatrix()
 */
 size_t QwtMatrixRasterData::numRows() const
+int QwtMatrixRasterData::numRows() const
+{
     return d_data->numRows;
 …
 /*!
+   \brief Pixel hint
+   \brief Calculate the pixel hint
+   pixelHint() returns the geometry of a pixel, that can be used
+   to calculate the resolution and alignment of the plot item, that is
+   representing the data.
    - NearestNeighbour\n
 …
      to render in target device ( f.e. screen ) resolution.
+   \param area Requested area, ignored
+   \return Calculated hint
    \sa ResampleMode, setMatrix(), setInterval()
 */
+QRectF QwtMatrixRasterData::pixelHint( const QRectF & ) const
+{
+QRectF QwtMatrixRasterData::pixelHint( const QRectF &area ) const
+{
+    Q_UNUSED( area )
     QRectF rect;
     if ( d_data->resampleMode == NearestNeighbour )
 …
             if ( col1 < 0 )
                 col1 = col2;
             else if ( col2 >= (int)d_data->numColumns )
+            else if ( col2 >= static_cast<int>( d_data->numColumns ) )
                 col2 = col1;
             if ( row1 < 0 )
                 row1 = row2;
             else if ( row2 >= (int)d_data->numRows )
+            else if ( row2 >= static_cast<int>( d_data->numRows ) )
                 row2 = row1;
 …
         default:
+        {
             uint row = uint( (y - yInterval.minValue() ) / d_data->dy );
             uint col = uint( (x - xInterval.minValue() ) / d_data->dx );
+            int row = int( (y - yInterval.minValue() ) / d_data->dy );
+            int col = int( (x - xInterval.minValue() ) / d_data->dx );
             // In case of intervals, where the maximum is included

trunk/BNC/qwt/qwt_matrix_raster_data.h

-              r4271
+              r8127
     virtual void setInterval( Qt::Axis, const QwtInterval & );
+    void setValueMatrix( const QVector<double> &values, size_t numColumns );
+    void setValueMatrix( const QVector<double> &values, int numColumns );
     const QVector<double> valueMatrix() const;
+    size_t numColumns() const;
+    size_t numRows() const;
+    void setValue( int row, int col, double value );
+    int numColumns() const;
+    int numRows() const;
     virtual QRectF pixelHint( const QRectF & ) const;

trunk/BNC/qwt/qwt_null_paintdevice.cpp

-              r4271
+              r8127
 public:
     PrivateData():
         size( 0, 0 )
+    {
+    }
     QSize size;
+        mode( QwtNullPaintDevice::NormalMode )
+    {
+    }
+    QwtNullPaintDevice::Mode mode;
 };
 …
+{
 public:
     PaintEngine( QPaintEngine::PaintEngineFeatures );
+    PaintEngine();
     virtual bool begin( QPaintDevice * );
 …
     virtual void drawTextItem(const QPointF &, const QTextItem &);
     virtual void drawTiledPixmap(const QRectF &,
         const QPixmap &, const QPointF &s);
     virtual void drawImage(const QRectF &,
         const QImage &, const QRectF &, Qt::ImageConversionFlags );
 private:
     QwtNullPaintDevice *d_device;
+    QwtNullPaintDevice *nullDevice();
 };
+QwtNullPaintDevice::PaintEngine::PaintEngine(
+        QPaintEngine::PaintEngineFeatures features ):
+    QPaintEngine( features ),
+    d_device(NULL)
+{
+}
+bool QwtNullPaintDevice::PaintEngine::begin(
+    QPaintDevice *device )
+{
+    d_device = static_cast<QwtNullPaintDevice *>( device );
+QwtNullPaintDevice::PaintEngine::PaintEngine():
+    QPaintEngine( QPaintEngine::AllFeatures )
+{
+}
+bool QwtNullPaintDevice::PaintEngine::begin( QPaintDevice * )
+{
+    setActive( true );
     return true;
+}
 …
 bool QwtNullPaintDevice::PaintEngine::end()
+{
     d_device = NULL;
+    setActive( false );
     return true;
+}
+QPaintEngine::Type
+QwtNullPaintDevice::PaintEngine::type () const
+QPaintEngine::Type QwtNullPaintDevice::PaintEngine::type() const
+{
     return QPaintEngine::User;
 …
     const QRect *rects, int rectCount)
+{
+    if ( d_device )
+        d_device->drawRects( rects, rectCount );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawRects( rects, rectCount );
+        return;
+    }
+    device->drawRects( rects, rectCount );
+}
 …
     const QRectF *rects, int rectCount)
+{
+    if ( d_device )
+        d_device->drawRects( rects, rectCount );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawRects( rects, rectCount );
+        return;
+    }
+    device->drawRects( rects, rectCount );
+}
 …
     const QLine *lines, int lineCount)
+{
+    if ( d_device )
+        d_device->drawLines( lines, lineCount );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawLines( lines, lineCount );
+        return;
+    }
+    device->drawLines( lines, lineCount );
+}
 …
     const QLineF *lines, int lineCount)
+{
+    if ( d_device )
+        d_device->drawLines( lines, lineCount );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawLines( lines, lineCount );
+        return;
+    }
+    device->drawLines( lines, lineCount );
+}
 …
     const QRectF &rect)
+{
+    if ( d_device )
+        d_device->drawEllipse( rect );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawEllipse( rect );
+        return;
+    }
+    device->drawEllipse( rect );
+}
 …
     const QRect &rect)
+{
+    if ( d_device )
+        d_device->drawEllipse( rect );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawEllipse( rect );
+        return;
+    }
+    device->drawEllipse( rect );
+}
 …
     const QPainterPath &path)
+{
+    if ( d_device )
+        d_device->drawPath( path );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    device->drawPath( path );
+}
 …
     const QPointF *points, int pointCount)
+{
+    if ( d_device )
+        d_device->drawPoints( points, pointCount );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawPoints( points, pointCount );
+        return;
+    }
+    device->drawPoints( points, pointCount );
+}
 …
     const QPoint *points, int pointCount)
+{
+    if ( d_device )
+        d_device->drawPoints( points, pointCount );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawPoints( points, pointCount );
+        return;
+    }
+    device->drawPoints( points, pointCount );
+}
 …
     const QPointF *points, int pointCount, PolygonDrawMode mode)
+{
+    if ( d_device )
+        d_device->drawPolygon( points, pointCount, mode );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() == QwtNullPaintDevice::PathMode )
+    {
+        QPainterPath path;
+        if ( pointCount > 0 )
+        {
+            path.moveTo( points[0] );
+            for ( int i = 1; i < pointCount; i++ )
+                path.lineTo( points[i] );
+            if ( mode != PolylineMode )
+                path.closeSubpath();
+        }
+        device->drawPath( path );
+        return;
+    }
+    device->drawPolygon( points, pointCount, mode );
+}
 …
     const QPoint *points, int pointCount, PolygonDrawMode mode)
+{
+    if ( d_device )
+        d_device->drawPolygon( points, pointCount, mode );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() == QwtNullPaintDevice::PathMode )
+    {
+        QPainterPath path;
+        if ( pointCount > 0 )
+        {
+            path.moveTo( points[0] );
+            for ( int i = 1; i < pointCount; i++ )
+                path.lineTo( points[i] );
+            if ( mode != PolylineMode )
+                path.closeSubpath();
+        }
+        device->drawPath( path );
+        return;
+    }
+    device->drawPolygon( points, pointCount, mode );
+}
 …
     const QRectF &rect, const QPixmap &pm, const QRectF &subRect )
+{
+    if ( d_device )
+        d_device->drawPixmap( rect, pm, subRect );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    device->drawPixmap( rect, pm, subRect );
+}
 …
     const QPointF &pos, const QTextItem &textItem)
+{
+    if ( d_device )
+        d_device->drawTextItem( pos, textItem );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawTextItem( pos, textItem );
+        return;
+    }
+    device->drawTextItem( pos, textItem );
+}
 …
     const QPointF &subRect)
+{
+    if ( d_device )
+        d_device->drawTiledPixmap( rect, pixmap, subRect );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    if ( device->mode() != QwtNullPaintDevice::NormalMode )
+    {
+        QPaintEngine::drawTiledPixmap( rect, pixmap, subRect );
+        return;
+    }
+    device->drawTiledPixmap( rect, pixmap, subRect );
+}
 …
     const QRectF &subRect, Qt::ImageConversionFlags flags)
+{
+    if ( d_device )
+        d_device->drawImage( rect, image, subRect, flags );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    device->drawImage( rect, image, subRect, flags );
+}
 …
     const QPaintEngineState &state)
+{
+    if ( d_device )
+        d_device->updateState( state );
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    device->updateState( state );
+}
+inline QwtNullPaintDevice *QwtNullPaintDevice::PaintEngine::nullDevice()
+{
+    if ( !isActive() )
+        return NULL;
+    return static_cast<QwtNullPaintDevice *>( paintDevice() );
+}
 //! Constructor
+QwtNullPaintDevice::QwtNullPaintDevice(
+    QPaintEngine::PaintEngineFeatures features )
+{
+    init( features );
+}
+//! Constructor
+QwtNullPaintDevice::QwtNullPaintDevice( const QSize &size,
+    QPaintEngine::PaintEngineFeatures features )
+{
+    init( features );
+    d_data->size = size;
+}
+void QwtNullPaintDevice::init(
+    QPaintEngine::PaintEngineFeatures features )
+{
+    d_engine = new PaintEngine( features );
+QwtNullPaintDevice::QwtNullPaintDevice():
+    d_engine( NULL )
+{
     d_data = new PrivateData;
+}
 …
 /*!
+   Set the size of the paint device
+   \param size Size
+   \sa size()
+    Set the render mode
+    \param mode New mode
+    \sa mode()
+ */
+void QwtNullPaintDevice::setMode( Mode mode )
+{
+    d_data->mode = mode;
+}
+/*!
+    \return Render mode
+    \sa setMode()
 */
+void QwtNullPaintDevice::setSize( const QSize & size )
+{
+    d_data->size = size;
+}
+/*!
+    \return Size of the paint device
+    \sa setSize()
+*/
+QSize QwtNullPaintDevice::size() const
+{
+    return d_data->size;
+QwtNullPaintDevice::Mode QwtNullPaintDevice::mode() const
+{
+    return d_data->mode;
+}
 …
 QPaintEngine *QwtNullPaintDevice::paintEngine() const
+{
+    if ( d_engine == NULL )
+    {
+        QwtNullPaintDevice *that =
+            const_cast< QwtNullPaintDevice * >( this );
+        that->d_engine = new PaintEngine();
+    }
     return d_engine;
+}
 …
 /*!
     See QPaintDevice::metric()
+    \sa setSize()
+    \param deviceMetric Type of metric
+    \return Metric information for the given paint device metric.
+    \sa sizeMetrics()
 */
+int QwtNullPaintDevice::metric( PaintDeviceMetric metric ) const
+{
+    static QPixmap pm;
+int QwtNullPaintDevice::metric( PaintDeviceMetric deviceMetric ) const
+{
     int value;
     switch ( metric )
+    switch ( deviceMetric )
+    {
         case PdmWidth:
+            value = qMax( d_data->size.width(), 0 );
+            break;
+        {
+            value = sizeMetrics().width();
+            break;
+        }
         case PdmHeight:
+            value = qMax( d_data->size.height(), 0 );
+            break;
+        {
+            value = sizeMetrics().height();
+            break;
+        }
         case PdmNumColors:
+            value = 16777216;
+            break;
+        {
+            value = 0xffffffff;
+            break;
+        }
         case PdmDepth:
+            value = 24;
+            break;
+        {
+            value = 32;
+            break;
+        }
         case PdmPhysicalDpiX:
+        case PdmPhysicalDpiY:
         case PdmDpiY:
+        case PdmPhysicalDpiY:
+        case PdmDpiX:
+        {
+            value = 72;
+            break;
+        }
         case PdmWidthMM:
+        {
+            value = qRound( metric( PdmWidth ) * 25.4 / metric( PdmDpiX ) );
+            break;
+        }
         case PdmHeightMM:
+        case PdmDpiX:
+        {
+            value = qRound( metric( PdmHeight ) * 25.4 / metric( PdmDpiY ) );
+            break;
+        }
         default:
             value = 0;

trunk/BNC/qwt/qwt_null_paintdevice.h

-              r4271
+              r8127
   Sometimes important layout/rendering geometries are not
   available or changable from the public Qt class interface.
+  available or changeable from the public Qt class interface.
   ( f.e hidden in the style implementation ).
   QwtNullPaintDevice can be used to manipulate or filter out
   these informations by analyzing the stream of paint primitives.
+  this information by analyzing the stream of paint primitives.
   F.e. QwtNullPaintDevice is used by QwtPlotCanvas to identify
 …
+{
 public:
+    QwtNullPaintDevice( QPaintEngine::PaintEngineFeatures );
+    QwtNullPaintDevice( const QSize &size,
+        QPaintEngine::PaintEngineFeatures );
+    /*!
+      \brief Render mode
+      \sa setMode(), mode()
+     */
+    enum Mode
+    {
+        /*!
+           All vector graphic primitives are painted by
+           the corresponding draw methods
+         */
+        NormalMode,
+        /*!
+           Vector graphic primitives ( beside polygons ) are mapped to a QPainterPath
+           and are painted by drawPath. In PathMode mode
+           only a few draw methods are called:
+           - drawPath()
+           - drawPixmap()
+           - drawImage()
+           - drawPolygon()
+         */
+        PolygonPathMode,
+        /*!
+           Vector graphic primitives are mapped to a QPainterPath
+           and are painted by drawPath. In PathMode mode
+           only a few draw methods are called:
+           - drawPath()
+           - drawPixmap()
+           - drawImage()
+         */
+        PathMode
+    };
+    QwtNullPaintDevice();
     virtual ~QwtNullPaintDevice();
     void setSize( const QSize &);
     QSize size() const;
+    void setMode( Mode );
+    Mode mode() const;
     virtual QPaintEngine *paintEngine() const;
     virtual int metric( PaintDeviceMetric metric ) const;
 …
     virtual void updateState( const QPaintEngineState &state );
+protected:
+    //! \return Size needed to implement metric()
+    virtual QSize sizeMetrics() const = 0;
 private:
-    void init( QPaintEngine::PaintEngineFeatures );
     class PaintEngine;
     PaintEngine *d_engine;

trunk/BNC/qwt/qwt_painter.cpp

-              r4271
+              r8127
 #include <qdesktopwidget.h>
+#if QT_VERSION >= 0x050000
+#include <qwindow.h>
+#endif
+#if QT_VERSION < 0x050000
+#ifdef Q_WS_X11
+#include <qx11info_x11.h>
+#endif
+#endif
 bool QwtPainter::d_polylineSplitting = true;
 bool QwtPainter::d_roundingAlignment = true;
+static inline bool isClippingNeeded( const QPainter *painter, QRectF &clipRect )
+static inline bool qwtIsClippingNeeded(
+    const QPainter *painter, QRectF &clipRect )
+{
     bool doClipping = false;
 …
+}
+static inline void drawPolyline( QPainter *painter,
+    const QPointF *points, int pointCount, bool polylineSplitting )
+template <class T>
+static inline void qwtDrawPolyline( QPainter *painter,
+    const T *points, int pointCount, bool polylineSplitting )
+{
     bool doSplit = false;
 …
     if ( doSplit )
+    {
+        const int splitSize = 20;
+        const int splitSize = 6;
         for ( int i = 0; i < pointCount; i += splitSize )
+        {
 …
+    }
     else
+    {
         painter->drawPolyline( points, pointCount );
+}
+static inline void unscaleFont( QPainter *painter )
+    }
+}
+static inline QSize qwtScreenResolution()
+{
+    static QSize screenResolution;
+    if ( !screenResolution.isValid() )
+    {
+        QDesktopWidget *desktop = QApplication::desktop();
+        if ( desktop )
+        {
+            screenResolution.setWidth( desktop->logicalDpiX() );
+            screenResolution.setHeight( desktop->logicalDpiY() );
+        }
+    }
+    return screenResolution;
+}
+static inline void qwtUnscaleFont( QPainter *painter )
+{
     if ( painter->font().pixelSize() >= 0 )
         return;
+    static QSize screenResolution;
+    if ( !screenResolution.isValid() )
+    {
+        QDesktopWidget *desktop = QApplication::desktop();
+        if ( desktop )
+        {
+            screenResolution.setWidth( desktop->logicalDpiX() );
+            screenResolution.setHeight( desktop->logicalDpiY() );
+        }
+    }
+    const QSize screenResolution = qwtScreenResolution();
     const QPaintDevice *pd = painter->device();
 …
         painter->setFont( pixelFont );
+    }
+}
+/*!
+  Check is the application is running with the X11 graphics system
+  that has some special capabilities that can be used for incremental
+  painting to a widget.
+  \return True, when the graphics system is X11
+*/
+bool QwtPainter::isX11GraphicsSystem()
+{
+    static int onX11 = -1;
+    if ( onX11 < 0 )
+    {
+        QPixmap pm( 1, 1 );
+        QPainter painter( &pm );
+        onX11 = ( painter.paintEngine()->type() == QPaintEngine::X11 ) ? 1 : 0;
+    }
+    return onX11 == 1;
+}
 …
   beside QPaintEngine::Pdf and QPaintEngine::SVG.
+  If we have an integer based paint engine it is also
+  checked if the painter has a transformation matrix,
+  that rotates or scales.
   \param  painter Painter
   \return true, when the paint engine is aligning
+  \return true, when the painter is aligning
   \sa setRoundingAlignment()
 …
             default:;
+        }
+        const QTransform tr = painter->transform();
+        if ( tr.isRotating() || tr.isScaling() )
+        {
+            // we might have to check translations too
+            return false;
+        }
+    }
 …
   Enable whether coordinates should be rounded, before they are painted
   to a paint engine that floors to integer values. For other paint engines
   this ( Pdf, SVG ), this flag has no effect.
   QwtPainter stores this flag only, the rounding itsself is done in
+  ( PDF, SVG ) this flag has no effect.
+  QwtPainter stores this flag only, the rounding itself is done in
   the painting code ( f.e the plot items ).
 …
   \brief En/Disable line splitting for the raster paint engine
+  The raster paint engine paints polylines of many points
+  much faster when they are splitted in smaller chunks.
+  In some Qt versions the raster paint engine paints polylines of many points
+  much faster when they are split in smaller chunks: f.e all supported Qt versions
+  >= Qt 5.0 when drawing an antialiased polyline with a pen width >=2.
+  The default setting is true.
   \sa polylineSplitting()
 …
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping )
 …
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     /*
       Performance of Qt4 is horrible for non trivial brushs. Without
       clipping expect minutes or hours for repainting large rects
+      Performance of Qt4 is horrible for a non trivial brush. Without
+      clipping expect minutes or hours for repainting large rectangles
       (might result from zooming)
     */
 …
     QRectF r = rect;
     if ( deviceClipping )
         r = r.intersect( clipRect );
+        r = r.intersected( clipRect );
     if ( r.isValid() )
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping && !clipRect.contains( rect ) )
         return;
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping && !clipRect.contains( rect ) )
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping && !clipRect.contains( pos ) )
 …
     painter->save();
     unscaleFont( painter );
+    qwtUnscaleFont( painter );
     painter->drawText( pos, text );
     painter->restore();
 …
+{
     painter->save();
     unscaleFont( painter );
+    qwtUnscaleFont( painter );
     painter->drawText( rect, flags, text );
     painter->restore();
 …
     painter->save();
+    painter->setFont( txt->defaultFont() );
+    unscaleFont( painter );
+    QRectF unscaledRect = rect;
+    if ( painter->font().pixelSize() < 0 )
+    {
+        const QSize res = qwtScreenResolution();
+        const QPaintDevice *pd = painter->device();
+        if ( pd->logicalDpiX() != res.width() ||
+            pd->logicalDpiY() != res.height() )
+        {
+            QTransform transform;
+            transform.scale( res.width() / double( pd->logicalDpiX() ),
+                res.height() / double( pd->logicalDpiY() ));
+            painter->setWorldTransform( transform, true );
+            unscaledRect = transform.inverted().mapRect(rect);
+        }
+    }
     txt->setDefaultFont( painter->font() );
     txt->setPageSize( QSizeF( rect.width(), QWIDGETSIZE_MAX ) );
+    txt->setPageSize( QSizeF( unscaledRect.width(), QWIDGETSIZE_MAX ) );
     QAbstractTextDocumentLayout* layout = txt->documentLayout();
     const double height = layout->documentSize().height();
     double y = rect.y();
+    double y = unscaledRect.y();
     if ( flags & Qt::AlignBottom )
         y += ( rect.height() - height );
+        y += ( unscaledRect.height() - height );
     else if ( flags & Qt::AlignVCenter )
         y += ( rect.height() - height ) / 2;
+        y += ( unscaledRect.height() - height ) / 2;
     QAbstractTextDocumentLayout::PaintContext context;
     context.palette.setColor( QPalette::Text, painter->pen().color() );
     painter->translate( rect.x(), y );
+    painter->translate( unscaledRect.x(), y );
     layout->draw( painter, context );
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping &&
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     QPolygonF cpa = polygon;
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     QPolygonF cpa = polygon;
 …
         cpa = QwtClipper::clipPolygonF( clipRect, cpa );
     ::drawPolyline( painter,
+    qwtDrawPolyline<QPointF>( painter,
         cpa.constData(), cpa.size(), d_polylineSplitting );
+}
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping )
+    {
         QPolygonF polygon( pointCount );
         qMemCopy( polygon.data(), points, pointCount * sizeof( QPointF ) );
+        ::memcpy( polygon.data(), points, pointCount * sizeof( QPointF ) );
         polygon = QwtClipper::clipPolygonF( clipRect, polygon );
         ::drawPolyline( painter,
+        qwtDrawPolyline<QPointF>( painter,
             polygon.constData(), polygon.size(), d_polylineSplitting );
+    }
     else
+        ::drawPolyline( painter, points, pointCount, d_polylineSplitting );
+    {
+        qwtDrawPolyline<QPointF>( painter, points, pointCount, d_polylineSplitting );
+    }
+}
+//! Wrapper for QPainter::drawPolygon()
+void QwtPainter::drawPolygon( QPainter *painter, const QPolygon &polygon )
+{
+    QRectF clipRect;
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
+    QPolygon cpa = polygon;
+    if ( deviceClipping )
+        cpa = QwtClipper::clipPolygon( clipRect, polygon );
+    painter->drawPolygon( cpa );
+}
+//! Wrapper for QPainter::drawPolyline()
+void QwtPainter::drawPolyline( QPainter *painter, const QPolygon &polygon )
+{
+    QRectF clipRect;
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
+    QPolygon cpa = polygon;
+    if ( deviceClipping )
+        cpa = QwtClipper::clipPolygon( clipRect, cpa );
+    qwtDrawPolyline<QPoint>( painter,
+        cpa.constData(), cpa.size(), d_polylineSplitting );
+}
+//! Wrapper for QPainter::drawPolyline()
+void QwtPainter::drawPolyline( QPainter *painter,
+    const QPoint *points, int pointCount )
+{
+    QRectF clipRect;
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
+    if ( deviceClipping )
+    {
+        QPolygon polygon( pointCount );
+        ::memcpy( polygon.data(), points, pointCount * sizeof( QPoint ) );
+        polygon = QwtClipper::clipPolygon( clipRect, polygon );
+        qwtDrawPolyline<QPoint>( painter,
+            polygon.constData(), polygon.size(), d_polylineSplitting );
+    }
+    else
+        qwtDrawPolyline<QPoint>( painter, points, pointCount, d_polylineSplitting );
+}
 …
+{
     QRectF clipRect;
     const bool deviceClipping = isClippingNeeded( painter, clipRect );
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
     if ( deviceClipping && !clipRect.contains( pos ) )
 …
     painter->drawPoint( pos );
+}
+//! Wrapper for QPainter::drawPoint()
+void QwtPainter::drawPoint( QPainter *painter, const QPoint &pos )
+{
+    QRectF clipRect;
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
+    if ( deviceClipping )
+    {
+        const int minX = qCeil( clipRect.left() );
+        const int maxX = qFloor( clipRect.right() );
+        const int minY = qCeil( clipRect.top() );
+        const int maxY = qFloor( clipRect.bottom() );
+        if ( pos.x() < minX || pos.x() > maxX
+            || pos.y() < minY || pos.y() > maxY )
+        {
+            return;
+        }
+    }
+    painter->drawPoint( pos );
+}
+//! Wrapper for QPainter::drawPoints()
+void QwtPainter::drawPoints( QPainter *painter,
+    const QPoint *points, int pointCount )
+{
+    QRectF clipRect;
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
+    if ( deviceClipping )
+    {
+        const int minX = qCeil( clipRect.left() );
+        const int maxX = qFloor( clipRect.right() );
+        const int minY = qCeil( clipRect.top() );
+        const int maxY = qFloor( clipRect.bottom() );
+        const QRect r( minX, minY, maxX - minX, maxY - minY );
+        QPolygon clippedPolygon( pointCount );
+        QPoint *clippedData = clippedPolygon.data();
+        int numClippedPoints = 0;
+        for ( int i = 0; i < pointCount; i++ )
+        {
+            if ( r.contains( points[i] ) )
+                clippedData[ numClippedPoints++ ] = points[i];
+        }
+        painter->drawPoints( clippedData, numClippedPoints );
+    }
+    else
+    {
+        painter->drawPoints( points, pointCount );
+    }
+}
+//! Wrapper for QPainter::drawPoints()
+void QwtPainter::drawPoints( QPainter *painter,
+    const QPointF *points, int pointCount )
+{
+    QRectF clipRect;
+    const bool deviceClipping = qwtIsClippingNeeded( painter, clipRect );
+    if ( deviceClipping )
+    {
+        QPolygonF clippedPolygon( pointCount );
+        QPointF *clippedData = clippedPolygon.data();
+        int numClippedPoints = 0;
+        for ( int i = 0; i < pointCount; i++ )
+        {
+            if ( clipRect.contains( points[i] ) )
+                clippedData[ numClippedPoints++ ] = points[i];
+        }
+        painter->drawPoints( clippedData, numClippedPoints );
+    }
+    else
+    {
+        painter->drawPoints( points, pointCount );
+    }
+}
 …
 //! Draw a focus rectangle on a widget using its style.
 void QwtPainter::drawFocusRect( QPainter *painter, QWidget *widget )
+void QwtPainter::drawFocusRect( QPainter *painter, const QWidget *widget )
+{
     drawFocusRect( painter, widget, widget->rect() );
 …
 //! Draw a focus rectangle on a widget using its style.
 void QwtPainter::drawFocusRect( QPainter *painter, QWidget *widget,
+void QwtPainter::drawFocusRect( QPainter *painter, const QWidget *widget,
     const QRect &rect )
+{
 …
     opt.rect = rect;
     opt.state |= QStyle::State_HasFocus;
+    widget->style()->drawPrimitive( QStyle::PE_FrameFocusRect,
+        &opt, painter, widget );
+    opt.backgroundColor = widget->palette().color( widget->backgroundRole() );
+    widget->style()->drawPrimitive(
+        QStyle::PE_FrameFocusRect, &opt, painter, widget );
+}
 /*!
+  Draw a frame with rounded borders
+  Draw a round frame
+  \param painter Painter
+  \param rect Frame rectangle
+  \param palette QPalette::WindowText is used for plain borders
+                 QPalette::Dark and QPalette::Light for raised
+                 or sunken borders
+  \param lineWidth Line width
+  \param frameStyle bitwise OR´ed value of QFrame::Shape and QFrame::Shadow
+*/
+void QwtPainter::drawRoundFrame( QPainter *painter,
+    const QRectF &rect, const QPalette &palette,
+    int lineWidth, int frameStyle )
+{
+    enum Style
+    {
+        Plain,
+        Sunken,
+        Raised
+    };
+    Style style = Plain;
+    if ( (frameStyle & QFrame::Sunken) == QFrame::Sunken )
+        style = Sunken;
+    else if ( (frameStyle & QFrame::Raised) == QFrame::Raised )
+        style = Raised;
+    const double lw2 = 0.5 * lineWidth;
+    QRectF r = rect.adjusted( lw2, lw2, -lw2, -lw2 );
+    QBrush brush;
+    if ( style != Plain )
+    {
+        QColor c1 = palette.color( QPalette::Light );
+        QColor c2 = palette.color( QPalette::Dark );
+        if ( style == Sunken )
+            qSwap( c1, c2 );
+        QLinearGradient gradient( r.topLeft(), r.bottomRight() );
+        gradient.setColorAt( 0.0, c1 );
+#if 0
+        gradient.setColorAt( 0.3, c1 );
+        gradient.setColorAt( 0.7, c2 );
+#endif
+        gradient.setColorAt( 1.0, c2 );
+        brush = QBrush( gradient );
+    }
+    else // Plain
+    {
+        brush = palette.brush( QPalette::WindowText );
+    }
+    painter->save();
+    painter->setPen( QPen( brush, lineWidth ) );
+    painter->setBrush( Qt::NoBrush );
+    painter->drawEllipse( r );
+    painter->restore();
+}
+/*!
+  Draw a rectangular frame
+  \param painter Painter
+  \param rect Frame rectangle
+  \param palette Palette
+  \param foregroundRole Foreground role used for QFrame::Plain
+  \param frameWidth Frame width
+  \param midLineWidth Used for QFrame::Box
+  \param frameStyle bitwise OR´ed value of QFrame::Shape and QFrame::Shadow
+*/
+void QwtPainter::drawFrame( QPainter *painter, const QRectF &rect,
+    const QPalette &palette, QPalette::ColorRole foregroundRole,
+    int frameWidth, int midLineWidth, int frameStyle )
+{
+    if ( frameWidth <= 0 || rect.isEmpty() )
+        return;
+    const int shadow = frameStyle & QFrame::Shadow_Mask;
+    painter->save();
+    if ( shadow == QFrame::Plain )
+    {
+        const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 );
+        const QRectF innerRect = outerRect.adjusted(
+            frameWidth, frameWidth, -frameWidth, -frameWidth );
+        QPainterPath path;
+        path.addRect( outerRect );
+        path.addRect( innerRect );
+        painter->setPen( Qt::NoPen );
+        painter->setBrush( palette.color( foregroundRole ) );
+        painter->drawPath( path );
+    }
+    else
+    {
+        const int shape = frameStyle & QFrame::Shape_Mask;
+        if ( shape == QFrame::Box )
+        {
+            const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 );
+            const QRectF midRect1 = outerRect.adjusted(
+                frameWidth, frameWidth, -frameWidth, -frameWidth );
+            const QRectF midRect2 = midRect1.adjusted(
+                midLineWidth, midLineWidth, -midLineWidth, -midLineWidth );
+            const QRectF innerRect = midRect2.adjusted(
+                frameWidth, frameWidth, -frameWidth, -frameWidth );
+            QPainterPath path1;
+            path1.moveTo( outerRect.bottomLeft() );
+            path1.lineTo( outerRect.topLeft() );
+            path1.lineTo( outerRect.topRight() );
+            path1.lineTo( midRect1.topRight() );
+            path1.lineTo( midRect1.topLeft() );
+            path1.lineTo( midRect1.bottomLeft() );
+            QPainterPath path2;
+            path2.moveTo( outerRect.bottomLeft() );
+            path2.lineTo( outerRect.bottomRight() );
+            path2.lineTo( outerRect.topRight() );
+            path2.lineTo( midRect1.topRight() );
+            path2.lineTo( midRect1.bottomRight() );
+            path2.lineTo( midRect1.bottomLeft() );
+            QPainterPath path3;
+            path3.moveTo( midRect2.bottomLeft() );
+            path3.lineTo( midRect2.topLeft() );
+            path3.lineTo( midRect2.topRight() );
+            path3.lineTo( innerRect.topRight() );
+            path3.lineTo( innerRect.topLeft() );
+            path3.lineTo( innerRect.bottomLeft() );
+            QPainterPath path4;
+            path4.moveTo( midRect2.bottomLeft() );
+            path4.lineTo( midRect2.bottomRight() );
+            path4.lineTo( midRect2.topRight() );
+            path4.lineTo( innerRect.topRight() );
+            path4.lineTo( innerRect.bottomRight() );
+            path4.lineTo( innerRect.bottomLeft() );
+            QPainterPath path5;
+            path5.addRect( midRect1 );
+            path5.addRect( midRect2 );
+            painter->setPen( Qt::NoPen );
+            QBrush brush1 = palette.dark().color();
+            QBrush brush2 = palette.light().color();
+            if ( shadow == QFrame::Raised )
+                qSwap( brush1, brush2 );
+            painter->setBrush( brush1 );
+            painter->drawPath( path1 );
+            painter->drawPath( path4 );
+            painter->setBrush( brush2 );
+            painter->drawPath( path2 );
+            painter->drawPath( path3 );
+            painter->setBrush( palette.mid() );
+            painter->drawPath( path5 );
+        }
+#if 0
+        // qDrawWinPanel doesn't result in something nice
+        // on a scalable document like PDF. Better draw a
+        // Panel.
+        else if ( shape == QFrame::WinPanel )
+        {
+            painter->setRenderHint( QPainter::NonCosmeticDefaultPen, true );
+            qDrawWinPanel ( painter, rect.toRect(), palette,
+                frameStyle & QFrame::Sunken );
+        }
+        else if ( shape == QFrame::StyledPanel )
+        {
+        }
+#endif
+        else
+        {
+            const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 );
+            const QRectF innerRect = outerRect.adjusted(
+                frameWidth - 1.0, frameWidth - 1.0,
+                -( frameWidth - 1.0 ), -( frameWidth - 1.0 ) );
+            QPainterPath path1;
+            path1.moveTo( outerRect.bottomLeft() );
+            path1.lineTo( outerRect.topLeft() );
+            path1.lineTo( outerRect.topRight() );
+            path1.lineTo( innerRect.topRight() );
+            path1.lineTo( innerRect.topLeft() );
+            path1.lineTo( innerRect.bottomLeft() );
+            QPainterPath path2;
+            path2.moveTo( outerRect.bottomLeft() );
+            path2.lineTo( outerRect.bottomRight() );
+            path2.lineTo( outerRect.topRight() );
+            path2.lineTo( innerRect.topRight() );
+            path2.lineTo( innerRect.bottomRight() );
+            path2.lineTo( innerRect.bottomLeft() );
+            painter->setPen( Qt::NoPen );
+            QBrush brush1 = palette.dark().color();
+            QBrush brush2 = palette.light().color();
+            if ( shadow == QFrame::Raised )
+                qSwap( brush1, brush2 );
+            painter->setBrush( brush1 );
+            painter->drawPath( path1 );
+            painter->setBrush( brush2 );
+            painter->drawPath( path2 );
+        }
+    }
+    painter->restore();
+}
+/*!
+  Draw a rectangular frame with rounded borders
   \param painter Painter
 …
             QPen arcPen;
+            arcPen.setCapStyle( Qt::FlatCap );
             arcPen.setWidth( lineWidth );
             QPen linePen;
+            linePen.setCapStyle( Qt::FlatCap );
             linePen.setWidth( lineWidth );
 …
     QPixmap pixmap( devRect.size() );
+    pixmap.fill( Qt::transparent );
     QPainter pmPainter( &pixmap );
     pmPainter.translate( -devRect.x(), -devRect.y() );
 …
             if ( colorMap.format() == QwtColorMap::RGB )
                 c.setRgb( colorMap.rgb( interval, value ) );
+                c.setRgba( colorMap.rgb( interval, value ) );
             else
                 c = colorTable[colorMap.colorIndex( interval, value )];
 …
             if ( colorMap.format() == QwtColorMap::RGB )
                 c.setRgb( colorMap.rgb( interval, value ) );
+                c.setRgba( colorMap.rgb( interval, value ) );
             else
                 c = colorTable[colorMap.colorIndex( interval, value )];
 …
     drawPixmap( painter, rect, pixmap );
+}
+static inline void qwtFillRect( const QWidget *widget, QPainter *painter,
+    const QRect &rect, const QBrush &brush)
+{
+    if ( brush.style() == Qt::TexturePattern )
+    {
+        painter->save();
+        painter->setClipRect( rect );
+        painter->drawTiledPixmap(rect, brush.texture(), rect.topLeft());
+        painter->restore();
+    }
+    else if ( brush.gradient() )
+    {
+        painter->save();
+        painter->setClipRect( rect );
+        painter->fillRect(0, 0, widget->width(),
+            widget->height(), brush);
+        painter->restore();
+    }
+    else
+    {
+        painter->fillRect(rect, brush);
+    }
+}
+/*!
+  Fill a pixmap with the content of a widget
+  In Qt >= 5.0 QPixmap::fill() is a nop, in Qt 4.x it is buggy
+  for backgrounds with gradients. Thus fillPixmap() offers
+  an alternative implementation.
+  \param widget Widget
+  \param pixmap Pixmap to be filled
+  \param offset Offset
+  \sa QPixmap::fill()
+ */
+void QwtPainter::fillPixmap( const QWidget *widget,
+    QPixmap &pixmap, const QPoint &offset )
+{
+    const QRect rect( offset, pixmap.size() );
+    QPainter painter( &pixmap );
+    painter.translate( -offset );
+    const QBrush autoFillBrush =
+        widget->palette().brush( widget->backgroundRole() );
+    if ( !( widget->autoFillBackground() && autoFillBrush.isOpaque() ) )
+    {
+        const QBrush bg = widget->palette().brush( QPalette::Window );
+        qwtFillRect( widget, &painter, rect, bg);
+    }
+    if ( widget->autoFillBackground() )
+        qwtFillRect( widget, &painter, rect, autoFillBrush);
+    if ( widget->testAttribute(Qt::WA_StyledBackground) )
+    {
+        painter.setClipRegion( rect );
+        QStyleOption opt;
+        opt.initFrom( widget );
+        widget->style()->drawPrimitive( QStyle::PE_Widget,
+            &opt, &painter, widget );
+    }
+}
+/*!
+  Fill rect with the background of a widget
+  \param painter Painter
+  \param rect Rectangle to be filled
+  \param widget Widget
+  \sa QStyle::PE_Widget, QWidget::backgroundRole()
+ */
+void QwtPainter::drawBackgound( QPainter *painter,
+    const QRectF &rect, const QWidget *widget )
+{
+    if ( widget->testAttribute( Qt::WA_StyledBackground ) )
+    {
+        QStyleOption opt;
+        opt.initFrom( widget );
+        opt.rect = rect.toAlignedRect();
+        widget->style()->drawPrimitive(
+            QStyle::PE_Widget, &opt, painter, widget);
+    }
+    else
+    {
+        const QBrush brush =
+            widget->palette().brush( widget->backgroundRole() );
+        painter->fillRect( rect, brush );
+    }
+}
+/*!
+  \return A pixmap that can be used as backing store
+  \param widget Widget, for which the backingstore is intended
+  \param size Size of the pixmap
+ */
+QPixmap QwtPainter::backingStore( QWidget *widget, const QSize &size )
+{
+    QPixmap pm;
+#define QWT_HIGH_DPI 1
+#if QT_VERSION >= 0x050000 && QWT_HIGH_DPI
+    qreal pixelRatio = 1.0;
+    if ( widget && widget->windowHandle() )
+    {
+#if QT_VERSION < 0x050100
+        pixelRatio = widget->windowHandle()->devicePixelRatio();
+#else
+        pixelRatio = widget->devicePixelRatio();
+#endif
+    }
+    else
+    {
+        if ( qApp )
+            pixelRatio = qApp->devicePixelRatio();
+    }
+    pm = QPixmap( size * pixelRatio );
+    pm.setDevicePixelRatio( pixelRatio );
+#else
+    Q_UNUSED( widget )
+    pm = QPixmap( size );
+#endif
+#if QT_VERSION < 0x050000
+#ifdef Q_WS_X11
+    if ( widget && isX11GraphicsSystem() )
+    {
+        if ( pm.x11Info().screen() != widget->x11Info().screen() )
+            pm.x11SetScreen( widget->x11Info().screen() );
+    }
+#endif
+#endif
+    return pm;
+}

trunk/BNC/qwt/qwt_painter.h

-              r4271
+              r8127
 #include <qpen.h>
 #include <qline.h>
+#include <qpalette.h>
 class QPainter;
 …
 class QwtInterval;
-class QPalette;
 class QTextDocument;
 class QPainterPath;
 …
     static void drawLine( QPainter *, const QLineF & );
     static void drawPolygon( QPainter *, const QPolygonF &pa );
     static void drawPolyline( QPainter *, const QPolygonF &pa );
+    static void drawPolygon( QPainter *, const QPolygonF & );
+    static void drawPolyline( QPainter *, const QPolygonF & );
     static void drawPolyline( QPainter *, const QPointF *, int pointCount );
+    static void drawPolygon( QPainter *, const QPolygon & );
+    static void drawPolyline( QPainter *, const QPolygon & );
+    static void drawPolyline( QPainter *, const QPoint *, int pointCount );
+    static void drawPoint( QPainter *, const QPoint & );
+    static void drawPoints( QPainter *, const QPolygon & );
+    static void drawPoints( QPainter *, const QPoint *, int pointCount );
     static void drawPoint( QPainter *, double x, double y );
     static void drawPoint( QPainter *, const QPointF & );
+    static void drawPoints( QPainter *, const QPolygonF & );
+    static void drawPoints( QPainter *, const QPointF *, int pointCount );
     static void drawPath( QPainter *, const QPainterPath & );
 …
     static void drawPixmap( QPainter *, const QRectF &, const QPixmap & );
+    static void drawRoundFrame( QPainter *,
+        const QRectF &, const QPalette &, int lineWidth, int frameStyle );
     static void drawRoundedFrame( QPainter *,
         const QRectF &, double xRadius, double yRadius,
         const QPalette &, int lineWidth, int frameStyle );
+    static void drawFocusRect( QPainter *, QWidget * );
+    static void drawFocusRect( QPainter *, QWidget *, const QRect & );
+    static void drawFrame( QPainter *, const QRectF &rect,
+        const QPalette &palette, QPalette::ColorRole foregroundRole,
+        int lineWidth, int midLineWidth, int frameStyle );
+    static void drawFocusRect( QPainter *, const QWidget * );
+    static void drawFocusRect( QPainter *, const QWidget *, const QRect & );
     static void drawColorBar( QPainter *painter,
 …
     static bool isAligning( QPainter *painter );
+    static bool isX11GraphicsSystem();
+    static void fillPixmap( const QWidget *,
+        QPixmap &, const QPoint &offset = QPoint() );
+    static void drawBackgound( QPainter *painter,
+        const QRectF &rect, const QWidget *widget );
+    static QPixmap backingStore( QWidget *, const QSize & );
 private:
 …
+{
     QwtPainter::drawPoint( painter, QPointF( x, y ) );
+}
+//! Wrapper for QPainter::drawPoints()
+inline void QwtPainter::drawPoints( QPainter *painter, const QPolygon &polygon )
+{
+    drawPoints( painter, polygon.data(), polygon.size() );
+}
+//! Wrapper for QPainter::drawPoints()
+inline void QwtPainter::drawPoints( QPainter *painter, const QPolygonF &polygon )
+{
+    drawPoints( painter, polygon.data(), polygon.size() );
+}
 …
 /*!
   Returns whether line splitting for the raster paint engine is enabled.
+  \return True, when line splitting for the raster paint engine is enabled.
   \sa setPolylineSplitting()
 */
 …
 /*!
   Returns whether coordinates should be rounded, before they are painted
   to a paint engine that floors to integer values.  For other paint engines
   this ( Pdf, SVG ), this flag has no effect.
+  Check whether coordinates should be rounded, before they are painted
+  to a paint engine that rounds to integer values. For other paint engines
+  ( PDF, SVG ), this flag has no effect.
+  \return True, when rounding is enabled
   \sa setRoundingAlignment(), isAligning()
 */

trunk/BNC/qwt/qwt_panner.cpp

-              r4271
+              r8127
 #include "qwt_panner.h"
 #include "qwt_picker.h"
+#include "qwt_painter.h"
 #include <qpainter.h>
 #include <qpixmap.h>
 …
     for ( int i = 0; i < children.size(); i++ )
+    {
+        QObject *obj = children[i];
+        if ( obj->inherits( "QwtPicker" ) )
+        {
+            QwtPicker *picker = ( QwtPicker * )obj;
+            if ( picker->isEnabled() )
+                pickers += picker;
+        }
+        QwtPicker *picker = qobject_cast<QwtPicker *>( children[i] );
+        if ( picker && picker->isEnabled() )
+            pickers += picker;
+    }
 …
     PrivateData():
         button( Qt::LeftButton ),
         buttonState( Qt::NoButton ),
+        buttonModifiers( Qt::NoModifier ),
         abortKey( Qt::Key_Escape ),
         abortKeyState( Qt::NoButton ),
+        abortKeyModifiers( Qt::NoModifier ),
 #ifndef QT_NO_CURSOR
         cursor( NULL ),
 …
+    }
+    int button;
+    int buttonState;
+    Qt::MouseButton button;
+    Qt::KeyboardModifiers  buttonModifiers;
     int abortKey;
     int abortKeyState;
+    Qt::KeyboardModifiers abortKeyModifiers;
     QPoint initialPos;
 …
 /*!
+   Change the mouse button
+   The defaults are Qt::LeftButton and Qt::NoButton
+*/
+void QwtPanner::setMouseButton( int button, int buttonState )
+   Change the mouse button and modifiers used for panning
+   The defaults are Qt::LeftButton and Qt::NoModifier
+*/
+void QwtPanner::setMouseButton( Qt::MouseButton button,
+    Qt::KeyboardModifiers modifiers )
+{
     d_data->button = button;
+    d_data->buttonState = buttonState;
+}
+//! Get the mouse button
+void QwtPanner::getMouseButton( int &button, int &buttonState ) const
+    d_data->buttonModifiers = modifiers;
+}
+//! Get mouse button and modifiers used for panning
+void QwtPanner::getMouseButton( Qt::MouseButton &button,
+    Qt::KeyboardModifiers &modifiers ) const
+{
     button = d_data->button;
     buttonState = d_data->buttonState;
+    modifiers = d_data->buttonModifiers;
+}
 /*!
    Change the abort key
    The defaults are Qt::Key_Escape and Qt::NoButton
+   The defaults are Qt::Key_Escape and Qt::NoModifiers
    \param key Key ( See Qt::Keycode )
+   \param state State
+*/
+void QwtPanner::setAbortKey( int key, int state )
+   \param modifiers Keyboard modifiers
+*/
+void QwtPanner::setAbortKey( int key,
+    Qt::KeyboardModifiers modifiers )
+{
     d_data->abortKey = key;
+    d_data->abortKeyState = state;
+}
+//! Get the abort key
+void QwtPanner::getAbortKey( int &key, int &state ) const
+    d_data->abortKeyModifiers = modifiers;
+}
+//! Get the abort key and modifiers
+void QwtPanner::getAbortKey( int &key,
+    Qt::KeyboardModifiers &modifiers ) const
+{
     key = d_data->abortKey;
     state = d_data->abortKeyState;
+    modifiers = d_data->abortKeyModifiers;
+}
 …
 /*!
    Return true if a orientatio is enabled
+   \return True if an orientation is enabled
    \sa orientations(), setOrientations()
 */
 …
     QPixmap pm( size() );
     pm.fill( parentWidget(), 0, 0 );
+    QwtPainter::fillPixmap( parentWidget(), pm );
     QPainter painter( &pm );
 …
 /*!
   Grab the widget into a pixmap.
+  \return Grabbed pixmap
 */
 QPixmap QwtPanner::grab() const
+{
+#if QT_VERSION >= 0x050000
+    return parentWidget()->grab( parentWidget()->rect() );
+#else
     return QPixmap::grabWidget( parentWidget() );
+#endif
+}
 …
   \brief Event filter
+  When isEnabled() the mouse events of the observed widget are filtered.
+  When isEnabled() is true mouse events of the
+  observed widget are filtered.
   \param object Object to be filtered
   \param event Event
+  \return Always false, beside for paint events for the
+          parent widget.
   \sa widgetMousePressEvent(), widgetMouseReleaseEvent(),
       widgetMouseMoveEvent()
 …
         case QEvent::MouseButtonPress:
+        {
             widgetMousePressEvent( ( QMouseEvent * )event );
+            widgetMousePressEvent( static_cast<QMouseEvent *>( event ) );
             break;
+        }
         case QEvent::MouseMove:
+        {
             widgetMouseMoveEvent( ( QMouseEvent * )event );
+            widgetMouseMoveEvent( static_cast<QMouseEvent *>( event ) );
             break;
+        }
         case QEvent::MouseButtonRelease:
+        {
             widgetMouseReleaseEvent( ( QMouseEvent * )event );
+            widgetMouseReleaseEvent( static_cast<QMouseEvent *>( event ) );
             break;
+        }
         case QEvent::KeyPress:
+        {
             widgetKeyPressEvent( ( QKeyEvent * )event );
+            widgetKeyPressEvent( static_cast<QKeyEvent *>( event ) );
             break;
+        }
         case QEvent::KeyRelease:
+        {
             widgetKeyReleaseEvent( ( QKeyEvent * )event );
+            widgetKeyReleaseEvent( static_cast<QKeyEvent *>( event ) );
             break;
+        }
 …
 void QwtPanner::widgetMousePressEvent( QMouseEvent *mouseEvent )
+{
+    if ( mouseEvent->button() != d_data->button )
+    if ( ( mouseEvent->button() != d_data->button )
+        || ( mouseEvent->modifiers() != d_data->buttonModifiers ) )
+    {
         return;
+    }
     QWidget *w = parentWidget();
 …
         return;
-    if ( ( mouseEvent->modifiers() & Qt::KeyboardModifierMask ) !=
-        ( int )( d_data->buttonState & Qt::KeyboardModifierMask ) )
+    {
-        return;
+    }
 #ifndef QT_NO_CURSOR
     showCursor( true );
 …
     // We don't want to grab the picker !
     QVector<QwtPicker *> pickers = qwtActivePickers( parentWidget() );
     for ( int i = 0; i < ( int )pickers.size(); i++ )
+    for ( int i = 0; i < pickers.size(); i++ )
         pickers[i]->setEnabled( false );
 …
     d_data->contentsMask = contentsMask();
     for ( int i = 0; i < ( int )pickers.size(); i++ )
+    for ( int i = 0; i < pickers.size(); i++ )
         pickers[i]->setEnabled( true );
 …
 void QwtPanner::widgetKeyPressEvent( QKeyEvent *keyEvent )
+{
+    if ( keyEvent->key() == d_data->abortKey )
+    {
+        const bool matched =
+            ( keyEvent->modifiers() & Qt::KeyboardModifierMask ) ==
+                ( int )( d_data->abortKeyState & Qt::KeyboardModifierMask );
+        if ( matched )
+        {
+            hide();
+#ifndef QT_NO_CURSOR
+            showCursor( false );
+#endif
+            d_data->pixmap = QPixmap();
+        }
+    if ( ( keyEvent->key() == d_data->abortKey )
+        && ( keyEvent->modifiers() == d_data->abortKeyModifiers ) )
+    {
+        hide();
+#ifndef QT_NO_CURSOR
+        showCursor( false );
+#endif
+        d_data->pixmap = QPixmap();
+    }
+}

trunk/BNC/qwt/qwt_panner.h

-              r4271
+              r8127
     bool isEnabled() const;
+    void setMouseButton( int button, int buttonState = Qt::NoButton );
+    void getMouseButton( int &button, int &buttonState ) const;
+    void setAbortKey( int key, int state = Qt::NoButton );
+    void getAbortKey( int &key, int &state ) const;
+    void setMouseButton( Qt::MouseButton,
+        Qt::KeyboardModifiers = Qt::NoModifier );
+    void getMouseButton( Qt::MouseButton &button,
+        Qt::KeyboardModifiers & ) const;
+    void setAbortKey( int key, Qt::KeyboardModifiers = Qt::NoModifier );
+    void getAbortKey( int &key, Qt::KeyboardModifiers & ) const;
     void setCursor( const QCursor & );

trunk/BNC/qwt/qwt_picker.cpp

-              r4271
+              r8127
 #include "qwt_painter.h"
 #include "qwt_math.h"
+#include "qwt_widget_overlay.h"
 #include <qapplication.h>
 #include <qevent.h>
 …
 #include <qmath.h>
+class QwtPicker::PickerWidget: public QWidget
+static inline QRegion qwtMaskRegion( const QRect &r, int penWidth )
+{
+    const int pw = qMax( penWidth, 1 );
+    const int pw2 = penWidth / 2;
+    int x1 = r.left() - pw2;
+    int x2 = r.right() + 1 + pw2 + ( pw % 2 );
+    int y1 = r.top() - pw2;
+    int y2 = r.bottom() + 1 + pw2 + ( pw % 2 );
+    QRegion region;
+    region += QRect( x1, y1, x2 - x1, pw );
+    region += QRect( x1, y1, pw, y2 - y1 );
+    region += QRect( x1, y2 - pw, x2 - x1, pw );
+    region += QRect( x2 - pw, y1, pw, y2 - y1 );
+    return region;
+}
+static inline QRegion qwtMaskRegion( const QLine &l, int penWidth )
+{
+    const int pw = qMax( penWidth, 1 );
+    const int pw2 = penWidth / 2;
+    QRegion region;
+    if ( l.x1() == l.x2() )
+    {
+        region += QRect( l.x1() - pw2, l.y1(),
+            pw, l.y2() ).normalized();
+    }
+    else if ( l.y1() == l.y2() )
+    {
+        region += QRect( l.x1(), l.y1() - pw2,
+            l.x2(), pw ).normalized();
+    }
+    return region;
+}
+class QwtPickerRubberband: public QwtWidgetOverlay
+{
 public:
+    enum Type
+    {
+        RubberBand,
+        Text
+    };
+    PickerWidget( QwtPicker *, QWidget *, Type );
+    void updateMask();
+    /*
+       For a tracker text with a background we can use the background
+       rect as mask. Also for "regular" Qt widgets >= 4.3.0 we
+       don't need to mask the text anymore.
+     */
+    bool d_hasTextMask;
+    QwtPickerRubberband( QwtPicker *, QWidget * );
 protected:
+    virtual void paintEvent( QPaintEvent * );
+    virtual void drawOverlay( QPainter * ) const;
+    virtual QRegion maskHint() const;
     QwtPicker *d_picker;
-    Type d_type;
 };
+class QwtPickerTracker: public QwtWidgetOverlay
+{
+public:
+    QwtPickerTracker( QwtPicker *, QWidget * );
+protected:
+    virtual void drawOverlay( QPainter * ) const;
+    virtual QRegion maskHint() const;
+    QwtPicker *d_picker;
+};
 class QwtPicker::PrivateData
+{
 public:
+    PrivateData():
+        enabled( false ),
+        stateMachine( NULL ),
+        resizeMode( QwtPicker::Stretch ),
+        rubberBand( QwtPicker::NoRubberBand ),
+        trackerMode( QwtPicker::AlwaysOff ),
+        isActive( false ),
+        trackerPosition( -1, -1 ),
+        mouseTracking( false ),
+        openGL( false )
+    {
+    }
     bool enabled;
 …
     bool mouseTracking; // used to save previous value
+    /*
+      On X11 the widget below the picker widgets gets paint events
+      with a region that is the bounding rect of the mask, if it is complex.
+      In case of (f.e) a CrossRubberBand and a text this creates complete
+      repaints of the widget. So we better use two different widgets.
+     */
+    QPointer<PickerWidget> rubberBandWidget;
+    QPointer<PickerWidget> trackerWidget;
+    QPointer< QwtPickerRubberband > rubberBandOverlay;
+    QPointer< QwtPickerTracker> trackerOverlay;
+    bool openGL;
 };
+QwtPicker::PickerWidget::PickerWidget(
+        QwtPicker *picker, QWidget *parent, Type type ):
+    QWidget( parent ),
+    d_hasTextMask( false ),
+    d_picker( picker ),
+    d_type( type )
+{
+    setAttribute( Qt::WA_TransparentForMouseEvents );
+    setAttribute( Qt::WA_NoSystemBackground );
+    setFocusPolicy( Qt::NoFocus );
+}
+void QwtPicker::PickerWidget::updateMask()
+{
+    QRegion mask;
+    if ( d_type == RubberBand )
+    {
+        QBitmap bm( width(), height() );
+        bm.fill( Qt::color0 );
+        QPainter painter( &bm );
+        QPen pen = d_picker->rubberBandPen();
+        pen.setColor( Qt::color1 );
+        painter.setPen( pen );
+        d_picker->drawRubberBand( &painter );
+        mask = QRegion( bm );
+    }
+    if ( d_type == Text )
+    {
+        d_hasTextMask = parentWidget()->testAttribute( Qt::WA_PaintOnScreen );
+        if ( d_hasTextMask )
+        {
+            const QwtText label = d_picker->trackerText(
+                d_picker->trackerPosition() );
+            if ( label.testPaintAttribute( QwtText::PaintBackground )
+                && label.backgroundBrush().style() != Qt::NoBrush )
+            {
+                if ( label.backgroundBrush().color().alpha() > 0 )
+                {
+                    // We don't need a text mask, when we have a background
+                    d_hasTextMask = false;
+                }
+            }
+        }
+        if ( d_hasTextMask )
+        {
+            QBitmap bm( width(), height() );
+            bm.fill( Qt::color0 );
+            QPainter painter( &bm );
+            painter.setFont( font() );
+            QPen pen = d_picker->trackerPen();
+            pen.setColor( Qt::color1 );
+            painter.setPen( pen );
+            d_picker->drawTracker( &painter );
+            mask = QRegion( bm );
+        }
+        else
+        {
+            mask = d_picker->trackerRect( font() );
+        }
+    }
+    QWidget *w = parentWidget();
+    if ( w && !w->testAttribute( Qt::WA_PaintOnScreen ) )
+    {
+        // The parent widget gets an update for its complete rectangle
+        // when the mask is changed in visible state.
+        // With this hide/show we only get an update for the
+        // previous mask.
+        hide();
+    }
+    setMask( mask );
+    setVisible( !mask.isEmpty() );
+}
+void QwtPicker::PickerWidget::paintEvent( QPaintEvent *e )
+{
+    QPainter painter( this );
+    painter.setClipRegion( e->region() );
+    if ( d_type == RubberBand )
+    {
+        painter.setPen( d_picker->rubberBandPen() );
+        d_picker->drawRubberBand( &painter );
+    }
+    if ( d_type == Text )
+    {
+        /*
+           If we have a text mask we simply fill the region of
+           the mask. This gives better results for antialiased fonts.
+         */
+        if ( d_hasTextMask )
+        {
+            painter.fillRect( e->rect(),
+                QBrush( d_picker->trackerPen().color() ) );
+        }
+        else
+        {
+            painter.setPen( d_picker->trackerPen() );
+            d_picker->drawTracker( &painter );
+        }
+    }
+QwtPickerRubberband::QwtPickerRubberband(
+        QwtPicker *picker, QWidget *parent ):
+    QwtWidgetOverlay( parent ),
+    d_picker( picker )
+{
+    setMaskMode( QwtWidgetOverlay::MaskHint );
+}
+QRegion QwtPickerRubberband::maskHint() const
+{
+    return d_picker->rubberBandMask();
+}
+void QwtPickerRubberband::drawOverlay( QPainter *painter ) const
+{
+    painter->setPen( d_picker->rubberBandPen() );
+    d_picker->drawRubberBand( painter );
+}
+QwtPickerTracker::QwtPickerTracker(
+        QwtPicker *picker, QWidget *parent ):
+    QwtWidgetOverlay( parent ),
+    d_picker( picker )
+{
+    setMaskMode( QwtWidgetOverlay::MaskHint );
+}
+QRegion QwtPickerTracker::maskHint() const
+{
+    return d_picker->trackerRect( font() );
+}
+void QwtPickerTracker::drawOverlay( QPainter *painter ) const
+{
+    painter->setPen( d_picker->trackerPen() );
+    d_picker->drawTracker( painter );
+}
 …
   Creates an picker that is enabled, but without a state machine.
   rubberband and tracker are disabled.
+  rubber band and tracker are disabled.
   \param parent Parent widget, that will be observed
 …
   Constructor
   \param rubberBand Rubberband style
+  \param rubberBand Rubber band style
   \param trackerMode Tracker mode
   \param parent Parent widget, that will be observed
 …
+{
     setMouseTracking( false );
     delete d_data->stateMachine;
+    delete d_data->rubberBandWidget;
+    delete d_data->trackerWidget;
+    delete d_data->rubberBandOverlay;
+    delete d_data->trackerOverlay;
     delete d_data;
+}
 //! Init the picker, used by the constructors
+//! Initialize the picker - used by the constructors
 void QwtPicker::init( QWidget *parent,
     RubberBand rubberBand, DisplayMode trackerMode )
 …
     d_data = new PrivateData;
-    d_data->rubberBandWidget = NULL;
-    d_data->trackerWidget = NULL;
     d_data->rubberBand = rubberBand;
-    d_data->enabled = false;
-    d_data->resizeMode = Stretch;
-    d_data->trackerMode = AlwaysOff;
-    d_data->isActive = false;
-    d_data->trackerPosition = QPoint( -1, -1 );
-    d_data->mouseTracking = false;
-    d_data->stateMachine = NULL;
     if ( parent )
 …
             parent->setFocusPolicy( Qt::WheelFocus );
+        d_data->openGL = parent->inherits( "QGLWidget" );
         d_data->trackerFont = parent->font();
         d_data->mouseTracking = parent->hasMouseTracking();
         setEnabled( true );
+    }
     setTrackerMode( trackerMode );
+}
 …
 /*!
   Set the rubberband style
   \param rubberBand Rubberband style
+  Set the rubber band style
+  \param rubberBand Rubber band style
          The default value is NoRubberBand.
 …
 /*!
   \return Rubberband style
+  \return Rubber band style
   \sa setRubberBand(), RubberBand, rubberBandPen()
 */
 …
   Set the pen for the rubberband
   \param pen Rubberband pen
+  \param pen Rubber band pen
   \sa rubberBandPen(), setRubberBand()
 */
 …
 /*!
   \return Rubberband pen
+  \return Rubber band pen
   \sa setRubberBandPen(), rubberBand()
 */
 …
 /*!
    Draw a rubberband, depending on rubberBand()
    \param painter Painter, initialized with clip rect
    \sa rubberBand(), RubberBand
+*/
+void QwtPicker::drawRubberBand( QPainter *painter ) const
+{
+  Calculate the mask for the rubber band overlay
+  \return Region for the mask
+  \sa QWidget::setMask()
+ */
+QRegion QwtPicker::rubberBandMask() const
+{
+    QRegion mask;
     if ( !isActive() || rubberBand() == NoRubberBand ||
         rubberBandPen().style() == Qt::NoPen )
+    {
+        return;
+    }
+    const QRect &pRect = pickRect();
+        return mask;
+    }
     const QPolygon pa = adjustedPoints( d_data->pickedPoints );
 …
+        {
             if ( pa.count() < 1 )
+                return mask;
+            const QPoint pos = pa[0];
+            const int pw = rubberBandPen().width();
+            const QRect pRect = pickArea().boundingRect().toRect();
+            switch ( rubberBand() )
+            {
+                case VLineRubberBand:
+                {
+                    mask += qwtMaskRegion( QLine( pos.x(), pRect.top(),
+                        pos.x(), pRect.bottom() ), pw );
+                    break;
+                }
+                case HLineRubberBand:
+                {
+                    mask += qwtMaskRegion( QLine( pRect.left(), pos.y(),
+                        pRect.right(), pos.y() ), pw );
+                    break;
+                }
+                case CrossRubberBand:
+                {
+                    mask += qwtMaskRegion( QLine( pos.x(), pRect.top(),
+                        pos.x(), pRect.bottom() ), pw );
+                    mask += qwtMaskRegion( QLine( pRect.left(), pos.y(),
+                        pRect.right(), pos.y() ), pw );
+                    break;
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        case QwtPickerMachine::RectSelection:
+        {
+            if ( pa.count() < 2 )
+                return mask;
+            const int pw = rubberBandPen().width();
+            switch ( rubberBand() )
+            {
+                case RectRubberBand:
+                {
+                    const QRect r = QRect( pa.first(), pa.last() );
+                    mask = qwtMaskRegion( r.normalized(), pw );
+                    break;
+                }
+                case EllipseRubberBand:
+                {
+                    const QRect r = QRect( pa.first(), pa.last() );
+                    mask += r.adjusted( -pw, -pw, pw, pw );
+                    break;
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        case QwtPickerMachine::PolygonSelection:
+        {
+            const int pw = rubberBandPen().width();
+            if ( pw <= 1 )
+            {
+                // because of the join style we better
+                // return a mask for a pen width <= 1 only
+                const int off = 2 * pw;
+                const QRect r = pa.boundingRect();
+                mask += r.adjusted( -off, -off, off, off );
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return mask;
+}
+/*!
+   Draw a rubber band, depending on rubberBand()
+   \param painter Painter, initialized with a clip region
+   \sa rubberBand(), RubberBand
+*/
+void QwtPicker::drawRubberBand( QPainter *painter ) const
+{
+    if ( !isActive() || rubberBand() == NoRubberBand ||
+        rubberBandPen().style() == Qt::NoPen )
+    {
+        return;
+    }
+    const QPolygon pa = adjustedPoints( d_data->pickedPoints );
+    QwtPickerMachine::SelectionType selectionType =
+        QwtPickerMachine::NoSelection;
+    if ( d_data->stateMachine )
+        selectionType = d_data->stateMachine->selectionType();
+    switch ( selectionType )
+    {
+        case QwtPickerMachine::NoSelection:
+        case QwtPickerMachine::PointSelection:
+        {
+            if ( pa.count() < 1 )
                 return;
             const QPoint pos = pa[0];
+            const QRect pRect = pickArea().boundingRect().toRect();
             switch ( rubberBand() )
+            {
                 case VLineRubberBand:
+                {
                     QwtPainter::drawLine( painter, pos.x(),
                         pRect.top(), pos.x(), pRect.bottom() );
                     break;
+                }
                 case HLineRubberBand:
+                {
                     QwtPainter::drawLine( painter, pRect.left(),
                         pos.y(), pRect.right(), pos.y() );
                     break;
+                }
                 case CrossRubberBand:
+                {
                     QwtPainter::drawLine( painter, pos.x(),
                         pRect.top(), pos.x(), pRect.bottom() );
 …
                         pos.y(), pRect.right(), pos.y() );
                     break;
+                }
                 default:
                     break;
 …
                 return;
+            const QPoint p1 = pa[0];
+            const QPoint p2 = pa[int( pa.count() - 1 )];
+            const QRect rect = QRect( p1, p2 ).normalized();
+            const QRect rect = QRect( pa.first(), pa.last() ).normalized();
             switch ( rubberBand() )
+            {
                 case EllipseRubberBand:
+                {
                     QwtPainter::drawEllipse( painter, rect );
                     break;
+                }
                 case RectRubberBand:
+                {
                     QwtPainter::drawRect( painter, rect );
                     break;
+                }
                 default:
                     break;
 …
     return adjusted;
 }\endverbatim\n
+  \param points Selected points
+  \return Selected points unmodified
 */
 QPolygon QwtPicker::adjustedPoints( const QPolygon &points ) const
 …
     textRect.moveTopLeft( QPoint( x, y ) );
+    int right = qMin( textRect.right(), pickRect().right() - margin );
+    int bottom = qMin( textRect.bottom(), pickRect().bottom() - margin );
+    const QRect pickRect = pickArea().boundingRect().toRect();
+    int right = qMin( textRect.right(), pickRect.right() - margin );
+    int bottom = qMin( textRect.bottom(), pickRect.bottom() - margin );
     textRect.moveBottomRight( QPoint( right, bottom ) );
     int left = qMax( textRect.left(), pickRect().left() + margin );
     int top = qMax( textRect.top(), pickRect().top() + margin );
+    int left = qMax( textRect.left(), pickRect.left() + margin );
+    int top = qMax( textRect.top(), pickRect.top() + margin );
     textRect.moveTopLeft( QPoint( left, top ) );
 …
   \brief Event filter
   When isEnabled() == true all events of the observed widget are filtered.
+  When isEnabled() is true all events of the observed widget are filtered.
   Mouse and keyboard events are translated into widgetMouse- and widgetKey-
   and widgetWheel-events. Paint and Resize events are handled to keep
   rubberband and tracker up to date.
+  rubber band and tracker up to date.
   \param object Object to be filtered
   \param event Event
+  \return Always false.
   \sa widgetEnterEvent(), widgetLeaveEvent(),
 …
             case QEvent::Resize:
+            {
+                const QResizeEvent *re = ( QResizeEvent * )event;
+                const QResizeEvent *re = static_cast<QResizeEvent *>( event );
+                /*
+                   Adding/deleting additional event filters inside of an event filter
+                   is not safe dues to the implementation in Qt ( changing alist while iterating ).
+                   So we create the overlays in a way, that they don't install en event filter
+                   ( parent set to NULL ) and do the resizing here.
+                 */
+                if ( d_data->trackerOverlay )
+                    d_data->trackerOverlay->resize( re->size() );
+                if ( d_data->rubberBandOverlay )
+                    d_data->rubberBandOverlay->resize( re->size() );
                 if ( d_data->resizeMode == Stretch )
                     stretchSelection( re->oldSize(), re->size() );
+                if ( d_data->rubberBandWidget )
+                    d_data->rubberBandWidget->resize( re->size() );
+                if ( d_data->trackerWidget )
+                    d_data->trackerWidget->resize( re->size() );
+                updateDisplay();
                 break;
+            }
             case QEvent::Enter:
+            {
                 widgetEnterEvent( event );
                 break;
+            }
             case QEvent::Leave:
+            {
                 widgetLeaveEvent( event );
                 break;
+            }
             case QEvent::MouseButtonPress:
+                widgetMousePressEvent( ( QMouseEvent * )event );
+            {
+                widgetMousePressEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::MouseButtonRelease:
+                widgetMouseReleaseEvent( ( QMouseEvent * )event );
+            {
+                widgetMouseReleaseEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::MouseButtonDblClick:
+                widgetMouseDoubleClickEvent( ( QMouseEvent * )event );
+            {
+                widgetMouseDoubleClickEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::MouseMove:
+                widgetMouseMoveEvent( ( QMouseEvent * )event );
+            {
+                widgetMouseMoveEvent( static_cast<QMouseEvent *>( event ) );
                 break;
+            }
             case QEvent::KeyPress:
+                widgetKeyPressEvent( ( QKeyEvent * )event );
+            {
+                widgetKeyPressEvent( static_cast<QKeyEvent *>( event ) );
                 break;
+            }
             case QEvent::KeyRelease:
+                widgetKeyReleaseEvent( ( QKeyEvent * )event );
+            {
+                widgetKeyReleaseEvent( static_cast<QKeyEvent *>( event ) );
                 break;
+            }
             case QEvent::Wheel:
+                widgetWheelEvent( ( QWheelEvent * )event );
+            {
+                widgetWheelEvent( static_cast<QWheelEvent *>( event ) );
                 break;
+            }
             default:
                 break;
 …
 void QwtPicker::widgetMouseMoveEvent( QMouseEvent *mouseEvent )
+{
     if ( pickRect().contains( mouseEvent->pos() ) )
+    if ( pickArea().contains( mouseEvent->pos() ) )
         d_data->trackerPosition = mouseEvent->pos();
     else
 …
 /*!
   Handle a mouse relase event for the observed widget.
+  Handle a mouse release event for the observed widget.
   \param mouseEvent Mouse event
 …
 void QwtPicker::widgetWheelEvent( QWheelEvent *wheelEvent )
+{
     if ( pickRect().contains( wheelEvent->pos() ) )
+    if ( pickArea().contains( wheelEvent->pos() ) )
         d_data->trackerPosition = wheelEvent->pos();
     else
 …
     if ( dx != 0 || dy != 0 )
+    {
         const QRect rect = pickRect();
+        const QRect rect = pickArea().boundingRect().toRect();
         const QPoint pos = parentWidget()->mapFromGlobal( QCursor::pos() );
 …
   Passes an event to the state machine and executes the resulting
   commands. Append and Move commands use the current position
   of the cursor (QCursor::pos()).
+  of the cursor ( QCursor::pos() ).
   \param event Event
 …
 /*!
    Reset the state machine and terminate (end(false)) the selection
+   Reset the state machine and terminate ( end(false) ) the selection
 */
 void QwtPicker::reset()
 …
 /*!
   Append a point to the selection and update rubberband and tracker.
+  Append a point to the selection and update rubber band and tracker.
   The appended() signal is emitted.
 …
 /*!
   \brief Validate and fixup the selection
+  \brief Validate and fix up the selection
   Accepts all selections unmodified
   \param selection Selection to validate and fixup
+  \param selection Selection to validate and fix up
   \return true, when accepted, false otherwise
 */
 …
   \return parentWidget()->contentsRect()
 */
+QRect QwtPicker::pickRect() const
+{
+QPainterPath QwtPicker::pickArea() const
+{
+    QPainterPath path;
     const QWidget *widget = parentWidget();
     if ( widget )
         return widget->contentsRect();
     return QRect();
+}
 //! Update the state of rubberband and tracker label
+        path.addRect( widget->contentsRect() );
+    return path;
+}
+//! Update the state of rubber band and tracker label
 void QwtPicker::updateDisplay()
+{
 …
     bool showRubberband = false;
     bool showTracker = false;
     if ( w && w->isVisible() && d_data->enabled )
+    {
 …
             ( trackerMode() == ActiveOnly && isActive() ) )
+        {
+            if ( trackerPen() != Qt::NoPen )
+            if ( trackerPen() != Qt::NoPen
+                && !trackerRect( QFont() ).isEmpty() )
+            {
                 showTracker = true;
+        }
+    }
+    QPointer<PickerWidget> &rw = d_data->rubberBandWidget;
+            }
+        }
+    }
+    QPointer< QwtPickerRubberband > &rw = d_data->rubberBandOverlay;
     if ( showRubberband )
+    {
         if ( rw.isNull() )
+        {
+            rw = new PickerWidget( this, w, PickerWidget::RubberBand );
+            rw = new QwtPickerRubberband( this, NULL ); // NULL -> no extra event filter
+            rw->setObjectName( "PickerRubberBand" );
+            rw->setParent( w );
             rw->resize( w->size() );
+        }
+        rw->updateMask();
+        rw->update(); // Needed, when the mask doesn't change
+        if ( d_data->rubberBand <= RectRubberBand )
+            rw->setMaskMode( QwtWidgetOverlay::MaskHint );
+        else
+            rw->setMaskMode( QwtWidgetOverlay::AlphaMask );
+        rw->updateOverlay();
+    }
     else
+        delete rw;
+    QPointer<PickerWidget> &tw = d_data->trackerWidget;
+    {
+        if ( d_data->openGL )
+        {
+            // Qt 4.8 crashes for a delete
+            if ( !rw.isNull() )
+            {
+                rw->hide();
+                rw->deleteLater();
+                rw = NULL;
+            }
+        }
+        else
+        {
+            delete rw;
+        }
+    }
+    QPointer< QwtPickerTracker > &tw = d_data->trackerOverlay;
     if ( showTracker )
+    {
         if ( tw.isNull() )
+        {
+            tw = new PickerWidget( this, w, PickerWidget::Text );
+            tw = new QwtPickerTracker( this, NULL ); // NULL -> no extra event filter
+            tw->setObjectName( "PickerTracker" );
+            tw->setParent( w );
             tw->resize( w->size() );
+        }
         tw->setFont( d_data->trackerFont );
+        tw->updateMask();
+        tw->update(); // Needed, when the mask doesn't change
+        tw->updateOverlay();
+    }
     else
+        delete tw;
+}
+//! \return Widget displaying the rubberband
+const QWidget *QwtPicker::rubberBandWidget() const
+{
+    return d_data->rubberBandWidget;
+}
+//! \return Widget displaying the tracker text
+const QWidget *QwtPicker::trackerWidget() const
+{
+    return d_data->trackerWidget;
+}
+    {
+        if ( d_data->openGL )
+        {
+            // Qt 4.8 crashes for a delete
+            if ( !tw.isNull() )
+            {
+                tw->hide();
+                tw->deleteLater();
+                tw = NULL;
+            }
+        }
+        else
+        {
+            delete tw;
+        }
+    }
+}
+//! \return Overlay displaying the rubber band
+const QwtWidgetOverlay *QwtPicker::rubberBandOverlay() const
+{
+    return d_data->rubberBandOverlay;
+}
+//! \return Overlay displaying the tracker text
+const QwtWidgetOverlay *QwtPicker::trackerOverlay() const
+{
+    return d_data->trackerOverlay;
+}

trunk/BNC/qwt/qwt_picker.h

-              r4271
+              r8127
 #include <qfont.h>
 #include <qrect.h>
+#include <qpainterpath.h>
 class QWidget;
 …
 class QKeyEvent;
 class QwtPickerMachine;
+class QwtWidgetOverlay;
 /*!
 …
   QwtPicker translates the picked points into a selection using the
   adjustedPoints method. adjustedPoints is intended to be reimplemented
   to fixup the selection according to application specific requirements.
+  adjustedPoints() method. adjustedPoints() is intended to be reimplemented
+  to fix up the selection according to application specific requirements.
   (F.e. when an application accepts rectangles of a fixed aspect ratio only.)
   Optionally QwtPicker support the process of collecting points by a
   rubberband and tracker displaying a text for the current mouse
+  rubber band and tracker displaying a text for the current mouse
   position.
 …
   The picker is active (isActive()), between begin() and end().
   In active state the rubberband is displayed, and the tracker is visible
+  In active state the rubber band is displayed, and the tracker is visible
   in case of trackerMode is ActiveOnly or AlwaysOn.
 …
     Q_OBJECT
+    Q_ENUMS( RubberBand )
+    Q_ENUMS( DisplayMode )
+    Q_ENUMS( ResizeMode )
+    Q_ENUMS( RubberBand DisplayMode ResizeMode )
     Q_PROPERTY( bool isEnabled READ isEnabled WRITE setEnabled )
 …
 public:
     /*!
       Rubberband style
+      Rubber band style
       The default value is QwtPicker::NoRubberBand.
 …
         NoRubberBand = 0,
         //! A horizontal line ( only for QwtPicker::PointSelection )
+        //! A horizontal line ( only for QwtPickerMachine::PointSelection )
         HLineRubberBand,
         //! A vertical line ( only for QwtPicker::PointSelection )
+        //! A vertical line ( only for QwtPickerMachine::PointSelection )
         VLineRubberBand,
         //! A crosshair ( only for QwtPicker::PointSelection )
+        //! A crosshair ( only for QwtPickerMachine::PointSelection )
         CrossRubberBand,
         //! A rectangle ( only for QwtPicker::RectSelection )
+        //! A rectangle ( only for QwtPickerMachine::RectSelection )
         RectRubberBand,
         //! An ellipse ( only for QwtPicker::RectSelection )
+        //! An ellipse ( only for QwtPickerMachine::RectSelection )
         EllipseRubberBand,
         //! A polygon ( only for QwtPicker::&PolygonSelection )
+        //! A polygon ( only for QwtPickerMachine::PolygonSelection )
         PolygonRubberBand,
 …
     const QWidget *parentWidget() const;
     virtual QRect pickRect() const;
+    virtual QPainterPath pickArea() const;
     virtual void drawRubberBand( QPainter * ) const;
     virtual void drawTracker( QPainter * ) const;
+    virtual QRegion rubberBandMask() const;
     virtual QwtText trackerText( const QPoint &pos ) const;
 …
       selection has been removed.
+      \param pos Position of the point, that has been removed
       \sa remove(), appended()
     */
 …
     virtual void updateDisplay();
     const QWidget *rubberBandWidget() const;
     const QWidget *trackerWidget() const;
+    const QwtWidgetOverlay *rubberBandOverlay() const;
+    const QwtWidgetOverlay *trackerOverlay() const;
     const QPolygon &pickedPoints() const;
 …
     void setMouseTracking( bool );
-    class PickerWidget;
     class PrivateData;
     PrivateData *d_data;

trunk/BNC/qwt/qwt_picker_machine.cpp

-              r4271
+              r8127
 //! Transition
 QList<QwtPickerMachine::Command> QwtPickerClickPointMachine::transition(
     const QwtEventPattern &eventPattern, const QEvent *e )
+{
     QList<QwtPickerMachine::Command> cmdList;
     switch ( e->type() )
+    const QwtEventPattern &eventPattern, const QEvent *event )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch ( event->type() )
+    {
         case QEvent::MouseButtonPress:
+        {
             if ( eventPattern.mouseMatch(
                 QwtEventPattern::MouseSelect1, ( const QMouseEvent * )e ) )
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
                 cmdList += Begin;
 …
         case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch(
+                QwtEventPattern::KeySelect1, ( const QKeyEvent * )e ) )
+            {
+                cmdList += Begin;
+                cmdList += Append;
+                cmdList += End;
+            const QKeyEvent *keyEvent = static_cast<const QKeyEvent *> ( event );
+            if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1, keyEvent ) )
+            {
+                if ( !keyEvent->isAutoRepeat() )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += End;
+                }
+            }
             break;
 …
 //! Transition
 QList<QwtPickerMachine::Command> QwtPickerDragPointMachine::transition(
     const QwtEventPattern &eventPattern, const QEvent *e )
+{
     QList<QwtPickerMachine::Command> cmdList;
     switch ( e->type() )
+    const QwtEventPattern &eventPattern, const QEvent *event )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch ( event->type() )
+    {
         case QEvent::MouseButtonPress:
+        {
             if ( eventPattern.mouseMatch(
                 QwtEventPattern::MouseSelect1, ( const QMouseEvent * )e ) )
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
                 if ( state() == 0 )
 …
         case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch(
+                QwtEventPattern::KeySelect1, ( const QKeyEvent * )e ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    setState( 1 );
+                }
+                else
+                {
+                    cmdList += End;
+                    setState( 0 );
+            const QKeyEvent *keyEvent = static_cast<const QKeyEvent *> ( event );
+            if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1, keyEvent ) )
+            {
+                if ( !keyEvent->isAutoRepeat() )
+                {
+                    if ( state() == 0 )
+                    {
+                        cmdList += Begin;
+                        cmdList += Append;
+                        setState( 1 );
+                    }
+                    else
+                    {
+                        cmdList += End;
+                        setState( 0 );
+                    }
+                }
+            }
 …
 //! Transition
 QList<QwtPickerMachine::Command> QwtPickerClickRectMachine::transition(
     const QwtEventPattern &eventPattern, const QEvent *e )
+{
     QList<QwtPickerMachine::Command> cmdList;
     switch ( e->type() )
+    const QwtEventPattern &eventPattern, const QEvent *event )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch ( event->type() )
+    {
         case QEvent::MouseButtonPress:
+        {
             if ( eventPattern.mouseMatch(
                 QwtEventPattern::MouseSelect1, ( const QMouseEvent * )e ) )
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
                 switch ( state() )
 …
+                }
+            }
+            break;
+        }
         case QEvent::MouseMove:
 …
         case QEvent::MouseButtonRelease:
+        {
             if ( eventPattern.mouseMatch(
                 QwtEventPattern::MouseSelect1, ( const QMouseEvent * )e ) )
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
                 if ( state() == 1 )
 …
         case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch(
+                QwtEventPattern::KeySelect1, ( const QKeyEvent * )e ) )
+            const QKeyEvent *keyEvent = static_cast<const QKeyEvent *> ( event );
+            if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1, keyEvent ) )
+            {
+                if ( !keyEvent->isAutoRepeat() )
+                {
+                    if ( state() == 0 )
+                    {
+                        cmdList += Begin;
+                        cmdList += Append;
+                        setState( 1 );
+                    }
+                    else
+                    {
+                        if ( state() == 1 )
+                        {
+                            cmdList += Append;
+                            setState( 2 );
+                        }
+                        else if ( state() == 2 )
+                        {
+                            cmdList += End;
+                            setState( 0 );
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return cmdList;
+}
+//! Constructor
+QwtPickerDragRectMachine::QwtPickerDragRectMachine():
+    QwtPickerMachine( RectSelection )
+{
+}
+//! Transition
+QList<QwtPickerMachine::Command> QwtPickerDragRectMachine::transition(
+    const QwtEventPattern &eventPattern, const QEvent *event )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch ( event->type() )
+    {
+        case QEvent::MouseButtonPress:
+        {
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
                 if ( state() == 0 )
 …
                     cmdList += Begin;
                     cmdList += Append;
+                    cmdList += Append;
+                    setState( 2 );
+                }
+            }
+            break;
+        }
+        case QEvent::MouseMove:
+        case QEvent::Wheel:
+        {
+            if ( state() != 0 )
+                cmdList += Move;
+            break;
+        }
+        case QEvent::MouseButtonRelease:
+        {
+            if ( state() == 2 )
+            {
+                cmdList += End;
+                setState( 0 );
+            }
+            break;
+        }
+        case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1,
+                static_cast<const QKeyEvent *> ( event ) ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += Append;
+                    setState( 2 );
+                }
+                else
+                {
+                    cmdList += End;
+                    setState( 0 );
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return cmdList;
+}
+//! Constructor
+QwtPickerPolygonMachine::QwtPickerPolygonMachine():
+    QwtPickerMachine( PolygonSelection )
+{
+}
+//! Transition
+QList<QwtPickerMachine::Command> QwtPickerPolygonMachine::transition(
+    const QwtEventPattern &eventPattern, const QEvent *event )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch ( event->type() )
+    {
+        case QEvent::MouseButtonPress:
+        {
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += Append;
                     setState( 1 );
+                }
                 else
+                {
+                    cmdList += Append;
+                }
+            }
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect2,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
+                if ( state() == 1 )
+                {
+                    cmdList += End;
+                    setState( 0 );
+                }
+            }
+            break;
+        }
+        case QEvent::MouseMove:
+        case QEvent::Wheel:
+        {
+            if ( state() != 0 )
+                cmdList += Move;
+            break;
+        }
+        case QEvent::KeyPress:
+        {
+            const QKeyEvent *keyEvent = static_cast<const QKeyEvent *> ( event );
+            if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1, keyEvent ) )
+            {
+                if ( !keyEvent->isAutoRepeat() )
+                {
+                    if ( state() == 0 )
+                    {
+                        cmdList += Begin;
+                        cmdList += Append;
+                        cmdList += Append;
+                        setState( 1 );
+                    }
+                    else
+                    {
+                        cmdList += Append;
+                    }
+                }
+            }
+            else if ( eventPattern.keyMatch( QwtEventPattern::KeySelect2, keyEvent ) )
+            {
+                if ( !keyEvent->isAutoRepeat() )
+                {
                     if ( state() == 1 )
+                    {
-                        cmdList += Append;
-                        setState( 2 );
+                    }
-                    else if ( state() == 2 )
+                    {
                         cmdList += End;
 …
 //! Constructor
 QwtPickerDragRectMachine::QwtPickerDragRectMachine():
     QwtPickerMachine( RectSelection )
+{
+}
 //! Transition
 QList<QwtPickerMachine::Command> QwtPickerDragRectMachine::transition(
     const QwtEventPattern &eventPattern, const QEvent *e )
+{
     QList<QwtPickerMachine::Command> cmdList;
     switch ( e->type() )
+QwtPickerDragLineMachine::QwtPickerDragLineMachine():
+    QwtPickerMachine( PolygonSelection )
+{
+}
+//! Transition
+QList<QwtPickerMachine::Command> QwtPickerDragLineMachine::transition(
+    const QwtEventPattern &eventPattern, const QEvent *event )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch( event->type() )
+    {
         case QEvent::MouseButtonPress:
+        {
             if ( eventPattern.mouseMatch(
                 QwtEventPattern::MouseSelect1, ( const QMouseEvent * )e ) )
+            if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
+                static_cast<const QMouseEvent *>( event ) ) )
+            {
                 if ( state() == 0 )
 …
                     cmdList += Append;
                     cmdList += Append;
+                    setState( 2 );
+                    setState( 1 );
+                }
+            }
+            break;
+        }
+        case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1,
+                static_cast<const QKeyEvent *> ( event ) ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += Append;
+                    setState( 1 );
+                }
+                else
+                {
+                    cmdList += End;
+                    setState( 0 );
+                }
+            }
 …
             if ( state() != 0 )
                 cmdList += Move;
             break;
+        }
         case QEvent::MouseButtonRelease:
+        {
             if ( state() == 2 )
+            if ( state() != 0 )
+            {
                 cmdList += End;
                 setState( 0 );
+            }
+            break;
+        }
+        case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch(
+                QwtEventPattern::KeySelect1, ( const QKeyEvent * )e ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += Append;
+                    setState( 2 );
+                }
+                else
+                {
+                    cmdList += End;
+                    setState( 0 );
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return cmdList;
+}
+//! Constructor
+QwtPickerPolygonMachine::QwtPickerPolygonMachine():
+    QwtPickerMachine( PolygonSelection )
+{
+}
+//! Transition
+QList<QwtPickerMachine::Command> QwtPickerPolygonMachine::transition(
+    const QwtEventPattern &eventPattern, const QEvent *e )
+{
+    QList<QwtPickerMachine::Command> cmdList;
+    switch ( e->type() )
+    {
+        case QEvent::MouseButtonPress:
+        {
+            if ( eventPattern.mouseMatch(
+                QwtEventPattern::MouseSelect1, ( const QMouseEvent * )e ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += Append;
+                    setState( 1 );
+                }
+                else
+                {
+                    cmdList += End;
+                    setState( 0 );
+                }
+            }
+            if ( eventPattern.mouseMatch(
+                QwtEventPattern::MouseSelect2, ( const QMouseEvent * )e ) )
+            {
+                if ( state() == 1 )
+                    cmdList += Append;
+            }
+            break;
+        }
+        case QEvent::MouseMove:
+        case QEvent::Wheel:
+        {
+            if ( state() != 0 )
+                cmdList += Move;
+            break;
+        }
+        case QEvent::KeyPress:
+        {
+            if ( eventPattern.keyMatch(
+                QwtEventPattern::KeySelect1, ( const QKeyEvent * )e ) )
+            {
+                if ( state() == 0 )
+                {
+                    cmdList += Begin;
+                    cmdList += Append;
+                    cmdList += Append;
+                    setState( 1 );
+                }
+                else
+                {
+                    cmdList += End;
+                    setState( 0 );
+                }
+            }
+            else if ( eventPattern.keyMatch(
+                QwtEventPattern::KeySelect2, ( const QKeyEvent * )e ) )
+            {
+                if ( state() == 1 )
+                    cmdList += Append;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return cmdList;
+}
+        }
+        default:
+            break;
+    }
+    return cmdList;
+}

trunk/BNC/qwt/qwt_picker_machine.h

-              r4271
+              r8127
 /*!
+  \brief A state machine for line selections
+  Pressing QwtEventPattern::MouseSelect1 selects
+  the first point, releasing it the second point.
+  Pressing QwtEventPattern::KeySelect1 also selects the
+  first point, a second press selects the second point and terminates
+  the selection.
+  A common use case of QwtPickerDragLineMachine are pickers for
+  distance measurements.
+  \sa QwtEventPattern::MousePatternCode, QwtEventPattern::KeyPatternCode
+*/
+class QWT_EXPORT QwtPickerDragLineMachine: public QwtPickerMachine
+{
+public:
+    QwtPickerDragLineMachine();
+    virtual QList<Command> transition(
+        const QwtEventPattern &, const QEvent * );
+};
+/*!
   \brief A state machine for polygon selections

trunk/BNC/qwt/qwt_plot.cpp

-              r4271
+              r8127
 #include "qwt_text_label.h"
 #include "qwt_legend.h"
 #include "qwt_dyngrid_layout.h"
+#include "qwt_legend_data.h"
 #include "qwt_plot_canvas.h"
+#include <qmath.h>
 #include <qpainter.h>
 #include <qpointer.h>
 …
 #include <qevent.h>
+static inline void qwtEnableLegendItems( QwtPlot *plot, bool on )
+{
+    if ( on )
+    {
+        QObject::connect(
+            plot, SIGNAL( legendDataChanged(
+                const QVariant &, const QList<QwtLegendData> & ) ),
+            plot, SLOT( updateLegendItems(
+                const QVariant &, const QList<QwtLegendData> & ) ) );
+    }
+    else
+    {
+        QObject::disconnect(
+            plot, SIGNAL( legendDataChanged(
+                const QVariant &, const QList<QwtLegendData> & ) ),
+            plot, SLOT( updateLegendItems(
+                const QVariant &, const QList<QwtLegendData> & ) ) );
+    }
+}
+static void qwtSetTabOrder(
+    QWidget *first, QWidget *second, bool withChildren )
+{
+    QList<QWidget *> tabChain;
+    tabChain += first;
+    tabChain += second;
+    if ( withChildren )
+    {
+        QList<QWidget *> children = second->findChildren<QWidget *>();
+        QWidget *w = second->nextInFocusChain();
+        while ( children.contains( w ) )
+        {
+            children.removeAll( w );
+            tabChain += w;
+            w = w->nextInFocusChain();
+        }
+    }
+    for ( int i = 0; i < tabChain.size() - 1; i++ )
+    {
+        QWidget *from = tabChain[i];
+        QWidget *to = tabChain[i+1];
+        const Qt::FocusPolicy policy1 = from->focusPolicy();
+        const Qt::FocusPolicy policy2 = to->focusPolicy();
+        QWidget *proxy1 = from->focusProxy();
+        QWidget *proxy2 = to->focusProxy();
+        from->setFocusPolicy( Qt::TabFocus );
+        from->setFocusProxy( NULL);
+        to->setFocusPolicy( Qt::TabFocus );
+        to->setFocusProxy( NULL);
+        QWidget::setTabOrder( from, to );
+        from->setFocusPolicy( policy1 );
+        from->setFocusProxy( proxy1);
+        to->setFocusPolicy( policy2 );
+        to->setFocusProxy( proxy2 );
+    }
+}
 class QwtPlot::PrivateData
+{
 public:
+    QPointer<QwtTextLabel> lblTitle;
+    QPointer<QwtPlotCanvas> canvas;
+    QPointer<QwtLegend> legend;
+    QPointer<QwtTextLabel> titleLabel;
+    QPointer<QwtTextLabel> footerLabel;
+    QPointer<QWidget> canvas;
+    QPointer<QwtAbstractLegend> legend;
     QwtPlotLayout *layout;
 …
 QwtPlot::~QwtPlot()
+{
+    setAutoReplot( false );
     detachItems( QwtPlotItem::Rtti_PlotItem, autoDelete() );
 …
     d_data->autoReplot = false;
     d_data->lblTitle = new QwtTextLabel( title, this );
     d_data->lblTitle->setObjectName( "QwtPlotTitle" );
     d_data->lblTitle->setFont( QFont( fontInfo().family(), 14, QFont::Bold ) );
+    // title
+    d_data->titleLabel = new QwtTextLabel( this );
+    d_data->titleLabel->setObjectName( "QwtPlotTitle" );
+    d_data->titleLabel->setFont( QFont( fontInfo().family(), 14, QFont::Bold ) );
     QwtText text( title );
     text.setRenderFlags( Qt::AlignCenter | Qt::TextWordWrap );
+    d_data->lblTitle->setText( text );
+    d_data->titleLabel->setText( text );
+    // footer
+    d_data->footerLabel = new QwtTextLabel( this );
+    d_data->footerLabel->setObjectName( "QwtPlotFooter" );
+    QwtText footer;
+    footer.setRenderFlags( Qt::AlignCenter | Qt::TextWordWrap );
+    d_data->footerLabel->setText( footer );
+    // legend
     d_data->legend = NULL;
+    // axis
     initAxesData();
+    // canvas
     d_data->canvas = new QwtPlotCanvas( this );
     d_data->canvas->setObjectName( "QwtPlotCanvas" );
+    d_data->canvas->setFrameStyle( QFrame::Panel | QFrame::Sunken );
+    d_data->canvas->setLineWidth( 2 );
+    updateTabOrder();
+    d_data->canvas->installEventFilter( this );
     setSizePolicy( QSizePolicy::MinimumExpanding,
 …
     resize( 200, 200 );
+    QList<QWidget *> focusChain;
+    focusChain << this << d_data->titleLabel << axisWidget( xTop )
+        << axisWidget( yLeft ) << d_data->canvas << axisWidget( yRight )
+        << axisWidget( xBottom ) << d_data->footerLabel;
+    for ( int i = 0; i < focusChain.size() - 1; i++ )
+        qwtSetTabOrder( focusChain[i], focusChain[i+1], false );
+    qwtEnableLegendItems( this, true );
+}
+/*!
+  \brief Set the drawing canvas of the plot widget
+  QwtPlot invokes methods of the canvas as meta methods ( see QMetaObject ).
+  In opposite to using conventional C++ techniques like virtual methods
+  they allow to use canvas implementations that are derived from
+  QWidget or QGLWidget.
+  The following meta methods could be implemented:
+  - replot()
+    When the canvas doesn't offer a replot method, QwtPlot calls
+    update() instead.
+  - borderPath()
+    The border path is necessary to clip the content of the canvas
+    When the canvas doesn't have any special border ( f.e rounded corners )
+    it is o.k. not to implement this method.
+  The default canvas is a QwtPlotCanvas
+  \param canvas Canvas Widget
+  \sa canvas()
+ */
+void QwtPlot::setCanvas( QWidget *canvas )
+{
+    if ( canvas == d_data->canvas )
+        return;
+    delete d_data->canvas;
+    d_data->canvas = canvas;
+    if ( canvas )
+    {
+        canvas->setParent( this );
+        canvas->installEventFilter( this );
+        if ( isVisible() )
+            canvas->show();
+    }
+}
 …
   \brief Adds handling of layout requests
   \param event Event
+  \return See QFrame::event()
 */
 bool QwtPlot::event( QEvent *event )
 …
+}
+/*!
+  \brief Event filter
+  The plot handles the following events for the canvas:
+  - QEvent::Resize
+    The canvas margins might depend on its size
+  - QEvent::ContentsRectChange
+    The layout needs to be recalculated
+  \param object Object to be filtered
+  \param event Event
+  \return See QFrame::eventFilter()
+  \sa updateCanvasMargins(), updateLayout()
+*/
+bool QwtPlot::eventFilter( QObject *object, QEvent *event )
+{
+    if ( object == d_data->canvas )
+    {
+        if ( event->type() == QEvent::Resize )
+        {
+            updateCanvasMargins();
+        }
+        else if ( event->type() == QEvent::ContentsRectChange )
+        {
+            updateLayout();
+        }
+    }
+    return QFrame::eventFilter( object, event );
+}
 //! Replots the plot if autoReplot() is \c true.
 void QwtPlot::autoRefresh()
 …
 void QwtPlot::setTitle( const QString &title )
+{
     if ( title != d_data->lblTitle->text().text() )
+    {
         d_data->lblTitle->setText( title );
+    if ( title != d_data->titleLabel->text().text() )
+    {
+        d_data->titleLabel->setText( title );
         updateLayout();
+    }
 …
 void QwtPlot::setTitle( const QwtText &title )
+{
     if ( title != d_data->lblTitle->text() )
+    {
         d_data->lblTitle->setText( title );
+    if ( title != d_data->titleLabel->text() )
+    {
+        d_data->titleLabel->setText( title );
         updateLayout();
+    }
+}
 //! \return the plot's title
+//! \return Title of the plot
 QwtText QwtPlot::title() const
+{
+    return d_data->lblTitle->text();
+}
+//! \return the plot's title
+    return d_data->titleLabel->text();
+}
+//! \return Title label widget.
+QwtTextLabel *QwtPlot::titleLabel()
+{
+    return d_data->titleLabel;
+}
+//! \return Title label widget.
+const QwtTextLabel *QwtPlot::titleLabel() const
+{
+    return d_data->titleLabel;
+}
+/*!
+  Change the text the footer
+  \param text New text of the footer
+*/
+void QwtPlot::setFooter( const QString &text )
+{
+    if ( text != d_data->footerLabel->text().text() )
+    {
+        d_data->footerLabel->setText( text );
+        updateLayout();
+    }
+}
+/*!
+  Change the text the footer
+  \param text New text of the footer
+*/
+void QwtPlot::setFooter( const QwtText &text )
+{
+    if ( text != d_data->footerLabel->text() )
+    {
+        d_data->footerLabel->setText( text );
+        updateLayout();
+    }
+}
+//! \return Text of the footer
+QwtText QwtPlot::footer() const
+{
+    return d_data->footerLabel->text();
+}
+//! \return Footer label widget.
+QwtTextLabel *QwtPlot::footerLabel()
+{
+    return d_data->footerLabel;
+}
+//! \return Footer label widget.
+const QwtTextLabel *QwtPlot::footerLabel() const
+{
+    return d_data->footerLabel;
+}
+/*!
+   \brief Assign a new plot layout
+   \param layout Layout()
+   \sa plotLayout()
+ */
+void QwtPlot::setPlotLayout( QwtPlotLayout *layout )
+{
+    if ( layout != d_data->layout )
+    {
+        delete d_data->layout;
+        d_data->layout = layout;
+        updateLayout();
+    }
+}
+//! \return the plot's layout
 QwtPlotLayout *QwtPlot::plotLayout()
+{
 …
+}
 //! \return the plot's titel label.
+//! \return the plot's layout
 const QwtPlotLayout *QwtPlot::plotLayout() const
+{
     return d_data->layout;
+}
-//! \return the plot's titel label.
-QwtTextLabel *QwtPlot::titleLabel()
+{
-    return d_data->lblTitle;
+}
-/*!
-  \return the plot's titel label.
-*/
-const QwtTextLabel *QwtPlot::titleLabel() const
+{
-    return d_data->lblTitle;
+}
 …
   \sa insertLegend()
 */
 QwtLegend *QwtPlot::legend()
+QwtAbstractLegend *QwtPlot::legend()
+{
     return d_data->legend;
 …
   \sa insertLegend()
 */
 const QwtLegend *QwtPlot::legend() const
+const QwtAbstractLegend *QwtPlot::legend() const
+{
     return d_data->legend;
 …
   \return the plot's canvas
 */
 QwtPlotCanvas *QwtPlot::canvas()
+QWidget *QwtPlot::canvas()
+{
     return d_data->canvas;
 …
   \return the plot's canvas
 */
 const QwtPlotCanvas *QwtPlot::canvas() const
+const QWidget *QwtPlot::canvas() const
+{
     return d_data->canvas;
 …
 /*!
   Return sizeHint
+  \return Size hint for the plot widget
   \sa minimumSizeHint()
 */
 QSize QwtPlot::sizeHint() const
+{
 …
   be refreshed explicitly in order to make changes visible.
+  \sa setAutoReplot()
+  \warning Calls canvas()->repaint, take care of infinite recursions
+  \sa updateAxes(), setAutoReplot()
 */
 void QwtPlot::replot()
 …
     QApplication::sendPostedEvents( this, QEvent::LayoutRequest );
+    d_data->canvas->replot();
+    if ( d_data->canvas )
+    {
+        const bool ok = QMetaObject::invokeMethod(
+            d_data->canvas, "replot", Qt::DirectConnection );
+        if ( !ok )
+        {
+            // fallback, when canvas has no a replot method
+            d_data->canvas->update( d_data->canvas->contentsRect() );
+        }
+    }
     setAutoReplot( doAutoReplot );
 …
     QRect titleRect = d_data->layout->titleRect().toRect();
+    QRect footerRect = d_data->layout->footerRect().toRect();
     QRect scaleRect[QwtPlot::axisCnt];
     for ( int axisId = 0; axisId < axisCnt; axisId++ )
 …
     QRect canvasRect = d_data->layout->canvasRect().toRect();
-    //
     // resize and show the visible widgets
+    //
     if ( !d_data->lblTitle->text().isEmpty() )
+    {
         d_data->lblTitle->setGeometry( titleRect );
         if ( !d_data->lblTitle->isVisibleTo( this ) )
             d_data->lblTitle->show();
+    if ( !d_data->titleLabel->text().isEmpty() )
+    {
+        d_data->titleLabel->setGeometry( titleRect );
+        if ( !d_data->titleLabel->isVisibleTo( this ) )
+            d_data->titleLabel->show();
+    }
     else
+        d_data->lblTitle->hide();
+        d_data->titleLabel->hide();
+    if ( !d_data->footerLabel->text().isEmpty() )
+    {
+        d_data->footerLabel->setGeometry( footerRect );
+        if ( !d_data->footerLabel->isVisibleTo( this ) )
+            d_data->footerLabel->show();
+    }
+    else
+    {
+        d_data->footerLabel->hide();
+    }
     for ( int axisId = 0; axisId < axisCnt; axisId++ )
+    {
+        QwtScaleWidget* scaleWidget = axisWidget( axisId );
         if ( axisEnabled( axisId ) )
+        {
+            axisWidget( axisId )->setGeometry( scaleRect[axisId] );
+            if ( scaleRect[axisId] != scaleWidget->geometry() )
+            {
+                scaleWidget->setGeometry( scaleRect[axisId] );
+                int startDist, endDist;
+                scaleWidget->getBorderDistHint( startDist, endDist );
+                scaleWidget->setBorderDist( startDist, endDist );
+            }
+#if 1
             if ( axisId == xBottom || axisId == xTop )
+            {
+                // do we need this code any longer ???
                 QRegion r( scaleRect[axisId] );
                 if ( axisEnabled( yLeft ) )
                     r = r.subtract( QRegion( scaleRect[yLeft] ) );
+                    r = r.subtracted( QRegion( scaleRect[yLeft] ) );
                 if ( axisEnabled( yRight ) )
                     r = r.subtract( QRegion( scaleRect[yRight] ) );
                 r.translate( -d_data->layout->scaleRect( axisId ).x(),
+                    r = r.subtracted( QRegion( scaleRect[yRight] ) );
+                r.translate( -scaleRect[ axisId ].x(),
                     -scaleRect[axisId].y() );
                 axisWidget( axisId )->setMask( r );
+                scaleWidget->setMask( r );
+            }
+            if ( !axisWidget( axisId )->isVisibleTo( this ) )
+                axisWidget( axisId )->show();
+#endif
+            if ( !scaleWidget->isVisibleTo( this ) )
+                scaleWidget->show();
+        }
         else
+            axisWidget( axisId )->hide();
+    }
+    if ( d_data->legend &&
+        d_data->layout->legendPosition() != ExternalLegend )
+    {
+        if ( d_data->legend->itemCount() > 0 )
+        {
+            scaleWidget->hide();
+        }
+    }
+    if ( d_data->legend )
+    {
+        if ( d_data->legend->isEmpty() )
+        {
+            d_data->legend->hide();
+        }
+        else
+        {
             d_data->legend->setGeometry( legendRect );
             d_data->legend->show();
+        }
-        else
-            d_data->legend->hide();
+    }
 …
 /*!
+   Update the focus tab order
+   The order is changed so that the canvas will be in front of the
+   first legend item, or behind the last legend item - depending
+   on the position of the legend.
+*/
+void QwtPlot::updateTabOrder()
+{
+    if ( d_data->canvas->focusPolicy() == Qt::NoFocus )
+        return;
+    if ( d_data->legend.isNull()
+        || d_data->layout->legendPosition() == ExternalLegend
+        || d_data->legend->legendItems().count() == 0 )
+    {
+        return;
+    }
+    // Depending on the position of the legend the
+    // tab order will be changed that the canvas is
+    // next to the last legend item, or before
+    // the first one.
+    const bool canvasFirst =
+        d_data->layout->legendPosition() == QwtPlot::BottomLegend ||
+        d_data->layout->legendPosition() == QwtPlot::RightLegend;
+    QWidget *previous = NULL;
+    QWidget *w = d_data->canvas;
+    while ( ( w = w->nextInFocusChain() ) != d_data->canvas )
+    {
+        bool isLegendItem = false;
+        if ( w->focusPolicy() != Qt::NoFocus
+            && w->parent() && w->parent() == d_data->legend->contentsWidget() )
+        {
+            isLegendItem = true;
+        }
+        if ( canvasFirst )
+        {
+            if ( isLegendItem )
+                break;
+            previous = w;
+        }
+        else
+        {
+            if ( isLegendItem )
+                previous = w;
+            else
+            {
+                if ( previous )
+                    break;
+            }
+        }
+    }
+    if ( previous && previous != d_data->canvas )
+        setTabOrder( previous, d_data->canvas );
+  \brief Calculate the canvas margins
+  \param maps QwtPlot::axisCnt maps, mapping between plot and paint device coordinates
+  \param canvasRect Bounding rectangle where to paint
+  \param left Return parameter for the left margin
+  \param top Return parameter for the top margin
+  \param right Return parameter for the right margin
+  \param bottom Return parameter for the bottom margin
+  Plot items might indicate, that they need some extra space
+  at the borders of the canvas by the QwtPlotItem::Margins flag.
+  updateCanvasMargins(), QwtPlotItem::getCanvasMarginHint()
+ */
+void QwtPlot::getCanvasMarginsHint(
+    const QwtScaleMap maps[], const QRectF &canvasRect,
+    double &left, double &top, double &right, double &bottom) const
+{
+    left = top = right = bottom = -1.0;
+    const QwtPlotItemList& itmList = itemList();
+    for ( QwtPlotItemIterator it = itmList.begin();
+        it != itmList.end(); ++it )
+    {
+        const QwtPlotItem *item = *it;
+        if ( item->testItemAttribute( QwtPlotItem::Margins ) )
+        {
+            double m[ QwtPlot::axisCnt ];
+            item->getCanvasMarginHint(
+                maps[ item->xAxis() ], maps[ item->yAxis() ],
+                canvasRect, m[yLeft], m[xTop], m[yRight], m[xBottom] );
+            left = qMax( left, m[yLeft] );
+            top = qMax( top, m[xTop] );
+            right = qMax( right, m[yRight] );
+            bottom = qMax( bottom, m[xBottom] );
+        }
+    }
+}
+/*!
+  \brief Update the canvas margins
+  Plot items might indicate, that they need some extra space
+  at the borders of the canvas by the QwtPlotItem::Margins flag.
+  getCanvasMarginsHint(), QwtPlotItem::getCanvasMarginHint()
+ */
+void QwtPlot::updateCanvasMargins()
+{
+    QwtScaleMap maps[axisCnt];
+    for ( int axisId = 0; axisId < axisCnt; axisId++ )
+        maps[axisId] = canvasMap( axisId );
+    double margins[axisCnt];
+    getCanvasMarginsHint( maps, canvas()->contentsRect(),
+        margins[yLeft], margins[xTop], margins[yRight], margins[xBottom] );
+    bool doUpdate = false;
+    for ( int axisId = 0; axisId < axisCnt; axisId++ )
+    {
+        if ( margins[axisId] >= 0.0 )
+        {
+            const int m = qCeil( margins[axisId] );
+            plotLayout()->setCanvasMargin( m, axisId);
+            doUpdate = true;
+        }
+    }
+    if ( doUpdate )
+        updateLayout();
+}
 …
 /*!
   Redraw the canvas items.
   \param painter Painter used for drawing
   \param canvasRect Bounding rectangle where to paint
+  \param map QwtPlot::axisCnt maps, mapping between plot and paint device coordinates
+  \param maps QwtPlot::axisCnt maps, mapping between plot and paint device coordinates
+  \note Usually canvasRect is contentsRect() of the plot canvas.
+        Due to a bug in Qt this rectangle might be wrong for certain
+        frame styles ( f.e QFrame::Box ) and it might be necessary to
+        fix the margins manually using QWidget::setContentsMargins()
 */
 void QwtPlot::drawItems( QPainter *painter, const QRectF &canvasRect,
         const QwtScaleMap map[axisCnt] ) const
+        const QwtScaleMap maps[axisCnt] ) const
+{
     const QwtPlotItemList& itmList = itemList();
 …
             painter->setRenderHint( QPainter::Antialiasing,
                 item->testRenderHint( QwtPlotItem::RenderAntialiased ) );
+            painter->setRenderHint( QPainter::HighQualityAntialiasing,
+                item->testRenderHint( QwtPlotItem::RenderAntialiased ) );
             item->draw( painter,
                 map[item->xAxis()], map[item->yAxis()],
+                maps[item->xAxis()], maps[item->yAxis()],
                 canvasRect );
 …
     map.setTransformation( axisScaleEngine( axisId )->transformation() );
     const QwtScaleDiv *sd = axisScaleDiv( axisId );
     map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
+    const QwtScaleDiv &sd = axisScaleDiv( axisId );
+    map.setScaleInterval( sd.lowerBound(), sd.upperBound() );
     if ( axisEnabled( axisId ) )
 …
     else
+    {
-        int margin = 0;
-        if ( !plotLayout()->alignCanvasToScales() )
-            margin = plotLayout()->canvasMargin( axisId );
         const QRect &canvasRect = d_data->canvas->contentsRect();
         if ( axisId == yLeft || axisId == yRight )
+        {
+            map.setPaintInterval( canvasRect.bottom() - margin,
+                canvasRect.top() + margin );
+            int top = 0;
+            if ( !plotLayout()->alignCanvasToScale( xTop ) )
+                top = plotLayout()->canvasMargin( xTop );
+            int bottom = 0;
+            if ( !plotLayout()->alignCanvasToScale( xBottom ) )
+                bottom = plotLayout()->canvasMargin( xBottom );
+            map.setPaintInterval( canvasRect.bottom() - bottom,
+                canvasRect.top() + top );
+        }
         else
+        {
+            map.setPaintInterval( canvasRect.left() + margin,
+                canvasRect.right() - margin );
+        }
+    }
+            int left = 0;
+            if ( !plotLayout()->alignCanvasToScale( yLeft ) )
+                left = plotLayout()->canvasMargin( yLeft );
+            int right = 0;
+            if ( !plotLayout()->alignCanvasToScale( yRight ) )
+                right = plotLayout()->canvasMargin( yRight );
+            map.setPaintInterval( canvasRect.left() + left,
+                canvasRect.right() - right );
+        }
+    }
     return map;
+}
 …
   \brief Change the background of the plotting area
   Sets brush to QPalette::Window of all colorgroups of
+  Sets brush to QPalette::Window of all color groups of
   the palette of the canvas. Using canvas()->setPalette()
   is a more powerful way to set these colors.
 …
+{
     QPalette pal = d_data->canvas->palette();
+    for ( int i = 0; i < QPalette::NColorGroups; i++ )
+        pal.setBrush( ( QPalette::ColorGroup )i, QPalette::Window, brush );
+    pal.setBrush( QPalette::Window, brush );
     canvas()->setPalette( pal );
 …
 /*!
-  \brief Change the border width of the plotting area
-  Nothing else than canvas()->setLineWidth(w),
-  left for compatibility only.
-  \param width New border width
-*/
-void QwtPlot::setCanvasLineWidth( int width )
+{
-    canvas()->setLineWidth( width );
-    updateLayout();
+}
-/*!
-  Nothing else than: canvas()->lineWidth(),
-  left for compatibility only.
-  \return the border width of the plotting area
-*/
-int QwtPlot::canvasLineWidth() const
+{
-    return canvas()->lineWidth();
+}
-/*!
   \return \c true if the specified axis exists, otherwise \c false
   \param axisId axis index
 …
+{
     return ( ( axisId >= QwtPlot::yLeft ) && ( axisId < QwtPlot::axisCnt ) );
+}
-/*!
-  Called internally when the legend has been clicked on.
-  Emits a legendClicked() signal.
-*/
-void QwtPlot::legendItemClicked()
+{
-    if ( d_data->legend && sender()->isWidgetType() )
+    {
-        QwtPlotItem *plotItem =
-            ( QwtPlotItem* )d_data->legend->find( ( QWidget * )sender() );
-        if ( plotItem )
-            Q_EMIT legendClicked( plotItem );
+    }
+}
-/*!
-  Called internally when the legend has been checked
-  Emits a legendClicked() signal.
-*/
-void QwtPlot::legendItemChecked( bool on )
+{
-    if ( d_data->legend && sender()->isWidgetType() )
+    {
-        QwtPlotItem *plotItem =
-            ( QwtPlotItem* )d_data->legend->find( ( QWidget * )sender() );
-        if ( plotItem )
-            Q_EMIT legendChecked( plotItem, on );
+    }
+}
 …
   with a best fit number of columns from left to right.
+  If pos != QwtPlot::ExternalLegend the plot widget will become
+  parent of the legend. It will be deleted when the plot is deleted,
+  or another legend is set with insertLegend().
+  insertLegend() will set the plot widget as parent for the legend.
+  The legend will be deleted in the destructor of the plot or when
+  another legend is inserted.
+  Legends, that are not inserted into the layout of the plot widget
+  need to connect to the legendDataChanged() signal. Calling updateLegend()
+  initiates this signal for an initial update. When the application code
+  wants to implement its own layout this also needs to be done for
+  rendering plots to a document ( see QwtPlotRenderer ).
   \param legend Legend
   \param pos The legend's position. For top/left position the number
              of colums will be limited to 1, otherwise it will be set to
+             of columns will be limited to 1, otherwise it will be set to
              unlimited.
   \param ratio Ratio between legend and the bounding rect
                of title, canvas and axes. The legend will be shrinked
+  \param ratio Ratio between legend and the bounding rectangle
+               of title, canvas and axes. The legend will be shrunk
                if it would need more space than the given ratio.
                The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0
 …
       QwtPlotLayout::setLegendPosition()
 */
 void QwtPlot::insertLegend( QwtLegend *legend,
+void QwtPlot::insertLegend( QwtAbstractLegend *legend,
     QwtPlot::LegendPosition pos, double ratio )
+{
 …
         if ( d_data->legend )
+        {
+            if ( pos != ExternalLegend )
+            {
+                if ( d_data->legend->parent() != this )
+                    d_data->legend->setParent( this );
+            }
+            const QwtPlotItemList& itmList = itemList();
+            for ( QwtPlotItemIterator it = itmList.begin();
+                it != itmList.end(); ++it )
+            {
+                ( *it )->updateLegend( d_data->legend );
+            }
+            QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
+                d_data->legend->contentsWidget()->layout() );
+            if ( tl )
+            connect( this,
+                SIGNAL( legendDataChanged(
+                    const QVariant &, const QList<QwtLegendData> & ) ),
+                d_data->legend,
+                SLOT( updateLegend(
+                    const QVariant &, const QList<QwtLegendData> & ) )
+            );
+            if ( d_data->legend->parent() != this )
+                d_data->legend->setParent( this );
+            qwtEnableLegendItems( this, false );
+            updateLegend();
+            qwtEnableLegendItems( this, true );
+            QwtLegend *lgd = qobject_cast<QwtLegend *>( legend );
+            if ( lgd )
+            {
                 switch ( d_data->layout->legendPosition() )
 …
                     case LeftLegend:
                     case RightLegend:
+                        tl->setMaxCols( 1 ); // 1 column: align vertical
+                    {
+                        if ( lgd->maxColumns() == 0     )
+                            lgd->setMaxColumns( 1 ); // 1 column: align vertical
                         break;
+                    }
                     case TopLegend:
                     case BottomLegend:
+                        tl->setMaxCols( 0 ); // unlimited
+                    {
+                        lgd->setMaxColumns( 0 ); // unlimited
                         break;
+                    case ExternalLegend:
+                    }
+                    default:
                         break;
+                }
+            }
+        }
+        updateTabOrder();
+            QWidget *previousInChain = NULL;
+            switch ( d_data->layout->legendPosition() )
+            {
+                case LeftLegend:
+                {
+                    previousInChain = axisWidget( QwtPlot::xTop );
+                    break;
+                }
+                case TopLegend:
+                {
+                    previousInChain = this;
+                    break;
+                }
+                case RightLegend:
+                {
+                    previousInChain = axisWidget( QwtPlot::yRight );
+                    break;
+                }
+                case BottomLegend:
+                {
+                    previousInChain = footerLabel();
+                    break;
+                }
+            }
+            if ( previousInChain )
+                qwtSetTabOrder( previousInChain, legend, true );
+        }
+    }
     updateLayout();
+}
+/*!
+  Emit legendDataChanged() for all plot item
+  \sa QwtPlotItem::legendData(), legendDataChanged()
+ */
+void QwtPlot::updateLegend()
+{
+    const QwtPlotItemList& itmList = itemList();
+    for ( QwtPlotItemIterator it = itmList.begin();
+        it != itmList.end(); ++it )
+    {
+        updateLegend( *it );
+    }
+}
+/*!
+  Emit legendDataChanged() for a plot item
+  \param plotItem Plot item
+  \sa QwtPlotItem::legendData(), legendDataChanged()
+ */
+void QwtPlot::updateLegend( const QwtPlotItem *plotItem )
+{
+    if ( plotItem == NULL )
+        return;
+    QList<QwtLegendData> legendData;
+    if ( plotItem->testItemAttribute( QwtPlotItem::Legend ) )
+        legendData = plotItem->legendData();
+    const QVariant itemInfo = itemToInfo( const_cast< QwtPlotItem *>( plotItem) );
+    Q_EMIT legendDataChanged( itemInfo, legendData );
+}
+/*!
+  \brief Update all plot items interested in legend attributes
+  Call QwtPlotItem::updateLegend(), when the QwtPlotItem::LegendInterest
+  flag is set.
+  \param itemInfo Info about the plot item
+  \param legendData Entries to be displayed for the plot item ( usually 1 )
+  \sa QwtPlotItem::LegendInterest,
+      QwtPlotLegendItem, QwtPlotItem::updateLegend()
+ */
+void QwtPlot::updateLegendItems( const QVariant &itemInfo,
+    const QList<QwtLegendData> &legendData )
+{
+    QwtPlotItem *plotItem = infoToItem( itemInfo );
+    if ( plotItem )
+    {
+        const QwtPlotItemList& itmList = itemList();
+        for ( QwtPlotItemIterator it = itmList.begin();
+            it != itmList.end(); ++it )
+        {
+            QwtPlotItem *item = *it;
+            if ( item->testItemInterest( QwtPlotItem::LegendInterest ) )
+                item->updateLegend( plotItem, legendData );
+        }
+    }
+}
+/*!
+  \brief Attach/Detach a plot item
+  \param plotItem Plot item
+  \param on When true attach the item, otherwise detach it
+ */
+void QwtPlot::attachItem( QwtPlotItem *plotItem, bool on )
+{
+    if ( plotItem->testItemInterest( QwtPlotItem::LegendInterest ) )
+    {
+        // plotItem is some sort of legend
+        const QwtPlotItemList& itmList = itemList();
+        for ( QwtPlotItemIterator it = itmList.begin();
+            it != itmList.end(); ++it )
+        {
+            QwtPlotItem *item = *it;
+            QList<QwtLegendData> legendData;
+            if ( on && item->testItemAttribute( QwtPlotItem::Legend ) )
+            {
+                legendData = item->legendData();
+                plotItem->updateLegend( item, legendData );
+            }
+        }
+    }
+    if ( on )
+        insertItem( plotItem );
+    else
+        removeItem( plotItem );
+    Q_EMIT itemAttached( plotItem, on );
+    if ( plotItem->testItemAttribute( QwtPlotItem::Legend ) )
+    {
+        // the item wants to be represented on the legend
+        if ( on )
+        {
+            updateLegend( plotItem );
+        }
+        else
+        {
+            const QVariant itemInfo = itemToInfo( plotItem );
+            Q_EMIT legendDataChanged( itemInfo, QList<QwtLegendData>() );
+        }
+    }
+    autoRefresh();
+}
+/*!
+  \brief Build an information, that can be used to identify
+         a plot item on the legend.
+  The default implementation simply wraps the plot item
+  into a QVariant object. When overloading itemToInfo()
+  usually infoToItem() needs to reimplemeted too.
+\code
+    QVariant itemInfo;
+    qVariantSetValue( itemInfo, plotItem );
+\endcode
+  \param plotItem Plot item
+  \return Plot item embedded in a QVariant
+  \sa infoToItem()
+ */
+QVariant QwtPlot::itemToInfo( QwtPlotItem *plotItem ) const
+{
+    QVariant itemInfo;
+    qVariantSetValue( itemInfo, plotItem );
+    return itemInfo;
+}
+/*!
+  \brief Identify the plot item according to an item info object,
+         that has bee generated from itemToInfo().
+  The default implementation simply tries to unwrap a QwtPlotItem
+  pointer:
+\code
+    if ( itemInfo.canConvert<QwtPlotItem *>() )
+        return qvariant_cast<QwtPlotItem *>( itemInfo );
+\endcode
+  \param itemInfo Plot item
+  \return A plot item, when successful, otherwise a NULL pointer.
+  \sa itemToInfo()
+*/
+QwtPlotItem *QwtPlot::infoToItem( const QVariant &itemInfo ) const
+{
+    if ( itemInfo.canConvert<QwtPlotItem *>() )
+        return qvariant_cast<QwtPlotItem *>( itemInfo );
+    return NULL;
+}

trunk/BNC/qwt/qwt_plot.h

-              r4271
+              r8127
 #include "qwt_interval.h"
 #include <qframe.h>
+#include <qlist.h>
+#include <qvariant.h>
 class QwtPlotLayout;
 class QwtLegend;
+class QwtAbstractLegend;
 class QwtScaleWidget;
 class QwtScaleEngine;
 …
 class QwtScaleDraw;
 class QwtTextLabel;
-class QwtPlotCanvas;
 /*!
 …
   from QwtPlotItem.
   A plot can have up to four axes, with each plot item attached to an x- and
   a y axis. The scales at the axes can be explicitely set (QwtScaleDiv), or
+  a y axis. The scales at the axes can be explicitly set (QwtScaleDiv), or
   are calculated from the plot items, using algorithms (QwtScaleEngine) which
   can be configured separately for each axis.
+  The simpleplot example is a good starting point to see how to set up a
+  plot widget.
   \image html plot.png
 …
 QwtPlotCurve *curve2 = new QwtPlotCurve("Curve 2");
 // copy the data into the curves
+// connect or copy the data to the curves
 curve1->setData(...);
 curve2->setData(...);
 …
+{
     Q_OBJECT
+    Q_PROPERTY( QBrush canvasBackground
+        READ canvasBackground WRITE setCanvasBackground )
+    Q_PROPERTY( bool autoReplot READ autoReplot WRITE setAutoReplot )
+#if 0
+    // This property is intended to configure the plot
+    // widget from a special dialog in the deigner plugin.
+    // Disabled until such a dialog has been implemented.
     Q_PROPERTY( QString propertiesDocument
         READ grabProperties WRITE applyProperties )
+#endif
 public:
 …
         \sa insertLegend()
-        \note In case of ExternalLegend, the legend is not
-              handled by QwtPlotRenderer
      */
     enum LegendPosition
 …
         RightLegend,
         //! The legend will be below QwtPlot::xBottom axis.
+        //! The legend will be below the footer
         BottomLegend,
+        //! The legend will be between QwtPlot::xTop axis and the title.
+        TopLegend,
+        /*!
+          External means that only the content of the legend
+          will be handled by QwtPlot, but not its geometry.
+          This type can be used to have a legend in an
+          external window ( or on the canvas ).
+         */
+        ExternalLegend
+        //! The legend will be above the title
+        TopLegend
     };
     explicit QwtPlot( QWidget * = NULL );
     explicit QwtPlot( const QwtText &title, QWidget *p = NULL );
+    explicit QwtPlot( const QwtText &title, QWidget * = NULL );
     virtual ~QwtPlot();
 …
     QString grabProperties() const;
     void setAutoReplot( bool tf = true );
+    void setAutoReplot( bool = true );
     bool autoReplot() const;
     // Layout
+    void setPlotLayout( QwtPlotLayout * );
     QwtPlotLayout *plotLayout();
 …
     const QwtTextLabel *titleLabel() const;
+    // Footer
+    void setFooter( const QString & );
+    void setFooter( const QwtText &t );
+    QwtText footer() const;
+    QwtTextLabel *footerLabel();
+    const QwtTextLabel *footerLabel() const;
     // Canvas
+    QwtPlotCanvas *canvas();
+    const QwtPlotCanvas *canvas() const;
+    void setCanvas( QWidget * );
+    QWidget *canvas();
+    const QWidget *canvas() const;
     void setCanvasBackground( const QBrush & );
     QBrush canvasBackground() const;
-    void setCanvasLineWidth( int w );
-    int canvasLineWidth() const;
     virtual QwtScaleMap canvasMap( int axisId ) const;
 …
     QwtInterval axisInterval( int axisId ) const;
+    const QwtScaleDiv *axisScaleDiv( int axisId ) const;
+    QwtScaleDiv *axisScaleDiv( int axisId );
+    const QwtScaleDiv &axisScaleDiv( int axisId ) const;
     const QwtScaleDraw *axisScaleDraw( int axisId ) const;
 …
     // Legend
+    void insertLegend( QwtLegend *, LegendPosition = QwtPlot::RightLegend,
+        double ratio = -1.0 );
+    QwtLegend *legend();
+    const QwtLegend *legend() const;
+    void insertLegend( QwtAbstractLegend *,
+        LegendPosition = QwtPlot::RightLegend, double ratio = -1.0 );
+    QwtAbstractLegend *legend();
+    const QwtAbstractLegend *legend() const;
+    void updateLegend();
+    void updateLegend( const QwtPlotItem * );
     // Misc
 …
     void updateAxes();
+    void updateCanvasMargins();
+    virtual void getCanvasMarginsHint(
+        const QwtScaleMap maps[], const QRectF &canvasRect,
+        double &left, double &top, double &right, double &bottom) const;
     virtual bool event( QEvent * );
+    virtual bool eventFilter( QObject *, QEvent * );
     virtual void drawItems( QPainter *, const QRectF &,
         const QwtScaleMap maps[axisCnt] ) const;
+    virtual QVariant itemToInfo( QwtPlotItem * ) const;
+    virtual QwtPlotItem *infoToItem( const QVariant & ) const;
 Q_SIGNALS:
     /*!
+      A signal which is emitted when the user has clicked on
+      a legend item, which is in QwtLegend::ClickableItem mode.
+      \param plotItem Corresponding plot item of the
+                 selected legend item
+      \note clicks are disabled as default
+      \sa QwtLegend::setItemMode(), QwtLegend::itemMode()
+      A signal indicating, that an item has been attached/detached
+      \param plotItem Plot item
+      \param on Attached/Detached
      */
     void legendClicked( QwtPlotItem *plotItem );
+    void itemAttached( QwtPlotItem *plotItem, bool on );
     /*!
+      A signal which is emitted when the user has clicked on
+      a legend item, which is in QwtLegend::CheckableItem mode
+      \param plotItem Corresponding plot item of the
+                 selected legend item
+      \param on True when the legen item is checked
+      \note clicks are disabled as default
+      \sa QwtLegend::setItemMode(), QwtLegend::itemMode()
+      A signal with the attributes how to update
+      the legend entries for a plot item.
+      \param itemInfo Info about a plot item, build from itemToInfo()
+      \param data Attributes of the entries ( usually <= 1 ) for
+                  the plot item.
+      \sa itemToInfo(), infoToItem(), QwtAbstractLegend::updateLegend()
      */
     void legendChecked( QwtPlotItem *plotItem, bool on );
+    void legendDataChanged( const QVariant &itemInfo,
+        const QList<QwtLegendData> &data );
 public Q_SLOTS:
 …
     void autoRefresh();
-protected Q_SLOTS:
-    virtual void legendItemClicked();
-    virtual void legendItemChecked( bool );
 protected:
     static bool axisValid( int axisId );
-    virtual void updateTabOrder();
     virtual void resizeEvent( QResizeEvent *e );
+private Q_SLOTS:
+    void updateLegendItems( const QVariant &itemInfo,
+        const QList<QwtLegendData> &data );
 private:
+    friend class QwtPlotItem;
+    void attachItem( QwtPlotItem *, bool );
     void initAxesData();
     void deleteAxesData();

trunk/BNC/qwt/qwt_plot_axis.cpp

-              r4271
+              r8127
     int maxMinor;
+    bool isValid;
     QwtScaleDiv scaleDiv;
     QwtScaleEngine *scaleEngine;
 …
     d_axisData[xBottom]->scaleWidget->setObjectName( "QwtPlotAxisXBottom" );
+#if 1
+    // better find the font sizes from the application font
     QFont fscl( fontInfo().family(), 10 );
     QFont fttl( fontInfo().family(), 12, QFont::Bold );
+#endif
     for ( axisId = 0; axisId < axisCnt; axisId++ )
+    {
         AxisData &d = *d_axisData[axisId];
+        d.scaleEngine = new QwtLinearScaleEngine;
+        d.scaleWidget->setTransformation(
+            d.scaleEngine->transformation() );
         d.scaleWidget->setFont( fscl );
 …
         d.maxMajor = 8;
+        d.scaleEngine = new QwtLinearScaleEngine;
+        d.scaleDiv.invalidate();
+        d.isValid = false;
+    }
 …
 /*!
   \return specified axis, or NULL if axisId is invalid.
   \param axisId axis index
+  \return Scale widget of the specified axis, or NULL if axisId is invalid.
+  \param axisId Axis index
 */
 const QwtScaleWidget *QwtPlot::axisWidget( int axisId ) const
 …
 /*!
   \return specified axis, or NULL if axisId is invalid.
   \param axisId axis index
+  \return Scale widget of the specified axis, or NULL if axisId is invalid.
+  \param axisId Axis index
 */
 QwtScaleWidget *QwtPlot::axisWidget( int axisId )
 …
 /*!
    Change the scale engine for an axis
   \param axisId axis index
+  Change the scale engine for an axis
+  \param axisId Axis index
   \param scaleEngine Scale engine
 …
         d.scaleEngine = scaleEngine;
+        d.scaleDiv.invalidate();
+        d_axisData[axisId]->scaleWidget->setTransformation(
+            scaleEngine->transformation() );
+        d.isValid = false;
         autoRefresh();
 …
 /*!
   \param axisId axis index
+  \param axisId Axis index
   \return Scale engine for a specific axis
 */
 …
 /*!
   \param axisId axis index
+  \param axisId Axis index
   \return Scale engine for a specific axis
 */
 …
+}
 /*!
   \return \c true if autoscaling is enabled
   \param axisId axis index
+  \return \c True, if autoscaling is enabled
+  \param axisId Axis index
 */
 bool QwtPlot::axisAutoScale( int axisId ) const
 …
 /*!
   \return \c true if a specified axis is enabled
   \param axisId axis index
+  \return \c True, if a specified axis is enabled
+  \param axisId Axis index
 */
 bool QwtPlot::axisEnabled( int axisId ) const
 …
 /*!
   \return the font of the scale labels for a specified axis
   \param axisId axis index
+  \return The font of the scale labels for a specified axis
+  \param axisId Axis index
 */
 QFont QwtPlot::axisFont( int axisId ) const
 …
 /*!
   \return the maximum number of major ticks for a specified axis
   \param axisId axis index
   \sa setAxisMaxMajor()
+  \return The maximum number of major ticks for a specified axis
+  \param axisId Axis index
+  \sa setAxisMaxMajor(), QwtScaleEngine::divideScale()
 */
 int QwtPlot::axisMaxMajor( int axisId ) const
 …
 /*!
   \return the maximum number of minor ticks for a specified axis
   \param axisId axis index
   \sa setAxisMaxMinor()
+  \param axisId Axis index
+  \sa setAxisMaxMinor(), QwtScaleEngine::divideScale()
 */
 int QwtPlot::axisMaxMinor( int axisId ) const
 …
   \brief Return the scale division of a specified axis
   axisScaleDiv(axisId)->lowerBound(), axisScaleDiv(axisId)->upperBound()
+  axisScaleDiv(axisId).lowerBound(), axisScaleDiv(axisId).upperBound()
   are the current limits of the axis scale.
   \param axisId axis index
+  \param axisId Axis index
   \return Scale division
+  \sa QwtScaleDiv, setAxisScaleDiv()
+*/
+const QwtScaleDiv *QwtPlot::axisScaleDiv( int axisId ) const
+  \sa QwtScaleDiv, setAxisScaleDiv(), QwtScaleEngine::divideScale()
+*/
+const QwtScaleDiv &QwtPlot::axisScaleDiv( int axisId ) const
+{
+    return d_axisData[axisId]->scaleDiv;
+}
+/*!
+  \brief Return the scale draw of a specified axis
+  \param axisId Axis index
+  \return Specified scaleDraw for axis, or NULL if axis is invalid.
+*/
+const QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId ) const
+{
     if ( !axisValid( axisId ) )
         return NULL;
+    return &d_axisData[axisId]->scaleDiv;
+}
+/*!
+  \brief Return the scale division of a specified axis
+  axisScaleDiv(axisId)->lowerBound(), axisScaleDiv(axisId)->upperBound()
+  are the current limits of the axis scale.
+  \param axisId axis index
+  \return Scale division
+  \sa QwtScaleDiv, setAxisScaleDiv()
+*/
+QwtScaleDiv *QwtPlot::axisScaleDiv( int axisId )
+    return axisWidget( axisId )->scaleDraw();
+}
+/*!
+  \brief Return the scale draw of a specified axis
+  \param axisId Axis index
+  \return Specified scaleDraw for axis, or NULL if axis is invalid.
+*/
+QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId )
+{
     if ( !axisValid( axisId ) )
         return NULL;
-    return &d_axisData[axisId]->scaleDiv;
+}
-/*!
-  \returns the scale draw of a specified axis
-  \param axisId axis index
-  \return specified scaleDraw for axis, or NULL if axis is invalid.
-  \sa QwtScaleDraw
-*/
-const QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId ) const
+{
-    if ( !axisValid( axisId ) )
-        return NULL;
     return axisWidget( axisId )->scaleDraw();
+}
 /*!
+  \returns the scale draw of a specified axis
+  \param axisId axis index
+  \return specified scaleDraw for axis, or NULL if axis is invalid.
+  \sa QwtScaleDraw
+*/
+QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId )
+{
+    if ( !axisValid( axisId ) )
+        return NULL;
+    return axisWidget( axisId )->scaleDraw();
+}
+/*!
+   Return the step size parameter, that has been set
+   in setAxisScale. This doesn't need to be the step size
+   of the current scale.
+  \param axisId axis index
+  \brief Return the step size parameter that has been set in setAxisScale.
+  This doesn't need to be the step size of the current scale.
+  \param axisId Axis index
   \return step size parameter value
    \sa setAxisScale()
+   \sa setAxisScale(), QwtScaleEngine::divideScale()
 */
 double QwtPlot::axisStepSize( int axisId ) const
 …
   This is only a convenience function for axisScaleDiv( axisId )->interval();
   \param axisId axis index
+  \param axisId Axis index
   \return Scale interval
 …
 /*!
   \return the title of a specified axis
   \param axisId axis index
+  \return Title of a specified axis
+  \param axisId Axis index
 */
 QwtText QwtPlot::axisTitle( int axisId ) const
 …
   Only xBottom and yLeft are enabled by default.
+  \param axisId axis index
+  \param axisId Axis index
   \param tf \c true (enabled) or \c false (disabled)
 */
 …
   Transform the x or y coordinate of a position in the
   drawing region into a value.
+  \param axisId axis index
+  \param axisId Axis index
   \param pos position
+  \return Position as axis coordinate
   \warning The position can be an x or a y coordinate,
            depending on the specified axis.
 …
 /*!
   \brief Transform a value into a coordinate in the plotting region
+  \param axisId axis index
+  \param axisId Axis index
   \param value value
   \return X or y coordinate in the plotting region corresponding
+  \return X or Y coordinate in the plotting region corresponding
           to the value.
 */
 …
 /*!
   \brief Change the font of an axis
+  \param axisId axis index
+  \param f font
+  \param axisId Axis index
+  \param font Font
   \warning This function changes the font of the tick labels,
            not of the axis title.
 */
 void QwtPlot::setAxisFont( int axisId, const QFont &f )
+{
     if ( axisValid( axisId ) )
         axisWidget( axisId )->setFont( f );
+void QwtPlot::setAxisFont( int axisId, const QFont &font )
+{
+    if ( axisValid( axisId ) )
+        axisWidget( axisId )->setFont( font );
+}
 …
   after a fixed scale has been set. Autoscaling is enabled by default.
   \param axisId axis index
+  \param axisId Axis index
   \param on On/Off
   \sa setAxisScale(), setAxisScaleDiv(), updateAxes()
 …
 /*!
   \brief Disable autoscaling and specify a fixed scale for a selected axis.
+  \param axisId axis index
+  \param min
+  \param max minimum and maximum of the scale
+  In updateAxes() the scale engine calculates a scale division from the
+  specified parameters, that will be assigned to the scale widget. So
+  updates of the scale widget usually happen delayed with the next replot.
+  \param axisId Axis index
+  \param min Minimum of the scale
+  \param max Maximum of the scale
   \param stepSize Major step size. If <code>step == 0</code>, the step size is
+            calculated automatically using the maxMajor setting.
+  \sa setAxisMaxMajor(), setAxisAutoScale(), axisStepSize()
+                  calculated automatically using the maxMajor setting.
+  \sa setAxisMaxMajor(), setAxisAutoScale(), axisStepSize(), QwtScaleEngine::divideScale()
 */
 void QwtPlot::setAxisScale( int axisId, double min, double max, double stepSize )
 …
         d.doAutoScale = false;
         d.scaleDiv.invalidate();
+        d.isValid = false;
         d.minValue = min;
 …
 /*!
   \brief Disable autoscaling and specify a fixed scale for a selected axis.
+  \param axisId axis index
+  The scale division will be stored locally only until the next call
+  of updateAxes(). So updates of the scale widget usually happen delayed with
+  the next replot.
+  \param axisId Axis index
   \param scaleDiv Scale division
   \sa setAxisScale(), setAxisAutoScale()
 */
 …
         d.doAutoScale = false;
         d.scaleDiv = scaleDiv;
+        d.isValid = true;
         autoRefresh();
 …
 /*!
   \brief Set a scale draw
+  \param axisId axis index
+  \param scaleDraw object responsible for drawing scales.
+  \param axisId Axis index
+  \param scaleDraw Object responsible for drawing scales.
   By passing scaleDraw it is possible to extend QwtScaleDraw
 …
 /*!
   Change the alignment of the tick labels
+  \param axisId axis index
+  \param axisId Axis index
   \param alignment Or'd Qt::AlignmentFlags see <qnamespace.h>
   \sa QwtScaleDraw::setLabelAlignment()
 */
 …
 /*!
   Rotate all tick labels
+  \param axisId axis index
+  \param axisId Axis index
   \param rotation Angle in degrees. When changing the label rotation,
                   the label alignment might be adjusted too.
   \sa QwtScaleDraw::setLabelRotation(), setAxisLabelAlignment()
 */
 …
   Set the maximum number of minor scale intervals for a specified axis
+  \param axisId axis index
+  \param maxMinor maximum number of minor steps
+  \param axisId Axis index
+  \param maxMinor Maximum number of minor steps
   \sa axisMaxMinor()
 */
 …
+        {
             d.maxMinor = maxMinor;
             d.scaleDiv.invalidate();
+            d.isValid = false;
             autoRefresh();
+        }
 …
   Set the maximum number of major scale intervals for a specified axis
+  \param axisId axis index
+  \param maxMajor maximum number of major steps
+  \param axisId Axis index
+  \param maxMajor Maximum number of major steps
   \sa axisMaxMajor()
 */
 …
+        {
             d.maxMajor = maxMajor;
             d.scaleDiv.invalidate();
+            d.isValid = false;
             autoRefresh();
+        }
 …
 /*!
   \brief Change the title of a specified axis
+  \param axisId axis index
+  \param axisId Axis index
   \param title axis title
 */
 …
 /*!
   \brief Change the title of a specified axis
+  \param axisId axis index
+  \param title axis title
+  \param axisId Axis index
+  \param title Axis title
 */
 void QwtPlot::setAxisTitle( int axisId, const QwtText &title )
 …
+}
+//! Rebuild the scales
+/*!
+  \brief Rebuild the axes scales
+  In case of autoscaling the boundaries of a scale are calculated
+  from the bounding rectangles of all plot items, having the
+  QwtPlotItem::AutoScale flag enabled ( QwtScaleEngine::autoScale() ).
+  Then a scale division is calculated ( QwtScaleEngine::didvideScale() )
+  and assigned to scale widget.
+  When the scale boundaries have been assigned with setAxisScale() a
+  scale division is calculated ( QwtScaleEngine::didvideScale() )
+  for this interval and assigned to the scale widget.
+  When the scale has been set explicitly by setAxisScaleDiv() the
+  locally stored scale division gets assigned to the scale widget.
+  The scale widget indicates modifications by emitting a
+  QwtScaleWidget::scaleDivChanged() signal.
+  updateAxes() is usually called by replot().
+  \sa setAxisAutoScale(), setAxisScale(), setAxisScaleDiv(), replot()
+      QwtPlotItem::boundingRect()
+ */
 void QwtPlot::updateAxes()
+{
 …
+        {
             const QRectF rect = item->boundingRect();
+            intv[item->xAxis()] |= QwtInterval( rect.left(), rect.right() );
+            intv[item->yAxis()] |= QwtInterval( rect.top(), rect.bottom() );
+            if ( rect.width() >= 0.0 )
+                intv[item->xAxis()] |= QwtInterval( rect.left(), rect.right() );
+            if ( rect.height() >= 0.0 )
+                intv[item->yAxis()] |= QwtInterval( rect.top(), rect.bottom() );
+        }
+    }
 …
         if ( d.doAutoScale && intv[axisId].isValid() )
+        {
             d.scaleDiv.invalidate();
+            d.isValid = false;
             minValue = intv[axisId].minValue();
 …
                 minValue, maxValue, stepSize );
+        }
         if ( !d.scaleDiv.isValid() )
+        if ( !d.isValid )
+        {
             d.scaleDiv = d.scaleEngine->divideScale(
                 minValue, maxValue,
                 d.maxMajor, d.maxMinor, stepSize );
+            d.isValid = true;
+        }
         QwtScaleWidget *scaleWidget = axisWidget( axisId );
+        scaleWidget->setScaleDiv(
+            d.scaleEngine->transformation(), d.scaleDiv );
+        scaleWidget->setScaleDiv( d.scaleDiv );
         int startDist, endDist;
 …
+    {
         QwtPlotItem *item = *it;
+        item->updateScaleDiv( *axisScaleDiv( item->xAxis() ),
+            *axisScaleDiv( item->yAxis() ) );
+    }
+}
+        if ( item->testItemInterest( QwtPlotItem::ScaleInterest ) )
+        {
+            item->updateScaleDiv( axisScaleDiv( item->xAxis() ),
+                axisScaleDiv( item->yAxis() ) );
+        }
+    }
+}

trunk/BNC/qwt/qwt_plot_canvas.cpp

-              r4271
+              r8127
 #include <qpaintengine.h>
 #include <qevent.h>
-#include <qbitmap.h>
-#ifdef Q_WS_X11
-#include <qx11info_x11.h>
-#endif
 class QwtStyleSheetRecorder: public QwtNullPaintDevice
 …
 public:
     QwtStyleSheetRecorder( const QSize &size ):
+        QwtNullPaintDevice( QPaintEngine::AllFeatures )
+    {
+        setSize( size );
+        d_size( size )
+    {
+    }
 …
     virtual void drawPath( const QPainterPath &path )
+    {
         const QRectF rect( QPointF( 0.0, 0.0 ) , size() );
+        const QRectF rect( QPointF( 0.0, 0.0 ), d_size );
         if ( path.controlPointRect().contains( rect.center() ) )
+        {
 …
+    }
+protected:
+    virtual QSize sizeMetrics() const
+    {
+        return d_size;
+    }
 private:
     void alignCornerRects( const QRectF &rect )
 …
 private:
+    const QSize d_size;
     QPen d_pen;
     QBrush d_brush;
 …
 };
+static void qwtDrawBackground( QPainter *painter, QWidget *widget )
+{
+static void qwtDrawBackground( QPainter *painter, QwtPlotCanvas *canvas )
+{
+    painter->save();
+    const QPainterPath borderClip = canvas->borderPath( canvas->rect() );
+    if ( !borderClip.isEmpty() )
+        painter->setClipPath( borderClip, Qt::IntersectClip );
     const QBrush &brush =
         widget->palette().brush( widget->backgroundRole() );
+        canvas->palette().brush( canvas->backgroundRole() );
     if ( brush.style() == Qt::TexturePattern )
+    {
         QPixmap pm( widget->size() );
         pm.fill( widget, 0, 0 );
+        QPixmap pm( canvas->size() );
+        QwtPainter::fillPixmap( canvas, pm );
         painter->drawPixmap( 0, 0, pm );
+    }
 …
         if ( brush.gradient()->coordinateMode() == QGradient::ObjectBoundingMode )
+        {
             rects += widget->rect();
+            rects += canvas->rect();
+        }
         else
 …
+            }
             QImage image( widget->size(), format );
+            QImage image( canvas->size(), format );
             QPainter p( &image );
 …
         else
+        {
-            painter->save();
             painter->setPen( Qt::NoPen );
             painter->setBrush( brush );
             painter->drawRects( rects );
-            painter->restore();
+        }
+    }
     else
+    {
-        painter->save();
         painter->setPen( Qt::NoPen );
         painter->setBrush( brush );
 …
         painter->drawRects( painter->clipRegion().rects() );
+        painter->restore();
+    }
+    }
+    painter->restore();
+}
 …
     if ( path.elementCount() == 4 )
+    {
+        QPainterPath::Element &el0 =
+            const_cast<QPainterPath::Element &>( path.elementAt(0) );
+        QPainterPath::Element &el2 =
+            const_cast<QPainterPath::Element &>( path.elementAt(3) );
+        qSwap( el0.x, el2.x );
+        qSwap( el0.y, el2.y );
+        QPainterPath::Element el0 = path.elementAt(0);
+        QPainterPath::Element el3 = path.elementAt(3);
+        path.setElementPositionAt( 0, el3.x, el3.y );
+        path.setElementPositionAt( 3, el0.x, el0.y );
+    }
+}
 …
+        {
             QPixmap pm( rect.size() );
             pm.fill( bgWidget, widget->mapTo( bgWidget, rect.topLeft() ) );
+            QwtPainter::fillPixmap( bgWidget, pm, widget->mapTo( bgWidget, rect.topLeft() ) );
             painter->drawPixmap( rect, pm );
+        }
 …
         if ( radius > 0.0 )
+        {
             QSize sz( radius, radius );
+            QSizeF sz( radius, radius );
             rects += QRectF( r.topLeft(), sz );
 …
 };
+//! Sets a cross cursor, enables QwtPlotCanvas::BackingStore
+/*!
+  \brief Constructor
+  \param plot Parent plot widget
+  \sa QwtPlot::setCanvas()
+*/
 QwtPlotCanvas::QwtPlotCanvas( QwtPlot *plot ):
     QFrame( plot )
+{
+    setFrameStyle( QFrame::Panel | QFrame::Sunken );
+    setLineWidth( 2 );
     d_data = new PrivateData;
 …
 QwtPlot *QwtPlotCanvas::plot()
+{
     return qobject_cast<QwtPlot *>( parentWidget() );
+    return qobject_cast<QwtPlot *>( parent() );
+}
 …
 const QwtPlot *QwtPlotCanvas::plot() const
+{
     return qobject_cast<const QwtPlot *>( parentWidget() );
+    return qobject_cast<const QwtPlot *>( parent() );
+}
 …
                 if ( isVisible() )
+                {
+#if QT_VERSION >= 0x050000
+                    *d_data->backingStore = grab( rect() );
+#else
                     *d_data->backingStore =
                         QPixmap::grabWidget( this, rect() );
+#endif
+                }
+            }
 …
 /*!
   Test wether a paint attribute is enabled
+  Test whether a paint attribute is enabled
   \param attribute Paint attribute
   \return true if the attribute is enabled
+  \return true, when attribute is enabled
   \sa setPaintAttribute()
 */
 …
 /*!
   Qt event handler for QEvent::PolishRequest and QEvent::StyleChange
   \param event Qt Event
+  \return See QFrame::event()
 */
 bool QwtPlotCanvas::event( QEvent *event )
 …
         if ( bs.size() != size() )
+        {
+            bs = QPixmap( size() );
+#ifdef Q_WS_X11
+            if ( bs.x11Info().screen() != x11Info().screen() )
+                bs.x11SetScreen( x11Info().screen() );
+#endif
+            bs = QwtPainter::backingStore( this, size() );
             if ( testAttribute(Qt::WA_StyledBackground) )
 …
                 if ( d_data->borderRadius <= 0.0 )
+                {
                     bs.fill( this, 0, 0 );
+                    QwtPainter::fillPixmap( this, bs );
                     p.begin( &bs );
                     drawCanvas( &p, false );
 …
+            {
                 if ( autoFillBackground() )
+                {
+                    qwtFillBackground( &painter, this );
                     qwtDrawBackground( &painter, this );
+                }
+            }
+            else
+            {
+                if ( borderRadius() > 0.0 )
+                {
+                    QPainterPath clipPath;
+                    clipPath.addRect( rect() );
+                    clipPath = clipPath.subtracted( borderPath( rect() ) );
+                    painter.save();
+                    painter.setClipPath( clipPath, Qt::IntersectClip );
+                    qwtFillBackground( &painter, this );
+                    qwtDrawBackground( &painter, this );
+                    painter.restore();
+                }
+            }
 …
             painter->setBrush( palette().brush( backgroundRole() ) );
             if ( d_data->borderRadius > 0.0 )
+            if ( d_data->borderRadius > 0.0 && ( rect() == frameRect() ) )
+            {
                 if ( frameWidth() > 0 )
 …
             else
+            {
                 painter->drawRect( contentsRect() );
+                painter->drawRect( rect() );
+            }
+        }
 …
+    {
         if ( d_data->borderRadius > 0.0 )
             painter->setClipPath( borderPath( rect() ), Qt::IntersectClip );
+            painter->setClipPath( borderPath( frameRect() ), Qt::IntersectClip );
         else
             painter->setClipRect( contentsRect(), Qt::IntersectClip );
 …
   \param painter Painter
   \sa setBorderRadius(), QFrame::drawFrame()
+  \sa setBorderRadius()
 */
 void QwtPlotCanvas::drawBorder( QPainter *painter )
 …
         if ( frameWidth() > 0 )
+        {
             QwtPainter::drawRoundedFrame( painter, QRectF( rect() ),
+            QwtPainter::drawRoundedFrame( painter, QRectF( frameRect() ),
                 d_data->borderRadius, d_data->borderRadius,
                 palette(), frameWidth(), frameStyle() );
 …
     else
+    {
+#if QT_VERSION >= 0x040500
+#if QT_VERSION < 0x050000
+        QStyleOptionFrameV3 opt;
+#else
+        QStyleOptionFrame opt;
+#endif
+        opt.init(this);
+        int frameShape  = frameStyle() & QFrame::Shape_Mask;
+        int frameShadow = frameStyle() & QFrame::Shadow_Mask;
+        opt.frameShape = QFrame::Shape( int( opt.frameShape ) | frameShape );
+#if 0
+        opt.rect = frameRect();
+#endif
+        switch (frameShape)
+        {
+            case QFrame::Box:
+            case QFrame::HLine:
+            case QFrame::VLine:
+            case QFrame::StyledPanel:
+            case QFrame::Panel:
+            {
+                opt.lineWidth = lineWidth();
+                opt.midLineWidth = midLineWidth();
+                break;
+            }
+            default:
+            {
+                opt.lineWidth = frameWidth();
+                break;
+            }
+        }
+        if ( frameShadow == Sunken )
+            opt.state |= QStyle::State_Sunken;
+        else if ( frameShadow == Raised )
+            opt.state |= QStyle::State_Raised;
+        style()->drawControl(QStyle::CE_ShapedFrame, &opt, painter, this);
+#else
         drawFrame( painter );
+#endif
+    }
+}
 …
+}
 //! Update the cached informations about the current style sheet
+//! Update the cached information about the current style sheet
 void QwtPlotCanvas::updateStyleSheetInfo()
+{
 …
     return QPainterPath();
+}
-/*!
-   Calculate a mask, that can be used to clip away the border frame
-   \param size Size including the frame
-*/
-QBitmap QwtPlotCanvas::borderMask( const QSize &size ) const
+{
-    const QRect r( 0, 0, size.width(), size.height() );
-    const QPainterPath path = borderPath( r );
-    if ( path.isEmpty() )
-        return QBitmap();
-    QImage image( size, QImage::Format_ARGB32_Premultiplied );
-    image.fill( Qt::color0 );
-    QPainter painter( &image );
-    painter.setClipPath( path );
-    painter.fillRect( r, Qt::color1 );
-    // now erase the frame
-    painter.setCompositionMode( QPainter::CompositionMode_DestinationOut );
-    if ( testAttribute(Qt::WA_StyledBackground ) )
+    {
-        QStyleOptionFrame opt;
-        opt.initFrom(this);
-        opt.rect = r;
-        style()->drawPrimitive( QStyle::PE_Frame, &opt, &painter, this );
+    }
-    else
+    {
-        if ( d_data->borderRadius > 0 && frameWidth() > 0 )
+        {
-            painter.setPen( QPen( Qt::color1, frameWidth() ) );
-            painter.setBrush( Qt::NoBrush );
-            painter.setRenderHint( QPainter::Antialiasing, true );
-            painter.drawPath( path );
+        }
+    }
-    painter.end();
-    const QImage mask = image.createMaskFromColor(
-        QColor( Qt::color1 ).rgb(), Qt::MaskOutColor );
-    return QBitmap::fromImage( mask );
+}

trunk/BNC/qwt/qwt_plot_canvas.h

-              r4271
+              r8127
 #include "qwt_global.h"
 #include <qframe.h>
-#include <qpen.h>
 #include <qpainterpath.h>
-#include <qbitmap.h>
 class QwtPlot;
 …
 /*!
   \brief Canvas of a QwtPlot.
+  \sa QwtPlot
+   Canvas is the widget where all plot items are displayed
+  \sa QwtPlot::setCanvas(), QwtPlotGLCanvas
 */
 class QWT_EXPORT QwtPlotCanvas : public QFrame
+{
     Q_OBJECT
+    Q_PROPERTY( double borderRadius READ borderRadius WRITE setBorderRadius )
 public:
 …
           Using a backing store might improve the performance
           significantly, when workin with widget overlays ( like rubberbands ).
+          significantly, when working with widget overlays ( like rubber bands ).
           Disabling the cache might improve the performance for
           incremental paints (using QwtPlotDirectPainter ).
 …
           When HackStyledBackground is enabled the plot canvas tries
           to seperate the background from the background border
           by reverse engeneering to paint the background before and
+          to separate the background from the background border
+          by reverse engineering to paint the background before and
           the border after the plot items. In this order the border
           gets prefectly antialiased and you can avoid some pixel
+          gets perfectly antialiased and you can avoid some pixel
           artifacts in the corners.
          */
 …
     /*!
       \brief Focus indicator
+      - NoFocusIndicator\n
+        Don't paint a focus indicator
+      - CanvasFocusIndicator\n
+        The focus is related to the complete canvas.
+        Paint the focus indicator using paintFocus()
+      - ItemFocusIndicator\n
+        The focus is related to an item (curve, point, ...) on
+        the canvas. It is up to the application to display a
+        focus indication using f.e. highlighting.
+      \sa setFocusIndicator(), focusIndicator(), paintFocus()
+      The default setting is NoFocusIndicator
+      \sa setFocusIndicator(), focusIndicator(), drawFocusIndicator()
     */
     enum FocusIndicator
+    {
+        //! Don't paint a focus indicator
         NoFocusIndicator,
+        /*!
+          The focus is related to the complete canvas.
+          Paint the focus indicator using drawFocusIndicator()
+         */
         CanvasFocusIndicator,
+        /*!
+          The focus is related to an item (curve, point, ...) on
+          the canvas. It is up to the application to display a
+          focus indication using f.e. highlighting.
+         */
         ItemFocusIndicator
     };
     explicit QwtPlotCanvas( QwtPlot * );
+    explicit QwtPlotCanvas( QwtPlot * = NULL );
     virtual ~QwtPlotCanvas();
 …
     double borderRadius() const;
-    QPainterPath borderPath( const QRect &rect ) const;
-    QBitmap borderMask( const QSize & ) const;
     void setPaintAttribute( PaintAttribute, bool on = true );
     bool testPaintAttribute( PaintAttribute ) const;
 …
     void invalidateBackingStore();
+    virtual bool event( QEvent * );
+    Q_INVOKABLE QPainterPath borderPath( const QRect & ) const;
+public Q_SLOTS:
     void replot();
-    virtual bool event( QEvent * );
 protected:

trunk/BNC/qwt/qwt_plot_curve.cpp

-              r4271
+              r8127
 #include "qwt_plot_curve.h"
+#include "qwt_point_data.h"
 #include "qwt_math.h"
 #include "qwt_clipper.h"
 #include "qwt_painter.h"
-#include "qwt_legend.h"
-#include "qwt_legend_item.h"
 #include "qwt_scale_map.h"
 #include "qwt_plot.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_curve_fitter.h"
 #include "qwt_symbol.h"
+#include "qwt_point_mapper.h"
 #include <qpainter.h>
 #include <qpixmap.h>
 …
 #include <qmath.h>
+static int verifyRange( int size, int &i1, int &i2 )
+static void qwtUpdateLegendIconSize( QwtPlotCurve *curve )
+{
+    if ( curve->symbol() &&
+        curve->testLegendAttribute( QwtPlotCurve::LegendShowSymbol ) )
+    {
+        QSize sz = curve->symbol()->boundingRect().size();
+        sz += QSize( 2, 2 ); // margin
+        if ( curve->testLegendAttribute( QwtPlotCurve::LegendShowLine ) )
+        {
+            // Avoid, that the line is completely covered by the symbol
+            int w = qCeil( 1.5 * sz.width() );
+            if ( w % 2 )
+                w++;
+            sz.setWidth( qMax( 8, w ) );
+        }
+        curve->setLegendIconSize( sz );
+    }
+}
+static int qwtVerifyRange( int size, int &i1, int &i2 )
+{
     if ( size < 1 )
 …
         symbol( NULL ),
         attributes( 0 ),
+        paintAttributes( QwtPlotCurve::ClipPolygons ),
+        paintAttributes(
+            QwtPlotCurve::ClipPolygons | QwtPlotCurve::FilterPoints ),
         legendAttributes( 0 )
+    {
 …
 */
 QwtPlotCurve::QwtPlotCurve( const QwtText &title ):
     QwtPlotSeriesItem<QPointF>( title )
+    QwtPlotSeriesItem( title )
+{
     init();
 …
 */
 QwtPlotCurve::QwtPlotCurve( const QString &title ):
     QwtPlotSeriesItem<QPointF>( QwtText( title ) )
+    QwtPlotSeriesItem( QwtText( title ) )
+{
     init();
 …
     d_data = new PrivateData;
     d_series = new QwtPointSeriesData();
+    setData( new QwtPointSeriesData() );
     setZ( 20.0 );
 …
 /*!
     \brief Return the current paint attributes
+    \return True, when attribute is enabled
     \sa setPaintAttribute()
 */
 …
 /*!
   Specify an attribute how to draw the legend identifier
+  Specify an attribute how to draw the legend icon
   \param attribute Attribute
   \param on On/Off
   /sa testLegendAttribute()
+  /sa testLegendAttribute(). legendIcon()
 */
 void QwtPlotCurve::setLegendAttribute( LegendAttribute attribute, bool on )
+{
+    if ( on )
+        d_data->legendAttributes |= attribute;
+    else
+        d_data->legendAttributes &= ~attribute;
+}
+/*!
+    \brief Return the current paint attributes
+    \sa setLegendAttribute()
+    if ( on != testLegendAttribute( attribute ) )
+    {
+        if ( on )
+            d_data->legendAttributes |= attribute;
+        else
+            d_data->legendAttributes &= ~attribute;
+        qwtUpdateLegendIconSize( this );
+        legendChanged();
+    }
+}
+/*!
+  \return True, when attribute is enabled
+  \sa setLegendAttribute()
 */
 bool QwtPlotCurve::testLegendAttribute( LegendAttribute attribute ) const
 …
+    {
         d_data->style = style;
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
     Return the current style
     \sa setStyle()
+  \return Style of the curve
+  \sa setStyle()
 */
 QwtPlotCurve::CurveStyle QwtPlotCurve::style() const
 …
 /*!
+  Assign a symbol
+  \brief Assign a symbol
+  The curve will take the ownership of the symbol, hence the previously
+  set symbol will be delete by setting a new one. If \p symbol is
+  \c NULL no symbol will be drawn.
   \param symbol Symbol
   \sa symbol()
 */
 void QwtPlotCurve::setSymbol( const QwtSymbol *symbol )
+void QwtPlotCurve::setSymbol( QwtSymbol *symbol )
+{
     if ( symbol != d_data->symbol )
 …
         delete d_data->symbol;
         d_data->symbol = symbol;
+        qwtUpdateLegendIconSize( this );
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
+  Build and assign a pen
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotCurve::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
+/*!
   Assign a pen
 …
+    {
         d_data->pen = pen;
+        legendChanged();
         itemChanged();
+    }
 …
+    {
         d_data->brush = brush;
+        legendChanged();
         itemChanged();
+    }
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first point to be painted
   \param to Index of the last point to be painted. If to < 0 the
 …
     const QRectF &canvasRect, int from, int to ) const
+{
+    if ( !painter || dataSize() <= 0 )
+    const size_t numSamples = dataSize();
+    if ( !painter || numSamples <= 0 )
         return;
     if ( to < 0 )
         to = dataSize() - 1;
     if ( verifyRange( dataSize(), from, to ) > 0 )
+        to = numSamples - 1;
+    if ( qwtVerifyRange( numSamples, from, to ) > 0 )
+    {
         painter->save();
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
 …
     const QRectF &canvasRect, int from, int to ) const
+{
+    int size = to - from + 1;
+    if ( size <= 0 )
+    if ( from > to )
         return;
     const bool doAlign = QwtPainter::roundingAlignment( painter );
+    QPolygonF polyline( size );
+    QPointF *points = polyline.data();
+    for ( int i = from; i <= to; i++ )
+    {
+        const QPointF sample = d_series->sample( i );
+        double x = xMap.transform( sample.x() );
+        double y = yMap.transform( sample.y() );
+        if ( doAlign )
+        {
+            x = qRound( x );
+            y = qRound( y );
+        }
+        points[i - from].rx() = x;
+        points[i - from].ry() = y;
+    }
+    if ( ( d_data->attributes & Fitted ) && d_data->curveFitter )
+        polyline = d_data->curveFitter->fitCurve( polyline );
+    const bool doFit = ( d_data->attributes & Fitted ) && d_data->curveFitter;
+    const bool doFill = ( d_data->brush.style() != Qt::NoBrush )
+            && ( d_data->brush.color().alpha() > 0 );
+    QRectF clipRect;
     if ( d_data->paintAttributes & ClipPolygons )
+    {
         qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF());
+        const QPolygonF clipped = QwtClipper::clipPolygonF(
+            canvasRect.adjusted(-pw, -pw, pw, pw), polyline, false );
+        QwtPainter::drawPolyline( painter, clipped );
+        clipRect = canvasRect.adjusted(-pw, -pw, pw, pw);
+    }
+    bool doIntegers = false;
+#if QT_VERSION < 0x040800
+    // For Qt <= 4.7 the raster paint engine is significantly faster
+    // for rendering QPolygon than for QPolygonF. So let's
+    // see if we can use it.
+    if ( painter->paintEngine()->type() == QPaintEngine::Raster )
+    {
+        // In case of filling or fitting performance doesn't count
+        // because both operations are much more expensive
+        // then drawing the polyline itself
+        if ( !doFit && !doFill )
+            doIntegers = true;
+    }
+#endif
+    const bool noDuplicates = d_data->paintAttributes & FilterPoints;
+    QwtPointMapper mapper;
+    mapper.setFlag( QwtPointMapper::RoundPoints, doAlign );
+    mapper.setFlag( QwtPointMapper::WeedOutPoints, noDuplicates );
+    mapper.setBoundingRect( canvasRect );
+    if ( doIntegers )
+    {
+        QPolygon polyline = mapper.toPolygon(
+            xMap, yMap, data(), from, to );
+        if ( d_data->paintAttributes & ClipPolygons )
+        {
+            polyline = QwtClipper::clipPolygon(
+                clipRect.toAlignedRect(), polyline, false );
+        }
+        QwtPainter::drawPolyline( painter, polyline );
+    }
     else
+    {
+        QwtPainter::drawPolyline( painter, polyline );
+    }
+    if ( d_data->brush.style() != Qt::NoBrush )
+        fillCurve( painter, xMap, yMap, canvasRect, polyline );
+        QPolygonF polyline = mapper.toPolygonF( xMap, yMap, data(), from, to );
+        if ( doFit )
+            polyline = d_data->curveFitter->fitCurve( polyline );
+        if ( doFill )
+        {
+            if ( painter->pen().style() != Qt::NoPen )
+            {
+                // here we are wasting memory for the filled copy,
+                // do polygon clipping twice etc .. TODO
+                QPolygonF filled = polyline;
+                fillCurve( painter, xMap, yMap, canvasRect, filled );
+                filled.clear();
+                if ( d_data->paintAttributes & ClipPolygons )
+                {
+                    polyline = QwtClipper::clipPolygonF(
+                        clipRect, polyline, false );
+                }
+                QwtPainter::drawPolyline( painter, polyline );
+            }
+            else
+            {
+                fillCurve( painter, xMap, yMap, canvasRect, polyline );
+            }
+        }
+        else
+        {
+            if ( d_data->paintAttributes & ClipPolygons )
+            {
+                polyline = QwtClipper::clipPolygonF(
+                    clipRect, polyline, false );
+            }
+            QwtPainter::drawPolyline( painter, polyline );
+        }
+    }
+}
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
 …
     const Qt::Orientation o = orientation();
+    const QwtSeriesData<QPointF> *series = data();
     for ( int i = from; i <= to; i++ )
+    {
         const QPointF sample = d_series->sample( i );
+        const QPointF sample = series->sample( i );
         double xi = xMap.transform( sample.x() );
         double yi = yMap.transform( sample.y() );
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
 …
     const QRectF &canvasRect, int from, int to ) const
+{
+    const bool doFill = d_data->brush.style() != Qt::NoBrush;
+    const QColor color = painter->pen().color();
+    if ( painter->pen().style() == Qt::NoPen || color.alpha() == 0 )
+    {
+        return;
+    }
+    const bool doFill = ( d_data->brush.style() != Qt::NoBrush )
+            && ( d_data->brush.color().alpha() > 0 );
     const bool doAlign = QwtPainter::roundingAlignment( painter );
+    QPolygonF polyline;
+    QwtPointMapper mapper;
+    mapper.setBoundingRect( canvasRect );
+    mapper.setFlag( QwtPointMapper::RoundPoints, doAlign );
+    if ( d_data->paintAttributes & FilterPoints )
+    {
+        if ( ( color.alpha() == 255 )
+            && !( painter->renderHints() & QPainter::Antialiasing ) )
+        {
+            mapper.setFlag( QwtPointMapper::WeedOutPoints, true );
+        }
+    }
     if ( doFill )
+        polyline.resize( to - from + 1 );
+    QPointF *points = polyline.data();
+    for ( int i = from; i <= to; i++ )
+    {
+        const QPointF sample = d_series->sample( i );
+        double xi = xMap.transform( sample.x() );
+        double yi = yMap.transform( sample.y() );
+    {
+        mapper.setFlag( QwtPointMapper::WeedOutPoints, false );
+        QPolygonF points = mapper.toPointsF(
+            xMap, yMap, data(), from, to );
+        QwtPainter::drawPoints( painter, points );
+        fillCurve( painter, xMap, yMap, canvasRect, points );
+    }
+    else if ( d_data->paintAttributes & ImageBuffer )
+    {
+        const QImage image = mapper.toImage( xMap, yMap,
+            data(), from, to, d_data->pen,
+            painter->testRenderHint( QPainter::Antialiasing ),
+            renderThreadCount() );
+        painter->drawImage( canvasRect.toAlignedRect(), image );
+    }
+    else if ( d_data->paintAttributes & MinimizeMemory )
+    {
+        const QwtSeriesData<QPointF> *series = data();
+        for ( int i = from; i <= to; i++ )
+        {
+            const QPointF sample = series->sample( i );
+            double xi = xMap.transform( sample.x() );
+            double yi = yMap.transform( sample.y() );
+            if ( doAlign )
+            {
+                xi = qRound( xi );
+                yi = qRound( yi );
+            }
+            QwtPainter::drawPoint( painter, QPointF( xi, yi ) );
+        }
+    }
+    else
+    {
         if ( doAlign )
+        {
+            xi = qRound( xi );
+            yi = qRound( yi );
+        }
+        QwtPainter::drawPoint( painter, QPointF( xi, yi ) );
+        if ( doFill )
+        {
+            points[i - from].rx() = xi;
+            points[i - from].ry() = yi;
+        }
+    }
+    if ( doFill )
+        fillCurve( painter, xMap, yMap, canvasRect, polyline );
+            const QPolygon points = mapper.toPoints(
+                xMap, yMap, data(), from, to );
+            QwtPainter::drawPoints( painter, points );
+        }
+        else
+        {
+            const QPolygonF points = mapper.toPointsF(
+                xMap, yMap, data(), from, to );
+            QwtPainter::drawPoints( painter, points );
+        }
+    }
+}
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from index of the first point to be painted
   \param to index of the last point to be painted
 …
         inverted = !inverted;
+    const QwtSeriesData<QPointF> *series = data();
     int i, ip;
     for ( i = from, ip = 0; i <= to; i++, ip += 2 )
+    {
         const QPointF sample = d_series->sample( i );
+        const QPointF sample = series->sample( i );
         double xi = xMap.transform( sample.x() );
         double yi = yMap.transform( sample.y() );
 …
     if ( d_data->paintAttributes & ClipPolygons )
+    {
+        qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF());
+        const QRectF clipRect = canvasRect.adjusted(-pw, -pw, pw, pw);
         const QPolygonF clipped = QwtClipper::clipPolygonF(
             canvasRect, polygon, false );
+            clipRect, polygon, false );
         QwtPainter::drawPolyline( painter, clipped );
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param polygon Polygon - will be modified !
 …
     if ( orientation() == Qt::Vertical )
+    {
+        if ( yMap.transformation()->type() == QwtScaleTransformation::Log10 )
+        {
+            if ( baseline < QwtScaleMap::LogMin )
+                baseline = QwtScaleMap::LogMin;
+        }
+        if ( yMap.transformation() )
+            baseline = yMap.transformation()->bounded( baseline );
         double refY = yMap.transform( baseline );
 …
     else
+    {
+        if ( xMap.transformation()->type() == QwtScaleTransformation::Log10 )
+        {
+            if ( baseline < QwtScaleMap::LogMin )
+                baseline = QwtScaleMap::LogMin;
+        }
+        if ( xMap.transformation() )
+            baseline = xMap.transformation()->bounded( baseline );
         double refX = xMap.transform( baseline );
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first point to be painted
   \param to Index of the last point to be painted
 …
     const QRectF &canvasRect, int from, int to ) const
+{
+    const bool doAlign = QwtPainter::roundingAlignment( painter );
+    bool usePixmap = testPaintAttribute( CacheSymbols );
+    if ( usePixmap && !doAlign )
+    {
+        // Don't use the pixmap, when the paint device
+        // could generate scalable vectors
+        usePixmap = false;
+    }
+    if ( usePixmap )
+    {
+        QPixmap pm( symbol.boundingSize() );
+        pm.fill( Qt::transparent );
+        const double pw2 = 0.5 * pm.width();
+        const double ph2 = 0.5 * pm.height();
+        QPainter p( &pm );
+        p.setRenderHints( painter->renderHints() );
+        symbol.drawSymbol( &p, QPointF( pw2, ph2 ) );
+        p.end();
+        for ( int i = from; i <= to; i++ )
+        {
+            const QPointF sample = d_series->sample( i );
+            double xi = xMap.transform( sample.x() );
+            double yi = yMap.transform( sample.y() );
+            if ( doAlign )
+            {
+                xi = qRound( xi );
+                yi = qRound( yi );
+            }
+            if ( canvasRect.contains( xi, yi ) )
+            {
+                const int left = qCeil( xi ) - pw2;
+                const int top = qCeil( yi ) - ph2;
+                painter->drawPixmap( left, top, pm );
+            }
+        }
+    }
+    else
+    {
+        const int chunkSize = 500;
+        for ( int i = from; i <= to; i += chunkSize )
+        {
+            const int n = qMin( chunkSize, to - i + 1 );
+            QPolygonF points;
+            for ( int j = 0; j < n; j++ )
+            {
+                const QPointF sample = d_series->sample( i + j );
+                const double xi = xMap.transform( sample.x() );
+                const double yi = yMap.transform( sample.y() );
+                if ( canvasRect.contains( xi, yi ) )
+                    points += QPointF( xi, yi );
+            }
+            if ( points.size() > 0 )
+                symbol.drawSymbols( painter, points );
+        }
+    QwtPointMapper mapper;
+    mapper.setFlag( QwtPointMapper::RoundPoints,
+        QwtPainter::roundingAlignment( painter ) );
+    mapper.setFlag( QwtPointMapper::WeedOutPoints,
+        testPaintAttribute( QwtPlotCurve::FilterPoints ) );
+    mapper.setBoundingRect( canvasRect );
+    const int chunkSize = 500;
+    for ( int i = from; i <= to; i += chunkSize )
+    {
+        const int n = qMin( chunkSize, to - i + 1 );
+        const QPolygonF points = mapper.toPointsF( xMap, yMap,
+            data(), i, i + n - 1 );
+        if ( points.size() > 0 )
+            symbol.drawSymbols( painter, points );
+    }
+}
 …
   The baseline is needed for filling the curve with a brush or
   the Sticks drawing style.
+  The interpretation of the baseline depends on the CurveType.
+  With QwtPlotCurve::Yfx, the baseline is interpreted as a horizontal line
+  at y = baseline(), with QwtPlotCurve::Yfy, it is interpreted as a vertical
+  The interpretation of the baseline depends on the orientation().
+  With Qt::Horizontal, the baseline is interpreted as a horizontal line
+  at y = baseline(), with Qt::Vertical, it is interpreted as a vertical
   line at x = baseline().
 …
   \param value Value of the baseline
   \sa baseline(), setBrush(), setStyle(), setStyle()
+  \sa baseline(), setBrush(), setStyle(), QwtPlotAbstractSeriesItem::orientation()
 */
 void QwtPlotCurve::setBaseline( double value )
 …
   \param pos Position, where to look for the closest curve point
   \param dist If dist != NULL, closestPoint() returns the distance between
               the position and the clostest curve point
+              the position and the closest curve point
   \return Index of the closest curve point, or -1 if none can be found
           ( f.e when the curve has no points )
 …
 int QwtPlotCurve::closestPoint( const QPoint &pos, double *dist ) const
+{
+    if ( plot() == NULL || dataSize() <= 0 )
+    const size_t numSamples = dataSize();
+    if ( plot() == NULL || numSamples <= 0 )
         return -1;
+    const QwtSeriesData<QPointF> *series = data();
     const QwtScaleMap xMap = plot()->canvasMap( xAxis() );
 …
     double dmin = 1.0e10;
     for ( uint i = 0; i < dataSize(); i++ )
+    {
         const QPointF sample = d_series->sample( i );
+    for ( uint i = 0; i < numSamples; i++ )
+    {
+        const QPointF sample = series->sample( i );
         const double cx = xMap.transform( sample.x() ) - pos.x();
 …
 /*!
+   \brief Update the widget that represents the item on the legend
+   \param legend Legend
+   \sa drawLegendIdentifier(), legendItem(), QwtPlotItem::Legend
+*/
+void QwtPlotCurve::updateLegend( QwtLegend *legend ) const
+{
+    if ( legend && testItemAttribute( QwtPlotItem::Legend )
+        && ( d_data->legendAttributes & QwtPlotCurve::LegendShowSymbol )
+        && d_data->symbol
+        && d_data->symbol->style() != QwtSymbol::NoSymbol )
+    {
+        QWidget *lgdItem = legend->find( this );
+        if ( lgdItem == NULL )
+        {
+            lgdItem = legendItem();
+            if ( lgdItem )
+                legend->insert( this, lgdItem );
+        }
+        QwtLegendItem *l = qobject_cast<QwtLegendItem *>( lgdItem );
+        if ( l )
+        {
+            QSize sz = d_data->symbol->boundingSize();
+            sz += QSize( 2, 2 ); // margin
+            if ( d_data->legendAttributes & QwtPlotCurve::LegendShowLine )
+   \return Icon representing the curve on the legend
+   \param index Index of the legend entry
+                ( ignored as there is only one )
+   \param size Icon size
+   \sa QwtPlotItem::setLegendIconSize(), QwtPlotItem::legendData()
+ */
+QwtGraphic QwtPlotCurve::legendIcon( int index,
+    const QSizeF &size ) const
+{
+    Q_UNUSED( index );
+    if ( size.isEmpty() )
+        return QwtGraphic();
+    QwtGraphic graphic;
+    graphic.setDefaultSize( size );
+    graphic.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
+    QPainter painter( &graphic );
+    painter.setRenderHint( QPainter::Antialiasing,
+        testRenderHint( QwtPlotItem::RenderAntialiased ) );
+    if ( d_data->legendAttributes == 0 ||
+        d_data->legendAttributes & QwtPlotCurve::LegendShowBrush )
+    {
+        QBrush brush = d_data->brush;
+        if ( brush.style() == Qt::NoBrush &&
+            d_data->legendAttributes == 0 )
+        {
+            if ( style() != QwtPlotCurve::NoCurve )
+            {
+                // Avoid, that the line is completely covered by the symbol
+                int w = qCeil( 1.5 * sz.width() );
+                if ( w % 2 )
+                    w++;
+                sz.setWidth( qMax( 8, w ) );
+                brush = QBrush( pen().color() );
+            }
-            l->setIdentifierSize( sz );
+        }
+    }
-    QwtPlotItem::updateLegend( legend );
+}
-/*!
-  \brief Draw the identifier representing the curve on the legend
-  \param painter Painter
-  \param rect Bounding rectangle for the identifier
-  \sa setLegendAttribute(), QwtPlotItem::Legend
-*/
-void QwtPlotCurve::drawLegendIdentifier(
-    QPainter *painter, const QRectF &rect ) const
+{
-    if ( rect.isEmpty() )
-        return;
-    const int dim = qMin( rect.width(), rect.height() );
-    QSize size( dim, dim );
-    QRectF r( 0, 0, size.width(), size.height() );
-    r.moveCenter( rect.center() );
-    if ( d_data->legendAttributes == 0 )
+    {
-        QBrush brush = d_data->brush;
-        if ( brush.style() == Qt::NoBrush )
+        {
-            if ( style() != QwtPlotCurve::NoCurve )
-                brush = QBrush( pen().color() );
             else if ( d_data->symbol &&
                 ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
 …
+            }
+        }
         if ( brush.style() != Qt::NoBrush )
+            painter->fillRect( r, brush );
+    }
+    if ( d_data->legendAttributes & QwtPlotCurve::LegendShowBrush )
+    {
+        if ( d_data->brush.style() != Qt::NoBrush )
+            painter->fillRect( r, d_data->brush );
+    }
+        {
+            QRectF r( 0, 0, size.width(), size.height() );
+            painter.fillRect( r, brush );
+        }
+    }
     if ( d_data->legendAttributes & QwtPlotCurve::LegendShowLine )
+    {
         if ( pen() != Qt::NoPen )
+        {
+            painter->setPen( pen() );
+            QwtPainter::drawLine( painter, rect.left(), rect.center().y(),
+                                  rect.right() - 1.0, rect.center().y() );
+        }
+    }
+            QPen pn = pen();
+            pn.setCapStyle( Qt::FlatCap );
+            painter.setPen( pn );
+            const double y = 0.5 * size.height();
+            QwtPainter::drawLine( &painter, 0.0, y, size.width(), y );
+        }
+    }
     if ( d_data->legendAttributes & QwtPlotCurve::LegendShowSymbol )
+    {
+        if ( d_data->symbol &&
+            ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
+        {
+            QSize symbolSize = d_data->symbol->boundingSize();
+            symbolSize -= QSize( 2, 2 );
+            // scale the symbol size down if it doesn't fit into rect.
+            double xRatio = 1.0;
+            if ( rect.width() < symbolSize.width() )
+                xRatio = rect.width() / symbolSize.width();
+            double yRatio = 1.0;
+            if ( rect.height() < symbolSize.height() )
+                yRatio = rect.height() / symbolSize.height();
+            const double ratio = qMin( xRatio, yRatio );
+            painter->save();
+            painter->scale( ratio, ratio );
+            d_data->symbol->drawSymbol( painter, rect.center() / ratio );
+            painter->restore();
+        }
+    }
+}
+/*!
+  Initialize data with an array of points (explicitly shared).
+        if ( d_data->symbol )
+        {
+            QRectF r( 0, 0, size.width(), size.height() );
+            d_data->symbol->drawSymbol( &painter, r );
+        }
+    }
+    return graphic;
+}
+/*!
+  Initialize data with an array of points.
   \param samples Vector of points
+  \note QVector is implicitly shared
+  \note QPolygonF is derived from QVector<QPointF>
 */
 void QwtPlotCurve::setSamples( const QVector<QPointF> &samples )
+{
+    delete d_series;
+    d_series = new QwtPointSeriesData( samples );
+    itemChanged();
+    setData( new QwtPointSeriesData( samples ) );
+}
+/*!
+  Assign a series of points
+  setSamples() is just a wrapper for setData() without any additional
+  value - beside that it is easier to find for the developer.
+  \param data Data
+  \warning The item takes ownership of the data object, deleting
+           it when its not used anymore.
+*/
+void QwtPlotCurve::setSamples( QwtSeriesData<QPointF> *data )
+{
+    setData( data );
+}
 …
     const double *xData, const double *yData, int size )
+{
+    delete d_series;
+    d_series = new QwtCPointerData( xData, yData, size );
+    itemChanged();
+    setData( new QwtCPointerData( xData, yData, size ) );
+}
 …
     const double *xData, const double *yData, int size )
+{
+    delete d_series;
+    d_series = new QwtPointArrayData( xData, yData, size );
+    itemChanged();
+    setData( new QwtPointArrayData( xData, yData, size ) );
+}
 …
     const QVector<double> &yData )
+{
+    delete d_series;
+    d_series = new QwtPointArrayData( xData, yData );
+    itemChanged();
+}
+    setData( new QwtPointArrayData( xData, yData ) );
+}
 #endif // !QWT_NO_COMPAT

trunk/BNC/qwt/qwt_plot_curve.h

-              r4271
+              r8127
   \sa QwtPointSeriesData, QwtSymbol, QwtScaleMap
 */
+class QWT_EXPORT QwtPlotCurve: public QwtPlotSeriesItem<QPointF>
+class QWT_EXPORT QwtPlotCurve:
+    public QwtPlotSeriesItem, public QwtSeriesStore<QPointF>
+{
 public:
 …
           interpolate/smooth the curve, before it is painted.
           \note Curve fitting requires temorary memory
+          \note Curve fitting requires temporary memory
           for calculating coefficients and additional points.
           If painting in QwtPlotCurve::Fitted mode is slow it might be better
 …
         \sa setLegendAttribute(), testLegendAttribute(),
             drawLegendIdentifier()
+            QwtPlotItem::legendData(), legendIcon()
      */
 …
     /*!
         Attributes to modify the drawing algorithm.
         The default setting enables ClipPolygons
+        The default setting enables ClipPolygons | FilterPoints
         \sa setPaintAttribute(), testPaintAttribute()
 …
         /*!
+          Paint the symbol to a QPixmap and paint the pixmap
+          instead rendering the symbol for each point. The flag has
+          no effect, when the curve is not painted to the canvas
+          ( f.e when exporting the plot to a PDF document ).
+         */
+        CacheSymbols = 0x02
+          Tries to reduce the data that has to be painted, by sorting out
+          duplicates, or paintings outside the visible area. Might have a
+          notable impact on curves with many close points.
+          Only a couple of very basic filtering algorithms are implemented.
+         */
+        FilterPoints = 0x02,
+        /*!
+          Minimize memory usage that is temporarily needed for the
+          translated points, before they get painted.
+          This might slow down the performance of painting
+         */
+        MinimizeMemory = 0x04,
+        /*!
+          Render the points to a temporary image and paint the image.
+          This is a very special optimization for Dots style, when
+          having a huge amount of points.
+          With a reasonable number of points QPainter::drawPoints()
+          will be faster.
+         */
+        ImageBuffer = 0x08
     };
 …
 #endif
     void setSamples( const QVector<QPointF> & );
+    void setSamples( QwtSeriesData<QPointF> * );
     int closestPoint( const QPoint &pos, double *dist = NULL ) const;
 …
     bool testCurveAttribute( CurveAttribute ) const;
+    void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setPen( const QPen & );
     const QPen &pen() const;
 …
     const QBrush &brush() const;
     void setBaseline( double ref );
+    void setBaseline( double );
     double baseline() const;
 …
     CurveStyle style() const;
     void setSymbol( const QwtSymbol *s );
+    void setSymbol( QwtSymbol * );
     const QwtSymbol *symbol() const;
 …
         const QRectF &canvasRect, int from, int to ) const;
+    virtual void updateLegend( QwtLegend * ) const;
+    virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF & ) const;
 protected:
 …
         const QRectF &canvasRect, int from, int to ) const;
     void drawLines( QPainter *p,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;
     void drawSticks( QPainter *p,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;
     void drawDots( QPainter *p,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;
     void drawSteps( QPainter *p,
+    virtual void drawLines( QPainter *p,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawSticks( QPainter *p,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawDots( QPainter *p,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawSteps( QPainter *p,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;

trunk/BNC/qwt/qwt_plot_dict.cpp

-              r4271
+              r8127
    Auto deletion is enabled.
    \sa setAutoDelete(), attachItem()
+   \sa setAutoDelete(), QwtPlotItem::attach()
 */
 QwtPlotDict::QwtPlotDict()
 …
    Destructor
    If autoDelete is on, all attached items will be deleted
    \sa setAutoDelete(), autoDelete(), attachItem()
+   If autoDelete() is on, all attached items will be deleted
+   \sa setAutoDelete(), autoDelete(), QwtPlotItem::attach()
 */
 QwtPlotDict::~QwtPlotDict()
 …
    in the destructor of QwtPlotDict. The default value is on.
    \sa autoDelete(), attachItem()
+   \sa autoDelete(), insertItem()
 */
 void QwtPlotDict::setAutoDelete( bool autoDelete )
 …
 /*!
    \return true if auto deletion is enabled
    \sa setAutoDelete(), attachItem()
+   \sa setAutoDelete(), insertItem()
 */
 bool QwtPlotDict::autoDelete() const
 …
 /*!
    Attach/Detach a plot item
+  Insert a plot item
+   Attached items will be deleted in the destructor,
+   if auto deletion is enabled (default). Manually detached
+   items are not deleted.
+  \param item PlotItem
+  \sa removeItem()
+ */
+void QwtPlotDict::insertItem( QwtPlotItem *item )
+{
+    d_data->itemList.insertItem( item );
+}
+   \param item Plot item to attach/detach
    \ on If true attach, else detach the item
+/*!
+  Remove a plot item
+   \sa setAutoDelete(), ~QwtPlotDict()
+*/
+void QwtPlotDict::attachItem( QwtPlotItem *item, bool on )
+  \param item PlotItem
+  \sa insertItem()
+ */
+void QwtPlotDict::removeItem( QwtPlotItem *item )
+{
+    if ( on )
+        d_data->itemList.insertItem( item );
+    else
+        d_data->itemList.removeItem( item );
+    d_data->itemList.removeItem( item );
+}
 …
 /*!
   \return List of all attached plot items of a specific type.
+  \param rtti See QwtPlotItem::RttiValues
   \sa QwtPlotItem::rtti()
 */

trunk/BNC/qwt/qwt_plot_dict.h

-              r4271
+              r8127
   If autoDelete() is enabled, all attached items will be deleted
   in the destructor of the dictionary.
+  QwtPlotDict can be used to get access to all QwtPlotItem items - or all
+  items of a specific type -  that are currently on the plot.
   \sa QwtPlotItem::attach(), QwtPlotItem::detach(), QwtPlotItem::z()
 …
         bool autoDelete = true );
+protected:
+    void insertItem( QwtPlotItem * );
+    void removeItem( QwtPlotItem * );
 private:
-    friend class QwtPlotItem;
-    void attachItem( QwtPlotItem *, bool );
     class PrivateData;
     PrivateData *d_data;

trunk/BNC/qwt/qwt_plot_directpainter.cpp

-              r4271
+              r8127
 #include <qpixmap.h>
 static inline void renderItem(
+static inline void qwtRenderItem(
     QPainter *painter, const QRect &canvasRect,
     QwtPlotAbstractSeriesItem *seriesItem, int from, int to )
+    QwtPlotSeriesItem *seriesItem, int from, int to )
+{
     // A minor performance improvement is possible
 …
         seriesItem->testRenderHint( QwtPlotItem::RenderAntialiased ) );
     seriesItem->drawSeries( painter, xMap, yMap, canvasRect, from, to );
+}
+static inline bool qwtHasBackingStore( const QwtPlotCanvas *canvas )
+{
+    return canvas->testPaintAttribute( QwtPlotCanvas::BackingStore )
+        && canvas->backingStore() && !canvas->backingStore()->isNull();
+}
 …
         attributes( 0 ),
         hasClipping(false),
+        seriesItem( NULL )
+        seriesItem( NULL ),
+        from( 0 ),
+        to( 0 )
+    {
+    }
 …
     QPainter painter;
     QwtPlotAbstractSeriesItem *seriesItem;
+    QwtPlotSeriesItem *seriesItem;
     int from;
     int to;
 …
 /*!
+  Check if a attribute is set.
+  \return True, when attribute is enabled
   \param attribute Attribute to be tested
   \sa Attribute, setAttribute()
 …
   When observing an measurement while it is running, new points have to be
   added to an existing seriesItem. drawSeries can be used to display them avoiding
+  added to an existing seriesItem. drawSeries() can be used to display them avoiding
   a complete redraw of the canvas.
 …
 */
 void QwtPlotDirectPainter::drawSeries(
     QwtPlotAbstractSeriesItem *seriesItem, int from, int to )
+    QwtPlotSeriesItem *seriesItem, int from, int to )
+{
     if ( seriesItem == NULL || seriesItem->plot() == NULL )
         return;
     QwtPlotCanvas *canvas = seriesItem->plot()->canvas();
+    QWidget *canvas = seriesItem->plot()->canvas();
     const QRect canvasRect = canvas->contentsRect();
+    const bool hasBackingStore =
+        canvas->testPaintAttribute( QwtPlotCanvas::BackingStore )
+        && canvas->backingStore() && !canvas->backingStore()->isNull();
+    if ( hasBackingStore )
+    {
+        QPainter painter( const_cast<QPixmap *>( canvas->backingStore() ) );
+        painter.translate( -canvasRect.x(), -canvasRect.y() );
+    QwtPlotCanvas *plotCanvas = qobject_cast<QwtPlotCanvas *>( canvas );
+    if ( plotCanvas && qwtHasBackingStore( plotCanvas ) )
+    {
+        QPainter painter( const_cast<QPixmap *>( plotCanvas->backingStore() ) );
         if ( d_data->hasClipping )
             painter.setClipRegion( d_data->clipRegion );
+        renderItem( &painter, canvasRect, seriesItem, from, to );
+        qwtRenderItem( &painter, canvasRect, seriesItem, from, to );
+        painter.end();
         if ( testAttribute( QwtPlotDirectPainter::FullRepaint ) )
+        {
             canvas->repaint();
+            plotCanvas->repaint();
             return;
+        }
 …
     bool immediatePaint = true;
+    if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) &&
+        !canvas->testAttribute( Qt::WA_PaintOutsidePaintEvent ) )
+    {
+        immediatePaint = false;
+    if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) )
+    {
+#if QT_VERSION < 0x050000
+        if ( !canvas->testAttribute( Qt::WA_PaintOutsidePaintEvent ) )
+#endif
+            immediatePaint = false;
+    }
     if ( immediatePaint )
+    {
-        QwtPlotCanvas *canvas = seriesItem->plot()->canvas();
         if ( !d_data->painter.isActive() )
+        {
 …
+        }
         renderItem( &d_data->painter, canvasRect, seriesItem, from, to );
+        qwtRenderItem( &d_data->painter, canvasRect, seriesItem, from, to );
         if ( d_data->attributes & QwtPlotDirectPainter::AtomicPainter )
 …
     if ( d_data->painter.isActive() )
+    {
         QWidget *w = ( QWidget * )d_data->painter.device();
+        QWidget *w = static_cast<QWidget *>( d_data->painter.device() );
         if ( w )
             w->removeEventFilter( this );
 …
             const QPaintEvent *pe = static_cast< QPaintEvent *>( event );
             QwtPlotCanvas *canvas = d_data->seriesItem->plot()->canvas();
+            QWidget *canvas = d_data->seriesItem->plot()->canvas();
             QPainter painter( canvas );
             painter.setClipRegion( pe->region() );
+            bool copyCache = testAttribute( CopyBackingStore )
+                && canvas->testPaintAttribute( QwtPlotCanvas::BackingStore );
+            if ( copyCache )
+            bool doCopyCache = testAttribute( CopyBackingStore );
+            if ( doCopyCache )
+            {
+                // is something valid in the cache ?
+                copyCache = ( canvas->backingStore() != NULL )
+                    && !canvas->backingStore()->isNull();
+                QwtPlotCanvas *plotCanvas =
+                    qobject_cast<QwtPlotCanvas *>( canvas );
+                if ( plotCanvas )
+                {
+                    doCopyCache = qwtHasBackingStore( plotCanvas );
+                    if ( doCopyCache )
+                    {
+                        painter.drawPixmap( plotCanvas->rect().topLeft(),
+                            *plotCanvas->backingStore() );
+                    }
+                }
+            }
             if ( copyCache )
+            if ( !doCopyCache )
+            {
+                painter.drawPixmap(
+                    canvas->contentsRect().topLeft(),
+                    *canvas->backingStore() );
+            }
+            else
+            {
+                renderItem( &painter, canvas->contentsRect(),
+                qwtRenderItem( &painter, canvas->contentsRect(),
                     d_data->seriesItem, d_data->from, d_data->to );
+            }

trunk/BNC/qwt/qwt_plot_directpainter.h

-              r4271
+              r8127
 class QRegion;
 class QwtPlotAbstractSeriesItem;
+class QwtPlotSeriesItem;
 /*!
 …
         /*!
           When FullRepaint is set the plot canvas is explicitely repainted
+          When FullRepaint is set the plot canvas is explicitly repainted
           after the samples have been rendered.
          */
 …
           has to paint to the backing store and the widget. In certain
           situations/environments it might be faster to paint to
           the backing store only and then copy the backingstore to the canvas.
+          the backing store only and then copy the backing store to the canvas.
           This flag can also be useful for settings, where Qt fills the
           the clip region with the widget background.
 …
     QRegion clipRegion() const;
     void drawSeries( QwtPlotAbstractSeriesItem *, int from, int to );
+    void drawSeries( QwtPlotSeriesItem *, int from, int to );
     void reset();

trunk/BNC/qwt/qwt_plot_grid.cpp

-              r4271
+              r8127
     QwtScaleDiv yScaleDiv;
     QPen majPen;
     QPen minPen;
+    QPen majorPen;
+    QPen minorPen;
 };
 …
+{
     d_data = new PrivateData;
+    setItemInterest( QwtPlotItem::ScaleInterest, true );
     setZ( 10.0 );
+}
 …
 /*!
   \brief Enable or disable vertical gridlines
   \param tf Enable (true) or disable
   \sa Minor gridlines can be enabled or disabled with
+  \brief Enable or disable vertical grid lines
+  \param on Enable (true) or disable
+  \sa Minor grid lines can be enabled or disabled with
       enableXMin()
 */
+void QwtPlotGrid::enableX( bool tf )
+{
+    if ( d_data->xEnabled != tf )
+    {
+        d_data->xEnabled = tf;
+        itemChanged();
+    }
+}
+/*!
+  \brief Enable or disable horizontal gridlines
+  \param tf Enable (true) or disable
+  \sa Minor gridlines can be enabled or disabled with enableYMin()
+*/
+void QwtPlotGrid::enableY( bool tf )
+{
+    if ( d_data->yEnabled != tf )
+    {
+        d_data->yEnabled = tf;
+        itemChanged();
+    }
+}
+/*!
+  \brief Enable or disable  minor vertical gridlines.
+  \param tf Enable (true) or disable
+void QwtPlotGrid::enableX( bool on )
+{
+    if ( d_data->xEnabled != on )
+    {
+        d_data->xEnabled = on;
+        legendChanged();
+        itemChanged();
+    }
+}
+/*!
+  \brief Enable or disable horizontal grid lines
+  \param on Enable (true) or disable
+  \sa Minor grid lines can be enabled or disabled with enableYMin()
+*/
+void QwtPlotGrid::enableY( bool on )
+{
+    if ( d_data->yEnabled != on )
+    {
+        d_data->yEnabled = on;
+        legendChanged();
+        itemChanged();
+    }
+}
+/*!
+  \brief Enable or disable  minor vertical grid lines.
+  \param on Enable (true) or disable
   \sa enableX()
 */
+void QwtPlotGrid::enableXMin( bool tf )
+{
+    if ( d_data->xMinEnabled != tf )
+    {
+        d_data->xMinEnabled = tf;
+        itemChanged();
+    }
+}
+/*!
+  \brief Enable or disable minor horizontal gridlines
+  \param tf Enable (true) or disable
+void QwtPlotGrid::enableXMin( bool on )
+{
+    if ( d_data->xMinEnabled != on )
+    {
+        d_data->xMinEnabled = on;
+        legendChanged();
+        itemChanged();
+    }
+}
+/*!
+  \brief Enable or disable minor horizontal grid lines
+  \param on Enable (true) or disable
   \sa enableY()
 */
+void QwtPlotGrid::enableYMin( bool tf )
+{
+    if ( d_data->yMinEnabled != tf )
+    {
+        d_data->yMinEnabled = tf;
+void QwtPlotGrid::enableYMin( bool on )
+{
+    if ( d_data->yMinEnabled != on )
+    {
+        d_data->yMinEnabled = on;
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
+  Assign a pen for both major and minor gridlines
+  Build and assign a pen for both major and minor grid lines
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotGrid::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
+/*!
+  Assign a pen for both major and minor grid lines
   \param pen Pen
   \sa setMajPen(), setMinPen()
+  \sa setMajorPen(), setMinorPen()
 */
 void QwtPlotGrid::setPen( const QPen &pen )
+{
+    if ( d_data->majPen != pen || d_data->minPen != pen )
+    {
+        d_data->majPen = pen;
+        d_data->minPen = pen;
+        itemChanged();
+    }
+}
+/*!
+  Assign a pen for the major gridlines
+    if ( d_data->majorPen != pen || d_data->minorPen != pen )
+    {
+        d_data->majorPen = pen;
+        d_data->minorPen = pen;
+        legendChanged();
+        itemChanged();
+    }
+}
+/*!
+  Build and assign a pen for both major grid lines
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotGrid::setMajorPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setMajorPen( QPen( color, width, style ) );
+}
+/*!
+  Assign a pen for the major grid lines
   \param pen Pen
+  \sa majPen(), setMinPen(), setPen()
+*/
+void QwtPlotGrid::setMajPen( const QPen &pen )
+{
+    if ( d_data->majPen != pen )
+    {
+        d_data->majPen = pen;
+        itemChanged();
+    }
+}
+/*!
+  Assign a pen for the minor gridlines
+  \sa majorPen(), setMinorPen(), setPen()
+*/
+void QwtPlotGrid::setMajorPen( const QPen &pen )
+{
+    if ( d_data->majorPen != pen )
+    {
+        d_data->majorPen = pen;
+        legendChanged();
+        itemChanged();
+    }
+}
+/*!
+  Build and assign a pen for the minor grid lines
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotGrid::setMinorPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setMinorPen( QPen( color, width, style ) );
+}
+/*!
+  Assign a pen for the minor grid lines
   \param pen Pen
+  \sa minPen(), setMajPen(), setPen()
+*/
+void QwtPlotGrid::setMinPen( const QPen &pen )
+{
+    if ( d_data->minPen != pen )
+    {
+        d_data->minPen = pen;
+  \sa minorPen(), setMajorPen(), setPen()
+*/
+void QwtPlotGrid::setMinorPen( const QPen &pen )
+{
+    if ( d_data->minorPen != pen )
+    {
+        d_data->minorPen = pen;
+        legendChanged();
         itemChanged();
+    }
 …
   The grid is drawn into the bounding rectangle such that
   gridlines begin and end at the rectangle's borders. The X and Y
+  grid lines begin and end at the rectangle's borders. The X and Y
   maps are used to map the scale divisions into the drawing region
   screen.
   \param painter  Painter
   \param xMap X axis map
   \param yMap Y axis
   \param canvasRect Contents rect of the plot canvas
+  \param canvasRect Contents rectangle of the plot canvas
 */
 void QwtPlotGrid::draw( QPainter *painter,
 …
     const QRectF &canvasRect ) const
+{
     //  draw minor gridlines
     QPen minPen = d_data->minPen;
     minPen.setCapStyle( Qt::FlatCap );
     painter->setPen( minPen );
+    //  draw minor grid lines
+    QPen minorPen = d_data->minorPen;
+    minorPen.setCapStyle( Qt::FlatCap );
+    painter->setPen( minorPen );
     if ( d_data->xEnabled && d_data->xMinEnabled )
 …
+    }
     //  draw major gridlines
     QPen majPen = d_data->majPen;
     majPen.setCapStyle( Qt::FlatCap );
     painter->setPen( majPen );
+    //  draw major grid lines
+    QPen majorPen = d_data->majorPen;
+    majorPen.setCapStyle( Qt::FlatCap );
+    painter->setPen( majorPen );
     if ( d_data->xEnabled )
 …
 /*!
   \return the pen for the major gridlines
   \sa setMajPen(), setMinPen(), setPen()
 */
 const QPen &QwtPlotGrid::majPen() const
+{
     return d_data->majPen;
+}
 /*!
   \return the pen for the minor gridlines
   \sa setMinPen(), setMajPen(), setPen()
 */
 const QPen &QwtPlotGrid::minPen() const
+{
     return d_data->minPen;
+}
 /*!
   \return true if vertical gridlines are enabled
+  \return the pen for the major grid lines
+  \sa setMajorPen(), setMinorPen(), setPen()
+*/
+const QPen &QwtPlotGrid::majorPen() const
+{
+    return d_data->majorPen;
+}
+/*!
+  \return the pen for the minor grid lines
+  \sa setMinorPen(), setMajorPen(), setPen()
+*/
+const QPen &QwtPlotGrid::minorPen() const
+{
+    return d_data->minorPen;
+}
+/*!
+  \return true if vertical grid lines are enabled
   \sa enableX()
 */
 …
 /*!
   \return true if minor vertical gridlines are enabled
+  \return true if minor vertical grid lines are enabled
   \sa enableXMin()
 */
 …
 /*!
   \return true if horizontal gridlines are enabled
+  \return true if horizontal grid lines are enabled
   \sa enableY()
 */
 …
 /*!
   \return true if minor horizontal gridlines are enabled
+  \return true if minor horizontal grid lines are enabled
   \sa enableYMin()
 */

trunk/BNC/qwt/qwt_plot_grid.h

-              r4271
+              r8127
   The QwtPlotGrid class can be used to draw a coordinate grid.
   A coordinate grid consists of major and minor vertical
   and horizontal gridlines. The locations of the gridlines
+  and horizontal grid lines. The locations of the grid lines
   are determined by the X and Y scale divisions which can
   be assigned with setXDiv() and setYDiv().
 …
     const QwtScaleDiv &yScaleDiv() const;
+    void setPen( const QPen &p );
+    void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
+    void setPen( const QPen & );
+    void setMajPen( const QPen &p );
+    const QPen& majPen() const;
+    void setMajorPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
+    void setMajorPen( const QPen & );
+    const QPen& majorPen() const;
+    void setMinPen( const QPen &p );
+    const QPen& minPen() const;
+    void setMinorPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
+    void setMinorPen( const QPen &p );
+    const QPen& minorPen() const;
     virtual void draw( QPainter *p,

trunk/BNC/qwt/qwt_plot_histogram.cpp

-              r4271
+              r8127
 #include "qwt_plot_histogram.h"
 #include "qwt_plot.h"
-#include "qwt_legend.h"
-#include "qwt_legend_item.h"
 #include "qwt_painter.h"
 #include "qwt_column_symbol.h"
 …
 #include <qpainter.h>
 static inline bool isCombinable( const QwtInterval &d1,
+static inline bool qwtIsCombinable( const QwtInterval &d1,
     const QwtInterval &d2 )
+{
 …
   \param title Title of the histogram.
 */
 QwtPlotHistogram::QwtPlotHistogram( const QwtText &title ):
     QwtPlotSeriesItem<QwtIntervalSample>( title )
+    QwtPlotSeriesItem( title )
+{
     init();
 …
 */
 QwtPlotHistogram::QwtPlotHistogram( const QString &title ):
     QwtPlotSeriesItem<QwtIntervalSample>( title )
+    QwtPlotSeriesItem( title )
+{
     init();
 …
+{
     d_data = new PrivateData();
     d_series = new QwtIntervalSeriesData();
+    setData( new QwtIntervalSeriesData() );
     setItemAttribute( QwtPlotItem::AutoScale, true );
 …
+    {
         d_data->style = style;
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
     Return the current style
+    \return Style of the histogram
     \sa HistogramStyle, setStyle()
 */
 …
     return d_data->style;
+}
+/*!
+  Build and assign a pen
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotHistogram::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
 /*!
 …
+    {
         d_data->pen = pen;
+        legendChanged();
         itemChanged();
+    }
 …
+    {
         d_data->brush = brush;
+        legendChanged();
         itemChanged();
+    }
 …
   \note In applications, where different intervals need to be displayed
         in a different way ( f.e different colors or even using differnt symbols)
+        in a different way ( f.e different colors or even using different symbols)
         it is recommended to overload drawColumn().
 */
 …
         delete d_data->symbol;
         d_data->symbol = symbol;
+        legendChanged();
         itemChanged();
+    }
 …
 QRectF QwtPlotHistogram::boundingRect() const
+{
     QRectF rect = d_series->boundingRect();
+    QRectF rect = data()->boundingRect();
     if ( !rect.isValid() )
         return rect;
 …
     const QVector<QwtIntervalSample> &samples )
+{
+    delete d_series;
+    d_series = new QwtIntervalSeriesData( samples );
+    itemChanged();
+    setData( new QwtIntervalSeriesData( samples ) );
+}
+/*!
+  Assign a series of samples
+  setSamples() is just a wrapper for setData() without any additional
+  value - beside that it is easier to find for the developer.
+  \param data Data
+  \warning The item takes ownership of the data object, deleting
+           it when its not used anymore.
+*/
+void QwtPlotHistogram::setSamples(
+    QwtSeriesData<QwtIntervalSample> *data )
+{
+    setData( data );
+}
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first sample to be painted
   \param to Index of the last sample to be painted. If to < 0 the
 …
     for ( int i = from; i <= to; i++ )
+    {
         const QwtIntervalSample sample = d_series->sample( i );
+        const QwtIntervalSample sample = this->sample( i );
         if ( !sample.interval.isValid() )
 …
         if ( previous.interval.isValid() )
+        {
             if ( !isCombinable( previous.interval, sample.interval ) )
+            if ( !qwtIsCombinable( previous.interval, sample.interval ) )
                 flushPolygon( painter, v0, polygon );
+        }
 …
     painter->setBrush( d_data->brush );
+    const QwtSeriesData<QwtIntervalSample> *series = data();
     for ( int i = from; i <= to; i++ )
+    {
         const QwtIntervalSample sample = d_series->sample( i );
+        const QwtIntervalSample sample = series->sample( i );
         if ( !sample.interval.isNull() )
+        {
 …
     painter->setBrush( Qt::NoBrush );
+    const QwtSeriesData<QwtIntervalSample> *series = data();
     for ( int i = from; i <= to; i++ )
+    {
         const QwtIntervalSample sample = d_series->sample( i );
+        const QwtIntervalSample sample = series->sample( i );
         if ( !sample.interval.isNull() )
+        {
 …
             polygon += QPointF( baseLine, polygon.first().y() );
+        }
         QwtPainter::drawPolygon( painter, polygon );
+        polygon.resize( polygon.size() - 2 );
+        polygon.pop_back();
+        polygon.pop_back();
+    }
     if ( d_data->pen.style() != Qt::NoPen )
 …
   \note In applications, where different intervals need to be displayed
         in a different way ( f.e different colors or even using differnt symbols)
+        in a different way ( f.e different colors or even using different symbols)
         it is recommended to overload drawColumn().
 */
 …
 /*!
+  Draw a plain rectangle without pen using the brush() as identifier
+  \param painter Painter
+  \param rect Bounding rectangle for the identifier
+*/
+void QwtPlotHistogram::drawLegendIdentifier(
+    QPainter *painter, const QRectF &rect ) const
+{
+    const double dim = qMin( rect.width(), rect.height() );
+    QSizeF size( dim, dim );
+    QRectF r( 0, 0, size.width(), size.height() );
+    r.moveCenter( rect.center() );
+    painter->fillRect( r, d_data->brush );
+}
+  A plain rectangle without pen using the brush()
+  \param index Index of the legend entry
+                ( ignored as there is only one )
+  \param size Icon size
+  \return A graphic displaying the icon
+  \sa QwtPlotItem::setLegendIconSize(), QwtPlotItem::legendData()
+*/
+QwtGraphic QwtPlotHistogram::legendIcon( int index,
+    const QSizeF &size ) const
+{
+    Q_UNUSED( index );
+    return defaultIcon( d_data->brush, size );
+}

trunk/BNC/qwt/qwt_plot_histogram.h

-              r4271
+              r8127
         While "image histograms" can be displayed by a QwtPlotCurve there
         is no applicable plot item for a "color histogram" yet.
+  \sa QwtPlotBarChart, QwtPlotMultiBarChart
 */
+class QWT_EXPORT QwtPlotHistogram: public QwtPlotSeriesItem<QwtIntervalSample>
+class QWT_EXPORT QwtPlotHistogram:
+    public QwtPlotSeriesItem, public QwtSeriesStore<QwtIntervalSample>
+{
 public:
 …
     virtual int rtti() const;
+    void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setPen( const QPen & );
     const QPen &pen() const;
 …
     void setSamples( const QVector<QwtIntervalSample> & );
+    void setSamples( QwtSeriesData<QwtIntervalSample> * );
     void setBaseline( double reference );
 …
     virtual QRectF boundingRect() const;
     virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF & ) const;
 protected:

trunk/BNC/qwt/qwt_plot_intervalcurve.cpp

-              r4271
+              r8127
 #include "qwt_clipper.h"
 #include "qwt_painter.h"
+#include <string.h>
 #include <qpainter.h>
 …
     const bool isOffScreen = ( y < yMin ) || ( y > yMax )
         || ( x1 < xMin && x2 < xMin ) || ( x1 > yMax && x2 > xMax );
+        || ( x1 < xMin && x2 < xMin ) || ( x1 > xMax && x2 > xMax );
     return !isOffScreen;
 …
 public:
     PrivateData():
         style( Tube ),
+        style( QwtPlotIntervalCurve::Tube ),
         symbol( NULL ),
         pen( Qt::black ),
 …
         paintAttributes = QwtPlotIntervalCurve::ClipPolygons;
         paintAttributes |= QwtPlotIntervalCurve::ClipSymbol;
         pen.setCapStyle( Qt::FlatCap );
+    }
 …
+    }
     CurveStyle style;
+    QwtPlotIntervalCurve::CurveStyle style;
     const QwtIntervalSymbol *symbol;
 …
 */
 QwtPlotIntervalCurve::QwtPlotIntervalCurve( const QwtText &title ):
     QwtPlotSeriesItem<QwtIntervalSample>( title )
+    QwtPlotSeriesItem( title )
+{
     init();
 …
 */
 QwtPlotIntervalCurve::QwtPlotIntervalCurve( const QString &title ):
     QwtPlotSeriesItem<QwtIntervalSample>( QwtText( title ) )
+    QwtPlotSeriesItem( QwtText( title ) )
+{
     init();
 …
     d_data = new PrivateData;
     d_series = new QwtIntervalSeriesData();
+    setData( new QwtIntervalSeriesData() );
     setZ( 19.0 );
 …
   \sa testPaintAttribute()
 */
 void QwtPlotIntervalCurve::setPaintAttribute(
+void QwtPlotIntervalCurve::setPaintAttribute(
     PaintAttribute attribute, bool on )
+{
 …
 /*!
     \brief Return the current paint attributes
+    \return True, when attribute is enabled
     \sa PaintAttribute, setPaintAttribute()
 */
 bool QwtPlotIntervalCurve::testPaintAttribute(
+bool QwtPlotIntervalCurve::testPaintAttribute(
     PaintAttribute attribute ) const
+{
 …
     const QVector<QwtIntervalSample> &samples )
+{
+    delete d_series;
+    d_series = new QwtIntervalSeriesData( samples );
+    itemChanged();
+    setData( new QwtIntervalSeriesData( samples ) );
+}
+/*!
+  Assign a series of samples
+  setSamples() is just a wrapper for setData() without any additional
+  value - beside that it is easier to find for the developer.
+  \param data Data
+  \warning The item takes ownership of the data object, deleting
+           it when its not used anymore.
+*/
+void QwtPlotIntervalCurve::setSamples(
+    QwtSeriesData<QwtIntervalSample> *data )
+{
+    setData( data );
+}
 …
+    {
         d_data->style = style;
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
     \brief Return the current style
+    \return Style of the curve
     \sa setStyle()
 */
 …
         delete d_data->symbol;
         d_data->symbol = symbol;
+        legendChanged();
         itemChanged();
+    }
 …
     return d_data->symbol;
+}
+/*!
+  Build and assign a pen
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotIntervalCurve::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
 /*!
 …
+    {
         d_data->pen = pen;
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
     \brief Return the pen used to draw the lines
+    \return Pen used to draw the lines
     \sa setPen(), brush()
 */
 …
+    {
         d_data->brush = brush;
+        legendChanged();
         itemChanged();
+    }
 …
 QRectF QwtPlotIntervalCurve::boundingRect() const
+{
     QRectF rect = QwtPlotSeriesItem<QwtIntervalSample>::boundingRect();
+    QRectF rect = QwtPlotSeriesItem::boundingRect();
     if ( rect.isValid() && orientation() == Qt::Vertical )
         rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first sample to be painted
   \param to Index of the last sample to be painted. If to < 0 the
 …
         ( d_data->symbol->style() != QwtIntervalSymbol::NoSymbol ) )
+    {
         drawSymbols( painter, *d_data->symbol,
+        drawSymbols( painter, *d_data->symbol,
             xMap, yMap, canvasRect, from, to );
+    }
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first sample to be painted
   \param to Index of the last sample to be painted. If to < 0 the
 …
+        {
             const qreal m = 1.0;
             const QPolygonF p = QwtClipper::clipPolygonF(
                 canvasRect.adjusted(-m, -m, m, m), polygon, true );
+            const QPolygonF p = QwtClipper::clipPolygonF(
+               canvasRect.adjusted( -m, -m, m, m ), polygon, true );
             QwtPainter::drawPolygon( painter, p );
 …
         if ( d_data->paintAttributes & ClipPolygons )
+        {
             qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF());
             const QRectF clipRect = canvasRect.adjusted(-pw, -pw, pw, pw);
+            qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF() );
+            const QRectF clipRect = canvasRect.adjusted( -pw, -pw, pw, pw );
             QPolygonF p;
             p.resize( size );
             qMemCopy( p.data(), points, size * sizeof( QPointF ) );
             p = QwtClipper::clipPolygonF( canvasRect, p );
+            ::memcpy( p.data(), points, size * sizeof( QPointF ) );
+            p = QwtClipper::clipPolygonF( clipRect, p );
             QwtPainter::drawPolyline( painter, p );
             p.resize( size );
             qMemCopy( p.data(), points + size, size * sizeof( QPointF ) );
             p = QwtClipper::clipPolygonF( canvasRect, p );
+            ::memcpy( p.data(), points + size, size * sizeof( QPointF ) );
+            p = QwtClipper::clipPolygonF( clipRect, p );
             QwtPainter::drawPolyline( painter, p );
+        }
 …
   \param xMap x map
   \param yMap y map
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first sample to be painted
   \param to Index of the last sample to be painted
 …
     painter->setBrush( symbol.brush() );
     const QRectF &tr = QwtScaleMap::invTransform( xMap, yMap, canvasRect);
+    const QRectF tr = QwtScaleMap::invTransform( xMap, yMap, canvasRect );
     const double xMin = tr.left();
 …
     const double yMax = tr.bottom();
     const bool doClip = d_data->paintAttributes & ClipPolygons;
+    const bool doClip = d_data->paintAttributes & ClipSymbol;
     for ( int i = from; i <= to; i++ )
 …
 /*!
+  In case of Tibe stale() a plain rectangle is painted without a pen filled
+  the brush(). If a symbol is assigned it is painted cebtered into rect.
+  \param painter Painter
+  \param rect Bounding rectangle for the identifier
+*/
+void QwtPlotIntervalCurve::drawLegendIdentifier(
+    QPainter *painter, const QRectF &rect ) const
+{
+    const double dim = qMin( rect.width(), rect.height() );
+    QSizeF size( dim, dim );
+    QRectF r( 0, 0, size.width(), size.height() );
+    r.moveCenter( rect.center() );
+  \return Icon for the legend
+  In case of Tube style() the icon is a plain rectangle filled with the brush().
+  If a symbol is assigned it is scaled to size.
+  \param index Index of the legend entry
+               ( ignored as there is only one )
+  \param size Icon size
+  \sa QwtPlotItem::setLegendIconSize(), QwtPlotItem::legendData()
+*/
+QwtGraphic QwtPlotIntervalCurve::legendIcon(
+    int index, const QSizeF &size ) const
+{
+    Q_UNUSED( index );
+    if ( size.isEmpty() )
+        return QwtGraphic();
+    QwtGraphic icon;
+    icon.setDefaultSize( size );
+    icon.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
+    QPainter painter( &icon );
+    painter.setRenderHint( QPainter::Antialiasing,
+        testRenderHint( QwtPlotItem::RenderAntialiased ) );
     if ( d_data->style == Tube )
+    {
+        painter->fillRect( r, d_data->brush );
+        QRectF r( 0, 0, size.width(), size.height() );
+        painter.fillRect( r, d_data->brush );
+    }
 …
         pen.setCapStyle( Qt::FlatCap );
         painter->setPen( pen );
         painter->setBrush( d_data->symbol->brush() );
+        painter.setPen( pen );
+        painter.setBrush( d_data->symbol->brush() );
         if ( orientation() == Qt::Vertical )
+        {
+            d_data->symbol->draw( painter, orientation(),
+                QPointF( r.center().x(), r.top() ),
+                QPointF( r.center().x(), r.bottom() - 1 ) );
+            const double x = 0.5 * size.width();
+            d_data->symbol->draw( &painter, orientation(),
+                QPointF( x, 0 ), QPointF( x, size.height() - 1.0 ) );
+        }
         else
+        {
+            d_data->symbol->draw( painter, orientation(),
+                QPointF( r.left(), r.center().y() ),
+                QPointF( r.right() - 1, r.center().y() ) );
+        }
+    }
+}
+            const double y = 0.5 * size.height();
+            d_data->symbol->draw( &painter, orientation(),
+                QPointF( 0.0, y ), QPointF( size.width() - 1.0, y ) );
+        }
+    }
+    return icon;
+}

trunk/BNC/qwt/qwt_plot_intervalcurve.h

-              r4271
+              r8127
   The representation depends on the style() and an optional symbol()
   that is displayed for each interval. QwtPlotIntervalCurve might be used
   to disply error bars or the area between 2 curves.
+  to display error bars or the area between 2 curves.
 */
 class QWT_EXPORT QwtPlotIntervalCurve: public QwtPlotSeriesItem<QwtIntervalSample>
+class QWT_EXPORT QwtPlotIntervalCurve:
+    public QwtPlotSeriesItem, public QwtSeriesStore<QwtIntervalSample>
+{
 public:
 …
         \sa setStyle(), style()
     */
     enum CurveStyle
+    {
 …
     void setSamples( const QVector<QwtIntervalSample> & );
+    void setSamples( QwtSeriesData<QwtIntervalSample> * );
+    void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setPen( const QPen & );
     const QPen &pen() const;
 …
     virtual QRectF boundingRect() const;
+    virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF & ) const;
 protected:

trunk/BNC/qwt/qwt_plot_item.cpp

-              r4271
+              r8127
 #include "qwt_text.h"
 #include "qwt_plot.h"
+#include "qwt_legend.h"
+#include "qwt_legend_item.h"
+#include "qwt_legend_data.h"
 #include "qwt_scale_div.h"
+#include "qwt_graphic.h"
 #include <qpainter.h>
 …
         isVisible( true ),
         attributes( 0 ),
+        interests( 0 ),
         renderHints( 0 ),
+        renderThreadCount( 1 ),
         z( 0.0 ),
         xAxis( QwtPlot::xBottom ),
+        yAxis( QwtPlot::yLeft )
+        yAxis( QwtPlot::yLeft ),
+        legendIconSize( 8, 8 )
+    {
+    }
 …
     bool isVisible;
     QwtPlotItem::ItemAttributes attributes;
+    QwtPlotItem::ItemInterests interests;
     QwtPlotItem::RenderHints renderHints;
+    uint renderThreadCount;
     double z;
 …
     QwtText title;
+    QSize legendIconSize;
 };
 …
         return;
-    // remove the item from the previous plot
     if ( d_data->plot )
+    {
-        if ( d_data->plot->legend() )
-            d_data->plot->legend()->remove( this );
         d_data->plot->attachItem( this, false );
-        if ( d_data->plot->autoReplot() )
-            d_data->plot->update();
+    }
     d_data->plot = plot;
     if ( d_data->plot )
+    {
-        // insert the item into the current plot
         d_data->plot->attachItem( this, true );
-        itemChanged();
+    }
+}
 …
+    {
         d_data->title = title;
+        itemChanged();
+        legendChanged();
+#if 0
+        itemChanged();
+#endif
+    }
+}
 …
    \param on true/false
    \sa testItemAttribute(), ItemAttribute
+   \sa testItemAttribute(), ItemInterest
 */
 void QwtPlotItem::setItemAttribute( ItemAttribute attribute, bool on )
+{
     if ( bool( d_data->attributes & attribute ) != on )
+    if ( d_data->attributes.testFlag( attribute ) != on )
+    {
         if ( on )
 …
             d_data->attributes &= ~attribute;
+        if ( attribute == QwtPlotItem::Legend )
+            legendChanged();
         itemChanged();
+    }
 …
    \param attribute Attribute type
    \return true/false
    \sa setItemAttribute(), ItemAttribute
+   \sa setItemAttribute(), ItemInterest
 */
 bool QwtPlotItem::testItemAttribute( ItemAttribute attribute ) const
+{
+    return ( d_data->attributes & attribute );
+    return d_data->attributes.testFlag( attribute );
+}
+/*!
+   Toggle an item interest
+   \param interest Interest type
+   \param on true/false
+   \sa testItemInterest(), ItemAttribute
+*/
+void QwtPlotItem::setItemInterest( ItemInterest interest, bool on )
+{
+    if ( d_data->interests.testFlag( interest ) != on )
+    {
+        if ( on )
+            d_data->interests |= interest;
+        else
+            d_data->interests &= ~interest;
+        itemChanged();
+    }
+}
+/*!
+   Test an item interest
+   \param interest Interest type
+   \return true/false
+   \sa setItemInterest(), ItemAttribute
+*/
+bool QwtPlotItem::testItemInterest( ItemInterest interest ) const
+{
+    return d_data->interests.testFlag( interest );
+}
 …
 void QwtPlotItem::setRenderHint( RenderHint hint, bool on )
+{
     if ( ( ( d_data->renderHints & hint ) != 0 ) != on )
+    if ( d_data->renderHints.testFlag( hint ) != on )
+    {
         if ( on )
 …
 bool QwtPlotItem::testRenderHint( RenderHint hint ) const
+{
+    return ( d_data->renderHints & hint );
+}
+    return d_data->renderHints.testFlag( hint );
+}
+/*!
+   On multi core systems rendering of certain plot item
+   ( f.e QwtPlotRasterItem ) can be done in parallel in
+   several threads.
+   The default setting is set to 1.
+   \param numThreads Number of threads to be used for rendering.
+                     If numThreads is set to 0, the system specific
+                     ideal thread count is used.
+   The default thread count is 1 ( = no additional threads )
+*/
+void QwtPlotItem::setRenderThreadCount( uint numThreads )
+{
+    d_data->renderThreadCount = numThreads;
+}
+/*!
+   \return Number of threads to be used for rendering.
+           If numThreads() is set to 0, the system specific
+           ideal thread count is used.
+*/
+uint QwtPlotItem::renderThreadCount() const
+{
+    return d_data->renderThreadCount;
+}
+/*!
+   Set the size of the legend icon
+   The default setting is 8x8 pixels
+   \param size Size
+   \sa legendIconSize(), legendIcon()
+*/
+void QwtPlotItem::setLegendIconSize( const QSize &size )
+{
+    if ( d_data->legendIconSize != size )
+    {
+        d_data->legendIconSize = size;
+        legendChanged();
+    }
+}
+/*!
+   \return Legend icon size
+   \sa setLegendIconSize(), legendIcon()
+*/
+QSize QwtPlotItem::legendIconSize() const
+{
+    return d_data->legendIconSize;
+}
+/*!
+   \return Icon representing the item on the legend
+   The default implementation returns an invalid icon
+   \param index Index of the legend entry
+                ( usually there is only one )
+   \param size Icon size
+   \sa setLegendIconSize(), legendData()
+ */
+QwtGraphic QwtPlotItem::legendIcon(
+    int index, const QSizeF &size ) const
+{
+    Q_UNUSED( index )
+    Q_UNUSED( size )
+    return QwtGraphic();
+}
+/*!
+   \brief Return a default icon from a brush
+   The default icon is a filled rectangle used
+   in several derived classes as legendIcon().
+   \param brush Fill brush
+   \param size Icon size
+   \return A filled rectangle
+ */
+QwtGraphic QwtPlotItem::defaultIcon(
+    const QBrush &brush, const QSizeF &size ) const
+{
+    QwtGraphic icon;
+    if ( !size.isEmpty() )
+    {
+        icon.setDefaultSize( size );
+        QRectF r( 0, 0, size.width(), size.height() );
+        QPainter painter( &icon );
+        painter.fillRect( r, brush );
+    }
+    return icon;
+}
 //! Show the item
 …
 /*!
    Update the legend and call QwtPlot::autoRefresh for the
+   Update the legend and call QwtPlot::autoRefresh() for the
    parent plot.
    \sa updateLegend()
+   \sa QwtPlot::legendChanged(), QwtPlot::autoRefresh()
 */
 void QwtPlotItem::itemChanged()
+{
     if ( d_data->plot )
+    {
-        if ( d_data->plot->legend() )
-            updateLegend( d_data->plot->legend() );
         d_data->plot->autoRefresh();
+    }
+}
+/*!
+   Update the legend of the parent plot.
+   \sa QwtPlot::updateLegend(), itemChanged()
+*/
+void QwtPlotItem::legendChanged()
+{
+    if ( testItemAttribute( QwtPlotItem::Legend ) && d_data->plot )
+        d_data->plot->updateLegend( this );
+}
 …
    Set X and Y axis
    The item will painted according to the coordinates its Axes.
    \param xAxis X Axis
    \param yAxis Y Axis
    \sa setXAxis(), setYAxis(), xAxis(), yAxis()
+   The item will painted according to the coordinates of its Axes.
+   \param xAxis X Axis ( QwtPlot::xBottom or QwtPlot::xTop )
+   \param yAxis Y Axis ( QwtPlot::yLeft or QwtPlot::yRight )
+   \sa setXAxis(), setYAxis(), xAxis(), yAxis(), QwtPlot::Axis
 */
 void QwtPlotItem::setAxes( int xAxis, int yAxis )
 …
    The item will painted according to the coordinates its Axes.
    \param axis X Axis
    \sa setAxes(), setYAxis(), xAxis()
+   \param axis X Axis ( QwtPlot::xBottom or QwtPlot::xTop )
+   \sa setAxes(), setYAxis(), xAxis(), QwtPlot::Axis
 */
 void QwtPlotItem::setXAxis( int axis )
 …
    The item will painted according to the coordinates its Axes.
    \param axis Y Axis
    \sa setAxes(), setXAxis(), yAxis()
+   \param axis Y Axis ( QwtPlot::yLeft or QwtPlot::yRight )
+   \sa setAxes(), setXAxis(), yAxis(), QwtPlot::Axis
 */
 void QwtPlotItem::setYAxis( int axis )
 …
 /*!
    \return An invalid bounding rect: QRectF(1.0, 1.0, -2.0, -2.0)
+   \note A width or height < 0.0 is ignored by the autoscaler
 */
 QRectF QwtPlotItem::boundingRect() const
 …
 /*!
+   \brief Allocate the widget that represents the item on the legend
+   The default implementation returns a QwtLegendItem(), but an item
+   could be represented by any type of widget,
+   by overloading legendItem() and updateLegend().
+   \return QwtLegendItem()
+   \sa updateLegend() QwtLegend()
+*/
+QWidget *QwtPlotItem::legendItem() const
+{
+    QwtLegendItem *item = new QwtLegendItem;
+    if ( d_data->plot )
+    {
+        QObject::connect( item, SIGNAL( clicked() ),
+            d_data->plot, SLOT( legendItemClicked() ) );
+        QObject::connect( item, SIGNAL( checked( bool ) ),
+            d_data->plot, SLOT( legendItemChecked( bool ) ) );
+    }
+    return item;
+}
+/*!
+   \brief Update the widget that represents the item on the legend
+   updateLegend() is called from itemChanged() to adopt the widget
+   representing the item on the legend to its new configuration.
+   The default implementation updates a QwtLegendItem(),
+   but an item could be represented by any type of widget,
+   by overloading legendItem() and updateLegend().
+   \param legend Legend
+   \sa legendItem(), itemChanged(), QwtLegend()
+*/
+void QwtPlotItem::updateLegend( QwtLegend *legend ) const
+{
+    if ( legend == NULL )
+        return;
+    QWidget *lgdItem = legend->find( this );
+    if ( testItemAttribute( QwtPlotItem::Legend ) )
+    {
+        if ( lgdItem == NULL )
+        {
+            lgdItem = legendItem();
+            if ( lgdItem )
+                legend->insert( this, lgdItem );
+        }
+        QwtLegendItem *label = qobject_cast<QwtLegendItem *>( lgdItem );
+        if ( label )
+        {
+            // paint the identifier
+            const QSize sz = label->identifierSize();
+            QPixmap identifier( sz.width(), sz.height() );
+            identifier.fill( Qt::transparent );
+            QPainter painter( &identifier );
+            painter.setRenderHint( QPainter::Antialiasing,
+                testRenderHint( QwtPlotItem::RenderAntialiased ) );
+            drawLegendIdentifier( &painter,
+                QRect( 0, 0, sz.width(), sz.height() ) );
+            painter.end();
+            const bool doUpdate = label->updatesEnabled();
+            if ( doUpdate )
+                label->setUpdatesEnabled( false );
+            label->setText( title() );
+            label->setIdentifier( identifier );
+            label->setItemMode( legend->itemMode() );
+            if ( doUpdate )
+                label->setUpdatesEnabled( true );
+            label->update();
+        }
+    }
+    else
+    {
+        if ( lgdItem )
+        {
+            lgdItem->hide();
+            lgdItem->deleteLater();
+        }
+    }
+   \brief Calculate a hint for the canvas margin
+   When the QwtPlotItem::Margins flag is enabled the plot item
+   indicates, that it needs some margins at the borders of the canvas.
+   This is f.e. used by bar charts to reserve space for displaying
+   the bars.
+   The margins are in target device coordinates ( pixels on screen )
+   \param xMap Maps x-values into pixel coordinates.
+   \param yMap Maps y-values into pixel coordinates.
+   \param canvasRect Contents rectangle of the canvas in painter coordinates
+   \param left Returns the left margin
+   \param top Returns the top margin
+   \param right Returns the right margin
+   \param bottom Returns the bottom margin
+   \return The default implementation returns 0 for all margins
+   \sa QwtPlot::getCanvasMarginsHint(), QwtPlot::updateCanvasMargins()
+ */
+void QwtPlotItem::getCanvasMarginHint( const QwtScaleMap &xMap,
+    const QwtScaleMap &yMap, const QRectF &canvasRect,
+    double &left, double &top, double &right, double &bottom ) const
+{
+    Q_UNUSED( xMap );
+    Q_UNUSED( yMap );
+    Q_UNUSED( canvasRect );
+    // use QMargins, when we don't need to support Qt < 4.6 anymore
+    left = top = right = bottom = 0.0;
+}
+/*!
+   \brief Return all information, that is needed to represent
+          the item on the legend
+   Most items are represented by one entry on the legend
+   showing an icon and a text, but f.e. QwtPlotMultiBarChart
+   displays one entry for each bar.
+   QwtLegendData is basically a list of QVariants that makes it
+   possible to overload and reimplement legendData() to
+   return almost any type of information, that is understood
+   by the receiver that acts as the legend.
+   The default implementation returns one entry with
+   the title() of the item and the legendIcon().
+   \return Data, that is needed to represent the item on the legend
+   \sa title(), legendIcon(), QwtLegend, QwtPlotLegendItem
+ */
+QList<QwtLegendData> QwtPlotItem::legendData() const
+{
+    QwtLegendData data;
+    QwtText label = title();
+    label.setRenderFlags( label.renderFlags() & Qt::AlignLeft );
+    QVariant titleValue;
+    qVariantSetValue( titleValue, label );
+    data.setValue( QwtLegendData::TitleRole, titleValue );
+    const QwtGraphic graphic = legendIcon( 0, legendIconSize() );
+    if ( !graphic.isNull() )
+    {
+        QVariant iconValue;
+        qVariantSetValue( iconValue, graphic );
+        data.setValue( QwtLegendData::IconRole, iconValue );
+    }
+    QList<QwtLegendData> list;
+    list += data;
+    return list;
+}
 …
    updateScaleDiv()
+   updateScaleDiv() is only called when the ScaleInterest interest
+   is enabled. The default implementation does nothing.
    \param xScaleDiv Scale division of the x-axis
    \param yScaleDiv Scale division of the y-axis
    \sa QwtPlot::updateAxes()
+   \sa QwtPlot::updateAxes(), ScaleInterest
 */
 void QwtPlotItem::updateScaleDiv( const QwtScaleDiv &xScaleDiv,
 …
 /*!
+   \brief Calculate the bounding scale rect of 2 maps
+   \param xMap X map
+   \param yMap X map
+   \return Bounding scale rect of the scale maps, normalized
+   \brief Update the item to changes of the legend info
+   Plot items that want to display a legend ( not those, that want to
+   be displayed on a legend ! ) will have to implement updateLegend().
+   updateLegend() is only called when the LegendInterest interest
+   is enabled. The default implementation does nothing.
+   \param item Plot item to be displayed on a legend
+   \param data Attributes how to display item on the legend
+   \sa QwtPlotLegendItem
+   \note Plot items, that want to be displayed on a legend
+         need to enable the QwtPlotItem::Legend flag and to implement
+         legendData() and legendIcon()
+ */
+void QwtPlotItem::updateLegend( const QwtPlotItem *item,
+    const QList<QwtLegendData> &data )
+{
+    Q_UNUSED( item );
+    Q_UNUSED( data );
+}
+/*!
+   \brief Calculate the bounding scale rectangle of 2 maps
+   \param xMap Maps x-values into pixel coordinates.
+   \param yMap Maps y-values into pixel coordinates.
+   \return Bounding scale rect of the scale maps, not normalized
 */
 QRectF QwtPlotItem::scaleRect( const QwtScaleMap &xMap,
 …
 /*!
    \brief Calculate the bounding paint rect of 2 maps
    \param xMap X map
    \param yMap X map
    \return Bounding paint rect of the scale maps, normalized
+   \brief Calculate the bounding paint rectangle of 2 maps
+   \param xMap Maps x-values into pixel coordinates.
+   \param yMap Maps y-values into pixel coordinates.
+   \return Bounding paint rectangle of the scale maps, not normalized
 */
 QRectF QwtPlotItem::paintRect( const QwtScaleMap &xMap,

trunk/BNC/qwt/qwt_plot_item.h

-              r4271
+              r8127
 #include "qwt_global.h"
-#include "qwt_legend_itemmanager.h"
 #include "qwt_text.h"
+#include "qwt_legend_data.h"
+#include "qwt_graphic.h"
 #include <qrect.h>
+class QString;
+#include <qlist.h>
+#include <qmetatype.h>
 class QPainter;
-class QWidget;
-class QwtPlot;
-class QwtLegend;
 class QwtScaleMap;
 class QwtScaleDiv;
+class QwtPlot;
 /*!
 …
   Depending on the QwtPlotItem::ItemAttribute flags, an item is included
   into autoscaling or has an entry on the legnd.
+  into autoscaling or has an entry on the legend.
   Before misusing the existing item classes it might be better to
 …
 */
 class QWT_EXPORT QwtPlotItem: public QwtLegendItemManager
+class QWT_EXPORT QwtPlotItem
+{
 public:
 …
     enum RttiValues
+    {
+        //! Unspecific value, that can be used, when it doesn't matter
         Rtti_PlotItem = 0,
+        //! For QwtPlotGrid
         Rtti_PlotGrid,
+        //! For QwtPlotScaleItem
         Rtti_PlotScale,
+        //! For QwtPlotLegendItem
+        Rtti_PlotLegend,
+        //! For QwtPlotMarker
         Rtti_PlotMarker,
+        //! For QwtPlotCurve
         Rtti_PlotCurve,
+        //! For QwtPlotSpectroCurve
         Rtti_PlotSpectroCurve,
+        //! For QwtPlotIntervalCurve
         Rtti_PlotIntervalCurve,
+        //! For QwtPlotHistogram
         Rtti_PlotHistogram,
+        //! For QwtPlotSpectrogram
         Rtti_PlotSpectrogram,
+        //! For QwtPlotSvgItem
         Rtti_PlotSVG,
+        //! For QwtPlotTradingCurve
+        Rtti_PlotTradingCurve,
+        //! For QwtPlotBarChart
+        Rtti_PlotBarChart,
+        //! For QwtPlotMultiBarChart
+        Rtti_PlotMultiBarChart,
+        //! For QwtPlotShapeItem
+        Rtti_PlotShape,
+        //! For QwtPlotTextLabel
+        Rtti_PlotTextLabel,
+        //! For QwtPlotZoneItem
+        Rtti_PlotZone,
+        /*!
+           Values >= Rtti_PlotUserItem are reserved for plot items
+           not implemented in the Qwt library.
+         */
         Rtti_PlotUserItem = 1000
     };
     /*!
+       Plot Item Attributes
+       \sa setItemAttribute(), testItemAttribute()
+       \brief Plot Item Attributes
+       Various aspects of a plot widget depend on the attributes of
+       the attached plot items. If and how a single plot item
+       participates in these updates depends on its attributes.
+       \sa setItemAttribute(), testItemAttribute(), ItemInterest
      */
     enum ItemAttribute
 …
         /*!
+         The boundingRect() of the item is included in the
+         autoscaling calculation.
+         */
+        AutoScale = 0x02
+           The boundingRect() of the item is included in the
+           autoscaling calculation as long as its width or height
+           is >= 0.0.
+         */
+        AutoScale = 0x02,
+        /*!
+           The item needs extra space to display something outside
+           its bounding rectangle.
+           \sa getCanvasMarginHint()
+         */
+        Margins = 0x04
     };
     //! Plot Item Attributes
     typedef QFlags<ItemAttribute> ItemAttributes;
+    /*!
+       \brief Plot Item Interests
+       Plot items might depend on the situation of the corresponding
+       plot widget. By enabling an interest the plot item will be
+       notified, when the corresponding attribute of the plot widgets
+       has changed.
+       \sa setItemAttribute(), testItemAttribute(), ItemInterest
+     */
+    enum ItemInterest
+    {
+        /*!
+           The item is interested in updates of the scales
+           \sa updateScaleDiv()
+         */
+        ScaleInterest = 0x01,
+        /*!
+           The item is interested in updates of the legend ( of other items )
+           This flag is intended for items, that want to implement a legend
+           for displaying entries of other plot item.
+           \note If the plot item wants to be represented on a legend
+                 enable QwtPlotItem::Legend instead.
+           \sa updateLegend()
+         */
+        LegendInterest = 0x02
+    };
+    //! Plot Item Interests
+    typedef QFlags<ItemInterest> ItemInterests;
     //! Render hints
 …
+    {
         //! Enable antialiasing
         RenderAntialiased = 1
+        RenderAntialiased = 0x1
     };
 …
     bool testItemAttribute( ItemAttribute ) const;
+    void setItemInterest( ItemInterest, bool on = true );
+    bool testItemInterest( ItemInterest ) const;
     void setRenderHint( RenderHint, bool on = true );
     bool testRenderHint( RenderHint ) const;
+    void setRenderThreadCount( uint numThreads );
+    uint renderThreadCount() const;
+    void setLegendIconSize( const QSize & );
+    QSize legendIconSize() const;
     double z() const;
 …
     virtual void itemChanged();
+    virtual void legendChanged();
     /*!
 …
     virtual QRectF boundingRect() const;
+    virtual void updateLegend( QwtLegend * ) const;
+    virtual void getCanvasMarginHint(
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasSize,
+        double &left, double &top, double &right, double &bottom) const;
     virtual void updateScaleDiv(
         const QwtScaleDiv&, const QwtScaleDiv& );
+    virtual QWidget *legendItem() const;
+    virtual void updateLegend( const QwtPlotItem *,
+        const QList<QwtLegendData> & );
     QRectF scaleRect( const QwtScaleMap &, const QwtScaleMap & ) const;
     QRectF paintRect( const QwtScaleMap &, const QwtScaleMap & ) const;
+    virtual QList<QwtLegendData> legendData() const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF  & ) const;
+protected:
+    QwtGraphic defaultIcon( const QBrush &, const QSizeF & ) const;
 private:
 …
 Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPlotItem::ItemAttributes )
+Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPlotItem::ItemInterests )
 Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPlotItem::RenderHints )
+Q_DECLARE_METATYPE( QwtPlotItem * )
 #endif

trunk/BNC/qwt/qwt_plot_layout.cpp

-              r4271
+              r8127
 #include "qwt_text.h"
 #include "qwt_text_label.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_scale_widget.h"
 #include "qwt_legend.h"
+#include "qwt_abstract_legend.h"
 #include <qscrollbar.h>
 #include <qmath.h>
 …
+    {
         int frameWidth;
         int vScrollBarWidth;
         int hScrollBarHeight;
+        int hScrollExtent;
+        int vScrollExtent;
         QSize hint;
     } legend;
 …
         int frameWidth;
     } title;
+    struct t_footerData
+    {
+        QwtText text;
+        int frameWidth;
+    } footer;
     struct t_scaleData
 …
         int end;
         int baseLineOffset;
         int tickOffset;
+        double tickOffset;
         int dimWithoutTitle;
     } scale[QwtPlot::axisCnt];
 …
     struct t_canvasData
+    {
+        int frameWidth;
+        int contentsMargins[ QwtPlot::axisCnt ];
     } canvas;
 };
 …
   Extract all layout relevant data from the plot components
 */
 void QwtPlotLayout::LayoutData::init( const QwtPlot *plot, const QRectF &rect )
+{
     // legend
+    if ( plot->plotLayout()->legendPosition() != QwtPlot::ExternalLegend
+        && plot->legend() )
+    if ( plot->legend() )
+    {
         legend.frameWidth = plot->legend()->frameWidth();
         legend.vScrollBarWidth =
             plot->legend()->verticalScrollBar()->sizeHint().width();
         legend.hScrollBarHeight =
             plot->legend()->horizontalScrollBar()->sizeHint().height();
+        legend.hScrollExtent =
+            plot->legend()->scrollExtent( Qt::Horizontal );
+        legend.vScrollExtent =
+            plot->legend()->scrollExtent( Qt::Vertical );
         const QSize hint = plot->legend()->sizeHint();
+        int w = qMin( hint.width(), qFloor( rect.width() ) );
+        const int w = qMin( hint.width(), qFloor( rect.width() ) );
         int h = plot->legend()->heightForWidth( w );
         if ( h == 0 )
+        if ( h <= 0 )
             h = hint.height();
-        if ( h > rect.height() )
-            w += legend.vScrollBarWidth;
         legend.hint = QSize( w, h );
 …
+    }
+    // footer
+    footer.frameWidth = 0;
+    footer.text = QwtText();
+    if ( plot->footerLabel() )
+    {
+        const QwtTextLabel *label = plot->footerLabel();
+        footer.text = label->text();
+        if ( !( footer.text.testPaintAttribute( QwtText::PaintUsingTextFont ) ) )
+            footer.text.setFont( label->font() );
+        footer.frameWidth = plot->footerLabel()->frameWidth();
+    }
     // scales
 …
             scale[axis].end = 0;
             scale[axis].baseLineOffset = 0;
             scale[axis].tickOffset = 0;
+            scale[axis].tickOffset = 0.0;
             scale[axis].dimWithoutTitle = 0;
+        }
 …
     // canvas
+    canvas.frameWidth = plot->canvas()->frameWidth();
+    plot->canvas()->getContentsMargins(
+        &canvas.contentsMargins[ QwtPlot::yLeft ],
+        &canvas.contentsMargins[ QwtPlot::xTop ],
+        &canvas.contentsMargins[ QwtPlot::yRight ],
+        &canvas.contentsMargins[ QwtPlot::xBottom ] );
+}
 …
 public:
     PrivateData():
+        spacing( 5 ),
+        alignCanvasToScales( false )
+        spacing( 5 )
+    {
+    }
     QRectF titleRect;
+    QRectF footerRect;
     QRectF legendRect;
     QRectF scaleRect[QwtPlot::axisCnt];
 …
     unsigned int spacing;
     unsigned int canvasMargin[QwtPlot::axisCnt];
     bool alignCanvasToScales;
+    bool alignCanvasToScales[QwtPlot::axisCnt];
 };
 …
     setLegendPosition( QwtPlot::BottomLegend );
     setCanvasMargin( 4 );
+    setAlignCanvasToScales( false );
     invalidate();
 …
   \sa canvasMargin()
   \warning The margin will have no effect when alignCanvasToScales is true
+  \warning The margin will have no effect when alignCanvasToScale() is true
 */
 …
 /*!
+    \param axisId Axis index
     \return Margin around the scale tick borders
     \sa setCanvasMargin()
 */
 int QwtPlotLayout::canvasMargin( int axis ) const
+{
     if ( axis < 0 || axis >= QwtPlot::axisCnt )
+int QwtPlotLayout::canvasMargin( int axisId ) const
+{
+    if ( axisId < 0 || axisId >= QwtPlot::axisCnt )
         return 0;
+    return d_data->canvasMargin[axis];
+    return d_data->canvasMargin[axisId];
+}
+/*!
+  \brief Set the align-canvas-to-axis-scales flag for all axes
+  \param on True/False
+  \sa setAlignCanvasToScale(), alignCanvasToScale()
+*/
+void QwtPlotLayout::setAlignCanvasToScales( bool on )
+{
+    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+        d_data->alignCanvasToScales[axis] = on;
+}
 /*!
   Change the align-canvas-to-axis-scales setting. The canvas may:
   - extend beyond the axis scale ends to maximize its size,
   - align with the axis scale ends to control its size.
+  \param alignCanvasToScales New align-canvas-to-axis-scales setting
+  \sa setCanvasMargin()
+  \note In this context the term 'scale' means the backbone of a scale.
+  \warning In case of alignCanvasToScales == true canvasMargin will have
+           no effect
+*/
+void QwtPlotLayout::setAlignCanvasToScales( bool alignCanvasToScales )
+{
+    d_data->alignCanvasToScales = alignCanvasToScales;
+  The axisId parameter is somehow confusing as it identifies a border
+  of the plot and not the axes, that are aligned. F.e when QwtPlot::yLeft
+  is set, the left end of the the x-axes ( QwtPlot::xTop, QwtPlot::xBottom )
+  is aligned.
+  \param axisId Axis index
+  \param on New align-canvas-to-axis-scales setting
+  \sa setCanvasMargin(), alignCanvasToScale(), setAlignCanvasToScales()
+  \warning In case of on == true canvasMargin() will have no effect
+*/
+void QwtPlotLayout::setAlignCanvasToScale( int axisId, bool on )
+{
+    if ( axisId >= 0 && axisId < QwtPlot::axisCnt )
+        d_data->alignCanvasToScales[axisId] = on;
+}
 …
   - align with the axis scale ends to control its size.
+  \param axisId Axis index
   \return align-canvas-to-axis-scales setting
+  \sa setAlignCanvasToScales, setCanvasMargin()
+  \note In this context the term 'scale' means the backbone of a scale.
+*/
+bool QwtPlotLayout::alignCanvasToScales() const
+{
+    return d_data->alignCanvasToScales;
+  \sa setAlignCanvasToScale(), setAlignCanvasToScale(), setCanvasMargin()
+*/
+bool QwtPlotLayout::alignCanvasToScale( int axisId ) const
+{
+    if ( axisId < 0 || axisId >= QwtPlot::axisCnt )
+        return false;
+    return d_data->alignCanvasToScales[ axisId ];
+}
 …
   between the plot components.
   \param spacing new spacing
   \sa setMargin(), spacing()
+  \param spacing New spacing
+  \sa setCanvasMargin(), spacing()
 */
 void QwtPlotLayout::setSpacing( int spacing )
 …
 /*!
   \return spacing
+  \return Spacing
   \sa margin(), setSpacing()
 */
 …
   \brief Specify the position of the legend
   \param pos The legend's position.
   \param ratio Ratio between legend and the bounding rect
                of title, canvas and axes. The legend will be shrinked
+  \param ratio Ratio between legend and the bounding rectangle
+               of title, footer, canvas and axes. The legend will be shrunk
                if it would need more space than the given ratio.
                The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0
 …
             d_data->legendPos = pos;
             break;
-        case QwtPlot::ExternalLegend:
-            d_data->legendRatio = ratio; // meaningless
-            d_data->legendPos = pos;
         default:
             break;
 …
 /*!
   Specify the relative size of the legend in the plot
   \param ratio Ratio between legend and the bounding rect
                of title, canvas and axes. The legend will be shrinked
+  \param ratio Ratio between legend and the bounding rectangle
+               of title, footer, canvas and axes. The legend will be shrunk
                if it would need more space than the given ratio.
                The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0
 …
 /*!
+  \brief Set the geometry for the title
+  This method is intended to be used from derived layouts
+  overloading activate()
+  \sa titleRect(), activate()
+ */
+void QwtPlotLayout::setTitleRect( const QRectF &rect )
+{
+    d_data->titleRect = rect;
+}
+/*!
   \return Geometry for the title
   \sa activate(), invalidate()
 */
+const QRectF &QwtPlotLayout::titleRect() const
+QRectF QwtPlotLayout::titleRect() const
+{
     return d_data->titleRect;
+}
+/*!
+  \brief Set the geometry for the footer
+  This method is intended to be used from derived layouts
+  overloading activate()
+  \sa footerRect(), activate()
+ */
+void QwtPlotLayout::setFooterRect( const QRectF &rect )
+{
+    d_data->footerRect = rect;
+}
+/*!
+  \return Geometry for the footer
+  \sa activate(), invalidate()
+*/
+QRectF QwtPlotLayout::footerRect() const
+{
+    return d_data->footerRect;
+}
+/*!
+  \brief Set the geometry for the legend
+  This method is intended to be used from derived layouts
+  overloading activate()
+  \param rect Rectangle for the legend
+  \sa legendRect(), activate()
+ */
+void QwtPlotLayout::setLegendRect( const QRectF &rect )
+{
+    d_data->legendRect = rect;
+}
 …
   \sa activate(), invalidate()
 */
+const QRectF &QwtPlotLayout::legendRect() const
+QRectF QwtPlotLayout::legendRect() const
+{
     return d_data->legendRect;
+}
+/*!
+  \brief Set the geometry for an axis
+  This method is intended to be used from derived layouts
+  overloading activate()
+  \param axis Axis index
+  \param rect Rectangle for the scale
+  \sa scaleRect(), activate()
+ */
+void QwtPlotLayout::setScaleRect( int axis, const QRectF &rect )
+{
+    if ( axis >= 0 && axis < QwtPlot::axisCnt )
+        d_data->scaleRect[axis] = rect;
+}
 …
   \sa activate(), invalidate()
 */
+const QRectF &QwtPlotLayout::scaleRect( int axis ) const
+QRectF QwtPlotLayout::scaleRect( int axis ) const
+{
     if ( axis < 0 || axis >= QwtPlot::axisCnt )
 …
 /*!
+  \brief Set the geometry for the canvas
+  This method is intended to be used from derived layouts
+  overloading activate()
+  \sa canvasRect(), activate()
+ */
+void QwtPlotLayout::setCanvasRect( const QRectF &rect )
+{
+    d_data->canvasRect = rect;
+}
+/*!
   \return Geometry for the canvas
   \sa activate(), invalidate()
 */
+const QRectF &QwtPlotLayout::canvasRect() const
+QRectF QwtPlotLayout::canvasRect() const
+{
     return d_data->canvasRect;
 …
 void QwtPlotLayout::invalidate()
+{
+    d_data->titleRect = d_data->legendRect = d_data->canvasRect = QRect();
+    d_data->titleRect = d_data->footerRect
+        = d_data->legendRect = d_data->canvasRect = QRect();
     for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         d_data->scaleRect[axis] = QRect();
 …
 /*!
+  \brief Return a minimum size hint
+  \return Minimum size hint
+  \param plot Plot widget
   \sa QwtPlot::minimumSizeHint()
 */
 …
     int canvasBorder[QwtPlot::axisCnt];
+    int fw;
+    plot->canvas()->getContentsMargins( &fw, NULL, NULL, NULL );
     int axis;
     for ( axis = 0; axis < QwtPlot::axisCnt; axis++ )
 …
             sd.tickOffset = scl->margin();
             if ( scl->scaleDraw()->hasComponent( QwtAbstractScaleDraw::Ticks ) )
+                sd.tickOffset += scl->scaleDraw()->maxTickLength();
+        }
+        canvasBorder[axis] = plot->canvas()->frameWidth() +
+            d_data->canvasMargin[axis] + 1;
+                sd.tickOffset += qCeil( scl->scaleDraw()->maxTickLength() );
+        }
+        canvasBorder[axis] = fw + d_data->canvasMargin[axis] + 1;
+    }
 …
+    }
+    const QwtPlotCanvas *canvas = plot->canvas();
+    const QWidget *canvas = plot->canvas();
+    int left, top, right, bottom;
+    canvas->getContentsMargins( &left, &top, &right, &bottom );
     const QSize minCanvasSize = canvas->minimumSize();
     int w = scaleData[QwtPlot::yLeft].w + scaleData[QwtPlot::yRight].w;
     int cw = qMax( scaleData[QwtPlot::xBottom].w, scaleData[QwtPlot::xTop].w )
         + 2 * ( canvas->frameWidth() + 1 );
+        + left + 1 + right + 1;
     w += qMax( cw, minCanvasSize.width() );
     int h = scaleData[QwtPlot::xBottom].h + scaleData[QwtPlot::xTop].h;
     int ch = qMax( scaleData[QwtPlot::yLeft].h, scaleData[QwtPlot::yRight].h )
         + 2 * ( canvas->frameWidth() + 1 );
+        + top + 1 + bottom + 1;
     h += qMax( ch, minCanvasSize.height() );
+    const QwtTextLabel *title = plot->titleLabel();
+    if ( title && !title->text().isEmpty() )
+    {
+        // If only QwtPlot::yLeft or QwtPlot::yRight is showing,
+        // we center on the plot canvas.
+        const bool centerOnCanvas = !( plot->axisEnabled( QwtPlot::yLeft )
+            && plot->axisEnabled( QwtPlot::yRight ) );
+        int titleW = w;
+        if ( centerOnCanvas )
+        {
+            titleW -= scaleData[QwtPlot::yLeft].w
+                + scaleData[QwtPlot::yRight].w;
+        }
+        int titleH = title->heightForWidth( titleW );
+        if ( titleH > titleW ) // Compensate for a long title
+        {
+            w = titleW = titleH;
+    const QwtTextLabel *labels[2];
+    labels[0] = plot->titleLabel();
+    labels[1] = plot->footerLabel();
+    for ( int i = 0; i < 2; i++ )
+    {
+        const QwtTextLabel *label   = labels[i];
+        if ( label && !label->text().isEmpty() )
+        {
+            // If only QwtPlot::yLeft or QwtPlot::yRight is showing,
+            // we center on the plot canvas.
+            const bool centerOnCanvas = !( plot->axisEnabled( QwtPlot::yLeft )
+                && plot->axisEnabled( QwtPlot::yRight ) );
+            int labelW = w;
             if ( centerOnCanvas )
+            {
                 w += scaleData[QwtPlot::yLeft].w
+                labelW -= scaleData[QwtPlot::yLeft].w
                     + scaleData[QwtPlot::yRight].w;
+            }
+            titleH = title->heightForWidth( titleW );
+        }
+        h += titleH + d_data->spacing;
+            int labelH = label->heightForWidth( labelW );
+            if ( labelH > labelW ) // Compensate for a long title
+            {
+                w = labelW = labelH;
+                if ( centerOnCanvas )
+                {
+                    w += scaleData[QwtPlot::yLeft].w
+                        + scaleData[QwtPlot::yRight].w;
+                }
+                labelH = label->heightForWidth( labelW );
+            }
+            h += labelH + d_data->spacing;
+        }
+    }
     // Compute the legend contribution
+    const QwtLegend *legend = plot->legend();
+    if ( d_data->legendPos != QwtPlot::ExternalLegend
+        && legend && !legend->isEmpty() )
+    const QwtAbstractLegend *legend = plot->legend();
+    if ( legend && !legend->isEmpty() )
+    {
         if ( d_data->legendPos == QwtPlot::LeftLegend
 …
             if ( legendH > h )
                 legendW += legend->verticalScrollBar()->sizeHint().height();
+                legendW += legend->scrollExtent( Qt::Horizontal );
             if ( d_data->legendRatio < 1.0 )
 …
 /*!
   Find the geometry for the legend
   \param options Options how to layout the legend
   \param rect Rectangle where to place the legend
   \return Geometry for the legend
   \sa Options
 …
                 // space for the vertical scrollbar.
                 dim += d_data->layoutData.legend.vScrollBarWidth;
+                dim += d_data->layoutData.legend.hScrollExtent;
+            }
+        }
 …
+    {
         dim = qMin( hint.height(), int( rect.height() * d_data->legendRatio ) );
         dim = qMax( dim, d_data->layoutData.legend.hScrollBarHeight );
+        dim = qMax( dim, d_data->layoutData.legend.vScrollExtent );
+    }
 …
             legendRect.setHeight( dim );
             break;
-        case QwtPlot::ExternalLegend:
-            break;
+    }
 …
 /*!
   Align the legend to the canvas
   \param canvasRect Geometry of the canvas
   \param legendRect Maximum geometry for the legend
   \return Geometry for the aligned legend
 */
 …
   \param options Options how to layout the legend
   \param rect Bounding rect for title, axes and canvas.
+  \param rect Bounding rectangle for title, footer, axes and canvas.
   \param dimTitle Expanded height of the title widget
+  \param dimFooter Expanded height of the footer widget
   \param dimAxis Expanded heights of the axis in axis orientation.
   \sa Options
 */
 void QwtPlotLayout::expandLineBreaks( int options, const QRectF &rect,
     int &dimTitle, int dimAxis[QwtPlot::axisCnt] ) const
+{
     dimTitle = 0;
+void QwtPlotLayout::expandLineBreaks( Options options, const QRectF &rect,
+    int &dimTitle, int &dimFooter, int dimAxis[QwtPlot::axisCnt] ) const
+{
+    dimTitle = dimFooter = 0;
     for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         dimAxis[axis] = 0;
 …
+    {
         backboneOffset[axis] = 0;
+        if ( !d_data->alignCanvasToScales )
+        if ( !( options & IgnoreFrames ) )
+            backboneOffset[axis] += d_data->layoutData.canvas.contentsMargins[ axis ];
+        if ( !d_data->alignCanvasToScales[axis] )
             backboneOffset[axis] += d_data->canvasMargin[axis];
-        if ( !( options & IgnoreFrames ) )
-            backboneOffset[axis] += d_data->layoutData.canvas.frameWidth;
+    }
 …
         // axis ... . So we loop as long until no size changes.
+        if ( !d_data->layoutData.title.text.isEmpty() )
+        {
+            int w = rect.width();
+        if ( !( ( options & IgnoreTitle ) ||
+            d_data->layoutData.title.text.isEmpty() ) )
+        {
+            double w = rect.width();
             if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled
 …
+        }
+        if ( !( ( options & IgnoreFooter ) ||
+            d_data->layoutData.footer.text.isEmpty() ) )
+        {
+            double w = rect.width();
+            if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled
+                != d_data->layoutData.scale[QwtPlot::yRight].isEnabled )
+            {
+                // center to the canvas
+                w -= dimAxis[QwtPlot::yLeft] + dimAxis[QwtPlot::yRight];
+            }
+            int d = qCeil( d_data->layoutData.footer.text.heightForWidth( w ) );
+            if ( !( options & IgnoreFrames ) )
+                d += 2 * d_data->layoutData.footer.frameWidth;
+            if ( d > dimFooter )
+            {
+                dimFooter = d;
+                done = false;
+            }
+        }
         for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+        {
 …
             if ( scaleData.isEnabled )
+            {
                 int length;
+                double length;
                 if ( axis == QwtPlot::xTop || axis == QwtPlot::xBottom )
+                {
 …
                         length += qMin(
                             d_data->layoutData.scale[QwtPlot::xBottom].tickOffset,
                             scaleData.start - backboneOffset[QwtPlot::xBottom] );
+                            double( scaleData.start - backboneOffset[QwtPlot::xBottom] ) );
+                    }
                     if ( dimAxis[QwtPlot::xTop] > 0 )
 …
                         length += qMin(
                             d_data->layoutData.scale[QwtPlot::xTop].tickOffset,
                             scaleData.end - backboneOffset[QwtPlot::xTop] );
+                            double( scaleData.end - backboneOffset[QwtPlot::xTop] ) );
+                    }
 …
                 if ( !scaleData.scaleWidget->title().isEmpty() )
+                {
                     d += scaleData.scaleWidget->titleHeightForWidth( length );
+                    d += scaleData.scaleWidget->titleHeightForWidth( qFloor( length ) );
+                }
 …
   the empty corners.
+  \param options Layout options
+  \param canvasRect Geometry of the canvas ( IN/OUT )
+  \param scaleRect Geometries of the scales ( IN/OUT )
   \sa Options
 */
 void QwtPlotLayout::alignScales( int options,
+void QwtPlotLayout::alignScales( Options options,
     QRectF &canvasRect, QRectF scaleRect[QwtPlot::axisCnt] ) const
+{
 …
+    {
         backboneOffset[axis] = 0;
+        if ( !d_data->alignCanvasToScales )
+        if ( !d_data->alignCanvasToScales[axis] )
+        {
             backboneOffset[axis] += d_data->canvasMargin[axis];
+        }
         if ( !( options & IgnoreFrames ) )
+            backboneOffset[axis] += d_data->layoutData.canvas.frameWidth;
+        {
+            backboneOffset[axis] +=
+                d_data->layoutData.canvas.contentsMargins[axis];
+        }
+    }
 …
             if ( leftScaleRect.isValid() )
+            {
                 const int dx = leftOffset + leftScaleRect.width();
                 if ( d_data->alignCanvasToScales && dx < 0 )
+                const double dx = leftOffset + leftScaleRect.width();
+                if ( d_data->alignCanvasToScales[QwtPlot::yLeft] && dx < 0.0 )
+                {
                     /*
 …
                       of the left scale.
                      */
                     canvasRect.setLeft( qMax( canvasRect.left(),
                         axisRect.left() - dx ) );
+                    const double cLeft = canvasRect.left(); // qreal -> double
+                    canvasRect.setLeft( qMax( cLeft, axisRect.left() - dx ) );
+                }
                 else
 …
             else
+            {
                 if ( d_data->alignCanvasToScales && leftOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::yLeft] && leftOffset < 0 )
+                {
                     canvasRect.setLeft( qMax( canvasRect.left(),
 …
             if ( rightScaleRect.isValid() )
+            {
                 const int dx = rightOffset + rightScaleRect.width();
                 if ( d_data->alignCanvasToScales && dx < 0 )
+                const double dx = rightOffset + rightScaleRect.width();
+                if ( d_data->alignCanvasToScales[QwtPlot::yRight] && dx < 0 )
+                {
                     /*
 …
                       of the right scale.
                      */
                     canvasRect.setRight( qMin( canvasRect.right(),
                         axisRect.right() + dx ) );
+                    const double cRight = canvasRect.right(); // qreal -> double
+                    canvasRect.setRight( qMin( cRight, axisRect.right() + dx ) );
+                }
 …
             else
+            {
                 if ( d_data->alignCanvasToScales && rightOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::yRight] && rightOffset < 0 )
+                {
                     canvasRect.setRight( qMin( canvasRect.right(),
 …
             if ( bottomScaleRect.isValid() )
+            {
                 const int dy = bottomOffset + bottomScaleRect.height();
                 if ( d_data->alignCanvasToScales && dy < 0 )
+                const double dy = bottomOffset + bottomScaleRect.height();
+                if ( d_data->alignCanvasToScales[QwtPlot::xBottom] && dy < 0 )
+                {
                     /*
 …
                       of the bottom scale.
                      */
                     canvasRect.setBottom( qMin( canvasRect.bottom(),
                         axisRect.bottom() + dy ) );
+                    const double cBottom = canvasRect.bottom(); // qreal -> double
+                    canvasRect.setBottom( qMin( cBottom, axisRect.bottom() + dy ) );
+                }
                 else
 …
             else
+            {
                 if ( d_data->alignCanvasToScales && bottomOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::xBottom] && bottomOffset < 0 )
+                {
                     canvasRect.setBottom( qMin( canvasRect.bottom(),
 …
             if ( topScaleRect.isValid() )
+            {
                 const int dy = topOffset + topScaleRect.height();
                 if ( d_data->alignCanvasToScales && dy < 0 )
+                const double dy = topOffset + topScaleRect.height();
+                if ( d_data->alignCanvasToScales[QwtPlot::xTop] && dy < 0 )
+                {
                     /*
 …
                       of the top scale.
                      */
                     canvasRect.setTop( qMax( canvasRect.top(),
                         axisRect.top() - dy ) );
+                    const double cTop = canvasRect.top(); // qreal -> double
+                    canvasRect.setTop( qMax( cTop, axisRect.top() - dy ) );
+                }
                 else
 …
             else
+            {
                 if ( d_data->alignCanvasToScales && topOffset < 0 )
+                if ( d_data->alignCanvasToScales[QwtPlot::xTop] && topOffset < 0 )
+                {
                     canvasRect.setTop( qMax( canvasRect.top(),
 …
+    }
+    if ( d_data->alignCanvasToScales )
+    {
+        /*
+          The canvas has been aligned to the scale with largest
+          border distances. Now we have to realign the other scale.
+         */
+        int fw = 0;
+        if ( !( options & IgnoreFrames ) )
+            fw = d_data->layoutData.canvas.frameWidth;
+        for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+        {
+            if ( !scaleRect[axis].isValid() )
+                continue;
+            if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
+            {
+                scaleRect[axis].setLeft( canvasRect.left() + fw
+                    - d_data->layoutData.scale[axis].start );
+                scaleRect[axis].setRight( canvasRect.right() - fw - 1
+                    + d_data->layoutData.scale[axis].end );
+            }
+            else
+            {
+                scaleRect[axis].setTop( canvasRect.top() + fw
+                    - d_data->layoutData.scale[axis].start );
+                scaleRect[axis].setBottom( canvasRect.bottom() - fw - 1
+                    + d_data->layoutData.scale[axis].end );
+            }
+        }
+        if ( scaleRect[QwtPlot::xTop].isValid() )
+            scaleRect[QwtPlot::xTop].setBottom( canvasRect.top() );
+        if ( scaleRect[QwtPlot::xBottom].isValid() )
+            scaleRect[QwtPlot::xBottom].setTop( canvasRect.bottom() );
+        if ( scaleRect[QwtPlot::yLeft].isValid() )
+            scaleRect[QwtPlot::yLeft].setRight( canvasRect.left() );
+        if ( scaleRect[QwtPlot::yRight].isValid() )
+            scaleRect[QwtPlot::yRight].setLeft( canvasRect.right() );
+    /*
+      The canvas has been aligned to the scale with largest
+      border distances. Now we have to realign the other scale.
+     */
+    for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
+    {
+        QRectF &sRect = scaleRect[axis];
+        if ( !sRect.isValid() )
+            continue;
+        if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
+        {
+            if ( d_data->alignCanvasToScales[QwtPlot::yLeft] )
+            {
+                double y = canvasRect.left() - d_data->layoutData.scale[axis].start;
+                if ( !( options & IgnoreFrames ) )
+                    y += d_data->layoutData.canvas.contentsMargins[ QwtPlot::yLeft ];
+                sRect.setLeft( y );
+            }
+            if ( d_data->alignCanvasToScales[QwtPlot::yRight] )
+            {
+                double y = canvasRect.right() - 1 + d_data->layoutData.scale[axis].end;
+                if ( !( options & IgnoreFrames ) )
+                    y -= d_data->layoutData.canvas.contentsMargins[ QwtPlot::yRight ];
+                sRect.setRight( y );
+            }
+            if ( d_data->alignCanvasToScales[ axis ] )
+            {
+                if ( axis == QwtPlot::xTop )
+                    sRect.setBottom( canvasRect.top() );
+                else
+                    sRect.setTop( canvasRect.bottom() );
+            }
+        }
+        else
+        {
+            if ( d_data->alignCanvasToScales[QwtPlot::xTop] )
+            {
+                double x = canvasRect.top() - d_data->layoutData.scale[axis].start;
+                if ( !( options & IgnoreFrames ) )
+                    x += d_data->layoutData.canvas.contentsMargins[ QwtPlot::xTop ];
+                sRect.setTop( x );
+            }
+            if ( d_data->alignCanvasToScales[QwtPlot::xBottom] )
+            {
+                double x = canvasRect.bottom() - 1 + d_data->layoutData.scale[axis].end;
+                if ( !( options & IgnoreFrames ) )
+                    x -= d_data->layoutData.canvas.contentsMargins[ QwtPlot::xBottom ];
+                sRect.setBottom( x );
+            }
+            if ( d_data->alignCanvasToScales[ axis ] )
+            {
+                if ( axis == QwtPlot::yLeft )
+                    sRect.setRight( canvasRect.left() );
+                else
+                    sRect.setLeft( canvasRect.right() );
+            }
+        }
+    }
+}
 …
   \param plot Plot to be layout
   \param plotRect Rect where to place the components
+  \param plotRect Rectangle where to place the components
   \param options Layout options
   \sa invalidate(), titleRect(),
+  \sa invalidate(), titleRect(), footerRect()
       legendRect(), scaleRect(), canvasRect()
 */
 …
     QRectF rect( plotRect );  // undistributed rest of the plot rect
     // We extract all layout relevant data from the widgets,
     // filter them through pfilter and save them to d_data->layoutData.
+    // We extract all layout relevant parameters from the widgets,
+    // and save them to d_data->layoutData.
     d_data->layoutData.init( plot, rect );
     if ( !( options & IgnoreLegend )
-        && d_data->legendPos != QwtPlot::ExternalLegend
         && plot->legend() && !plot->legend()->isEmpty() )
+    {
 …
         const QRegion region( rect.toRect() );
         rect = region.subtract( d_data->legendRect.toRect() ).boundingRect();
+        rect = region.subtracted( d_data->legendRect.toRect() ).boundingRect();
         switch ( d_data->legendPos )
 …
                 rect.setBottom( rect.bottom() - d_data->spacing );
                 break;
-            case QwtPlot::ExternalLegend:
-                break; // suppress compiler warning
+        }
+    }
 …
      |   |   Axis    |   |
      +---+-----------+---+
+     |      Footer       |
+     +---+-----------+---+
     */
     // axes and title include text labels. The height of each
+    // title, footer and axes include text labels. The height of each
     // label depends on its line breaks, that depend on the width
     // for the label. A line break in a horizontal text will reduce
     // the available width for vertical texts and vice versa.
     // expandLineBreaks finds the height/width for title and axes
+    // expandLineBreaks finds the height/width for title, footer and axes
     // including all line breaks.
     int dimTitle, dimAxes[QwtPlot::axisCnt];
     expandLineBreaks( options, rect, dimTitle, dimAxes );
+    int dimTitle, dimFooter, dimAxes[QwtPlot::axisCnt];
+    expandLineBreaks( options, rect, dimTitle, dimFooter, dimAxes );
     if ( dimTitle > 0 )
+    {
+        d_data->titleRect = QRect( rect.x(), rect.y(),
+            rect.width(), dimTitle );
+        d_data->titleRect.setRect(
+            rect.left(), rect.top(), rect.width(), dimTitle );
+        rect.setTop( d_data->titleRect.bottom() + d_data->spacing );
         if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled !=
 …
             // the title centered to the canvas
             d_data->titleRect.setX( rect.x() + dimAxes[QwtPlot::yLeft] );
+            d_data->titleRect.setX( rect.left() + dimAxes[QwtPlot::yLeft] );
             d_data->titleRect.setWidth( rect.width()
                 - dimAxes[QwtPlot::yLeft] - dimAxes[QwtPlot::yRight] );
+        }
+        // subtract title
+        rect.setTop( rect.top() + dimTitle + d_data->spacing );
+    }
+    if ( dimFooter > 0 )
+    {
+        d_data->footerRect.setRect(
+            rect.left(), rect.bottom() - dimFooter, rect.width(), dimFooter );
+        rect.setBottom( d_data->footerRect.top() - d_data->spacing );
+        if ( d_data->layoutData.scale[QwtPlot::yLeft].isEnabled !=
+            d_data->layoutData.scale[QwtPlot::yRight].isEnabled )
+        {
+            // if only one of the y axes is missing we align
+            // the footer centered to the canvas
+            d_data->footerRect.setX( rect.left() + dimAxes[QwtPlot::yLeft] );
+            d_data->footerRect.setWidth( rect.width()
+                - dimAxes[QwtPlot::yLeft] - dimAxes[QwtPlot::yRight] );
+        }
+    }

trunk/BNC/qwt/qwt_plot_layout.h

-              r4271
+              r8127
   or by QwtPlot::print() to render its content to a QPaintDevice like
   a QPrinter, QPixmap/QImage or QSvgRenderer.
+  \sa QwtPlot::setPlotLayout()
 */
 …
         //! Ignore the legend.
+        IgnoreLegend = 0x08
+        IgnoreLegend = 0x08,
+        //! Ignore the title.
+        IgnoreTitle = 0x10,
+        //! Ignore the footer.
+        IgnoreFooter = 0x20
     };
 …
     void setAlignCanvasToScales( bool );
+    bool alignCanvasToScales() const;
+    void setAlignCanvasToScale( int axisId, bool );
+    bool alignCanvasToScale( int axisId ) const;
     void setSpacing( int );
 …
     virtual void invalidate();
+    const QRectF &titleRect() const;
+    const QRectF &legendRect() const;
+    const QRectF &scaleRect( int axis ) const;
+    const QRectF &canvasRect() const;
+    QRectF titleRect() const;
+    QRectF footerRect() const;
+    QRectF legendRect() const;
+    QRectF scaleRect( int axis ) const;
+    QRectF canvasRect() const;
     class LayoutData;
 …
 protected:
+    void setTitleRect( const QRectF & );
+    void setFooterRect( const QRectF & );
+    void setLegendRect( const QRectF & );
+    void setScaleRect( int axis, const QRectF & );
+    void setCanvasRect( const QRectF & );
     QRectF layoutLegend( Options options, const QRectF & ) const;
     QRectF alignLegend( const QRectF &canvasRect,
         const QRectF &legendRect ) const;
     void expandLineBreaks( int options, const QRectF &rect,
         int &dimTitle, int dimAxes[QwtPlot::axisCnt] ) const;
+    void expandLineBreaks( Options options, const QRectF &rect,
+        int &dimTitle, int &dimFooter, int dimAxes[QwtPlot::axisCnt] ) const;
     void alignScales( int options, QRectF &canvasRect,
+    void alignScales( Options options, QRectF &canvasRect,
         QRectF scaleRect[QwtPlot::axisCnt] ) const;

trunk/BNC/qwt/qwt_plot_magnifier.cpp

-              r4271
+              r8127
 #include "qwt_plot.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_scale_div.h"
 #include "qwt_plot_magnifier.h"
 …
    \param canvas Plot canvas to be magnified
 */
 QwtPlotMagnifier::QwtPlotMagnifier( QwtPlotCanvas *canvas ):
+QwtPlotMagnifier::QwtPlotMagnifier( QWidget *canvas ):
     QwtMagnifier( canvas )
+{
 …
 //! Return observed plot canvas
 QwtPlotCanvas *QwtPlotMagnifier::canvas()
+QWidget *QwtPlotMagnifier::canvas()
+{
     return qobject_cast<QwtPlotCanvas *>( parent() );
+    return parentWidget();
+}
 //! Return Observed plot canvas
 const QwtPlotCanvas *QwtPlotMagnifier::canvas() const
+const QWidget *QwtPlotMagnifier::canvas() const
+{
     return qobject_cast<const QwtPlotCanvas *>( parent() );
+    return parentWidget();
+}
 …
 QwtPlot *QwtPlotMagnifier::plot()
+{
     QwtPlotCanvas *w = canvas();
+    QWidget *w = canvas();
     if ( w )
         return w->plot();
+        w = w->parentWidget();
     return NULL;
+    return qobject_cast<QwtPlot *>( w );
+}
 …
 const QwtPlot *QwtPlotMagnifier::plot() const
+{
     const QwtPlotCanvas *w = canvas();
+    const QWidget *w = canvas();
     if ( w )
         return w->plot();
+        w = w->parentWidget();
     return NULL;
+    return qobject_cast<const QwtPlot *>( w );
+}
 …
 void QwtPlotMagnifier::rescale( double factor )
+{
+    QwtPlot* plt = plot();
+    if ( plt == NULL )
+        return;
     factor = qAbs( factor );
     if ( factor == 1.0 || factor == 0.0 )
 …
     bool doReplot = false;
-    QwtPlot* plt = plot();
     const bool autoReplot = plt->autoReplot();
 …
     for ( int axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+    {
+        const QwtScaleDiv *scaleDiv = plt->axisScaleDiv( axisId );
+        if ( isAxisEnabled( axisId ) && scaleDiv->isValid() )
+        if ( isAxisEnabled( axisId ) )
+        {
+            const double center =
+                scaleDiv->lowerBound() + scaleDiv->range() / 2;
+            const double width_2 = scaleDiv->range() / 2 * factor;
+            const QwtScaleMap scaleMap = plt->canvasMap( axisId );
+            plt->setAxisScale( axisId, center - width_2, center + width_2 );
+            double v1 = scaleMap.s1();
+            double v2 = scaleMap.s2();
+            if ( scaleMap.transformation() )
+            {
+                // the coordinate system of the paint device is always linear
+                v1 = scaleMap.transform( v1 ); // scaleMap.p1()
+                v2 = scaleMap.transform( v2 ); // scaleMap.p2()
+            }
+            const double center = 0.5 * ( v1 + v2 );
+            const double width_2 = 0.5 * ( v2 - v1 ) * factor;
+            v1 = center - width_2;
+            v2 = center + width_2;
+            if ( scaleMap.transformation() )
+            {
+                v1 = scaleMap.invTransform( v1 );
+                v2 = scaleMap.invTransform( v2 );
+            }
+            plt->setAxisScale( axisId, v1, v2 );
             doReplot = true;
+        }

trunk/BNC/qwt/qwt_plot_magnifier.h

-              r4271
+              r8127
 #include "qwt_magnifier.h"
-class QwtPlotCanvas;
 class QwtPlot;
 …
 public:
     explicit QwtPlotMagnifier( QwtPlotCanvas * );
+    explicit QwtPlotMagnifier( QWidget * );
     virtual ~QwtPlotMagnifier();
 …
     bool isAxisEnabled( int axis ) const;
     QwtPlotCanvas *canvas();
     const QwtPlotCanvas *canvas() const;
+    QWidget *canvas();
+    const QWidget *canvas() const;
     QwtPlot *plot();

trunk/BNC/qwt/qwt_plot_marker.cpp

-              r4271
+              r8127
 #include "qwt_text.h"
 #include "qwt_math.h"
-#include "qwt_legend.h"
-#include "qwt_legend_item.h"
 #include <qpainter.h>
 …
 //! Sets alignment to Qt::AlignCenter, and style to QwtPlotMarker::NoLine
+QwtPlotMarker::QwtPlotMarker():
+    QwtPlotItem( QwtText( "Marker" ) )
+QwtPlotMarker::QwtPlotMarker( const QString &title ):
+    QwtPlotItem( QwtText( title ) )
+{
+    d_data = new PrivateData;
+    setZ( 30.0 );
+}
+//! Sets alignment to Qt::AlignCenter, and style to QwtPlotMarker::NoLine
+QwtPlotMarker::QwtPlotMarker( const QwtText &title ):
+    QwtPlotItem( title )
+{
     d_data = new PrivateData;
 …
   \param xMap x Scale Map
   \param yMap y Scale Map
   \param canvasRect Contents rect of the canvas in painter coordinates
+  \param canvasRect Contents rectangle of the canvas in painter coordinates
 */
 void QwtPlotMarker::draw( QPainter *painter,
 …
         ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
+    {
+        d_data->symbol->drawSymbol( painter, pos );
+        const QSizeF sz = d_data->symbol->size();
+        const QRectF clipRect = canvasRect.adjusted(
+            -sz.width(), -sz.height(), sz.width(), sz.height() );
+        if ( clipRect.contains( pos ) )
+            d_data->symbol->drawSymbol( painter, pos );
+    }
 …
   \param painter Painter
   \param canvasRect Contents rect of the canvas in painter coordinates
+  \param canvasRect Contents rectangle of the canvas in painter coordinates
   \param pos Position of the marker, translated into widget coordinates
 …
   \param painter Painter
   \param canvasRect Contents rect of the canvas in painter coordinates
+  \param canvasRect Contents rectangle of the canvas in painter coordinates
   \param pos Position of the marker, translated into widget coordinates
 …
+    {
         d_data->style = style;
+        legendChanged();
         itemChanged();
+    }
 …
         delete d_data->symbol;
         d_data->symbol = symbol;
+        if ( symbol )
+            setLegendIconSize( symbol->boundingRect().size() );
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
   \brief Set the label
   \param label label text
+  \param label Label text
   \sa label()
 */
 …
+}
+/*!
+  Build and assign a line pen
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotMarker::setLinePen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setLinePen( QPen( color, width, style ) );
+}
 /*!
   Specify a pen for the line.
 …
+    {
         d_data->pen = pen;
+        legendChanged();
         itemChanged();
+    }
 …
 /*!
+   \brief Update the widget that represents the item on the legend
+   \param legend Legend
+   \sa drawLegendIdentifier(), legendItem(), itemChanged(), QwtLegend()
+   \note In the default setting QwtPlotItem::Legend is disabled
+*/
+void QwtPlotMarker::updateLegend( QwtLegend *legend ) const
+{
+    if ( legend && testItemAttribute( QwtPlotItem::Legend )
+        && d_data->symbol && d_data->symbol->style() != QwtSymbol::NoSymbol )
+    {
+        QWidget *lgdItem = legend->find( this );
+        if ( lgdItem == NULL )
+        {
+            lgdItem = legendItem();
+            if ( lgdItem )
+                legend->insert( this, lgdItem );
+        }
+        QwtLegendItem *l = qobject_cast<QwtLegendItem *>( lgdItem );
+        if ( l )
+            l->setIdentifierSize( d_data->symbol->boundingSize() );
+    }
+    QwtPlotItem::updateLegend( legend );
+}
+/*!
+  \brief Draw the identifier representing the marker on the legend
+  \param painter Painter
+  \param rect Bounding rectangle for the identifier
+  \sa updateLegend(), QwtPlotItem::Legend
+*/
+void QwtPlotMarker::drawLegendIdentifier(
+    QPainter *painter, const QRectF &rect ) const
+{
+    if ( rect.isEmpty() )
+        return;
+    painter->save();
+    painter->setClipRect( rect, Qt::IntersectClip );
+   \return Icon representing the marker on the legend
+   \param index Index of the legend entry
+                ( usually there is only one )
+   \param size Icon size
+   \sa setLegendIconSize(), legendData()
+*/
+QwtGraphic QwtPlotMarker::legendIcon( int index,
+    const QSizeF &size ) const
+{
+    Q_UNUSED( index );
+    if ( size.isEmpty() )
+        return QwtGraphic();
+    QwtGraphic icon;
+    icon.setDefaultSize( size );
+    icon.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
+    QPainter painter( &icon );
+    painter.setRenderHint( QPainter::Antialiasing,
+        testRenderHint( QwtPlotItem::RenderAntialiased ) );
     if ( d_data->style != QwtPlotMarker::NoLine )
+    {
         painter->setPen( d_data->pen );
+        painter.setPen( d_data->pen );
         if ( d_data->style == QwtPlotMarker::HLine ||
             d_data->style == QwtPlotMarker::Cross )
+        {
+            QwtPainter::drawLine( painter, rect.left(), rect.center().y(),
+                rect.right(), rect.center().y() );
+            const double y = 0.5 * size.height();
+            QwtPainter::drawLine( &painter,
+.0, y, size.width(), y );
+        }
 …
             d_data->style == QwtPlotMarker::Cross )
+        {
+            QwtPainter::drawLine( painter, rect.center().x(), rect.top(),
+                rect.center().x(), rect.bottom() );
+            const double x = 0.5 * size.width();
+            QwtPainter::drawLine( &painter,
+                x, 0.0, x, size.height() );
+        }
+    }
+    if ( d_data->symbol && d_data->symbol->style() != QwtSymbol::NoSymbol )
+    {
+        QSize symbolSize = d_data->symbol->boundingSize();
+        symbolSize -= QSize( 2, 2 );
+        // scale the symbol size down if it doesn't fit into rect.
+        double xRatio = 1.0;
+        if ( rect.width() < symbolSize.width() )
+            xRatio = rect.width() / symbolSize.width();
+        double yRatio = 1.0;
+        if ( rect.height() < symbolSize.height() )
+            yRatio = rect.height() / symbolSize.height();
+        const double ratio = qMin( xRatio, yRatio );
+        painter->scale( ratio, ratio );
+        d_data->symbol->drawSymbol( painter, rect.center() / ratio );
+    }
+    painter->restore();
+}
+    if ( d_data->symbol )
+    {
+        const QRect r( 0.0, 0.0, size.width(), size.height() );
+        d_data->symbol->drawSymbol( &painter, r );
+    }
+    return icon;
+}

trunk/BNC/qwt/qwt_plot_marker.h

-              r4271
+              r8127
   be drawn around a center point inside a bounding rectangle.
   The QwtPlotMarker::setSymbol() member assigns a symbol to the marker.
+  The setSymbol() member assigns a symbol to the marker.
   The symbol is drawn at the specified point.
 …
   left above the center point if the alignment was set to
   Qt::AlignLeft | Qt::AlignTop.
+  \note QwtPlotTextLabel is intended to align a text label
+        according to the geometry of canvas
+        ( unrelated to plot coordinates )
 */
 …
     };
+    explicit QwtPlotMarker();
+    explicit QwtPlotMarker( const QString &title = QString::null );
+    explicit QwtPlotMarker( const QwtText &title );
     virtual ~QwtPlotMarker();
 …
     LineStyle lineStyle() const;
+    void setLinePen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setLinePen( const QPen &p );
     const QPen &linePen() const;
 …
     virtual QRectF boundingRect() const;
+    virtual void updateLegend( QwtLegend * ) const;
+    virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF & ) const;
 protected:

trunk/BNC/qwt/qwt_plot_panner.cpp

-              r4271
+              r8127
 #include "qwt_scale_div.h"
 #include "qwt_plot.h"
+#include "qwt_plot_canvas.h"
+#include "qwt_painter.h"
+#include <qbitmap.h>
+#include <qstyle.h>
+#include <qstyleoption.h>
+static QBitmap qwtBorderMask( const QWidget *canvas, const QSize &size )
+{
+    const QRect r( 0, 0, size.width(), size.height() );
+    QPainterPath borderPath;
+    ( void )QMetaObject::invokeMethod(
+        const_cast< QWidget *>( canvas ), "borderPath", Qt::DirectConnection,
+        Q_RETURN_ARG( QPainterPath, borderPath ), Q_ARG( QRect, r ) );
+    if ( borderPath.isEmpty() )
+    {
+        if ( canvas->contentsRect() == canvas->rect() )
+            return QBitmap();
+        QBitmap mask( size );
+        mask.fill( Qt::color0 );
+        QPainter painter( &mask );
+        painter.fillRect( canvas->contentsRect(), Qt::color1 );
+        return mask;
+    }
+    QImage image( size, QImage::Format_ARGB32_Premultiplied );
+    image.fill( Qt::color0 );
+    QPainter painter( &image );
+    painter.setClipPath( borderPath );
+    painter.fillRect( r, Qt::color1 );
+    // now erase the frame
+    painter.setCompositionMode( QPainter::CompositionMode_DestinationOut );
+    if ( canvas->testAttribute(Qt::WA_StyledBackground ) )
+    {
+        QStyleOptionFrame opt;
+        opt.initFrom(canvas);
+        opt.rect = r;
+        canvas->style()->drawPrimitive( QStyle::PE_Frame, &opt, &painter, canvas );
+    }
+    else
+    {
+        const QVariant borderRadius = canvas->property( "borderRadius" );
+        const QVariant frameWidth = canvas->property( "frameWidth" );
+        if ( borderRadius.type() == QVariant::Double
+            && frameWidth.type() == QVariant::Int )
+        {
+            const double br = borderRadius.toDouble();
+            const int fw = frameWidth.toInt();
+            if ( br > 0.0 && fw > 0 )
+            {
+                painter.setPen( QPen( Qt::color1, fw ) );
+                painter.setBrush( Qt::NoBrush );
+                painter.setRenderHint( QPainter::Antialiasing, true );
+                painter.drawPath( borderPath );
+            }
+        }
+    }
+    painter.end();
+    const QImage mask = image.createMaskFromColor(
+        QColor( Qt::color1 ).rgb(), Qt::MaskOutColor );
+    return QBitmap::fromImage( mask );
+}
 class QwtPlotPanner::PrivateData
 …
 /*!
   \brief Create a plot panner
+  \brief A panner for the canvas of a QwtPlot
   The panner is enabled for all axes
 …
   \sa setAxisEnabled()
 */
 QwtPlotPanner::QwtPlotPanner( QwtPlotCanvas *canvas ):
+QwtPlotPanner::QwtPlotPanner( QWidget *canvas ):
     QwtPanner( canvas )
+{
 …
 //! Return observed plot canvas
 QwtPlotCanvas *QwtPlotPanner::canvas()
+{
     return qobject_cast<QwtPlotCanvas *>( parentWidget() );
+QWidget *QwtPlotPanner::canvas()
+{
+    return parentWidget();
+}
 //! Return Observed plot canvas
 const QwtPlotCanvas *QwtPlotPanner::canvas() const
+{
     return qobject_cast<const QwtPlotCanvas *>( parentWidget() );
+const QWidget *QwtPlotPanner::canvas() const
+{
+    return parentWidget();
+}
 …
 QwtPlot *QwtPlotPanner::plot()
+{
     QwtPlotCanvas *w = canvas();
+    QWidget *w = canvas();
     if ( w )
         return w->plot();
     return NULL;
+        w = w->parentWidget();
+    return qobject_cast<QwtPlot *>( w );
+}
 …
 const QwtPlot *QwtPlotPanner::plot() const
+{
     const QwtPlotCanvas *w = canvas();
+    const QWidget *w = canvas();
     if ( w )
         return w->plot();
     return NULL;
+        w = w->parentWidget();
+    return qobject_cast<const QwtPlot *>( w );
+}
 …
         const QwtScaleMap map = plot->canvasMap( axis );
         const double p1 = map.transform( plot->axisScaleDiv( axis )->lowerBound() );
         const double p2 = map.transform( plot->axisScaleDiv( axis )->upperBound() );
+        const double p1 = map.transform( plot->axisScaleDiv( axis ).lowerBound() );
+        const double p2 = map.transform( plot->axisScaleDiv( axis ).upperBound() );
         double d1, d2;
 …
 /*!
+    Calculate a mask from the border mask of the canvas
+    \sa QwtPlotCanvas::borderMask()
+   Calculate a mask from the border path of the canvas
+   \return Mask as bitmap
+   \sa QwtPlotCanvas::borderPath()
 */
 QBitmap QwtPlotPanner::contentsMask() const
+{
     if ( canvas() )
         return canvas()->borderMask( size() );
+        return qwtBorderMask( canvas(), size() );
     return QwtPanner::contentsMask();
+}
+/*!
+   \return Pixmap with the content of the canvas
+ */
+QPixmap QwtPlotPanner::grab() const
+{
+    const QWidget *cv = canvas();
+    if ( cv && cv->inherits( "QGLWidget" ) )
+    {
+        // we can't grab from a QGLWidget
+        QPixmap pm( cv->size() );
+        QwtPainter::fillPixmap( cv, pm );
+        QPainter painter( &pm );
+        const_cast<QwtPlot *>( plot() )->drawCanvas( &painter );
+        return pm;
+    }
+    return QwtPanner::grab();
+}

trunk/BNC/qwt/qwt_plot_panner.h

-              r4271
+              r8127
 #include "qwt_panner.h"
-class QwtPlotCanvas;
 class QwtPlot;
 …
   \brief QwtPlotPanner provides panning of a plot canvas
   QwtPlotPanner is a panner for a QwtPlotCanvas, that
+  QwtPlotPanner is a panner for a plot canvas, that
   adjusts the scales of the axes after dropping
   the canvas on its new position.
 …
 public:
     explicit QwtPlotPanner( QwtPlotCanvas * );
+    explicit QwtPlotPanner( QWidget * );
     virtual ~QwtPlotPanner();
     QwtPlotCanvas *canvas();
     const QwtPlotCanvas *canvas() const;
+    QWidget *canvas();
+    const QWidget *canvas() const;
     QwtPlot *plot();
 …
 protected:
     virtual QBitmap contentsMask() const;
+    virtual QPixmap grab() const;
 private:

trunk/BNC/qwt/qwt_plot_picker.cpp

-              r4271
+              r8127
 */
 QwtPlotPicker::QwtPlotPicker( QwtPlotCanvas *canvas ):
+QwtPlotPicker::QwtPlotPicker( QWidget *canvas ):
     QwtPicker( canvas ),
     d_xAxis( -1 ),
 …
   \sa QwtPlot::autoReplot(), QwtPlot::replot(), scaleRect()
 */
 QwtPlotPicker::QwtPlotPicker( int xAxis, int yAxis, QwtPlotCanvas *canvas ):
+QwtPlotPicker::QwtPlotPicker( int xAxis, int yAxis, QWidget *canvas ):
     QwtPicker( canvas ),
     d_xAxis( xAxis ),
 …
   \param xAxis X axis of the picker
   \param yAxis Y axis of the picker
   \param rubberBand Rubberband style
+  \param rubberBand Rubber band style
   \param trackerMode Tracker mode
   \param canvas Plot canvas to observe, also the parent object
 …
 QwtPlotPicker::QwtPlotPicker( int xAxis, int yAxis,
         RubberBand rubberBand, DisplayMode trackerMode,
         QwtPlotCanvas *canvas ):
+        QWidget *canvas ):
     QwtPicker( rubberBand, trackerMode, canvas ),
     d_xAxis( xAxis ),
 …
+}
 //! Return observed plot canvas
 QwtPlotCanvas *QwtPlotPicker::canvas()
+{
     return qobject_cast<QwtPlotCanvas *>( parentWidget() );
+}
 //! Return Observed plot canvas
 const QwtPlotCanvas *QwtPlotPicker::canvas() const
+{
     return qobject_cast<const QwtPlotCanvas *>( parentWidget() );
+}
 //! Return plot widget, containing the observed plot canvas
+//! \return Observed plot canvas
+QWidget *QwtPlotPicker::canvas()
+{
+    return parentWidget();
+}
+//! \return Observed plot canvas
+const QWidget *QwtPlotPicker::canvas() const
+{
+    return parentWidget();
+}
+//! \return Plot widget, containing the observed plot canvas
 QwtPlot *QwtPlotPicker::plot()
+{
     QwtPlotCanvas *w = canvas();
+    QWidget *w = canvas();
     if ( w )
         return w->plot();
     return NULL;
+}
 //! Return plot widget, containing the observed plot canvas
+        w = w->parentWidget();
+    return qobject_cast<QwtPlot *>( w );
+}
+//! \return Plot widget, containing the observed plot canvas
 const QwtPlot *QwtPlotPicker::plot() const
+{
     const QwtPlotCanvas *w = canvas();
+    const QWidget *w = canvas();
     if ( w )
+        return w->plot();
+    return NULL;
+}
+/*!
+  Return normalized bounding rect of the axes
+        w = w->parentWidget();
+    return qobject_cast<const QwtPlot *>( w );
+}
+/*!
+  \return Normalized bounding rectangle of the axes
   \sa QwtPlot::autoReplot(), QwtPlot::replot().
 */
 …
     if ( plot() )
+    {
+        const QwtScaleDiv *xs = plot()->axisScaleDiv( xAxis() );
+        const QwtScaleDiv *ys = plot()->axisScaleDiv( yAxis() );
+        if ( xs && ys )
+        {
+            rect = QRectF( xs->lowerBound(), ys->lowerBound(),
+                xs->range(), ys->range() );
+            rect = rect.normalized();
+        }
+        const QwtScaleDiv &xs = plot()->axisScaleDiv( xAxis() );
+        const QwtScaleDiv &ys = plot()->axisScaleDiv( yAxis() );
+        rect = QRectF( xs.lowerBound(), ys.lowerBound(),
+            xs.range(), ys.range() );
+        rect = rect.normalized();
+    }
 …
 /*!
   Append a point to the selection and update rubberband and tracker.
+  Append a point to the selection and update rubber band and tracker.
   \param pos Additional point
 …
   \param ok If true, complete the selection and emit selected signals
             otherwise discard the selection.
   \return true if the selection is accepted, false otherwise
+  \return True if the selection has been accepted, false otherwise
 */
 …
         return false;
     const QPolygon pa = selection();
     if ( pa.count() == 0 )
+    const QPolygon points = selection();
+    if ( points.count() == 0 )
         return false;
 …
         case QwtPickerMachine::PointSelection:
+        {
             const QPointF pos = invTransform( pa[0] );
+            const QPointF pos = invTransform( points.first() );
             Q_EMIT selected( pos );
             break;
 …
         case QwtPickerMachine::RectSelection:
+        {
             if ( pa.count() >= 2 )
+            if ( points.count() >= 2 )
+            {
                 const QPoint p1 = pa[0];
                 const QPoint p2 = pa[int( pa.count() - 1 )];
+                const QPoint p1 = points.first();
+                const QPoint p2 = points.last();
                 const QRect rect = QRect( p1, p2 ).normalized();
 …
         case QwtPickerMachine::PolygonSelection:
+        {
             QVector<QPointF> dpa( pa.count() );
             for ( int i = 0; i < int( pa.count() ); i++ )
                 dpa[i] = invTransform( pa[i] );
+            QVector<QPointF> dpa( points.count() );
+            for ( int i = 0; i < points.count(); i++ )
+                dpa[i] = invTransform( points[i] );
             Q_EMIT selected( dpa );

trunk/BNC/qwt/qwt_plot_picker.h

-              r4271
+              r8127
 #include "qwt_global.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_picker.h"
 #include <qvector.h>
 …
   QwtPlotPicker is a QwtPicker tailored for selections on
   a plot canvas. It is set to a x-Axis and y-Axis and
   translates all pixel coordinates into this coodinate system.
+  translates all pixel coordinates into this coordinate system.
 */
 …
 public:
     explicit QwtPlotPicker( QwtPlotCanvas * );
+    explicit QwtPlotPicker( QWidget *canvas );
     virtual ~QwtPlotPicker();
     explicit QwtPlotPicker( int xAxis, int yAxis, QwtPlotCanvas * );
+    explicit QwtPlotPicker( int xAxis, int yAxis, QWidget * );
     explicit QwtPlotPicker( int xAxis, int yAxis,
+        RubberBand rubberBand, DisplayMode trackerMode,
+        QwtPlotCanvas * );
+        RubberBand rubberBand, DisplayMode trackerMode, QWidget * );
     virtual void setAxis( int xAxis, int yAxis );
 …
     const QwtPlot *plot() const;
     QwtPlotCanvas *canvas();
     const QwtPlotCanvas *canvas() const;
+    QWidget *canvas();
+    const QWidget *canvas() const;
 Q_SIGNALS:
     /*!
       A signal emitted in case of selectionFlags() & PointSelection.
+      A signal emitted in case of QwtPickerMachine::PointSelection.
       \param pos Selected point
     */
 …
     /*!
       A signal emitted in case of selectionFlags() & RectSelection.
+      A signal emitted in case of QwtPickerMachine::RectSelection.
       \param rect Selected rectangle
     */

trunk/BNC/qwt/qwt_plot_rasteritem.cpp

-              r4271
+              r8127
 #include "qwt_plot_rasteritem.h"
-#include "qwt_legend.h"
-#include "qwt_legend_item.h"
 #include "qwt_scale_map.h"
 #include "qwt_painter.h"
 …
 #include <qpainter.h>
 #include <qpaintengine.h>
+#include <qmath.h>
+#if QT_VERSION >= 0x040400
+#include <qthread.h>
+#include <qfuture.h>
+#include <qtconcurrentrun.h>
+#endif
 #include <float.h>
 …
     int alpha;
     QwtPlotRasterItem::PaintAttributes paintAttributes;
 …
+                }
+                const quint32 *line1 = (const quint32 *) image.scanLine( y1 );
+                const quint32 *line1 =
+                    reinterpret_cast<const quint32 *>( image.scanLine( y1 ) );
                 for ( int x1 = 0; x1 < w; x1++ )
 …
                     for ( int y2 = yy1; y2 < yy2; y2++ )
+                    {
+                        quint32 *line2 = ( quint32 *) expanded.scanLine( y2 );
+                        quint32 *line2 = reinterpret_cast<quint32 *>(
+                            expanded.scanLine( y2 ) );
                         for ( int x2 = xx1; x2 < xx2; x2++ )
                             line2[x2] = rgb;
 …
+}
 static QRectF expandToPixels(const QRectF &rect, const QRectF &pixelRect)
+static QRectF qwtExpandToPixels(const QRectF &rect, const QRectF &pixelRect)
+{
     const double pw = pixelRect.width();
 …
+}
 static void transformMaps( const QTransform &tr,
+static void qwtTransformMaps( const QTransform &tr,
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     QwtScaleMap &xxMap, QwtScaleMap &yyMap )
 …
+}
 static void adjustMaps( QwtScaleMap &xMap, QwtScaleMap &yMap,
+static void qwtAdjustMaps( QwtScaleMap &xMap, QwtScaleMap &yMap,
     const QRectF &area, const QRectF &paintRect)
+{
 …
+}
 static bool useCache( QwtPlotRasterItem::CachePolicy policy,
+static bool qwtUseCache( QwtPlotRasterItem::CachePolicy policy,
     const QPainter *painter )
+{
 …
+}
+static QImage toRgba( const QImage& image, int alpha )
+{
+    if ( alpha < 0 || alpha >= 255 )
+        return image;
+    QImage alphaImage( image.size(), QImage::Format_ARGB32 );
+static void qwtToRgba( const QImage* from, QImage* to,
+    const QRect& tile, int alpha )
+{
     const QRgb mask1 = qRgba( 0, 0, 0, alpha );
     const QRgb mask2 = qRgba( 255, 255, 255, 0 );
     const QRgb mask3 = qRgba( 0, 0, 0, 255 );
+    const int w = image.size().width();
+    const int h = image.size().height();
+    if ( image.depth() == 8 )
+    {
+        for ( int y = 0; y < h; y++ )
+        {
+            QRgb* alphaLine = ( QRgb* )alphaImage.scanLine( y );
+            const unsigned char *line = image.scanLine( y );
+            for ( int x = 0; x < w; x++ )
+                *alphaLine++ = ( image.color( *line++ ) & mask2 ) | mask1;
+        }
+    }
+    else if ( image.depth() == 32 )
+    {
+        for ( int y = 0; y < h; y++ )
+        {
+            QRgb* alphaLine = ( QRgb* )alphaImage.scanLine( y );
+            const QRgb* line = ( const QRgb* ) image.scanLine( y );
+            for ( int x = 0; x < w; x++ )
+    const int y0 = tile.top();
+    const int y1 = tile.bottom();
+    const int x0 = tile.left();
+    const int x1 = tile.right();
+    if ( from->depth() == 8 )
+    {
+        for ( int y = y0; y <= y1; y++ )
+        {
+            QRgb *alphaLine = reinterpret_cast<QRgb *>( to->scanLine( y ) );
+            const unsigned char *line = from->scanLine( y );
+            for ( int x = x0; x <= x1; x++ )
+                *alphaLine++ = ( from->color( *line++ ) & mask2 ) | mask1;
+        }
+    }
+    else if ( from->depth() == 32 )
+    {
+        for ( int y = y0; y <= y1; y++ )
+        {
+            QRgb *alphaLine = reinterpret_cast<QRgb *>( to->scanLine( y ) );
+            const QRgb *line = reinterpret_cast<const QRgb *>( from->scanLine( y ) );
+            for ( int x = x0; x <= x1; x++ )
+            {
                 const QRgb rgb = *line++;
 …
+        }
+    }
-    return alphaImage;
+}
 …
 /*!
     \brief Return the current paint attributes
+    \return True, when attribute is enabled
     \sa PaintAttribute, setPaintAttribute()
 */
 …
    Width and height of the hint need to be the horizontal
    and vertical distances between 2 neighboured points.
+   and vertical distances between 2 neighbored points.
    The center of the hint has to be the position of any point
    ( it doesn't matter which one ).
 …
   \param xMap X-Scale Map
   \param yMap Y-Scale Map
   \param canvasRect Contents rect of the plot canvas
+  \param canvasRect Contents rectangle of the plot canvas
 */
 void QwtPlotRasterItem::draw( QPainter *painter,
 …
         return;
     const bool doCache = useCache( d_data->cache.policy, painter );
+    const bool doCache = qwtUseCache( d_data->cache.policy, painter );
     const QwtInterval xInterval = interval( Qt::XAxis );
 …
     /*
         Scaling a rastered image always results in a loss of
+        Scaling an image always results in a loss of
         precision/quality. So we always render the image in
         paint device resolution.
 …
     QwtScaleMap xxMap, yyMap;
     transformMaps( painter->transform(), xMap, yMap, xxMap, yyMap );
+    qwtTransformMaps( painter->transform(), xMap, yMap, xxMap, yyMap );
     QRectF paintRect = painter->transform().mapRect( canvasRect );
 …
     if ( !pixelRect.isEmpty() )
+    {
         const QRectF r = QwtScaleMap::invTransform(
             xxMap, yyMap, QRectF(0, 0, 1, 1) ).normalized();
+        if ( r.width() > pixelRect.width() &&
             r.height() > pixelRect.height() )
+        // one pixel of the target device in plot coordinates
+        const double dx = qAbs( xxMap.invTransform( 1 ) - xxMap.invTransform( 0 ) );
+        const double dy = qAbs( yyMap.invTransform( 1 ) - yyMap.invTransform( 0 ) );
+        if ( dx > pixelRect.width() && dy > pixelRect.height() )
+        {
             /*
 …
             pixelRect = QRectF();
+        }
+        else
+        {
+            /*
+              If only one dimension is of the data pixel is higher
+              we expand the pixel rect to the resolution of the target device.
+             */
+            if ( dx > pixelRect.width() )
+                pixelRect.setWidth( dx );
+            if ( dy > pixelRect.height() )
+                pixelRect.setHeight( dy );
+        }
+    }
 …
             paintRect = qwtAlignRect(paintRect);
             adjustMaps(xxMap, yyMap, area, paintRect);
+            qwtAdjustMaps(xxMap, yyMap, area, paintRect);
+        }
 …
         // align the area to the data pixels
         QRectF imageArea = expandToPixels(area, pixelRect);
+        QRectF imageArea = qwtExpandToPixels(area, pixelRect);
         if ( imageArea.right() == xInterval.maxValue() &&
 …
         imageSize.setWidth( qRound( imageArea.width() / pixelRect.width() ) );
         imageSize.setHeight( qRound( imageArea.height() / pixelRect.height() ) );
         image = compose(xxMap, yyMap,
             imageArea, paintRect, imageSize, doCache );
         if ( image.isNull() )
             return;
 …
 /*!
    \return Bounding rect of the data
+   \return Bounding rectangle of the data
    \sa QwtPlotRasterItem::interval()
 */
 …
     if ( d_data->alpha >= 0 && d_data->alpha < 255 )
+        image = toRgba( image, d_data->alpha );
+    {
+        QImage alphaImage( image.size(), QImage::Format_ARGB32 );
+#if QT_VERSION >= 0x040400 && !defined(QT_NO_QFUTURE)
+        uint numThreads = renderThreadCount();
+        if ( numThreads <= 0 )
+            numThreads = QThread::idealThreadCount();
+        if ( numThreads <= 0 )
+            numThreads = 1;
+        const int numRows = image.height() / numThreads;
+        QList< QFuture<void> > futures;
+        for ( uint i = 0; i < numThreads; i++ )
+        {
+            QRect tile( 0, i * numRows, image.width(), numRows );
+            if ( i == numThreads - 1 )
+            {
+                tile.setHeight( image.height() - i * numRows );
+                qwtToRgba( &image, &alphaImage, tile, d_data->alpha );
+            }
+            else
+            {
+                futures += QtConcurrent::run(
+                    &qwtToRgba, &image, &alphaImage, tile, d_data->alpha );
+            }
+        }
+        for ( int i = 0; i < futures.size(); i++ )
+            futures[i].waitForFinished();
+#else
+        const QRect tile( 0, 0, image.width(), image.height() );
+        qwtToRgba( &image, &alphaImage, tile, d_data->alpha );
+#endif
+        image = alphaImage;
+    }
     return image;
 …
    \param imageSize Image size
    \param pixelSize Width/Height of a data pixel
+   \return Calculated scale map
 */
 QwtScaleMap QwtPlotRasterItem::imageMap(

trunk/BNC/qwt/qwt_plot_rasteritem.h

-              r4271
+              r8127
 public:
     /*!
+      - NoCache\n
+        renderImage() is called, whenever the item has to be repainted
+      - PaintCache\n
+        renderImage() is called, whenever the image cache is not valid,
+        or the scales, or the size of the canvas has changed. This type
+        of cache is only useful for improving the performance of hide/show
+        operations. All other situations are already handled by the
+        plot canvas cache.
+      \brief Cache policy
       The default policy is NoCache
      */
     enum CachePolicy
+    {
+        /*!
+          renderImage() is called each time the item has to be repainted
+         */
         NoCache,
+        /*!
+          renderImage() is called, whenever the image cache is not valid,
+          or the scales, or the size of the canvas has changed.
+          This type of cache is useful for improving the performance
+          of hide/show operations or manipulations of the alpha value.
+          All other situations are handled by the canvas backing store.
+         */
         PaintCache
     };
 …
       \param area Requested area for the image in scale coordinates
       \param imageSize Requested size of the image
+      \return Rendered image
      */
     virtual QImage renderImage( const QwtScaleMap &xMap,

trunk/BNC/qwt/qwt_plot_renderer.cpp

-              r4271
+              r8127
 #include "qwt_plot.h"
 #include "qwt_painter.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_plot_layout.h"
+#include "qwt_legend.h"
+#include "qwt_legend_item.h"
+#include "qwt_dyngrid_layout.h"
+#include "qwt_abstract_legend.h"
 #include "qwt_scale_widget.h"
 #include "qwt_scale_engine.h"
 …
 #include <qtransform.h>
 #include <qprinter.h>
+#include <qprintdialog.h>
+#include <qfiledialog.h>
+#include <qfileinfo.h>
 #include <qstyle.h>
 #include <qstyleoption.h>
 #include <qimagewriter.h>
-#include <qfileinfo.h>
 #ifndef QWT_NO_SVG
 #ifdef QT_SVG_LIB
 …
 #endif
+static QPainterPath qwtCanvasClip(
+    const QWidget* canvas, const QRectF &canvasRect )
+{
+    // The clip region is calculated in integers
+    // To avoid too much rounding errors better
+    // calculate it in target device resolution
+    int x1 = qCeil( canvasRect.left() );
+    int x2 = qFloor( canvasRect.right() );
+    int y1 = qCeil( canvasRect.top() );
+    int y2 = qFloor( canvasRect.bottom() );
+    const QRect r( x1, y1, x2 - x1 - 1, y2 - y1 - 1 );
+    QPainterPath clipPath;
+    ( void ) QMetaObject::invokeMethod(
+        const_cast< QWidget *>( canvas ), "borderPath",
+        Qt::DirectConnection,
+        Q_RETURN_ARG( QPainterPath, clipPath ), Q_ARG( QRect, r ) );
+    return clipPath;
+}
 class QwtPlotRenderer::PrivateData
+{
 public:
     PrivateData():
         discardFlags( QwtPlotRenderer::DiscardBackground ),
+        discardFlags( QwtPlotRenderer::DiscardNone ),
         layoutFlags( QwtPlotRenderer::DefaultLayout )
+    {
 …
     QwtPlotRenderer::LayoutFlags layoutFlags;
 };
-static void qwtRenderBackground( QPainter *painter,
-    const QRectF &rect, const QWidget *widget )
+{
-    if ( widget->testAttribute( Qt::WA_StyledBackground ) )
+    {
-        QStyleOption opt;
-        opt.initFrom( widget );
-        opt.rect = rect.toAlignedRect();
-        widget->style()->drawPrimitive(
-            QStyle::PE_Widget, &opt, painter, widget);
+    }
-    else
+    {
-        const QBrush brush =
-            widget->palette().brush( widget->backgroundRole() );
-        painter->fillRect( rect, brush );
+    }
+}
 /*!
 …
 /*!
+  Check if a flag is set.
+  \return True, if flag is enabled.
   \param flag Flag to be tested
   \sa DiscardFlag, setDiscardFlag(), setDiscardFlags(), discardFlags()
 …
 /*!
+  Check if a flag is set.
+  \return True, if flag is enabled.
   \param flag Flag to be tested
   \sa LayoutFlag, setLayoutFlag(), setLayoutFlags(), layoutFlags()
 …
   Render a plot to a file
   The format of the document will be autodetected from the
   suffix of the filename.
+  The format of the document will be auto-detected from the
+  suffix of the file name.
   \param plot Plot widget
 …
     const QString fmt = format.toLower();
     if ( fmt == "pdf" || fmt == "ps" )
+    if ( fmt == "pdf" )
+    {
 #ifndef QT_NO_PRINTER
         QPrinter printer;
+        printer.setOutputFormat( QPrinter::PdfFormat );
+        printer.setColorMode( QPrinter::Color );
         printer.setFullPage( true );
         printer.setPaperSize( sizeMM, QPrinter::Millimeter );
         printer.setDocName( title );
         printer.setOutputFileName( fileName );
-        printer.setOutputFormat( ( format == "pdf" )
-            ? QPrinter::PdfFormat : QPrinter::PostScriptFormat );
         printer.setResolution( resolution );
         QPainter painter( &printer );
         render( plot, &painter, documentRect );
+#endif
+    }
+    else if ( fmt == "ps" )
+    {
+#if QT_VERSION < 0x050000
+#ifndef QT_NO_PRINTER
+        QPrinter printer;
+        printer.setOutputFormat( QPrinter::PostScriptFormat );
+        printer.setColorMode( QPrinter::Color );
+        printer.setFullPage( true );
+        printer.setPaperSize( sizeMM, QPrinter::Millimeter );
+        printer.setDocName( title );
+        printer.setOutputFileName( fileName );
+        printer.setResolution( resolution );
+        QPainter painter( &printer );
+        render( plot, &painter, documentRect );
+#endif
 #endif
+    }
 …
     QPainter *painter, const QRectF &plotRect ) const
+{
-    int axisId;
     if ( painter == 0 || !painter->isActive() ||
             !plotRect.isValid() || plot->size().isNull() )
+    {
         return;
+    }
     if ( !( d_data->discardFlags & DiscardBackground ) )
         qwtRenderBackground( painter, plotRect, plot );
+        QwtPainter::drawBackgound( painter, plotRect, plot );
     /*
 …
         double( painter->device()->logicalDpiY() ) / plot->logicalDpiY() );
+    painter->save();
+    QRectF layoutRect = transform.inverted().mapRect( plotRect );
+    if ( !( d_data->discardFlags & DiscardBackground ) )
+    {
+        // subtract the contents margins
+        int left, top, right, bottom;
+        plot->getContentsMargins( &left, &top, &right, &bottom );
+        layoutRect.adjust( left, top, -right, -bottom );
+    }
+    QwtPlotLayout *layout = plot->plotLayout();
     int baseLineDists[QwtPlot::axisCnt];
+    if ( d_data->layoutFlags & FrameWithScales )
+    {
+        for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+    int canvasMargins[QwtPlot::axisCnt];
+    for ( int axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+    {
+        canvasMargins[ axisId ] = layout->canvasMargin( axisId );
+        if ( d_data->layoutFlags & FrameWithScales )
+        {
             QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
 …
                 scaleWidget->setMargin( 0 );
+            }
+        }
+    }
+    // Calculate the layout for the print.
+    QwtPlotLayout::Options layoutOptions =
+        QwtPlotLayout::IgnoreScrollbars | QwtPlotLayout::IgnoreFrames;
+            if ( !plot->axisEnabled( axisId ) )
+            {
+                int left = 0;
+                int right = 0;
+                int top = 0;
+                int bottom = 0;
+                // When we have a scale the frame is painted on
+                // the position of the backbone - otherwise we
+                // need to introduce a margin around the canvas
+                switch( axisId )
+                {
+                    case QwtPlot::yLeft:
+                        layoutRect.adjust( 1, 0, 0, 0 );
+                        break;
+                    case QwtPlot::yRight:
+                        layoutRect.adjust( 0, 0, -1, 0 );
+                        break;
+                    case QwtPlot::xTop:
+                        layoutRect.adjust( 0, 1, 0, 0 );
+                        break;
+                    case QwtPlot::xBottom:
+                        layoutRect.adjust( 0, 0, 0, -1 );
+                        break;
+                    default:
+                        break;
+                }
+                layoutRect.adjust( left, top, right, bottom );
+            }
+        }
+    }
+    // Calculate the layout for the document.
+    QwtPlotLayout::Options layoutOptions = QwtPlotLayout::IgnoreScrollbars;
+    if ( ( d_data->layoutFlags & FrameWithScales ) ||
+        ( d_data->discardFlags & DiscardCanvasFrame ) )
+    {
+        layoutOptions |= QwtPlotLayout::IgnoreFrames;
+    }
     if ( d_data->discardFlags & DiscardLegend )
         layoutOptions |= QwtPlotLayout::IgnoreLegend;
+    const QRectF layoutRect = transform.inverted().mapRect( plotRect );
+    plot->plotLayout()->activate( plot, layoutRect, layoutOptions );
+    if ( d_data->discardFlags & DiscardTitle )
+        layoutOptions |= QwtPlotLayout::IgnoreTitle;
+    if ( d_data->discardFlags & DiscardFooter )
+        layoutOptions |= QwtPlotLayout::IgnoreFooter;
+    layout->activate( plot, layoutRect, layoutOptions );
+    // canvas
+    QwtScaleMap maps[QwtPlot::axisCnt];
+    buildCanvasMaps( plot, layout->canvasRect(), maps );
+    if ( updateCanvasMargins( plot, layout->canvasRect(), maps ) )
+    {
+        // recalculate maps and layout, when the margins
+        // have been changed
+        layout->activate( plot, layoutRect, layoutOptions );
+        buildCanvasMaps( plot, layout->canvasRect(), maps );
+    }
+    // now start painting
+    painter->save();
     painter->setWorldTransform( transform, true );
+    // canvas
+    QwtScaleMap maps[QwtPlot::axisCnt];
+    buildCanvasMaps( plot, plot->plotLayout()->canvasRect(), maps );
+    renderCanvas( plot, painter, plot->plotLayout()->canvasRect(), maps );
+    renderCanvas( plot, painter, layout->canvasRect(), maps );
     if ( !( d_data->discardFlags & DiscardTitle )
         && ( !plot->titleLabel()->text().isEmpty() ) )
+    {
+        renderTitle( plot, painter, plot->plotLayout()->titleRect() );
+        renderTitle( plot, painter, layout->titleRect() );
+    }
+    if ( !( d_data->discardFlags & DiscardFooter )
+        && ( !plot->footerLabel()->text().isEmpty() ) )
+    {
+        renderFooter( plot, painter, layout->footerRect() );
+    }
 …
         && plot->legend() && !plot->legend()->isEmpty() )
+    {
         renderLegend( plot, painter, plot->plotLayout()->legendRect() );
+    }
     for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+        renderLegend( plot, painter, layout->legendRect() );
+    }
+    for ( int axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+    {
         QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
 …
             renderScale( plot, painter, axisId, startDist, endDist,
+                baseDist, plot->plotLayout()->scaleRect( axisId ) );
+        }
+    }
+    plot->plotLayout()->invalidate();
+    // reset all widgets with their original attributes.
+    if ( d_data->layoutFlags & FrameWithScales )
+    {
+        // restore the previous base line dists
+        for ( axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+                baseDist, layout->scaleRect( axisId ) );
+        }
+    }
+    painter->restore();
+    // restore all setting to their original attributes.
+    for ( int axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+    {
+        if ( d_data->layoutFlags & FrameWithScales )
+        {
             QwtScaleWidget *scaleWidget = plot->axisWidget( axisId );
 …
                 scaleWidget->setMargin( baseLineDists[axisId] );
+        }
+    }
+    painter->restore();
+        layout->setCanvasMargin( canvasMargins[axisId] );
+    }
+    layout->invalidate();
+}
 …
 /*!
   Render the legend into a given rectangle.
+  Render the footer into a given rectangle.
   \param plot Plot widget
 …
   \param rect Bounding rectangle
 */
+void QwtPlotRenderer::renderFooter( const QwtPlot *plot,
+    QPainter *painter, const QRectF &rect ) const
+{
+    painter->setFont( plot->footerLabel()->font() );
+    const QColor color = plot->footerLabel()->palette().color(
+            QPalette::Active, QPalette::Text );
+    painter->setPen( color );
+    plot->footerLabel()->text().draw( painter, rect );
+}
+/*!
+  Render the legend into a given rectangle.
+  \param plot Plot widget
+  \param painter Painter
+  \param rect Bounding rectangle
+*/
 void QwtPlotRenderer::renderLegend( const QwtPlot *plot,
     QPainter *painter, const QRectF &rect ) const
+{
+    if ( !plot->legend() || plot->legend()->isEmpty() )
+        return;
+    if ( !( d_data->discardFlags & DiscardBackground ) )
+    {
+        if ( plot->legend()->autoFillBackground() ||
+            plot->legend()->testAttribute( Qt::WA_StyledBackground ) )
+        {
+            qwtRenderBackground( painter, rect, plot->legend() );
+        }
+    }
+    const QwtDynGridLayout *legendLayout = qobject_cast<QwtDynGridLayout *>(
+        plot->legend()->contentsWidget()->layout() );
+    if ( legendLayout == NULL )
+        return;
+    uint numCols = legendLayout->columnsForWidth( rect.width() );
+    QList<QRect> itemRects =
+        legendLayout->layoutItems( rect.toRect(), numCols );
+    int index = 0;
+    for ( int i = 0; i < legendLayout->count(); i++ )
+    {
+        QLayoutItem *item = legendLayout->itemAt( i );
+        QWidget *w = item->widget();
+        if ( w )
+        {
+            painter->save();
+            painter->setClipRect( itemRects[index] );
+            renderLegendItem( plot, painter, w, itemRects[index] );
+            index++;
+            painter->restore();
+        }
+    }
+}
+/*!
+  Render the legend item into a given rectangle.
+  \param plot Plot widget
+  \param painter Painter
+  \param widget Widget representing a legend item
+  \param rect Bounding rectangle
+  \note When widget is not derived from QwtLegendItem renderLegendItem
+        does nothing and needs to be overloaded
+*/
+void QwtPlotRenderer::renderLegendItem( const QwtPlot *plot,
+    QPainter *painter, const QWidget *widget, const QRectF &rect ) const
+{
+    if ( !( d_data->discardFlags & DiscardBackground ) )
+    {
+        if ( widget->autoFillBackground() ||
+            widget->testAttribute( Qt::WA_StyledBackground ) )
+        {
+            qwtRenderBackground( painter, rect, widget );
+        }
+    }
+    const QwtLegendItem *item = qobject_cast<const QwtLegendItem *>( widget );
+    if ( item )
+    {
+        const QSize sz = item->identifierSize();
+        const QRectF identifierRect( rect.x() + item->margin(),
+            rect.center().y() - 0.5 * sz.height(), sz.width(), sz.height() );
+        QwtLegendItemManager *itemManger = plot->legend()->find( item );
+        if ( itemManger )
+        {
+            painter->save();
+            painter->setClipRect( identifierRect, Qt::IntersectClip );
+            itemManger->drawLegendIdentifier( painter, identifierRect );
+            painter->restore();
+        }
+        // Label
+        QRectF titleRect = rect;
+        titleRect.setX( identifierRect.right() + 2 * item->spacing() );
+        painter->setFont( item->font() );
+        item->text().draw( painter, titleRect );
+    if ( plot->legend() )
+    {
+        bool fillBackground = !( d_data->discardFlags & DiscardBackground );
+        plot->legend()->renderLegend( painter, rect, fillBackground );
+    }
+}
 …
+    {
         scaleWidget->drawColorBar( painter, scaleWidget->colorBarRect( rect ) );
+        const int off = scaleWidget->colorBarWidth() + scaleWidget->spacing();
+        if ( scaleWidget->scaleDraw()->orientation() == Qt::Horizontal )
+            baseDist += off;
+        else
+            baseDist += off;
+        baseDist += scaleWidget->colorBarWidth() + scaleWidget->spacing();
+    }
 …
     const QwtScaleMap *map ) const
+{
+    painter->save();
+    QPainterPath clipPath;
+    const QWidget *canvas = plot->canvas();
     QRectF r = canvasRect.adjusted( 0.0, 0.0, -1.0, -1.0 );
 …
     if ( d_data->layoutFlags & FrameWithScales )
+    {
+        painter->save();
         r.adjust( -1.0, -1.0, 1.0, 1.0 );
         painter->setPen( QPen( Qt::black ) );
 …
+        {
             const QBrush bgBrush =
                 plot->canvas()->palette().brush( plot->backgroundRole() );
+                canvas->palette().brush( plot->backgroundRole() );
             painter->setBrush( bgBrush );
+        }
         QwtPainter::drawRect( painter, r );
+        painter->restore();
+        painter->save();
+        painter->setClipRect( canvasRect );
+        plot->drawItems( painter, canvasRect, map );
+        painter->restore();
+    }
+    else if ( canvas->testAttribute( Qt::WA_StyledBackground ) )
+    {
+        QPainterPath clipPath;
+        painter->save();
+        if ( !( d_data->discardFlags & DiscardCanvasBackground ) )
+        {
+            QwtPainter::drawBackgound( painter, r, canvas );
+            clipPath = qwtCanvasClip( canvas, canvasRect );
+        }
+        painter->restore();
+        painter->save();
+        if ( clipPath.isEmpty() )
+            painter->setClipRect( canvasRect );
+        else
+            painter->setClipPath( clipPath );
+        plot->drawItems( painter, canvasRect, map );
+        painter->restore();
+    }
     else
+    {
+        QPainterPath clipPath;
+        int frameWidth = 0;
+        if ( !( d_data->discardFlags & DiscardCanvasFrame ) )
+        {
+            const QVariant fw = canvas->property( "frameWidth" );
+            if ( fw.type() == QVariant::Int )
+                frameWidth = fw.toInt();
+            clipPath = qwtCanvasClip( canvas, canvasRect );
+        }
+        QRectF innerRect = canvasRect.adjusted(
+            frameWidth, frameWidth, -frameWidth, -frameWidth );
+        painter->save();
+        if ( clipPath.isEmpty() )
+        {
+            painter->setClipRect( innerRect );
+        }
+        else
+        {
+            painter->setClipPath( clipPath );
+        }
         if ( !( d_data->discardFlags & DiscardCanvasBackground ) )
+        {
+            qwtRenderBackground( painter, r, plot->canvas() );
+            if ( plot->canvas()->testAttribute( Qt::WA_StyledBackground ) )
+            QwtPainter::drawBackgound( painter, innerRect, canvas );
+        }
+        plot->drawItems( painter, innerRect, map );
+        painter->restore();
+        if ( frameWidth > 0 )
+        {
+            painter->save();
+            const int frameStyle =
+                canvas->property( "frameShadow" ).toInt() |
+                canvas->property( "frameShape" ).toInt();
+            const int frameWidth = canvas->property( "frameWidth" ).toInt();
+            const QVariant borderRadius = canvas->property( "borderRadius" );
+            if ( borderRadius.type() == QVariant::Double
+                && borderRadius.toDouble() > 0.0 )
+            {
+                // The clip region is calculated in integers
+                // To avoid too much rounding errors better
+                // calculate it in target device resolution
+                // TODO ...
+                int x1 = qCeil( canvasRect.left() );
+                int x2 = qFloor( canvasRect.right() );
+                int y1 = qCeil( canvasRect.top() );
+                int y2 = qFloor( canvasRect.bottom() );
+                clipPath = plot->canvas()->borderPath(
+                    QRect( x1, y1, x2 - x1 - 1, y2 - y1 - 1 ) );
+                const double r = borderRadius.toDouble();
+                QwtPainter::drawRoundedFrame( painter, canvasRect,
+                    r, r, canvas->palette(), frameWidth, frameStyle );
+            }
+        }
+    }
+    painter->restore();
+    painter->save();
+    if ( clipPath.isEmpty() )
+        painter->setClipRect( canvasRect );
+    else
+        painter->setClipPath( clipPath );
+    plot->drawItems( painter, canvasRect, map );
+    painter->restore();
+            else
+            {
+                const int midLineWidth = canvas->property( "midLineWidth" ).toInt();
+                QwtPainter::drawFrame( painter, canvasRect,
+                    canvas->palette(), canvas->foregroundRole(),
+                    frameWidth, midLineWidth, frameStyle );
+            }
+            painter->restore();
+        }
+    }
+}
 …
             plot->axisScaleEngine( axisId )->transformation() );
         const QwtScaleDiv &scaleDiv = *plot->axisScaleDiv( axisId );
+        const QwtScaleDiv &scaleDiv = plot->axisScaleDiv( axisId );
         maps[axisId].setScaleInterval(
             scaleDiv.lowerBound(), scaleDiv.upperBound() );
 …
             const int sDist = plot->axisWidget( axisId )->startBorderDist();
             const int eDist = plot->axisWidget( axisId )->endBorderDist();
             const QRectF &scaleRect = plot->plotLayout()->scaleRect( axisId );
+            const QRectF scaleRect = plot->plotLayout()->scaleRect( axisId );
             if ( axisId == QwtPlot::xTop || axisId == QwtPlot::xBottom )
 …
         else
+        {
+            int margin = plot->plotLayout()->canvasMargin( axisId );
+            int margin = 0;
+            if ( !plot->plotLayout()->alignCanvasToScale( axisId ) )
+                margin = plot->plotLayout()->canvasMargin( axisId );
             if ( axisId == QwtPlot::yLeft || axisId == QwtPlot::yRight )
+            {
 …
+    }
+}
+bool QwtPlotRenderer::updateCanvasMargins( QwtPlot *plot,
+    const QRectF &canvasRect, const QwtScaleMap maps[] ) const
+{
+    double margins[QwtPlot::axisCnt];
+    plot->getCanvasMarginsHint( maps, canvasRect,
+        margins[QwtPlot::yLeft], margins[QwtPlot::xTop],
+        margins[QwtPlot::yRight], margins[QwtPlot::xBottom] );
+    bool marginsChanged = false;
+    for ( int axisId = 0; axisId < QwtPlot::axisCnt; axisId++ )
+    {
+        if ( margins[axisId] >= 0.0 )
+        {
+            const int m = qCeil( margins[axisId] );
+            plot->plotLayout()->setCanvasMargin( m, axisId);
+            marginsChanged = true;
+        }
+    }
+    return marginsChanged;
+}
+/*!
+   \brief Execute a file dialog and render the plot to the selected file
+   \param plot Plot widget
+   \param documentName Default document name
+   \param sizeMM Size for the document in millimeters.
+   \param resolution Resolution in dots per Inch (dpi)
+   \return True, when exporting was successful
+   \sa renderDocument()
+*/
+bool QwtPlotRenderer::exportTo( QwtPlot *plot, const QString &documentName,
+     const QSizeF &sizeMM, int resolution )
+{
+    if ( plot == NULL )
+        return false;
+    QString fileName = documentName;
+    // What about translation
+#ifndef QT_NO_FILEDIALOG
+    const QList<QByteArray> imageFormats =
+        QImageWriter::supportedImageFormats();
+    QStringList filter;
+#ifndef QT_NO_PRINTER
+    filter += QString( "PDF " ) + tr( "Documents" ) + " (*.pdf)";
+#endif
+#ifndef QWT_NO_SVG
+    filter += QString( "SVG " ) + tr( "Documents" ) + " (*.svg)";
+#endif
+#ifndef QT_NO_PRINTER
+    filter += QString( "Postscript " ) + tr( "Documents" ) + " (*.ps)";
+#endif
+    if ( imageFormats.size() > 0 )
+    {
+        QString imageFilter( tr( "Images" ) );
+        imageFilter += " (";
+        for ( int i = 0; i < imageFormats.size(); i++ )
+        {
+            if ( i > 0 )
+                imageFilter += " ";
+            imageFilter += "*.";
+            imageFilter += imageFormats[i];
+        }
+        imageFilter += ")";
+        filter += imageFilter;
+    }
+    fileName = QFileDialog::getSaveFileName(
+        NULL, tr( "Export File Name" ), fileName,
+        filter.join( ";;" ), NULL, QFileDialog::DontConfirmOverwrite );
+#endif
+    if ( fileName.isEmpty() )
+        return false;
+    renderDocument( plot, fileName, sizeMM, resolution );
+    return true;
+}

trunk/BNC/qwt/qwt_plot_renderer.h

-              r4271
+              r8127
 #include "qwt_global.h"
 #include <qobject.h>
+#include <qsize.h>
 class QwtPlot;
 class QwtScaleMap;
-class QSizeF;
 class QRectF;
 class QPainter;
 …
         //! Don't render the background of the canvas
+        DiscardCanvasBackground = 0x08
+        DiscardCanvasBackground = 0x08,
+        //! Don't render the footer of the plot
+        DiscardFooter           = 0x10,
+        /*!
+            Don't render the frame of the canvas
+            \note This flag has no effect when using
+                  style sheets, where the frame is part
+                  of the background
+         */
+        DiscardCanvasFrame           = 0x20
     };
 …
     enum LayoutFlag
+    {
         //! Use the default layout without margins and frames
+        //! Use the default layout as on screen
         DefaultLayout   = 0x00,
-        //! Render all frames of the plot
-        KeepFrames      = 0x01,
         /*!
 …
           where the scale ticks are aligned to.
          */
         FrameWithScales = 0x02
+        FrameWithScales = 0x01
     };
 …
     LayoutFlags layoutFlags() const;
     void renderDocument( QwtPlot *, const QString &format,
+    void renderDocument( QwtPlot *, const QString &fileName,
         const QSizeF &sizeMM, int resolution = 85 );
     void renderDocument( QwtPlot *,
         const QString &title, const QString &format,
+        const QString &fileName, const QString &format,
         const QSizeF &sizeMM, int resolution = 85 );
 …
         QPainter *, const QRectF &rect ) const;
     virtual void renderLegendItem( const QwtPlot *,
         QPainter *, const QWidget *, const QRectF & ) const;
+    virtual void renderTitle( const QwtPlot *,
+        QPainter *, const QRectF & ) const;
     virtual void renderTitle( const QwtPlot *,
+    virtual void renderFooter( const QwtPlot *,
         QPainter *, const QRectF & ) const;
 …
         const QwtPlot *, QPainter *, const QRectF & ) const;
+protected:
+    bool exportTo( QwtPlot *, const QString &documentName,
+        const QSizeF &sizeMM = QSizeF( 300, 200 ), int resolution = 85 );
+private:
     void buildCanvasMaps( const QwtPlot *,
         const QRectF &, QwtScaleMap maps[] ) const;
+    bool updateCanvasMargins( QwtPlot *,
+        const QRectF &, const QwtScaleMap maps[] ) const;
 private:

trunk/BNC/qwt/qwt_plot_rescaler.cpp

-              r4271
+              r8127
 #include "qwt_plot_rescaler.h"
 #include "qwt_plot.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_scale_div.h"
 #include "qwt_interval.h"
+#include "qwt_plot_canvas.h"
 #include <qevent.h>
 #include <qalgorithms.h>
 …
    \sa setRescalePolicy(), setReferenceAxis()
 */
 QwtPlotRescaler::QwtPlotRescaler( QwtPlotCanvas *canvas,
+QwtPlotRescaler::QwtPlotRescaler( QWidget *canvas,
         int referenceAxis, RescalePolicy policy ):
     QObject( canvas )
 …
 /*!
   Return direction in which an axis should be expanded
+  \return Direction in which an axis should be expanded
   \param axis Axis index ( see QwtPlot::AxisId )
 …
 /*!
   Return aspect ratio between an axis and the reference axis.
+  \return Aspect ratio between an axis and the reference axis.
   \param axis Axis index ( see QwtPlot::AxisId )
 …
   In Fitting mode, the hint is used as minimal interval
   taht always needs to be displayed.
+  that always needs to be displayed.
   \param axis Axis, see QwtPlot::Axis
 …
 //! \return plot canvas
 QwtPlotCanvas *QwtPlotRescaler::canvas()
+{
     return qobject_cast<QwtPlotCanvas *>( parent() );
+QWidget *QwtPlotRescaler::canvas()
+{
+    return qobject_cast<QWidget *>( parent() );
+}
 //! \return plot canvas
 const QwtPlotCanvas *QwtPlotRescaler::canvas() const
+{
     return qobject_cast<const QwtPlotCanvas *>( parent() );
+const QWidget *QwtPlotRescaler::canvas() const
+{
+    return qobject_cast<const QWidget *>( parent() );
+}
 …
 QwtPlot *QwtPlotRescaler::plot()
+{
     QwtPlotCanvas *w = canvas();
+    QWidget *w = canvas();
     if ( w )
         return w->plot();
     return NULL;
+        w = w->parentWidget();
+    return qobject_cast<QwtPlot *>( w );
+}
 …
 const QwtPlot *QwtPlotRescaler::plot() const
+{
     const QwtPlotCanvas *w = canvas();
+    const QWidget *w = canvas();
     if ( w )
         return w->plot();
     return NULL;
+        w = w->parentWidget();
+    return qobject_cast<const QwtPlot *>( w );
+}
 //!  Event filter for the plot canvas
 bool QwtPlotRescaler::eventFilter( QObject *o, QEvent *e )
+{
     if ( o && o == canvas() )
+    {
         switch ( e->type() )
+bool QwtPlotRescaler::eventFilter( QObject *object, QEvent *event )
+{
+    if ( object && object == canvas() )
+    {
+        switch ( event->type() )
+        {
             case QEvent::Resize:
+                canvasResizeEvent( ( QResizeEvent * )e );
+            {
+                canvasResizeEvent( static_cast<QResizeEvent *>( event ) );
                 break;
+            }
             case QEvent::PolishRequest:
+            {
                 rescale();
                 break;
+            }
             default:;
+        }
 …
 void QwtPlotRescaler::canvasResizeEvent( QResizeEvent* event )
+{
+    const int fw = 2 * canvas()->frameWidth();
+    const QSize newSize = event->size() - QSize( fw, fw );
+    const QSize oldSize = event->oldSize() - QSize( fw, fw );
+    int left, top, right, bottom;
+    canvas()->getContentsMargins( &left, &top, &right, &bottom );
+    const QSize marginSize( left + right, top + bottom );
+    const QSize newSize = event->size() - marginSize;
+    const QSize oldSize = event->oldSize() - marginSize;
     rescale( oldSize, newSize );
 …
 /*!
    Synchronize an axis scale according to the scale of the reference axis
+  Synchronize an axis scale according to the scale of the reference axis
   \param axis Axis index ( see QwtPlot::AxisId )
   \param reference Interval of the reference axis
   \param size Size of the canvas
+  \return New interval for axis
 */
 QwtInterval QwtPlotRescaler::syncScale( int axis,
 …
 /*!
   Return orientation of an axis
+  \return Orientation of an axis
   \param axis Axis index ( see QwtPlot::AxisId )
 */
 …
 /*!
   Return interval of an axis
   \param axis Axis index ( see QwtPlot::AxisId )
+  \param axis Axis index ( see QwtPlot::AxisId )
+  \return Normalized interval of an axis
 */
 QwtInterval QwtPlotRescaler::interval( int axis ) const
 …
         return QwtInterval();
+    const QwtPlot *plt = plot();
+    const double v1 = plt->axisScaleDiv( axis )->lowerBound();
+    const double v2 = plt->axisScaleDiv( axis )->upperBound();
+    return QwtInterval( v1, v2 ).normalized();
+    return plot()->axisScaleDiv( axis ).interval().normalized();
+}
 …
             double v2 = intervals[axis].maxValue();
+            if ( plt->axisScaleDiv( axis )->lowerBound() >
+                plt->axisScaleDiv( axis )->upperBound() )
+            {
+            if ( !plt->axisScaleDiv( axis ).isIncreasing() )
                 qSwap( v1, v2 );
+            }
             if ( d_data->inReplot >= 1 )
+            {
+                d_data->axisData[axis].scaleDiv = *plt->axisScaleDiv( axis );
+            }
+                d_data->axisData[axis].scaleDiv = plt->axisScaleDiv( axis );
             if ( d_data->inReplot >= 2 )
 …
+    }
+    const bool immediatePaint =
+        plt->canvas()->testPaintAttribute( QwtPlotCanvas::ImmediatePaint );
+    plt->canvas()->setPaintAttribute( QwtPlotCanvas::ImmediatePaint, false );
+    QwtPlotCanvas *canvas = qobject_cast<QwtPlotCanvas *>( plt->canvas() );
+    bool immediatePaint = false;
+    if ( canvas )
+    {
+        immediatePaint = canvas->testPaintAttribute( QwtPlotCanvas::ImmediatePaint );
+        canvas->setPaintAttribute( QwtPlotCanvas::ImmediatePaint, false );
+    }
     plt->setAutoReplot( doReplot );
 …
     d_data->inReplot--;
+    plt->canvas()->setPaintAttribute(
+        QwtPlotCanvas::ImmediatePaint, immediatePaint );
+}
+    if ( canvas && immediatePaint )
+    {
+        canvas->setPaintAttribute( QwtPlotCanvas::ImmediatePaint, true );
+    }
+}

trunk/BNC/qwt/qwt_plot_rescaler.h

-              r4271
+              r8127
 #include <qobject.h>
-class QwtPlotCanvas;
 class QwtPlot;
 class QResizeEvent;
 …
     \brief QwtPlotRescaler takes care of fixed aspect ratios for plot scales
     QwtPlotRescaler autoadjusts the axes of a QwtPlot according
+    QwtPlotRescaler auto adjusts the axes of a QwtPlot according
     to fixed aspect ratios.
 */
 …
         /*!
           The interval of the reference axis will be shrinked/expanded,
+          The interval of the reference axis will be shrunk/expanded,
           when the geometry of the canvas changes. All other axes
           will be adjusted according to their aspect ratio.
 …
     };
     explicit QwtPlotRescaler( QwtPlotCanvas *,
+    explicit QwtPlotRescaler( QWidget *canvas,
         int referenceAxis = QwtPlot::xBottom,
         RescalePolicy = Expanding );
 …
     QwtInterval intervalHint( int axis ) const;
     QwtPlotCanvas *canvas();
     const QwtPlotCanvas *canvas() const;
+    QWidget *canvas();
+    const QWidget *canvas() const;
     QwtPlot *plot();

trunk/BNC/qwt/qwt_plot_scaleitem.cpp

-              r4271
+              r8127
 #include "qwt_plot_scaleitem.h"
 #include "qwt_plot.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_scale_map.h"
 #include "qwt_interval.h"
 …
+    }
     void updateBorders( const QRectF &,
         const QwtScaleMap &, const QwtScaleMap & );
+    QwtInterval scaleInterval( const QRectF &,
+        const QwtScaleMap &, const QwtScaleMap & ) const;
     QPalette palette;
 …
     bool scaleDivFromAxis;
     QwtScaleDraw *scaleDraw;
-    QRectF canvasRectCache;
 };
+void QwtPlotScaleItem::PrivateData::updateBorders( const QRectF &canvasRect,
+    const QwtScaleMap &xMap, const QwtScaleMap &yMap )
+{
+    canvasRectCache = canvasRect;
+QwtInterval QwtPlotScaleItem::PrivateData::scaleInterval( const QRectF &canvasRect,
+    const QwtScaleMap &xMap, const QwtScaleMap &yMap ) const
+{
     QwtInterval interval;
     if ( scaleDraw->orientation() == Qt::Horizontal )
 …
+    }
+    QwtScaleDiv scaleDiv = scaleDraw->scaleDiv();
+    scaleDiv.setInterval( interval );
+    scaleDraw->setScaleDiv( scaleDiv );
+}
+    return interval;
+}
 /*!
    \brief Constructor for scale item at the position pos.
 …
     d_data->scaleDraw->setAlignment( alignment );
+    setItemInterest( QwtPlotItem::ScaleInterest, true );
     setZ( 11.0 );
+}
 …
             if ( plt )
+            {
                 updateScaleDiv( *plt->axisScaleDiv( xAxis() ),
                     *plt->axisScaleDiv( yAxis() ) );
+                updateScaleDiv( plt->axisScaleDiv( xAxis() ),
+                    plt->axisScaleDiv( yAxis() ) );
                 itemChanged();
+            }
 …
+    {
         d_data->palette = palette;
+        legendChanged();
         itemChanged();
+    }
 …
     if ( plt )
+    {
         updateScaleDiv( *plt->axisScaleDiv( xAxis() ),
             *plt->axisScaleDiv( yAxis() ) );
+        updateScaleDiv( plt->axisScaleDiv( xAxis() ),
+            plt->axisScaleDiv( yAxis() ) );
+    }
 …
    If distance is >= 0 the scale will be aligned to a
    border of the contents rect of the canvas. If
+   border of the contents rectangle of the canvas. If
    alignment() is QwtScaleDraw::LeftScale, the scale will
    be aligned to the right border, if it is QwtScaleDraw::TopScale
 …
     const QRectF &canvasRect ) const
+{
+    QwtScaleDraw *sd = d_data->scaleDraw;
     if ( d_data->scaleDivFromAxis )
+    {
+        if ( canvasRect != d_data->canvasRectCache )
+            d_data->updateBorders( canvasRect, xMap, yMap );
+        const QwtInterval interval =
+            d_data->scaleInterval( canvasRect, xMap, yMap );
+        if ( interval != sd->scaleDiv().interval() )
+        {
+            QwtScaleDiv scaleDiv = sd->scaleDiv();
+            scaleDiv.setInterval( interval );
+            sd->setScaleDiv( scaleDiv );
+        }
+    }
 …
     painter->setPen( pen );
-    QwtScaleDraw *sd = d_data->scaleDraw;
     if ( sd->orientation() == Qt::Horizontal )
+    {
 …
         sd->move( canvasRect.left(), y );
         sd->setLength( canvasRect.width() - 1 );
+        sd->setTransformation( xMap.transformation()->copy() );
+        QwtTransform *transform = NULL;
+        if ( xMap.transformation() )
+            transform = xMap.transformation()->copy();
+        sd->setTransformation( transform );
+    }
     else // == Qt::Vertical
 …
         sd->move( x, canvasRect.top() );
         sd->setLength( canvasRect.height() - 1 );
+        sd->setTransformation( yMap.transformation()->copy() );
+        QwtTransform *transform = NULL;
+        if ( yMap.transformation() )
+            transform = yMap.transformation()->copy();
+        sd->setTransformation( transform );
+    }
 …
     const QwtScaleDiv& yScaleDiv )
+{
+    QwtScaleDraw *sd = d_data->scaleDraw;
+    if ( d_data->scaleDivFromAxis && sd )
+    {
+        sd->setScaleDiv(
+            sd->orientation() == Qt::Horizontal ? xScaleDiv : yScaleDiv );
+    QwtScaleDraw *scaleDraw = d_data->scaleDraw;
+    if ( d_data->scaleDivFromAxis && scaleDraw )
+    {
+        const QwtScaleDiv &scaleDiv =
+            scaleDraw->orientation() == Qt::Horizontal ? xScaleDiv : yScaleDiv;
         const QwtPlot *plt = plot();
         if ( plt != NULL )
+        {
+            d_data->updateBorders( plt->canvas()->contentsRect(),
+                plt->canvasMap( xAxis() ), plt->canvasMap( yAxis() ) );
+        }
+    }
+}
+            const QRectF canvasRect = plt->canvas()->contentsRect();
+            const QwtInterval interval = d_data->scaleInterval(
+                canvasRect, plt->canvasMap( xAxis() ), plt->canvasMap( yAxis() ) );
+            QwtScaleDiv sd = scaleDiv;
+            sd.setInterval( interval );
+            if ( sd != scaleDraw->scaleDiv() )
+            {
+                // the internal label cache of QwtScaleDraw
+                // is cleared here, so better avoid pointless
+                // assignments.
+                scaleDraw->setScaleDiv( sd );
+            }
+        }
+        else
+        {
+            scaleDraw->setScaleDiv( scaleDiv );
+        }
+    }
+}

trunk/BNC/qwt/qwt_plot_seriesitem.cpp

-              r4271
+              r8127
 #include "qwt_plot_seriesitem.h"
 class QwtPlotAbstractSeriesItem::PrivateData
+class QwtPlotSeriesItem::PrivateData
+{
 public:
 …
   \param title Title of the curve
 */
 QwtPlotAbstractSeriesItem::QwtPlotAbstractSeriesItem( const QwtText &title ):
+QwtPlotSeriesItem::QwtPlotSeriesItem( const QwtText &title ):
     QwtPlotItem( title )
+{
     d_data = new PrivateData();
+    setItemInterest( QwtPlotItem::ScaleInterest, true );
+}
 …
   \param title Title of the curve
 */
 QwtPlotAbstractSeriesItem::QwtPlotAbstractSeriesItem( const QString &title ):
+QwtPlotSeriesItem::QwtPlotSeriesItem( const QString &title ):
     QwtPlotItem( QwtText( title ) )
+{
 …
 //! Destructor
 QwtPlotAbstractSeriesItem::~QwtPlotAbstractSeriesItem()
+QwtPlotSeriesItem::~QwtPlotSeriesItem()
+{
     delete d_data;
 …
   \sa orientation()
 */
 void QwtPlotAbstractSeriesItem::setOrientation( Qt::Orientation orientation )
+void QwtPlotSeriesItem::setOrientation( Qt::Orientation orientation )
+{
     if ( d_data->orientation != orientation )
+    {
         d_data->orientation = orientation;
+        legendChanged();
         itemChanged();
+    }
 …
   \sa setOrientation()
 */
 Qt::Orientation QwtPlotAbstractSeriesItem::orientation() const
+Qt::Orientation QwtPlotSeriesItem::orientation() const
+{
     return d_data->orientation;
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
 */
 void QwtPlotAbstractSeriesItem::draw( QPainter *painter,
+void QwtPlotSeriesItem::draw( QPainter *painter,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect ) const
 …
+}
+QRectF QwtPlotSeriesItem::boundingRect() const
+{
+    return dataRect();
+}
+void QwtPlotSeriesItem::updateScaleDiv(
+    const QwtScaleDiv &xScaleDiv, const QwtScaleDiv &yScaleDiv )
+{
+    const QRectF rect = QRectF(
+        xScaleDiv.lowerBound(), yScaleDiv.lowerBound(),
+        xScaleDiv.range(), yScaleDiv.range() );
+    setRectOfInterest( rect );
+}
+void QwtPlotSeriesItem::dataChanged()
+{
+    itemChanged();
+}

trunk/BNC/qwt/qwt_plot_seriesitem.h

-              r4271
+              r8127
 #include "qwt_scale_div.h"
 #include "qwt_series_data.h"
+#include "qwt_series_store.h"
 /*!
   \brief Base class for plot items representing a series of samples
 */
+class QWT_EXPORT QwtPlotAbstractSeriesItem: public QwtPlotItem
+class QWT_EXPORT QwtPlotSeriesItem: public QwtPlotItem,
+    public virtual QwtAbstractSeriesStore
+{
 public:
     explicit QwtPlotAbstractSeriesItem( const QString &title = QString::null );
     explicit QwtPlotAbstractSeriesItem( const QwtText &title );
+    explicit QwtPlotSeriesItem( const QString &title = QString::null );
+    explicit QwtPlotSeriesItem( const QwtText &title );
     virtual ~QwtPlotAbstractSeriesItem();
+    virtual ~QwtPlotSeriesItem();
     void setOrientation( Qt::Orientation );
 …
       \param xMap Maps x-values into pixel coordinates.
       \param yMap Maps y-values into pixel coordinates.
       \param canvasRect Contents rect of the canvas
+      \param canvasRect Contents rectangle of the canvas
       \param from Index of the first point to be painted
       \param to Index of the last point to be painted. If to < 0 the
 …
         const QRectF &canvasRect, int from, int to ) const = 0;
+    virtual QRectF boundingRect() const;
+    virtual void updateScaleDiv(
+        const QwtScaleDiv &, const QwtScaleDiv & );
+protected:
+    virtual void dataChanged();
 private:
     class PrivateData;
 …
 };
-/*!
-  \brief Class template for plot items representing a series of samples
-*/
-template <typename T>
-class QwtPlotSeriesItem: public QwtPlotAbstractSeriesItem
+{
-public:
-    explicit QwtPlotSeriesItem<T>( const QString &title = QString::null );
-    explicit QwtPlotSeriesItem<T>( const QwtText &title );
-    virtual ~QwtPlotSeriesItem<T>();
-    void setData( QwtSeriesData<T> * );
-    QwtSeriesData<T> *data();
-    const QwtSeriesData<T> *data() const;
-    size_t dataSize() const;
-    T sample( int index ) const;
-    virtual QRectF boundingRect() const;
-    virtual void updateScaleDiv( const QwtScaleDiv &,
-                                 const QwtScaleDiv & );
-protected:
-    //! Series
-    QwtSeriesData<T> *d_series;
-};
-/*!
-  Constructor
-  \param title Title of the series item
-*/
-template <typename T>
-QwtPlotSeriesItem<T>::QwtPlotSeriesItem( const QString &title ):
-    QwtPlotAbstractSeriesItem( QwtText( title ) ),
-    d_series( NULL )
+{
+}
-/*!
-  Constructor
-  \param title Title of the series item
-*/
-template <typename T>
-QwtPlotSeriesItem<T>::QwtPlotSeriesItem( const QwtText &title ):
-    QwtPlotAbstractSeriesItem( title ),
-    d_series( NULL )
+{
+}
-//! Destructor
-template <typename T>
-QwtPlotSeriesItem<T>::~QwtPlotSeriesItem()
+{
-    delete d_series;
+}
-//! \return the the curve data
-template <typename T>
-inline QwtSeriesData<T> *QwtPlotSeriesItem<T>::data()
+{
-    return d_series;
+}
-//! \return the the curve data
-template <typename T>
-inline const QwtSeriesData<T> *QwtPlotSeriesItem<T>::data() const
+{
-    return d_series;
+}
-/*!
-    \param index Index
-    \return Sample at position index
-*/
-template <typename T>
-inline T QwtPlotSeriesItem<T>::sample( int index ) const
+{
-    return d_series ? d_series->sample( index ) : T();
+}
-/*!
-  Assign a series of samples
-  \param data Data
-  \warning The item takes ownership of the data object, deleting
-           it when its not used anymore.
-*/
-template <typename T>
-void QwtPlotSeriesItem<T>::setData( QwtSeriesData<T> *data )
+{
-    if ( d_series != data )
+    {
-        delete d_series;
-        d_series = data;
-        itemChanged();
+    }
+}
-/*!
-  Return the size of the data arrays
-  \sa setData()
-*/
-template <typename T>
-size_t QwtPlotSeriesItem<T>::dataSize() const
+{
-    if ( d_series == NULL )
-        return 0;
-    return d_series->size();
+}
-/*!
-  \return Bounding rectangle of the data.
-  If there is no bounding rect, like for empty data the rectangle is invalid.
-  \sa QwtSeriesData<T>::boundingRect(), QRectF::isValid()
-*/
-template <typename T>
-QRectF QwtPlotSeriesItem<T>::boundingRect() const
+{
-    if ( d_series == NULL )
-        return QRectF( 1.0, 1.0, -2.0, -2.0 ); // invalid
-    return d_series->boundingRect();
+}
-/*!
-   Update the rect of interest according to the current scale ranges
-   \param xScaleDiv Scale division of the x-axis
-   \param yScaleDiv Scale division of the y-axis
-   \sa QwtSeriesData<T>::setRectOfInterest()
-*/
-template <typename T>
-void QwtPlotSeriesItem<T>::updateScaleDiv(
-    const QwtScaleDiv &xScaleDiv, const QwtScaleDiv &yScaleDiv )
+{
-    const QRectF rect = QRectF(
-        xScaleDiv.lowerBound(), yScaleDiv.lowerBound(),
-        xScaleDiv.range(), yScaleDiv.range() );
-    d_series->setRectOfInterest( rect );
+}
 #endif

trunk/BNC/qwt/qwt_plot_spectrocurve.cpp

-              r4271
+              r8127
 */
 QwtPlotSpectroCurve::QwtPlotSpectroCurve( const QwtText &title ):
     QwtPlotSeriesItem<QwtPoint3D>( title )
+    QwtPlotSeriesItem( title )
+{
     init();
 …
 */
 QwtPlotSpectroCurve::QwtPlotSpectroCurve( const QString &title ):
     QwtPlotSeriesItem<QwtPoint3D>( QwtText( title ) )
+    QwtPlotSeriesItem( QwtText( title ) )
+{
     init();
 …
     d_data = new PrivateData;
     d_series = new QwtPoint3DSeriesData();
+    setData( new QwtPoint3DSeriesData() );
     setZ( 20.0 );
 …
 /*!
     \brief Return the current paint attributes
+    \return True, when attribute is enabled
     \sa PaintAttribute, setPaintAttribute()
 */
 …
 void QwtPlotSpectroCurve::setSamples( const QVector<QwtPoint3D> &samples )
+{
+    delete d_series;
+    d_series = new QwtPoint3DSeriesData( samples );
+    itemChanged();
+}
+    setData( new QwtPoint3DSeriesData( samples ) );
+}
+/*!
+  Assign a series of samples
+  setSamples() is just a wrapper for setData() without any additional
+  value - beside that it is easier to find for the developer.
+  \param data Data
+  \warning The item takes ownership of the data object, deleting
+           it when its not used anymore.
+*/
+void QwtPlotSpectroCurve::setSamples(
+    QwtSeriesData<QwtPoint3D> *data )
+{
+    setData( data );
+}
 /*!
 …
+    }
+    legendChanged();
     itemChanged();
+}
 …
+    {
         d_data->colorRange = interval;
+        legendChanged();
         itemChanged();
+    }
 …
+    {
         d_data->penWidth = penWidth;
+        legendChanged();
         itemChanged();
+    }
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first sample to be painted
   \param to Index of the last sample to be painted. If to < 0 the
 …
         from = 0;
     if ( from >= to )
+    if ( from > to )
         return;
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas
+  \param canvasRect Contents rectangle of the canvas
   \param from Index of the first sample to be painted
   \param to Index of the last sample to be painted. If to < 0 the
 …
         d_data->colorTable = d_data->colorMap->colorTable( d_data->colorRange );
+    const QwtSeriesData<QwtPoint3D> *series = data();
     for ( int i = from; i <= to; i++ )
+    {
         const QwtPoint3D sample = d_series->sample( i );
+        const QwtPoint3D sample = series->sample( i );
         double xi = xMap.transform( sample.x() );
 …
                 d_data->colorRange, sample.z() );
             painter->setPen( QPen( QColor( rgb ), d_data->penWidth ) );
+            painter->setPen( QPen( QColor::fromRgba( rgb ), d_data->penWidth ) );
+        }
         else
 …
                 d_data->colorRange, sample.z() );
             painter->setPen( QPen( QColor( d_data->colorTable[index] ),
+            painter->setPen( QPen( QColor::fromRgba( d_data->colorTable[index] ),
                 d_data->penWidth ) );
+        }

trunk/BNC/qwt/qwt_plot_spectrocurve.h

-              r4271
+              r8127
            mapped to a color.
 */
+class QWT_EXPORT QwtPlotSpectroCurve: public QwtPlotSeriesItem<QwtPoint3D>
+class QWT_EXPORT QwtPlotSpectroCurve:
+    public QwtPlotSeriesItem, QwtSeriesStore<QwtPoint3D>
+{
 public:
 …
     void setSamples( const QVector<QwtPoint3D> & );
+    void setSamples( QwtSeriesData<QwtPoint3D> * );
     void setColorMap( QwtColorMap * );

trunk/BNC/qwt/qwt_plot_spectrogram.cpp

-              r4271
+              r8127
 #endif
+#define DEBUG_RENDER 0
+#if DEBUG_RENDER
+#include <QElapsedTimer>
+#endif
 class QwtPlotSpectrogram::PrivateData
+{
 public:
     PrivateData():
+        data( NULL ),
+        renderThreadCount( 1 )
+        data( NULL )
+    {
         colorMap = new QwtLinearColorMap();
 …
         conrecFlags = QwtRasterData::IgnoreAllVerticesOnLevel;
+#if 0
         conrecFlags |= QwtRasterData::IgnoreOutOfRange;
+#endif
+    }
     ~PrivateData()
 …
     QwtColorMap *colorMap;
     DisplayModes displayMode;
-    uint renderThreadCount;
     QList<double> contourLevels;
 …
+    }
+    legendChanged();
     itemChanged();
+}
 …
 /*!
-   Rendering an image from the raster data can often be done
-   parallel on a multicore system.
-   \param numThreads Number of threads to be used for rendering.
-                     If numThreads is set to 0, the system specific
-                     ideal thread count is used.
-   The default thread count is 1 ( = no additional threads )
-   \warning Rendering in multiple threads is only supported for Qt >= 4.4
-   \sa renderThreadCount(), renderImage(), renderTile()
-*/
-void QwtPlotSpectrogram::setRenderThreadCount( uint numThreads )
+{
-    d_data->renderThreadCount = numThreads;
+}
-/*!
-   \return Number of threads to be used for rendering.
-           If numThreads is set to 0, the system specific
-           ideal thread count is used.
-   \warning Rendering in multiple threads is only supported for Qt >= 4.4
-   \sa setRenderThreadCount(), renderImage(), renderTile()
-*/
-uint QwtPlotSpectrogram::renderThreadCount() const
+{
-    return d_data->renderThreadCount;
+}
-/*!
   Change the color map
 …
     invalidateCache();
+    legendChanged();
     itemChanged();
+}
 …
+{
     return d_data->colorMap;
+}
+/*!
+  Build and assign the default pen for the contour lines
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+  to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtPlotSpectrogram::setDefaultContourPen(
+    const QColor &color, qreal width, Qt::PenStyle style )
+{
+    setDefaultContourPen( QPen( color, width, style ) );
+}
 …
+    {
         d_data->defaultContourPen = pen;
+        legendChanged();
         itemChanged();
+    }
 …
    \return true, is enabled
+   The default setting enables QwtRasterData::IgnoreAllVerticesOnLevel
    \sa setConrecClag(), renderContourLines(),
        QwtRasterData::contourLines()
 …
     d_data->contourLevels = levels;
     qSort( d_data->contourLevels );
+    legendChanged();
     itemChanged();
+}
 /*!
    \brief Return the levels of the contour lines.
+   \return Levels of the contour lines.
    The levels are sorted in increasing order.
 …
    \brief Render an image from data and color map.
    For each pixel of rect the value is mapped into a color.
+   For each pixel of area the value is mapped into a color.
   \param xMap X-Scale Map
 …
     d_data->data->initRaster( area, image.size() );
+#if DEBUG_RENDER
+        QElapsedTimer time;
+        time.start();
+#endif
 #if QT_VERSION >= 0x040400 && !defined(QT_NO_QFUTURE)
     uint numThreads = d_data->renderThreadCount;
+    uint numThreads = renderThreadCount();
     if ( numThreads <= 0 )
 …
 #endif
+#if DEBUG_RENDER
+    const qint64 elapsed = time.elapsed();
+    qDebug() << "renderImage" << imageSize << elapsed;
+#endif
     d_data->data->discardRaster();
 …
             const double ty = yMap.invTransform( y );
             QRgb *line = ( QRgb * )image->scanLine( y );
+            QRgb *line = reinterpret_cast<QRgb *>( image->scanLine( y ) );
             line += tile.left();
 …
    \brief Return the raster to be used by the CONREC contour algorithm.
    A larger size will improve the precisision of the CONREC algorithm,
+   A larger size will improve the precision of the CONREC algorithm,
    but will slow down the time that is needed to calculate the lines.
 …
    the resolution depending on pixelSize().
    \param area Rect, where to calculate the contour lines
    \param rect Rect in pixel coordinates, where to paint the contour lines
+   \param area Rectangle, where to calculate the contour lines
+   \param rect Rectangle in pixel coordinates, where to paint the contour lines
    \return Raster to be used by the CONREC contour algorithm.
 …
    \param rect Rectangle, where to calculate the contour lines
    \param raster Raster, used by the CONREC algorithm
+   \return Calculated contour lines
    \sa contourLevels(), setConrecFlag(),
 …
     if ( d_data->data == NULL )
         return;
-    const QwtInterval intensityRange = d_data->data->interval( Qt::ZAxis );
     const int numLevels = d_data->contourLevels.size();
 …
   \param xMap Maps x-values into pixel coordinates.
   \param yMap Maps y-values into pixel coordinates.
   \param canvasRect Contents rect of the canvas in painter coordinates
+  \param canvasRect Contents rectangle of the canvas in painter coordinates
   \sa setDisplayMode(), renderImage(),

trunk/BNC/qwt/qwt_plot_spectrogram.h

-              r4271
+              r8127
   \brief A plot item, which displays a spectrogram
   A spectrogram displays threedimenional data, where the 3rd dimension
+  A spectrogram displays 3-dimensional data, where the 3rd dimension
   ( the intensity ) is displayed using colors. The colors are calculated
   from the values using a color map.
+  On multi-core systems the performance of the image composition
+  can often be improved by dividing the area into tiles - each of them
+  rendered in a different thread ( see QwtPlotItem::setRenderThreadCount() ).
   In ContourMode contour lines are painted for the contour levels.
 …
   \image html spectrogram3.png
   \sa QwtRasterData, QwtColorMap
+  \sa QwtRasterData, QwtColorMap, QwtPlotItem::setRenderThreadCount()
 */
 …
     virtual ~QwtPlotSpectrogram();
-    void setRenderThreadCount( uint numThreads );
-    uint renderThreadCount() const;
     void setDisplayMode( DisplayMode, bool on = true );
     bool testDisplayMode( DisplayMode ) const;
 …
     virtual QRectF pixelHint( const QRectF & ) const;
+    void setDefaultContourPen( const QColor &,
+        qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setDefaultContourPen( const QPen & );
     QPen defaultContourPen() const;

trunk/BNC/qwt/qwt_plot_svgitem.cpp

-              r4621
+              r8127
 #include "qwt_plot_svgitem.h"
 #include "qwt_scale_map.h"
-#include "qwt_legend.h"
-#include "qwt_legend_item.h"
 #include "qwt_painter.h"
 #include <qpainter.h>
 …
+{
     d_data = new PrivateData();
+    d_data->boundingRect = QwtPlotItem::boundingRect();
     setItemAttribute( QwtPlotItem::AutoScale, true );
 …
     d_data->boundingRect = rect;
     const bool ok = d_data->renderer.load( fileName );
+    legendChanged();
     itemChanged();
     return ok;
+}
 …
     d_data->boundingRect = rect;
     const bool ok = d_data->renderer.load( data );
+    legendChanged();
     itemChanged();
     return ok;
+}
 //! Bounding rect of the item
+//! Bounding rectangle of the item
 QRectF QwtPlotSvgItem::boundingRect() const
+{
 …
   \param painter Painter
   \param viewBox View Box, see QSvgRenderer::viewBox
   \param rect Traget rectangle on the paint device
+  \param viewBox View Box, see QSvgRenderer::viewBox()
+  \param rect Target rectangle on the paint device
 */
 void QwtPlotSvgItem::render( QPainter *painter,
 …
 /*!
   Calculate the viewBox from an rect and boundingRect().
+  Calculate the view box from rect and boundingRect().
   \param rect Rectangle in scale coordinates
   \return viewBox View Box, see QSvgRenderer::viewBox
+  \return View box, see QSvgRenderer::viewBox()
 */
 QRectF QwtPlotSvgItem::viewBox( const QRectF &rect ) const

trunk/BNC/qwt/qwt_plot_xml.cpp

r4271	r8127
29	29	from a specific editor in the Qwt designer plugin.
30	30
	31	\return QString::null
31	32	\warning The plot editor has never been implemented.
32	33	*/

trunk/BNC/qwt/qwt_plot_zoomer.cpp

-              r4271
+              r8127
 #include "qwt_plot_zoomer.h"
 #include "qwt_plot.h"
-#include "qwt_plot_canvas.h"
 #include "qwt_scale_div.h"
 #include "qwt_picker_machine.h"
 #include <qalgorithms.h>
+static QwtInterval qwtExpandedZoomInterval( double v1, double v2,
+    double minRange, const QwtTransform* transform )
+{
+    double min = v1;
+    double max = v2;
+    if ( max - min < minRange )
+    {
+        min = 0.5 * ( min + max - minRange );
+        max = min + minRange;
+        if ( transform )
+        {
+            // f.e the logarithmic scale doesn't allow values
+            // outside [QwtLogTransform::LogMin/QwtLogTransform::LogMax]
+            double minBounded = transform->bounded( min );
+            double maxBounded = transform->bounded( max );
+            if ( minBounded != min )
+            {
+                maxBounded = transform->bounded( minBounded + minRange );
+            }
+            else if ( maxBounded != max )
+            {
+                minBounded = transform->bounded( maxBounded - minRange );
+            }
+            min = minBounded;
+            max = maxBounded;
+        }
+    }
+    return QwtInterval( min, max );
+}
+static QRectF qwtExpandedZoomRect( const QRectF &zoomRect, const QSizeF &minSize,
+    const QwtTransform* transformX, const QwtTransform* transformY )
+{
+    QRectF r = zoomRect;
+    if ( minSize.width() > r.width() )
+    {
+        const QwtInterval intv = qwtExpandedZoomInterval(
+            r.left(), r.right(), minSize.width(), transformX );
+        r.setLeft( intv.minValue() );
+        r.setRight( intv.maxValue() );
+    }
+    if ( minSize.height() > r.height() )
+    {
+        const QwtInterval intv = qwtExpandedZoomInterval(
+            zoomRect.top(), zoomRect.bottom(), minSize.height(), transformY );
+        r.setTop( intv.minValue() );
+        r.setBottom( intv.maxValue() );
+    }
+    return r;
+}
 class QwtPlotZoomer::PrivateData
 …
   The zoomer is initialized with a QwtPickerDragRectMachine,
   the tracker mode is set to QwtPicker::ActiveOnly and the rubberband
+  the tracker mode is set to QwtPicker::ActiveOnly and the rubber band
   is set to QwtPicker::RectRubberBand
   \param canvas Plot canvas to observe, also the parent object
   \param doReplot Call replot for the attached plot before initializing
+  \param doReplot Call QwtPlot::replot() for the attached plot before initializing
                   the zoomer with its scales. This might be necessary,
                   when the plot is in a state with pending scale changes.
 …
   \sa QwtPlot::autoReplot(), QwtPlot::replot(), setZoomBase()
 */
 QwtPlotZoomer::QwtPlotZoomer( QwtPlotCanvas *canvas, bool doReplot ):
+QwtPlotZoomer::QwtPlotZoomer( QWidget *canvas, bool doReplot ):
     QwtPlotPicker( canvas )
+{
 …
   The zoomer is initialized with a QwtPickerDragRectMachine,
   the tracker mode is set to QwtPicker::ActiveOnly and the rubberband
+  the tracker mode is set to QwtPicker::ActiveOnly and the rubber band
   is set to QwtPicker;;RectRubberBand
 …
   \param yAxis Y axis of the zoomer
   \param canvas Plot canvas to observe, also the parent object
   \param doReplot Call replot for the attached plot before initializing
+  \param doReplot Call QwtPlot::replot() for the attached plot before initializing
                   the zoomer with its scales. This might be necessary,
                   when the plot is in a state with pending scale changes.
 …
 QwtPlotZoomer::QwtPlotZoomer( int xAxis, int yAxis,
         QwtPlotCanvas *canvas, bool doReplot ):
+        QWidget *canvas, bool doReplot ):
     QwtPlotPicker( xAxis, yAxis, canvas )
+{
 …
 /*!
   Return the zoom stack. zoomStack()[0] is the zoom base,
   zoomStack()[1] the first zoomed rectangle.
+  \return The zoom stack. zoomStack()[0] is the zoom base,
+          zoomStack()[1] the first zoomed rectangle.
   \sa setZoomStack(), zoomRectIndex()
 …
   Reinitialized the zoom stack with scaleRect() as base.
   \param doReplot Call replot for the attached plot before initializing
+  \param doReplot Call QwtPlot::replot() for the attached plot before initializing
                   the zoomer with its scales. This might be necessary,
                   when the plot is in a state with pending scale changes.
 …
   base is united with the current scaleRect() and the zoom stack is
   reinitalized with it as zoom base. plot is zoomed to scaleRect().
+  reinitialized with it as zoom base. plot is zoomed to scaleRect().
   \param base Zoom base
 …
 /*!
+  Rectangle at the current position on the zoom stack.
+  \return Rectangle at the current position on the zoom stack.
   \sa zoomRectIndex(), scaleRect().
 */
 …
   Clears all rectangles above the current position of the
   zoom stack and pushs the normalized rect on it.
+  zoom stack and pushes the normalized rectangle on it.
   \note If the maximal stack depth is reached, zoom is ignored.
 …
   Activate a rectangle on the zoom stack with an offset relative
   to the current position. Negative values of offest will zoom out,
+  to the current position. Negative values of offset will zoom out,
   positive zoom in. A value of 0 zooms out to the zoom base.
 …
   Adjust the observed plot to zoomRect()
   \note Initiates QwtPlot::replot
+  \note Initiates QwtPlot::replot()
 */
 …
         double x1 = rect.left();
         double x2 = rect.right();
+        if ( plt->axisScaleDiv( xAxis() )->lowerBound() >
+            plt->axisScaleDiv( xAxis() )->upperBound() )
+        {
+        if ( !plt->axisScaleDiv( xAxis() ).isIncreasing() )
             qSwap( x1, x2 );
+        }
         plt->setAxisScale( xAxis(), x1, x2 );
 …
         double y1 = rect.top();
         double y2 = rect.bottom();
+        if ( plt->axisScaleDiv( yAxis() )->lowerBound() >
+            plt->axisScaleDiv( yAxis() )->upperBound() )
+        {
+        if ( !plt->axisScaleDiv( yAxis() ).isIncreasing() )
             qSwap( y1, y2 );
+        }
         plt->setAxisScale( yAxis(), y1, y2 );
 …
   \brief Check and correct a selected rectangle
   Reject rectangles with a hight or width < 2, otherwise
+  Reject rectangles with a height or width < 2, otherwise
   expand the selected rectangle to a minimum size of 11x11
   and accept it.
   \return true If rect is accepted, or has been changed
           to a accepted rectangle.
+  \return true If the rectangle is accepted, or has been changed
+          to an accepted one.
 */
 …
   if accepted.
+  \param ok If true, complete the selection and emit selected signals
+            otherwise discard the selection.
   \sa accept(), minZoomSize()
+  \return True if the selection has been accepted, false otherwise
 */
 bool QwtPlotZoomer::end( bool ok )
 …
     rect = rect.normalized();
+    QRectF zoomRect = invTransform( rect ).normalized();
+    const QSizeF minSize = minZoomSize();
+    if ( minSize.isValid() )
+    {
+        const QPointF center = zoomRect.center();
+        zoomRect.setSize( zoomRect.size().expandedTo( minZoomSize() ) );
+        zoomRect.moveCenter( center );
+    }
+    const QwtScaleMap xMap = plot->canvasMap( xAxis() );
+    const QwtScaleMap yMap = plot->canvasMap( yAxis() );
+    QRectF zoomRect = QwtScaleMap::invTransform( xMap, yMap, rect ).normalized();
+    zoomRect = qwtExpandedZoomRect( zoomRect, minZoomSize(),
+        xMap.transformation(), yMap.transformation() );
     zoom( zoomRect );

trunk/BNC/qwt/qwt_plot_zoomer.h

-              r4271
+              r8127
   \brief QwtPlotZoomer provides stacked zooming for a plot widget
+  QwtPlotZoomer offers rubberband selections on the plot canvas,
+  translating the selected rectangles into plot coordinates and
+  adjusting the axes to them. Zooming can repeated as often as
+  possible, limited only by maxStackDepth() or minZoomSize().
+  Each rectangle is pushed on a stack.
+  QwtPlotZoomer selects rectangles from user inputs ( mouse or keyboard )
+  translates them into plot coordinates and adjusts the axes to them.
+  The selection is supported by a rubber band and optionally by displaying
+  the coordinates of the current mouse position.
+  Zoom rectangles can be selected depending on selectionFlags() using the
+  mouse or keyboard (QwtEventPattern, QwtPickerMachine).
+  QwtEventPattern::MouseSelect3,QwtEventPattern::KeyUndo,
+  or QwtEventPattern::MouseSelect6,QwtEventPattern::KeyRedo
+  walk up and down the zoom stack.
+  QwtEventPattern::MouseSelect2 or QwtEventPattern::KeyHome unzoom to
+  the initial size.
+  Zooming can be repeated as often as possible, limited only by
+  maxStackDepth() or minZoomSize().  Each rectangle is pushed on a stack.
+  The default setting how to select rectangles is
+  a QwtPickerDragRectMachine with the following bindings:
+  - QwtEventPattern::MouseSelect1\n
+    The first point of the zoom rectangle is selected by a mouse press,
+    the second point from the position, where the mouse is released.
+  - QwtEventPattern::KeySelect1\n
+    The first key press selects the first, the second key press
+    selects the second point.
+  - QwtEventPattern::KeyAbort\n
+    Discard the selection in the state, where the first point
+    is selected.
+  To traverse the zoom stack the following bindings are used:
+  - QwtEventPattern::MouseSelect3, QwtEventPattern::KeyUndo\n
+    Zoom out one position on the zoom stack
+  - QwtEventPattern::MouseSelect6, QwtEventPattern::KeyRedo\n
+    Zoom in one position on the zoom stack
+  - QwtEventPattern::MouseSelect2, QwtEventPattern::KeyHome\n
+    Zoom to the zoom base
+  The setKeyPattern() and setMousePattern() functions can be used
+  to configure the zoomer actions. The following example
+  shows, how to configure the 'I' and 'O' keys for zooming in and out
+  one position on the zoom stack. The "Home" key is used to
+  "unzoom" the plot.
+  \code
+   zoomer = new QwtPlotZoomer( plot );
+   zoomer->setKeyPattern( QwtEventPattern::KeyRedo, Qt::Key_I, Qt::ShiftModifier );
+   zoomer->setKeyPattern( QwtEventPattern::KeyUndo, Qt::Key_O, Qt::ShiftModifier );
+   zoomer->setKeyPattern( QwtEventPattern::KeyHome, Qt::Key_Home );
+  \endcode
   QwtPlotZoomer is tailored for plots with one x and y axis, but it is
+  allowed to attach a second QwtPlotZoomer for the other axes.
+  allowed to attach a second QwtPlotZoomer ( without rubber band and tracker )
+  for the other axes.
   \note The realtime example includes an derived zoomer class that adds
         scrollbars to the plot canvas.
+  \sa QwtPlotPanner, QwtPlotMagnifier
 */
 …
     Q_OBJECT
 public:
     explicit QwtPlotZoomer( QwtPlotCanvas *, bool doReplot = true );
+    explicit QwtPlotZoomer( QWidget *, bool doReplot = true );
     explicit QwtPlotZoomer( int xAxis, int yAxis,
                             QwtPlotCanvas *, bool doReplot = true );
+                            QWidget *, bool doReplot = true );
     virtual ~QwtPlotZoomer();

trunk/BNC/qwt/qwt_point_3d.h

r4271	r8127
103	103
104	104	/*!
105		~~Returns t~~rue if the point is null; otherwise returns false.
	105	\return True if the point is null; otherwise returns false.
106	106
107	107	A point is considered to be null if x, y and z-coordinates
…	…
110	110	inline bool QwtPoint3D::isNull() const
111	111	{
112		return d_x == 0.0 && d_y == 0.0 && d_z == 0;
	112	return d_x == 0.0 && d_y == 0.0 && d_z == 0.0;
113	113	}
114	114
115		//! ~~Returns t~~he x-coordinate of the point.
	115	//! \return The x-coordinate of the point.
116	116	inline double QwtPoint3D::x() const
117	117	{
…	…
119	119	}
120	120
121		//! ~~Returns t~~he y-coordinate of the point.
	121	//! \return The y-coordinate of the point.
122	122	inline double QwtPoint3D::y() const
123	123	{
…	…
125	125	}
126	126
127		//! ~~Returns t~~he z-coordinate of the point.
	127	//! \return The z-coordinate of the point.
128	128	inline double QwtPoint3D::z() const
129	129	{
…	…
131	131	}
132	132
133		//! ~~Returns a~~ reference to the x-coordinate of the point.
	133	//! \return A reference to the x-coordinate of the point.
134	134	inline double &QwtPoint3D::rx()
135	135	{
…	…
137	137	}
138	138
139		//! ~~Returns a~~ reference to the y-coordinate of the point.
	139	//! \return A reference to the y-coordinate of the point.
140	140	inline double &QwtPoint3D::ry()
141	141	{
…	…
143	143	}
144	144
145		//! ~~Returns a~~ reference to the z-coordinate of the point.
	145	//! \return A reference to the z-coordinate of the point.
146	146	inline double &QwtPoint3D::rz()
147	147	{
…	…
168	168
169	169	/*!
170		~~Rounds~~ 2D point, where the z coordinate is dropped.
	170	\return 2D point, where the z coordinate is dropped.
171	171	*/
172	172	inline QPointF QwtPoint3D::toPoint() const
…	…
175	175	}
176	176
177		//! ~~Returns true~~ if this point and other are equal; otherwise returns false.
	177	//! \return True, if this point and other are equal; otherwise returns false.
178	178	inline bool QwtPoint3D::operator==( const QwtPoint3D &other ) const
179	179	{
…	…
181	181	}
182	182
183		//! ~~Returns t~~rue if this rect and other are different; otherwise returns false.
	183	//! \return True if this rect and other are different; otherwise returns false.
184	184	inline bool QwtPoint3D::operator!=( const QwtPoint3D &other ) const
185	185	{

trunk/BNC/qwt/qwt_point_polar.cpp

-              r4271
+              r8127
    Convert and return values in Cartesian coordinates
+   \return Converted point in Cartesian coordinates
    \note Invalid or null points will be returned as QPointF(0.0, 0.0)
    \sa isValid(), isNull()
 …
 /*!
     Returns true if point1 is equal to point2; otherwise returns false.
+    \brief Compare 2 points
     Two points are equal to each other if radius and
     azimuth-coordinates are the same. Points are not equal, when
     the azimuth differs, but other.azimuth() == azimuth() % (2 * PI).
+    \return True if the point is equal to other; otherwise return false.
     \sa normalized()
 …
 /*!
     Returns true if point1 is not equal to point2; otherwise returns false.
+    Compare 2 points
     Two points are equal to each other if radius and
 …
     the azimuth differs, but other.azimuth() == azimuth() % (2 * PI).
+    \return True if the point is not equal to other; otherwise return false.
     \sa normalized()
 */
 …
    When the radius is < 0.0 it is set to 0.0. The azimuth is
    a value >= 0.0 and < 2 * M_PI.
+   \return Normalized point
 */
 QwtPointPolar QwtPointPolar::normalized() const

trunk/BNC/qwt/qwt_point_polar.h

-              r4331
+              r8127
 /*!
     Constructs a null point, with a radius and azimuth set to 0.0.
     \sa QPointF::isNull
+    \sa QPointF::isNull()
 */
 inline QwtPointPolar::QwtPointPolar():
 …
+}
+inline QwtPointPolar qwtFastPos2Polar( const QPointF &pos )
+{
+    return QwtPointPolar( qwtFastAtan2( pos.y(), pos.x() ),
+        qSqrt( qwtSqr( pos.x() ) + qwtSqr( pos.y() ) ) );
+}
 #endif

trunk/BNC/qwt/qwt_raster_data.cpp

-              r4271
+              r8127
 #include "qwt_raster_data.h"
 #include "qwt_point_3d.h"
+#include <qnumeric.h>
 class QwtRasterData::ContourPlane
 …
         case 6:
             // e(-1,1,0), e(1,0,-1)
             line[0] = vertex[1].toPoint();
+            line[0] = vertex[2].toPoint();
             line[1] = intersection( vertex[0], vertex[1] );
             break;
 …
   \brief Initialize a raster
   Before the composition of an image QwtPlotSpectrogram calls initRaster,
+  Before the composition of an image QwtPlotSpectrogram calls initRaster(),
   announcing the area and its resolution that will be requested.
   The default implementation does nothing, but for data sets that
   are stored in files, it might be good idea to reimplement initRaster,
+  are stored in files, it might be good idea to reimplement initRaster(),
   where the data is resampled and loaded into memory.
 …
    Width and height of the hint need to be the horizontal
    and vertical distances between 2 neighboured points.
+   and vertical distances between 2 neighbored points.
    The center of the hint has to be the position of any point
    ( it doesn't matter which one ).
 …
 /*!
    Calculate contour lines
+   \param rect Bounding rectangle for the contour lines
+   \param raster Number of data pixels of the raster data
+   \param levels List of limits, where to insert contour lines
+   \param flags Flags to customize the contouring algorithm
+   \return Calculated contour lines
    An adaption of CONREC, a simple contouring algorithm.
 …
                 if ( z > zMax )
                     zMax = z;
+            }
+            if ( qIsNaN( zSum ) )
+            {
+                // one of the points is NaN
+                continue;
+            }

trunk/BNC/qwt/qwt_raster_data.h

r4271	r8127
39	39	enum ConrecFlag
40	40	{
41		//! Ignore all verices on the same level
	41	//! Ignore all vertices on the same level
42	42	IgnoreAllVerticesOnLevel = 0x01,
43	43

trunk/BNC/qwt/qwt_round_scale_draw.cpp

-              r4271
+              r8127
 #include "qwt_scale_div.h"
 #include "qwt_scale_map.h"
+#include "qwt_math.h"
 #include <qpen.h>
 #include <qpainter.h>
 …
 public:
     PrivateData():
         center( 50, 50 ),
         radius( 50 ),
         startAngle( -135 * 16 ),
         endAngle( 135 * 16 )
+        center( 50.0, 50.0 ),
+        radius( 50.0 ),
+        startAngle( -135.0 ),
+        endAngle( 135.0 )
+    {
+    }
 …
   \sa moveCenter()
 */
 void QwtRoundScaleDraw::setRadius( int radius )
+void QwtRoundScaleDraw::setRadius( double radius )
+{
     d_data->radius = radius;
 …
   Radius is the radius of the backbone without ticks and labels.
+  \return Radius of the scale
   \sa setRadius(), extent()
 */
 int QwtRoundScaleDraw::radius() const
+double QwtRoundScaleDraw::radius() const
+{
     return d_data->radius;
 …
   <li>The angle range is limited to [-360, 360] degrees. Angles exceeding
       this range will be clipped.
   <li>For angles more than 359 degrees above or below min(angle1, angle2),
+  <li>For angles more or equal than 360 degrees above or below min(angle1, angle2),
       scale marks will not be drawn.
   <li>If you need a counterclockwise scale, use QwtScaleDiv::setRange
+  <li>If you need a counterclockwise scale, use QwtScaleDiv::setInterval()
   </ul>
 */
 void QwtRoundScaleDraw::setAngleRange( double angle1, double angle2 )
+{
+#if 0
     angle1 = qBound( -360.0, angle1, 360.0 );
     angle2 = qBound( -360.0, angle2, 360.0 );
+    d_data->startAngle = angle1 * 16.0;
+    d_data->endAngle = angle2 * 16.0;
+#endif
+    d_data->startAngle = angle1;
+    d_data->endAngle = angle2;
     if ( d_data->startAngle == d_data->endAngle )
 …
 void QwtRoundScaleDraw::drawLabel( QPainter *painter, double value ) const
+{
+    const double tval = scaleMap().transform( value );
+    if ( ( tval >= d_data->startAngle + 360.0 )
+        || ( tval <= d_data->startAngle - 360.0 ) )
+    {
+        return;
+    }
     const QwtText label = tickLabel( painter->font(), value );
     if ( label.isEmpty() )
         return;
-    const double tval = scaleMap().transform( value );
-    if ( ( tval > d_data->startAngle + 359 * 16 )
-        || ( tval < d_data->startAngle - 359 * 16 ) )
+    {
-        return;
+    }
     double radius = d_data->radius;
     if ( hasComponent( QwtAbstractScaleDraw::Ticks ) ||
 …
     const QSizeF sz = label.textSize( painter->font() );
     const double arc = tval / 16.0 / 360.0 * 2 * M_PI;
+    const double arc = qwtRadians( tval );
     const double x = d_data->center.x() +
         ( radius + sz.width() / 2.0 ) * qSin( arc );
     const double y = d_data->center.y() -
         ( radius + sz.height() / 2.0 ) * cos( arc );
+        ( radius + sz.height() / 2.0 ) * qCos( arc );
     const QRectF r( x - sz.width() / 2, y - sz.height() / 2,
 …
     const double radius = d_data->radius;
     if ( ( tval <= d_data->startAngle + 359 * 16 )
         || ( tval >= d_data->startAngle - 359 * 16 ) )
+    {
         const double arc = double( tval ) / 16.0 * M_PI / 180.0;
+    if ( ( tval < d_data->startAngle + 360.0 )
+        && ( tval > d_data->startAngle - 360.0 ) )
+    {
+        const double arc = qwtRadians( tval );
         const double sinArc = qSin( arc );
 …
 void QwtRoundScaleDraw::drawBackbone( QPainter *painter ) const
+{
+    const double a1 = qMin( scaleMap().p1(), scaleMap().p2() ) - 90 * 16;
+    const double a2 = qMax( scaleMap().p1(), scaleMap().p2() ) - 90 * 16;
+    const double deg1 = scaleMap().p1();
+    const double deg2 = scaleMap().p2();
+    const int a1 = qRound( qMin( deg1, deg2 ) - 90 );
+    const int a2 = qRound( qMax( deg1, deg2 ) - 90 );
     const double radius = d_data->radius;
 …
     const double y = d_data->center.y() - radius;
     painter->drawArc( x, y, 2 * radius, 2 * radius,
         -a2, a2 - a1 + 1 );          // counterclockwise
+    painter->drawArc( QRectF( x, y, 2 * radius, 2 * radius ),
+        -a2 * 16, ( a2 - a1 + 1 ) * 16 );          // counterclockwise
+}
 …
    \param font Font used for painting the labels
+   \return Calculated extent
    \sa setMinimumExtent(), minimumExtent()
    \warning The implemented algo is not too smart and
+   \warning The implemented algorithm is not too smart and
             calculates only an upper limit, that might be a
             few pixels too large
 …
                 continue;
-            const QwtText label = tickLabel( font, value );
-            if ( label.isEmpty() )
-                continue;
             const double tval = scaleMap().transform( value );
             if ( ( tval < d_data->startAngle + 360 * 16 )
                 && ( tval > d_data->startAngle - 360 * 16 ) )
+            if ( ( tval < d_data->startAngle + 360 )
+                && ( tval > d_data->startAngle - 360 ) )
+            {
+                const double arc = tval / 16.0 / 360.0 * 2 * M_PI;
+                const QwtText label = tickLabel( font, value );
+                if ( label.isEmpty() )
+                    continue;
+                const double arc = qwtRadians( tval );
                 const QSizeF sz = label.textSize( font );
 …
     if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
+    {
         const double pw = qMax( 1, penWidth() );  // penwidth can be zero
+        const double pw = qMax( 1, penWidth() );  // pen width can be zero
         d += pw;
+    }

trunk/BNC/qwt/qwt_round_scale_draw.h

-              r4271
+              r8127
 #include <qpoint.h>
-class QPen;
 /*!
   \brief A class for drawing round scales
   QwtRoundScaleDraw can be used to draw round scales.
   The circle segment can be adjusted by QwtRoundScaleDraw::setAngleRange().
+  The circle segment can be adjusted by setAngleRange().
   The geometry of the scale can be specified with
   QwtRoundScaleDraw::moveCenter() and QwtRoundScaleDraw::setRadius().
+  moveCenter() and setRadius().
   After a scale division has been specified as a QwtScaleDiv object
 …
     virtual ~QwtRoundScaleDraw();
     void setRadius( int radius );
     int radius() const;
+    void setRadius( double radius );
+    double radius() const;
     void moveCenter( double x, double y );
 …
 protected:
     virtual void drawTick( QPainter *p, double val, double len ) const;
     virtual void drawBackbone( QPainter *p ) const;
     virtual void drawLabel( QPainter *p, double val ) const;
+    virtual void drawTick( QPainter *, double val, double len ) const;
+    virtual void drawBackbone( QPainter * ) const;
+    virtual void drawLabel( QPainter *, double val ) const;
 private:

trunk/BNC/qwt/qwt_sampling_thread.h

-              r4271
+              r8127
   \brief A thread collecting samples at regular intervals.
   Contiounous signals are converted into a discrete signal by
+  Continuous signals are converted into a discrete signal by
   collecting samples at regular intervals. A discrete signal
   can be displayed by a QwtPlotSeriesItem on a QwtPlot widget.
   QwtSamplingThread starts a thread calling perodically sample(),
+  QwtSamplingThread starts a thread calling periodically sample(),
   to collect and store ( or emit ) a single sample.
 …
        Collect a sample
        \param elapsed Time since the thread was started in miliseconds
+       \param elapsed Time since the thread was started in milliseconds
      */
     virtual void sample( double elapsed ) = 0;

trunk/BNC/qwt/qwt_scale_div.cpp

-              r4271
+              r8127
 #include "qwt_scale_div.h"
 #include "qwt_math.h"
-#include "qwt_interval.h"
 #include <qalgorithms.h>
+//! Construct an invalid QwtScaleDiv instance.
+QwtScaleDiv::QwtScaleDiv():
+    d_lowerBound( 0.0 ),
+    d_upperBound( 0.0 ),
+    d_isValid( false )
+{
+}
+/*!
+  Construct QwtScaleDiv instance.
+/*!
+  Construct a division without ticks
+  \param lowerBound First boundary
+  \param upperBound Second boundary
+  \note lowerBound might be greater than upperBound for inverted scales
+ */
+QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound ):
+    d_lowerBound( lowerBound ),
+    d_upperBound( upperBound )
+{
+}
+/*!
+  Construct a scale division
   \param interval Interval
 …
         QList<double> ticks[NTickTypes] ):
     d_lowerBound( interval.minValue() ),
+    d_upperBound( interval.maxValue() ),
+    d_isValid( true )
+    d_upperBound( interval.maxValue() )
+{
     for ( int i = 0; i < NTickTypes; i++ )
 …
 /*!
   Construct QwtScaleDiv instance.
   \param lowerBound First interval limit
   \param upperBound Second interval limit
+  Construct a scale division
+  \param lowerBound First boundary
+  \param upperBound Second boundary
   \param ticks List of major, medium and minor ticks
+*/
+QwtScaleDiv::QwtScaleDiv(
+        double lowerBound, double upperBound,
+  \note lowerBound might be greater than upperBound for inverted scales
+*/
+QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
         QList<double> ticks[NTickTypes] ):
     d_lowerBound( lowerBound ),
+    d_upperBound( upperBound ),
+    d_isValid( true )
+    d_upperBound( upperBound )
+{
     for ( int i = 0; i < NTickTypes; i++ )
 …
 /*!
+  Construct a scale division
+  \param lowerBound First boundary
+  \param upperBound Second boundary
+  \param minorTicks List of minor ticks
+  \param mediumTicks List medium ticks
+  \param majorTicks List of major ticks
+  \note lowerBound might be greater than upperBound for inverted scales
+*/
+QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
+        const QList<double> &minorTicks,
+        const QList<double> &mediumTicks,
+        const QList<double> &majorTicks ):
+    d_lowerBound( lowerBound ),
+    d_upperBound( upperBound )
+{
+    d_ticks[ MinorTick ] = minorTicks;
+    d_ticks[ MediumTick ] = mediumTicks;
+    d_ticks[ MajorTick ] = majorTicks;
+}
+/*!
+  Change the interval
+  \param lowerBound First boundary
+  \param upperBound Second boundary
+  \note lowerBound might be greater than upperBound for inverted scales
+*/
+void QwtScaleDiv::setInterval( double lowerBound, double upperBound )
+{
+    d_lowerBound = lowerBound;
+    d_upperBound = upperBound;
+}
+/*!
    Change the interval
    \param interval Interval
 */
 void QwtScaleDiv::setInterval( const QwtInterval &interval )
+{
+    setInterval( interval.minValue(), interval.maxValue() );
+    d_lowerBound = interval.minValue();
+    d_upperBound = interval.maxValue();
+}
+/*!
+  \return lowerBound -> upperBound
+*/
+QwtInterval QwtScaleDiv::interval() const
+{
+    return QwtInterval( d_lowerBound, d_upperBound );
+}
+/*!
+  Set the first boundary
+  \param lowerBound First boundary
+  \sa lowerBiound(), setUpperBound()
+ */
+void QwtScaleDiv::setLowerBound( double lowerBound  )
+{
+    d_lowerBound = lowerBound;
+}
+/*!
+  \return First boundary
+  \sa upperBound()
+*/
+double QwtScaleDiv::lowerBound() const
+{
+    return d_lowerBound;
+}
+/*!
+  Set the second boundary
+  \param upperBound Second boundary
+  \sa upperBound(), setLowerBound()
+ */
+void QwtScaleDiv::setUpperBound( double upperBound  )
+{
+    d_upperBound = upperBound;
+}
+/*!
+  \return upper bound
+  \sa lowerBound()
+*/
+double QwtScaleDiv::upperBound() const
+{
+    return d_upperBound;
+}
+/*!
+  \return upperBound() - lowerBound()
+*/
+double QwtScaleDiv::range() const
+{
+    return d_upperBound - d_lowerBound;
+}
 …
+{
     if ( d_lowerBound != other.d_lowerBound ||
+        d_upperBound != other.d_upperBound ||
+        d_isValid != other.d_isValid )
+        d_upperBound != other.d_upperBound )
+    {
         return false;
 …
 /*!
   \brief Inequality
+  \return true if this instance is not equal to s
+*/
+bool QwtScaleDiv::operator!=( const QwtScaleDiv &s ) const
+{
+    return ( !( *this == s ) );
+}
+//! Invalidate the scale division
+void QwtScaleDiv::invalidate()
+{
+    d_isValid = false;
+    // detach arrays
+    for ( int i = 0; i < NTickTypes; i++ )
+        d_ticks[i].clear();
+    d_lowerBound = d_upperBound = 0;
+}
+//! Check if the scale division is valid
+bool QwtScaleDiv::isValid() const
+{
+    return d_isValid;
+  \return true if this instance is not equal to other
+*/
+bool QwtScaleDiv::operator!=( const QwtScaleDiv &other ) const
+{
+    return ( !( *this == other ) );
+}
+//! Check if the scale division is empty( lowerBound() == upperBound() )
+bool QwtScaleDiv::isEmpty() const
+{
+    return ( d_lowerBound == d_upperBound );
+}
+//! Check if the scale division is increasing( lowerBound() <= upperBound() )
+bool QwtScaleDiv::isIncreasing() const
+{
+    return d_lowerBound <= d_upperBound;
+}
 …
 bool QwtScaleDiv::contains( double value ) const
+{
-    if ( !d_isValid )
-        return false;
     const double min = qMin( d_lowerBound, d_upperBound );
     const double max = qMax( d_lowerBound, d_upperBound );
 …
+}
+//! Invert the scale divison
+/*!
+   Invert the scale division
+   \sa inverted()
+ */
 void QwtScaleDiv::invert()
+{
 …
         const int size2 = size / 2;
         for ( int i = 0; i < size2; i++ )
             qSwap( ticks[i], ticks[size - 1 - i] );
+        for ( int j = 0; j < size2; j++ )
+            qSwap( ticks[j], ticks[size - 1 - j] );
+    }
+}
+/*!
+  \return A scale division with inverted boundaries and ticks
+  \sa invert()
+ */
+QwtScaleDiv QwtScaleDiv::inverted() const
+{
+    QwtScaleDiv other = *this;
+    other.invert();
+    return other;
+}
+/*!
+   Return a scale division with an interval [lowerBound, upperBound]
+   where all ticks outside this interval are removed
+   \param lowerBound Lower bound
+   \param upperBound Upper bound
+   \return Scale division with all ticks inside of the given interval
+   \note lowerBound might be greater than upperBound for inverted scales
+*/
+QwtScaleDiv QwtScaleDiv::bounded(
+    double lowerBound, double upperBound ) const
+{
+    const double min = qMin( lowerBound, upperBound );
+    const double max = qMax( lowerBound, upperBound );
+    QwtScaleDiv sd;
+    sd.setInterval( lowerBound, upperBound );
+    for ( int tickType = 0; tickType < QwtScaleDiv::NTickTypes; tickType++ )
+    {
+        const QList<double> &ticks = d_ticks[ tickType ];
+        QList<double> boundedTicks;
+        for ( int i = 0; i < ticks.size(); i++ )
+        {
+            const double tick = ticks[i];
+            if ( tick >= min && tick <= max )
+                boundedTicks += tick;
+        }
+        sd.setTicks( tickType, boundedTicks );
+    }
+    return sd;
+}
 …
 void QwtScaleDiv::setTicks( int type, const QList<double> &ticks )
+{
     if ( type >= 0 || type < NTickTypes )
+    if ( type >= 0 && type < NTickTypes )
         d_ticks[type] = ticks;
+}
 …
    \param type MinorTick, MediumTick or MajorTick
+*/
+const QList<double> &QwtScaleDiv::ticks( int type ) const
+{
+    if ( type >= 0 || type < NTickTypes )
+   \return Tick list
+*/
+QList<double> QwtScaleDiv::ticks( int type ) const
+{
+    if ( type >= 0 && type < NTickTypes )
         return d_ticks[type];
+    static QList<double> noTicks;
+    return noTicks;
+}
+    return QList<double>();
+}
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<( QDebug debug, const QwtScaleDiv &scaleDiv )
+{
+    debug << scaleDiv.lowerBound() << "<->" << scaleDiv.upperBound();
+    debug << "Major: " << scaleDiv.ticks( QwtScaleDiv::MajorTick );
+    debug << "Medium: " << scaleDiv.ticks( QwtScaleDiv::MediumTick );
+    debug << "Minor: " << scaleDiv.ticks( QwtScaleDiv::MinorTick );
+    return debug;
+}
+#endif

trunk/BNC/qwt/qwt_scale_div.h

-              r4271
+              r8127
 #include <qlist.h>
+class QwtInterval;
+#ifndef QT_NO_DEBUG_STREAM
+#include <qdebug.h>
+#endif
 /*!
   \brief A class representing a scale division
   A scale division consists of its limits and 3 list
   of tick values qualified as major, medium and minor ticks.
+  A Qwt scale is defined by its boundaries and 3 list
+  for the positions of the major, medium and minor ticks.
+  In most cases scale divisions are calculated by a QwtScaleEngine.
+  The upperBound() might be smaller than the lowerBound()
+  to indicate inverted scales.
+  \sa subDivideInto(), subDivide()
+  Scale divisions can be calculated from a QwtScaleEngine.
+  \sa QwtScaleEngine::divideScale(), QwtPlot::setAxisScaleDiv(),
+      QwtAbstractSlider::setScaleDiv()
 */
 …
     };
+    explicit QwtScaleDiv();
+    explicit QwtScaleDiv( double lowerBound = 0.0,
+        double upperBound = 0.0 );
     explicit QwtScaleDiv( const QwtInterval &, QList<double>[NTickTypes] );
-    explicit QwtScaleDiv(
-        double lowerBound, double upperBound, QList<double>[NTickTypes] );
+    bool operator==( const QwtScaleDiv &s ) const;
+    bool operator!=( const QwtScaleDiv &s ) const;
+    explicit QwtScaleDiv( double lowerBound, double upperBound,
+        QList<double>[NTickTypes] );
+    explicit QwtScaleDiv( double lowerBound, double upperBound,
+        const QList<double> &minorTicks, const QList<double> &mediumTicks,
+        const QList<double> &majorTicks );
+    bool operator==( const QwtScaleDiv & ) const;
+    bool operator!=( const QwtScaleDiv & ) const;
     void setInterval( double lowerBound, double upperBound );
 …
     QwtInterval interval() const;
+    void setLowerBound( double );
     double lowerBound() const;
+    void setUpperBound( double );
     double upperBound() const;
     double range() const;
     bool contains( double v ) const;
+    bool contains( double value ) const;
     void setTicks( int type, const QList<double> & );
     const QList<double> &ticks( int type ) const;
+    void setTicks( int tickType, const QList<double> & );
+    QList<double> ticks( int tickType ) const;
     void invalidate();
     bool isValid() const;
+    bool isEmpty() const;
+    bool isIncreasing() const;
     void invert();
+    QwtScaleDiv inverted() const;
+    QwtScaleDiv bounded( double lowerBound, double upperBound ) const;
 private:
 …
     double d_upperBound;
     QList<double> d_ticks[NTickTypes];
-    bool d_isValid;
 };
 Q_DECLARE_TYPEINFO(QwtScaleDiv, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO( QwtScaleDiv, Q_MOVABLE_TYPE );
+/*!
+   Change the interval
+   \param lowerBound lower bound
+   \param upperBound upper bound
+*/
+inline void QwtScaleDiv::setInterval( double lowerBound, double upperBound )
+{
+    d_lowerBound = lowerBound;
+    d_upperBound = upperBound;
+}
+#ifndef QT_NO_DEBUG_STREAM
+QWT_EXPORT QDebug operator<<( QDebug, const QwtScaleDiv & );
+#endif
-/*!
-  \return lowerBound -> upperBound
-*/
-inline QwtInterval QwtScaleDiv::interval() const
+{
-    return QwtInterval( d_lowerBound, d_upperBound );
+}
-/*!
-  \return lower bound
-  \sa upperBound()
-*/
-inline double QwtScaleDiv::lowerBound() const
+{
-    return d_lowerBound;
+}
-/*!
-  \return upper bound
-  \sa lowerBound()
-*/
-inline double QwtScaleDiv::upperBound() const
+{
-    return d_upperBound;
+}
-/*!
-  \return upperBound() - lowerBound()
-*/
-inline double QwtScaleDiv::range() const
+{
-    return d_upperBound - d_lowerBound;
+}
 #endif

trunk/BNC/qwt/qwt_scale_draw.cpp

-              r4271
+              r8127
 #include <qmath.h>
+#if QT_VERSION < 0x040601
+#define qFastSin(x) qSin(x)
+#define qFastCos(x) qCos(x)
+#endif
 class QwtScaleDraw::PrivateData
+{
 …
    Return alignment of the scale
    \sa setAlignment()
+   \return Alignment of the scale
 */
 QwtScaleDraw::Alignment QwtScaleDraw::alignment() const
 …
 /*!
    Set the alignment of the scale
+   \param align Alignment of the scale
    The default alignment is QwtScaleDraw::BottomScale
 …
   TopScale, BottomScale are horizontal (Qt::Horizontal) scales,
   LeftScale, RightScale are vertical (Qt::Vertical) scales.
+  \return Orientation of the scale
   \sa alignment()
 …
   \param end End border distance
 */
 void QwtScaleDraw::getBorderDistHint( const QFont &font,
                                       int &start, int &end ) const
+void QwtScaleDraw::getBorderDistHint(
+    const QFont &font, int &start, int &end ) const
+{
     start = 0;
     end = 0;
+    end = 1.0;
     if ( !hasComponent( QwtAbstractScaleDraw::Labels ) )
 …
     const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
     if ( ticks.count() == 0 )
+    if ( ticks.isEmpty() )
         return 0;
 …
     if ( vertical )
+    {
+        bRect2.setRect( -bRect2.bottom(), 0, bRect2.height(), bRect2.width() );
+    }
+    int maxDist = 0;
+        bRect2.setRect( -bRect2.bottom(), 0.0, bRect2.height(), bRect2.width() );
+    }
+    double maxDist = 0.0;
     for ( int i = 1; i < ticks.count(); i++ )
 …
         if ( vertical )
+        {
             bRect2.setRect( -bRect2.bottom(), 0,
+            bRect2.setRect( -bRect2.bottom(), 0.0,
                 bRect2.height(), bRect2.width() );
+        }
         int dist = fm.leading(); // space between the labels
+        double dist = fm.leading(); // space between the labels
         if ( bRect1.right() > 0 )
             dist += bRect1.right();
 …
+    }
     double angle = labelRotation() / 180.0 * M_PI;
+    double angle = qwtRadians( labelRotation() );
     if ( vertical )
         angle += M_PI / 2;
+    if ( qSin( angle ) == 0.0 )
+        return maxDist;
+    const double sinA = qFastSin( angle ); // qreal -> double
+    if ( qFuzzyCompare( sinA + 1.0, 1.0 ) )
+        return qCeil( maxDist );
     const int fmHeight = fm.ascent() - 2;
 …
     // The distance we need until there is
     // the height of the label font. This height is needed
     // for the neighbour labal.
     int labelDist = qFloor( fmHeight / qSin( angle ) * qCos( angle ) );
+    // for the neighbored label.
+    double labelDist = fmHeight / qFastSin( angle ) * qFastCos( angle );
     if ( labelDist < 0 )
         labelDist = -labelDist;
-    // The cast above floored labelDist. We want to ceil.
-    labelDist++;
     // For text orientations close to the scale orientation
 …
         labelDist = fmHeight;
     return labelDist;
+    return qCeil( labelDist );
+}
 …
    \param font Font used for painting the labels
+   \return Extent
    \sa minLength()
 …
     if ( hasComponent( QwtAbstractScaleDraw::Backbone ) )
+    {
         const double pw = qMax( 1, penWidth() );  // penwidth can be zero
+        const double pw = qMax( 1, penWidth() );  // pen width can be zero
         d += pw;
+    }
 …
    \param font Font used for painting the labels
+   \return Minimum length that is needed to draw the scale
    \sa extent()
 …
    Find the position, where to paint a label
    The position has a distance of majTickLength() + spacing() + 1
    from the backbone. The direction depends on the alignment()
+   The position has a distance that depends on the length of the ticks
+   in direction of the alignment().
    \param value Value
+   \return Position, where to paint a label
 */
 QPointF QwtScaleDraw::labelPosition( double value ) const
 …
    \param painter Painter
    \param value Value of the tick
    \param len Lenght of the tick
+   \param len Length of the tick
    \sa drawBackbone(), drawLabel()
 …
   overlapping labels.
+  \param length Length of the backbone
   \sa move(), minLabelDist()
 */
 void QwtScaleDraw::setLength( double length )
+{
+#if 1
     if ( length >= 0 && length < 10 )
         length = 10;
+    // why should we accept negative lengths ???
     if ( length < 0 && length > -10 )
         length = -10;
+#else
+    length = qMax( length, 10 );
+#endif
     d_data->len = length;
 …
 /*!
+  Find the bounding rect for the label. The coordinates of
+  the rect are absolute coordinates ( calculated from pos() ).
+  \brief Find the bounding rectangle for the label.
+  The coordinates of the rectangle are absolute ( calculated from pos() ).
   in direction of the tick.
 …
   \param value Value
+  \return Bounding rectangle
   \sa labelRect()
 */
 …
    \param size Size of the label
+   \return Transformation matrix
    \sa setLabelAlignment(), setLabelRotation()
 */
 …
 /*!
   Find the bounding rect for the label. The coordinates of
   the rect are relative to spacing + ticklength from the backbone
+  Find the bounding rectangle for the label. The coordinates of
+  the rectangle are relative to spacing + tick length from the backbone
   in direction of the tick.
   \param font Font used for painting
   \param value Value
+   \return Bounding rectangle that is needed to draw a label
 */
 QRectF QwtScaleDraw::labelRect( const QFont &font, double value ) const
 …
    \param font Label font
    \param value Value
+   \return Size that is needed to draw a label
 */
 QSizeF QwtScaleDraw::labelSize( const QFont &font, double value ) const
 …
   \brief Change the label flags
   Labels are aligned to the point ticklength + spacing away from the backbone.
+  Labels are aligned to the point tick length + spacing away from the backbone.
   The alignment is relative to the orientation of the label text.
 …
            The alignment of the label is not the alignment
            of the scale and is not the alignment of the flags
            (QwtText::flags()) returned from QwtAbstractScaleDraw::label().
+           ( QwtText::flags() ) returned from QwtAbstractScaleDraw::label().
 */
 …
 int QwtScaleDraw::maxLabelWidth( const QFont &font ) const
+{
     int maxWidth = 0;
+    double maxWidth = 0.0;
     const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
 …
         if ( scaleDiv().contains( v ) )
+        {
             const int w = labelSize( font, ticks[i] ).width();
+            const double w = labelSize( font, ticks[i] ).width();
             if ( w > maxWidth )
                 maxWidth = w;
 …
+    }
     return maxWidth;
+    return qCeil( maxWidth );
+}
 …
 int QwtScaleDraw::maxLabelHeight( const QFont &font ) const
+{
     int maxHeight = 0;
+    double maxHeight = 0.0;
     const QList<double> &ticks = scaleDiv().ticks( QwtScaleDiv::MajorTick );
 …
         if ( scaleDiv().contains( v ) )
+        {
             const int h = labelSize( font, ticks[i] ).height();
+            const double h = labelSize( font, ticks[i] ).height();
             if ( h > maxHeight )
                 maxHeight = h;
 …
+    }
     return maxHeight;
+    return qCeil( maxHeight );
+}

trunk/BNC/qwt/qwt_scale_draw.h

-              r4271
+              r8127
   the scale can be drawn with the QwtAbstractScaleDraw::draw() member.
 */
 class QWT_EXPORT QwtScaleDraw: public QwtAbstractScaleDraw
+{
 …
 /*!
    Move the position of the scale
+   \param x X coordinate
+   \param y Y coordinate
    \sa move(const QPointF &)
 */

trunk/BNC/qwt/qwt_scale_engine.cpp

-              r4271
+              r8127
 #include <qalgorithms.h>
 #include <qmath.h>
+#include <float.h>
+#include <limits>
 #if QT_VERSION < 0x040601
 …
 #endif
+static inline double qwtLog( double base, double value )
+{
+    return log( value ) / log( base );
+}
+static inline QwtInterval qwtLogInterval( double base, const QwtInterval &interval )
+{
+    return QwtInterval( qwtLog( base, interval.minValue() ),
+            qwtLog( base, interval.maxValue() ) );
+}
+static inline QwtInterval qwtPowInterval( double base, const QwtInterval &interval )
+{
+    return QwtInterval( qPow( base, interval.minValue() ),
+            qPow( base, interval.maxValue() ) );
+}
+static inline long double qwtIntervalWidthL( const QwtInterval &interval )
+{
+    if ( !interval.isValid() )
+        return 0.0;
+    return static_cast<long double>( interval.maxValue() )
+        - static_cast<long double>( interval.minValue() );
+}
+#if 1
+// this version often doesn't find the best ticks: f.e for 15: 5, 10
+static double qwtStepSize( double intervalSize, int maxSteps, uint base )
+{
+    const double minStep =
+        QwtScaleArithmetic::divideInterval( intervalSize, maxSteps, base );
+    if ( minStep != 0.0 )
+    {
+        // # ticks per interval
+        const int numTicks = qCeil( qAbs( intervalSize / minStep ) ) - 1;
+        // Do the minor steps fit into the interval?
+        if ( qwtFuzzyCompare( ( numTicks +  1 ) * qAbs( minStep ),
+            qAbs( intervalSize ), intervalSize ) > 0 )
+        {
+            // The minor steps doesn't fit into the interval
+            return 0.5 * intervalSize;
+        }
+    }
+    return minStep;
+}
+#else
+static double qwtStepSize( double intervalSize, int maxSteps, uint base )
+{
+    if ( maxSteps <= 0 )
+        return 0.0;
+    if ( maxSteps > 2 )
+    {
+        for ( int numSteps = maxSteps; numSteps > 1; numSteps-- )
+        {
+            const double stepSize = intervalSize / numSteps;
+            const double p = ::floor( ::log( stepSize ) / ::log( base ) );
+            const double fraction = qPow( base, p );
+            for ( uint n = base; n > 1; n /= 2 )
+            {
+                if ( qFuzzyCompare( stepSize, n * fraction ) )
+                    return stepSize;
+                if ( n == 3 && ( base % 2 ) == 0 )
+                {
+                    if ( qFuzzyCompare( stepSize, 2 * fraction ) )
+                        return stepSize;
+                }
+            }
+        }
+    }
+    return intervalSize * 0.5;
+}
+#endif
 static const double _eps = 1.0e-6;
 …
   Ceil a value, relative to an interval
   \param value Value to ceil
+  \param value Value to be ceiled
   \param intervalSize Interval size
+  \return Rounded value
   \sa floorEps()
 …
     value = ( value - eps ) / intervalSize;
     return qwtCeilF( value ) * intervalSize;
+    return ::ceil( value ) * intervalSize;
+}
 …
   Floor a value, relative to an interval
   \param value Value to floor
+  \param value Value to be floored
   \param intervalSize Interval size
+  \return Rounded value
   \sa floorEps()
 */
 …
     value = ( value + eps ) / intervalSize;
     return qwtFloorF( value ) * intervalSize;
+    return ::floor( value ) * intervalSize;
+}
 …
 /*!
+  Find the smallest value out of {1,2,5}*10^n with an integer number n
+  which is greater than or equal to x
+  \param x Input value
+*/
+double QwtScaleArithmetic::ceil125( double x )
+{
+    if ( x == 0.0 )
+  Calculate a step size for a given interval
+  \param intervalSize Interval size
+  \param numSteps Number of steps
+  \param base Base for the division ( usually 10 )
+  \return Calculated step size
+ */
+double QwtScaleArithmetic::divideInterval(
+    double intervalSize, int numSteps, uint base )
+{
+    if ( numSteps <= 0 )
         return 0.0;
+    const double sign = ( x > 0 ) ? 1.0 : -1.0;
+    const double lx = ::log10( qFabs( x ) );
+    const double p10 = qwtFloorF( lx );
+    double fr = qPow( 10.0, lx - p10 );
+    if ( fr <= 1.0 )
+        fr = 1.0;
+    else if ( fr <= 2.0 )
+        fr = 2.0;
+    else if ( fr <= 5.0 )
+        fr = 5.0;
+    else
+        fr = 10.0;
+    return sign * fr * qPow( 10.0, p10 );
+}
+/*!
+  \brief Find the largest value out of {1,2,5}*10^n with an integer number n
+  which is smaller than or equal to x
+  \param x Input value
+*/
+double QwtScaleArithmetic::floor125( double x )
+{
+    if ( x == 0.0 )
+    const double v = QwtScaleArithmetic::divideEps( intervalSize, numSteps );
+    if ( v == 0.0 )
         return 0.0;
+    double sign = ( x > 0 ) ? 1.0 : -1.0;
+    const double lx = ::log10( qFabs( x ) );
+    const double p10 = qwtFloorF( lx );
+    double fr = qPow( 10.0, lx - p10 );
+    if ( fr >= 10.0 )
+        fr = 10.0;
+    else if ( fr >= 5.0 )
+        fr = 5.0;
+    else if ( fr >= 2.0 )
+        fr = 2.0;
+    else
+        fr = 1.0;
+    return sign * fr * qPow( 10.0, p10 );
+    const double lx = qwtLog( base, qFabs( v ) );
+    const double p = ::floor( lx );
+    const double fraction = qPow( base, lx - p );
+    uint n = base;
+    while ( ( n > 1 ) && ( fraction <= n / 2 ) )
+        n /= 2;
+    double stepSize = n * qPow( base, p );
+    if ( v < 0 )
+        stepSize = -stepSize;
+    return stepSize;
+}
 …
         lowerMargin( 0.0 ),
         upperMargin( 0.0 ),
+        referenceValue( 0.0 )
+    {
+    }
+    QwtScaleEngine::Attributes attributes;       // scale attributes
+    double lowerMargin;      // margins
+        referenceValue( 0.0 ),
+        base( 10 ),
+        transform( NULL )
+    {
+    }
+    ~PrivateData()
+    {
+        delete transform;
+    }
+    QwtScaleEngine::Attributes attributes;
+    double lowerMargin;
     double upperMargin;
+    double referenceValue; // reference value
+    double referenceValue;
+    uint base;
+    QwtTransform* transform;
 };
+//! Constructor
+QwtScaleEngine::QwtScaleEngine()
+/*!
+  Constructor
+  \param base Base of the scale engine
+  \sa setBase()
+ */
+QwtScaleEngine::QwtScaleEngine( uint base )
+{
     d_data = new PrivateData;
+    setBase( base );
+}
 …
+{
     delete d_data;
+}
+/*!
+   Assign a transformation
+   \param transform Transformation
+   The transformation object is used as factory for clones
+   that are returned by transformation()
+   The scale engine takes ownership of the transformation.
+   \sa QwtTransform::copy(), transformation()
+ */
+void QwtScaleEngine::setTransformation( QwtTransform *transform )
+{
+    if ( transform != d_data->transform )
+    {
+        delete d_data->transform;
+        d_data->transform = transform;
+    }
+}
+/*!
+   Create and return a clone of the transformation
+   of the engine. When the engine has no special transformation
+   NULL is returned, indicating no transformation.
+   \return A clone of the transfomation
+   \sa setTransformation()
+ */
+QwtTransform *QwtScaleEngine::transformation() const
+{
+    QwtTransform *transform = NULL;
+    if ( d_data->transform )
+        transform = d_data->transform->copy();
+    return transform;
+}
 …
   \warning
   \li QwtLog10ScaleEngine measures the margins in decades.
+  \li QwtLogScaleEngine measures the margins in decades.
   \sa upperMargin(), lowerMargin()
 …
     double intervalSize, int numSteps ) const
+{
+    if ( numSteps <= 0 )
+        return 0.0;
+    double v = QwtScaleArithmetic::divideEps( intervalSize, numSteps );
+    return QwtScaleArithmetic::ceil125( v );
+    return QwtScaleArithmetic::divideInterval(
+        intervalSize, numSteps, d_data->base );
+}
 …
   \param value Value
   \sa QwtScaleArithmetic::compareEps()
+  \return True, when the value is inside the interval
 */
 bool QwtScaleEngine::contains(
 …
 /*!
   \brief Build an interval for a value
+  \brief Build an interval around a value
   In case of v == 0.0 the interval is [-0.5, 0.5],
   otherwide it is [0.5 * v, 1.5 * v]
+*/
+QwtInterval QwtScaleEngine::buildInterval( double v ) const
+{
+    const double delta = ( v == 0.0 ) ? 0.5 : qAbs( 0.5 * v );
+    return QwtInterval( v - delta, v + delta );
+  \param value Initial value
+  \return Calculated interval
+*/
+QwtInterval QwtScaleEngine::buildInterval( double value ) const
+{
+    const double delta = ( value == 0.0 ) ? 0.5 : qAbs( 0.5 * value );
+    if ( DBL_MAX - delta < value )
+        return QwtInterval( DBL_MAX - delta, DBL_MAX );
+    if ( -DBL_MAX + delta > value )
+        return QwtInterval( -DBL_MAX, -DBL_MAX + delta );
+    return QwtInterval( value - delta, value + delta );
+}
 …
 /*!
   Check if a attribute is set.
+  \return True, if attribute is enabled.
   \param attribute Attribute to be tested
 …
 /*!
   Return the scale attributes
+  \return Scale attributes
   \sa Attribute, setAttributes(), testAttribute()
 */
 …
 /*!
  \return the reference value
  \sa setReference(), setAttribute()
+  \return the reference value
+  \sa setReference(), setAttribute()
 */
 double QwtScaleEngine::reference() const
 …
 /*!
+  Return a transformation, for linear scales
+*/
+QwtScaleTransformation *QwtLinearScaleEngine::transformation() const
+{
+    return new QwtScaleTransformation( QwtScaleTransformation::Linear );
+}
+/*!
+    Align and divide an interval
+   \param maxNumSteps Max. number of steps
+   \param x1 First limit of the interval (In/Out)
+   \param x2 Second limit of the interval (In/Out)
+   \param stepSize Step size (Out)
+   \sa setAttribute()
+  Set the base of the scale engine
+  While a base of 10 is what 99.9% of all applications need
+  certain scales might need a different base: f.e 2
+  The default setting is 10
+  \param base Base of the engine
+  \sa base()
+ */
+void QwtScaleEngine::setBase( uint base )
+{
+    d_data->base = qMax( base, 2U );
+}
+/*!
+  \return base Base of the scale engine
+  \sa setBase()
+ */
+uint QwtScaleEngine::base() const
+{
+    return d_data->base;
+}
+/*!
+  Constructor
+  \param base Base of the scale engine
+  \sa setBase()
+ */
+QwtLinearScaleEngine::QwtLinearScaleEngine( uint base ):
+    QwtScaleEngine( base )
+{
+}
+//! Destructor
+QwtLinearScaleEngine::~QwtLinearScaleEngine()
+{
+}
+/*!
+  Align and divide an interval
+  \param maxNumSteps Max. number of steps
+  \param x1 First limit of the interval (In/Out)
+  \param x2 Second limit of the interval (In/Out)
+  \param stepSize Step size (Out)
+  \sa setAttribute()
 */
 void QwtLinearScaleEngine::autoScale( int maxNumSteps,
 …
         interval = buildInterval( interval.minValue() );
+    stepSize = divideInterval( interval.width(), qMax( maxNumSteps, 1 ) );
+    stepSize = QwtScaleArithmetic::divideInterval(
+        interval.width(), qMax( maxNumSteps, 1 ), base() );
     if ( !testAttribute( QwtScaleEngine::Floating ) )
 …
 /*!
    \brief Calculate a scale division
+   \brief Calculate a scale division for an interval
    \param x1 First interval limit
    \param x2 Second interval limit
    \param maxMajSteps Maximum for the number of major steps
    \param maxMinSteps Maximum number of minor steps
    \param stepSize Step size. If stepSize == 0, the scaleEngine
+   \param maxMajorSteps Maximum for the number of major steps
+   \param maxMinorSteps Maximum number of minor steps
+   \param stepSize Step size. If stepSize == 0, the engine
                    calculates one.
    \sa QwtScaleEngine::stepSize(), QwtScaleEngine::subDivide()
+   \return Calculated scale division
 */
 QwtScaleDiv QwtLinearScaleEngine::divideScale( double x1, double x2,
     int maxMajSteps, int maxMinSteps, double stepSize ) const
+    int maxMajorSteps, int maxMinorSteps, double stepSize ) const
+{
     QwtInterval interval = QwtInterval( x1, x2 ).normalized();
+    if ( qwtIntervalWidthL( interval ) > std::numeric_limits<double>::max() )
+    {
+        qWarning() << "QwtLinearScaleEngine::divideScale: overflow";
+        return QwtScaleDiv();
+    }
     if ( interval.width() <= 0 )
         return QwtScaleDiv();
 …
     if ( stepSize == 0.0 )
+    {
+        if ( maxMajSteps < 1 )
+            maxMajSteps = 1;
+        stepSize = divideInterval( interval.width(), maxMajSteps );
+        if ( maxMajorSteps < 1 )
+            maxMajorSteps = 1;
+        stepSize = QwtScaleArithmetic::divideInterval(
+            interval.width(), maxMajorSteps, base() );
+    }
 …
+    {
         QList<double> ticks[QwtScaleDiv::NTickTypes];
         buildTicks( interval, stepSize, maxMinSteps, ticks );
+        buildTicks( interval, stepSize, maxMinorSteps, ticks );
         scaleDiv = QwtScaleDiv( interval, ticks );
 …
    \param interval Interval
    \param stepSize Step size
    \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param ticks Arrays to be filled with the calculated ticks
 …
 */
 void QwtLinearScaleEngine::buildTicks(
     const QwtInterval& interval, double stepSize, int maxMinSteps,
+    const QwtInterval& interval, double stepSize, int maxMinorSteps,
     QList<double> ticks[QwtScaleDiv::NTickTypes] ) const
+{
+    const QwtInterval boundingInterval =
+        align( interval, stepSize );
+    const QwtInterval boundingInterval = align( interval, stepSize );
     ticks[QwtScaleDiv::MajorTick] =
         buildMajorTicks( boundingInterval, stepSize );
     if ( maxMinSteps > 0 )
+    {
         buildMinorTicks( ticks[QwtScaleDiv::MajorTick], maxMinSteps, stepSize,
+    if ( maxMinorSteps > 0 )
+    {
+        buildMinorTicks( ticks[QwtScaleDiv::MajorTick], maxMinorSteps, stepSize,
             ticks[QwtScaleDiv::MinorTick], ticks[QwtScaleDiv::MediumTick] );
+    }
 …
    \param majorTicks Major ticks
    \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param stepSize Step size
    \param minorTicks Array to be filled with the calculated minor ticks
 …
 void QwtLinearScaleEngine::buildMinorTicks(
     const QList<double>& majorTicks,
     int maxMinSteps, double stepSize,
+    int maxMinorSteps, double stepSize,
     QList<double> &minorTicks,
     QList<double> &mediumTicks ) const
+{
     double minStep = divideInterval( stepSize, maxMinSteps );
+    double minStep = qwtStepSize( stepSize, maxMinorSteps, base() );
     if ( minStep == 0.0 )
         return;
     // # ticks per interval
+    int numTicks = qCeil( qAbs( stepSize / minStep ) ) - 1;
+    // Do the minor steps fit into the interval?
+    if ( qwtFuzzyCompare( ( numTicks +  1 ) * qAbs( minStep ),
+        qAbs( stepSize ), stepSize ) > 0 )
+    {
+        numTicks = 1;
+        minStep = stepSize * 0.5;
+    }
+    const int numTicks = qCeil( qAbs( stepSize / minStep ) ) - 1;
     int medIndex = -1;
 …
     const QwtInterval &interval, double stepSize ) const
+{
+    double x1 = QwtScaleArithmetic::floorEps( interval.minValue(), stepSize );
+    if ( qwtFuzzyCompare( interval.minValue(), x1, stepSize ) == 0 )
+        x1 = interval.minValue();
+    double x2 = QwtScaleArithmetic::ceilEps( interval.maxValue(), stepSize );
+    if ( qwtFuzzyCompare( interval.maxValue(), x2, stepSize ) == 0 )
+        x2 = interval.maxValue();
+    double x1 = interval.minValue();
+    double x2 = interval.maxValue();
+    // when there is no rounding beside some effect, when
+    // calculating with doubles, we keep the original value
+    const double eps = 0.000000000001; // since Qt 4.8: qFuzzyIsNull
+    if ( -DBL_MAX + stepSize <= x1 )
+    {
+        const double x = QwtScaleArithmetic::floorEps( x1, stepSize );
+        if ( qAbs(x) <= eps || !qFuzzyCompare( x1, x ) )
+            x1 = x;
+    }
+    if ( DBL_MAX - stepSize >= x2 )
+    {
+        const double x = QwtScaleArithmetic::ceilEps( x2, stepSize );
+        if ( qAbs(x) <= eps || !qFuzzyCompare( x2, x ) )
+            x2 = x;
+    }
     return QwtInterval( x1, x2 );
 …
 /*!
+  Return a transformation, for logarithmic (base 10) scales
+*/
+QwtScaleTransformation *QwtLog10ScaleEngine::transformation() const
+{
+    return new QwtScaleTransformation( QwtScaleTransformation::Log10 );
+  Constructor
+  \param base Base of the scale engine
+  \sa setBase()
+ */
+QwtLogScaleEngine::QwtLogScaleEngine( uint base ):
+    QwtScaleEngine( base )
+{
+    setTransformation( new QwtLogTransform() );
+}
+//! Destructor
+QwtLogScaleEngine::~QwtLogScaleEngine()
+{
+}
 …
    \sa QwtScaleEngine::setAttribute()
 */
 void QwtLog10ScaleEngine::autoScale( int maxNumSteps,
                                      double &x1, double &x2, double &stepSize ) const
+void QwtLogScaleEngine::autoScale( int maxNumSteps,
+    double &x1, double &x2, double &stepSize ) const
+{
     if ( x1 > x2 )
         qSwap( x1, x2 );
+    QwtInterval interval( x1 / qPow( 10.0, lowerMargin() ),
+        x2 * qPow( 10.0, upperMargin() ) );
+    if ( interval.maxValue() / interval.minValue() < 10.0 )
+    {
+        // scale width is less than one decade -> build linear scale
+    const double logBase = base();
+    QwtInterval interval( x1 / qPow( logBase, lowerMargin() ),
+        x2 * qPow( logBase, upperMargin() ) );
+    if ( interval.maxValue() / interval.minValue() < logBase )
+    {
+        // scale width is less than one step -> try to build a linear scale
         QwtLinearScaleEngine linearScaler;
 …
         linearScaler.autoScale( maxNumSteps, x1, x2, stepSize );
+        stepSize = ::log10( stepSize );
+        return;
+        QwtInterval linearInterval = QwtInterval( x1, x2 ).normalized();
+        linearInterval = linearInterval.limited( LOG_MIN, LOG_MAX );
+        if ( linearInterval.maxValue() / linearInterval.minValue() < logBase )
+        {
+            // the aligned scale is still less than one step
+#if 1
+            // this code doesn't make any sense, but for compatibility
+            // reasons we keep it until 6.2. But it will be ignored
+            // in divideScale
+            if ( stepSize < 0.0 )
+                stepSize = -qwtLog( logBase, qAbs( stepSize ) );
+            else
+                stepSize = qwtLog( logBase, stepSize );
+#endif
+            return;
+        }
+    }
 …
         interval = buildInterval( interval.minValue() );
+    stepSize = divideInterval( log10( interval ).width(), qMax( maxNumSteps, 1 ) );
+    stepSize = divideInterval( qwtLogInterval( logBase, interval ).width(),
+        qMax( maxNumSteps, 1 ) );
     if ( stepSize < 1.0 )
         stepSize = 1.0;
 …
 /*!
    \brief Calculate a scale division
+   \brief Calculate a scale division for an interval
    \param x1 First interval limit
    \param x2 Second interval limit
    \param maxMajSteps Maximum for the number of major steps
    \param maxMinSteps Maximum number of minor steps
    \param stepSize Step size. If stepSize == 0, the scaleEngine
+   \param maxMajorSteps Maximum for the number of major steps
+   \param maxMinorSteps Maximum number of minor steps
+   \param stepSize Step size. If stepSize == 0, the engine
                    calculates one.
    \sa QwtScaleEngine::stepSize(), QwtLog10ScaleEngine::subDivide()
 */
 QwtScaleDiv QwtLog10ScaleEngine::divideScale( double x1, double x2,
     int maxMajSteps, int maxMinSteps, double stepSize ) const
+   \return Calculated scale division
+*/
+QwtScaleDiv QwtLogScaleEngine::divideScale( double x1, double x2,
+    int maxMajorSteps, int maxMinorSteps, double stepSize ) const
+{
     QwtInterval interval = QwtInterval( x1, x2 ).normalized();
 …
         return QwtScaleDiv();
+    if ( interval.maxValue() / interval.minValue() < 10.0 )
+    const double logBase = base();
+    if ( interval.maxValue() / interval.minValue() < logBase )
+    {
         // scale width is less than one decade -> build linear scale
 …
         linearScaler.setMargins( lowerMargin(), upperMargin() );
-        if ( stepSize != 0.0 )
-            stepSize = qPow( 10.0, stepSize );
         return linearScaler.divideScale( x1, x2,
             maxMajSteps, maxMinSteps, stepSize );
+            maxMajorSteps, maxMinorSteps, 0.0 );
+    }
 …
     if ( stepSize == 0.0 )
+    {
+        if ( maxMajSteps < 1 )
+            maxMajSteps = 1;
+        stepSize = divideInterval( log10( interval ).width(), maxMajSteps );
+        if ( maxMajorSteps < 1 )
+            maxMajorSteps = 1;
+        stepSize = divideInterval(
+            qwtLogInterval( logBase, interval ).width(), maxMajorSteps );
         if ( stepSize < 1.0 )
             stepSize = 1.0; // major step must be >= 1 decade
 …
+    {
         QList<double> ticks[QwtScaleDiv::NTickTypes];
         buildTicks( interval, stepSize, maxMinSteps, ticks );
+        buildTicks( interval, stepSize, maxMinorSteps, ticks );
         scaleDiv = QwtScaleDiv( interval, ticks );
 …
    \param interval Interval
    \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param stepSize Step size
    \param ticks Arrays to be filled with the calculated ticks
 …
    \sa buildMajorTicks(), buildMinorTicks
 */
 void QwtLog10ScaleEngine::buildTicks(
     const QwtInterval& interval, double stepSize, int maxMinSteps,
+void QwtLogScaleEngine::buildTicks(
+    const QwtInterval& interval, double stepSize, int maxMinorSteps,
     QList<double> ticks[QwtScaleDiv::NTickTypes] ) const
+{
 …
         buildMajorTicks( boundingInterval, stepSize );
     if ( maxMinSteps > 0 )
+    {
         ticks[QwtScaleDiv::MinorTick] = buildMinorTicks(
             ticks[QwtScaleDiv::MajorTick], maxMinSteps, stepSize );
+    if ( maxMinorSteps > 0 )
+    {
+        buildMinorTicks( ticks[QwtScaleDiv::MajorTick], maxMinorSteps, stepSize,
+            ticks[QwtScaleDiv::MinorTick], ticks[QwtScaleDiv::MediumTick] );
+    }
 …
    \return Calculated ticks
 */
 QList<double> QwtLog10ScaleEngine::buildMajorTicks(
+QList<double> QwtLogScaleEngine::buildMajorTicks(
     const QwtInterval &interval, double stepSize ) const
+{
     double width = log10( interval ).width();
+    double width = qwtLogInterval( base(), interval ).width();
     int numTicks = qRound( width / stepSize ) + 1;
 …
    \param majorTicks Major ticks
    \param maxMinSteps Maximum number of minor steps
+   \param maxMinorSteps Maximum number of minor steps
    \param stepSize Step size
+*/
+QList<double> QwtLog10ScaleEngine::buildMinorTicks(
+   \param minorTicks Array to be filled with the calculated minor ticks
+   \param mediumTicks Array to be filled with the calculated medium ticks
+*/
+void QwtLogScaleEngine::buildMinorTicks(
     const QList<double> &majorTicks,
+    int maxMinSteps, double stepSize ) const
+{
+    if ( stepSize < 1.1 )          // major step width is one decade
+    {
+        if ( maxMinSteps < 1 )
+            return QList<double>();
+        int k0, kstep, kmax;
+        if ( maxMinSteps >= 8 )
+    int maxMinorSteps, double stepSize,
+    QList<double> &minorTicks,
+    QList<double> &mediumTicks ) const
+{
+    const double logBase = base();
+    if ( stepSize < 1.1 )          // major step width is one base
+    {
+        double minStep = divideInterval( stepSize, maxMinorSteps + 1 );
+        if ( minStep == 0.0 )
+            return;
+        const int numSteps = qRound( stepSize / minStep );
+        int mediumTickIndex = -1;
+        if ( ( numSteps > 2 ) && ( numSteps % 2 == 0 ) )
+            mediumTickIndex = numSteps / 2;
+        for ( int i = 0; i < majorTicks.count() - 1; i++ )
+        {
+            k0 = 2;
+            kmax = 9;
+            kstep = 1;
+            const double v = majorTicks[i];
+            const double s = logBase / numSteps;
+            if ( s >= 1.0 )
+            {
+                if ( !qFuzzyCompare( s, 1.0 ) )
+                    minorTicks += v * s;
+                for ( int j = 2; j < numSteps; j++ )
+                {
+                    minorTicks += v * j * s;
+                }
+            }
+            else
+            {
+                for ( int j = 1; j < numSteps; j++ )
+                {
+                    const double tick = v + j * v * ( logBase - 1 ) / numSteps;
+                    if ( j == mediumTickIndex )
+                        mediumTicks += tick;
+                    else
+                        minorTicks += tick;
+                }
+            }
+        }
+        else if ( maxMinSteps >= 4 )
+    }
+    else
+    {
+        double minStep = divideInterval( stepSize, maxMinorSteps );
+        if ( minStep == 0.0 )
+            return;
+        if ( minStep < 1.0 )
+            minStep = 1.0;
+        // # subticks per interval
+        int numTicks = qRound( stepSize / minStep ) - 1;
+        // Do the minor steps fit into the interval?
+        if ( qwtFuzzyCompare( ( numTicks +  1 ) * minStep,
+            stepSize, stepSize ) > 0 )
+        {
+            k0 = 2;
+            kmax = 8;
+            kstep = 2;
+            numTicks = 0;
+        }
+        else if ( maxMinSteps >= 2 )
+        {
+            k0 = 2;
+            kmax = 5;
+            kstep = 3;
+        }
+        else
+        {
+            k0 = 5;
+            kmax = 5;
+            kstep = 1;
+        }
+        QList<double> minorTicks;
+        if ( numTicks < 1 )
+            return;
+        int mediumTickIndex = -1;
+        if ( ( numTicks > 2 ) && ( numTicks % 2 ) )
+            mediumTickIndex = numTicks / 2;
+        // substep factor = base^substeps
+        const qreal minFactor = qMax( qPow( logBase, minStep ), qreal( logBase ) );
         for ( int i = 0; i < majorTicks.count(); i++ )
+        {
+            const double v = majorTicks[i];
+            for ( int k = k0; k <= kmax; k += kstep )
+                minorTicks += v * double( k );
+        }
+        return minorTicks;
+    }
+    else  // major step > one decade
+    {
+        double minStep = divideInterval( stepSize, maxMinSteps );
+        if ( minStep == 0.0 )
+            return QList<double>();
+        if ( minStep < 1.0 )
+            minStep = 1.0;
+        // # subticks per interval
+        int nMin = qRound( stepSize / minStep ) - 1;
+        // Do the minor steps fit into the interval?
+        if ( qwtFuzzyCompare( ( nMin +  1 ) * minStep,
+            qAbs( stepSize ), stepSize ) > 0 )
+        {
+            nMin = 0;
+        }
+        if ( nMin < 1 )
+            return QList<double>();      // no subticks
+        // substep factor = 10^substeps
+        const qreal minFactor = qMax( qPow( 10.0, minStep ), qreal( 10.0 ) );
+        QList<double> minorTicks;
+        for ( int i = 0; i < majorTicks.count(); i++ )
+        {
+            double val = majorTicks[i];
+            for ( int k = 0; k < nMin; k++ )
+            double tick = majorTicks[i];
+            for ( int j = 0; j < numTicks; j++ )
+            {
+                val *= minFactor;
+                minorTicks += val;
+                tick *= minFactor;
+                if ( j == mediumTickIndex )
+                    mediumTicks += tick;
+                else
+                    minorTicks += tick;
+            }
+        }
-        return minorTicks;
+    }
+}
 …
   \return Aligned interval
 */
 QwtInterval QwtLog10ScaleEngine::align(
+QwtInterval QwtLogScaleEngine::align(
     const QwtInterval &interval, double stepSize ) const
+{
     const QwtInterval intv = log10( interval );
+    const QwtInterval intv = qwtLogInterval( base(), interval );
     double x1 = QwtScaleArithmetic::floorEps( intv.minValue(), stepSize );
 …
         x2 = interval.maxValue();
+    return pow10( QwtInterval( x1, x2 ) );
+}
+/*!
+  Return the interval [log10(interval.minValue(), log10(interval.maxValue]
+*/
+QwtInterval QwtLog10ScaleEngine::log10( const QwtInterval &interval ) const
+{
+    return QwtInterval( ::log10( interval.minValue() ),
+            ::log10( interval.maxValue() ) );
+}
+/*!
+  Return the interval [pow10(interval.minValue(), pow10(interval.maxValue]
+*/
+QwtInterval QwtLog10ScaleEngine::pow10( const QwtInterval &interval ) const
+{
+    return QwtInterval( qPow( 10.0, interval.minValue() ),
+            qPow( 10.0, interval.maxValue() ) );
+}
+    return qwtPowInterval( base(), QwtInterval( x1, x2 ) );
+}

trunk/BNC/qwt/qwt_scale_engine.h

-              r4271
+              r8127
 #include "qwt_interval.h"
 class QwtScaleTransformation;
+class QwtTransform;
 /*!
 …
     static double divideEps( double interval, double steps );
     static double ceil125( double x );
     static double floor125( double x );
+    static double divideInterval( double interval,
+        int numSteps, uint base );
 };
 …
   The layout of the scale can be varied with setAttribute().
+  Qwt offers implementations for logarithmic (log10)
+  and linear scales. Contributions for other types of scale engines
+  (date/time, log2 ... ) are welcome.
+  Qwt offers implementations for logarithmic and linear scales.
 */
 …
     typedef QFlags<Attribute> Attributes;
     explicit QwtScaleEngine();
+    explicit QwtScaleEngine( uint base = 10 );
     virtual ~QwtScaleEngine();
+    void setBase( uint base );
+    uint base() const;
     void setAttribute( Attribute, bool on = true );
 …
       \param x1 First interval limit
       \param x2 Second interval limit
       \param maxMajSteps Maximum for the number of major steps
       \param maxMinSteps Maximum number of minor steps
+      \param maxMajorSteps Maximum for the number of major steps
+      \param maxMinorSteps Maximum number of minor steps
       \param stepSize Step size. If stepSize == 0.0, the scaleEngine
                    calculates one.
+      \return Calculated scale division
     */
     virtual QwtScaleDiv divideScale( double x1, double x2,
         int maxMajSteps, int maxMinSteps,
+        int maxMajorSteps, int maxMinorSteps,
         double stepSize = 0.0 ) const = 0;
     //! \return a transformation
     virtual QwtScaleTransformation *transformation() const = 0;
+    void setTransformation( QwtTransform * );
+    QwtTransform *transformation() const;
 protected:
     bool contains( const QwtInterval &, double val ) const;
     QList<double> strip( const QList<double>&, const QwtInterval & ) const;
     double divideInterval( double interval, int numSteps ) const;
 …
+{
 public:
+    QwtLinearScaleEngine( uint base = 10 );
+    virtual ~QwtLinearScaleEngine();
     virtual void autoScale( int maxSteps,
         double &x1, double &x2, double &stepSize ) const;
 …
                                      double stepSize = 0.0 ) const;
-    virtual QwtScaleTransformation *transformation() const;
 protected:
 …
         const QwtInterval &interval, double stepSize ) const;
+    void buildMinorTicks(
+        const QList<double>& majorTicks,
+        int maxMinMark, double step,
+        QList<double> &, QList<double> & ) const;
+};
+/*!
+  \brief A scale engine for logarithmic (base 10) scales
+    void buildMinorTicks( const QList<double>& majorTicks,
+        int maxMinorSteps, double stepSize,
+        QList<double> &minorTicks, QList<double> &mediumTicks ) const;
+};
+/*!
+  \brief A scale engine for logarithmic scales
   The step size is measured in *decades*
 …
 */
+class QWT_EXPORT QwtLog10ScaleEngine: public QwtScaleEngine
+{
+public:
+class QWT_EXPORT QwtLogScaleEngine: public QwtScaleEngine
+{
+public:
+    QwtLogScaleEngine( uint base = 10 );
+    virtual ~QwtLogScaleEngine();
     virtual void autoScale( int maxSteps,
         double &x1, double &x2, double &stepSize ) const;
 …
         double stepSize = 0.0 ) const;
-    virtual QwtScaleTransformation *transformation() const;
 protected:
-    QwtInterval log10( const QwtInterval& ) const;
-    QwtInterval pow10( const QwtInterval& ) const;
     QwtInterval align( const QwtInterval&, double stepSize ) const;
 …
         const QwtInterval &interval, double stepSize ) const;
     QList<double> buildMinorTicks(
         const QList<double>& majorTicks,
         int maxMinMark, double step ) const;
+    void buildMinorTicks( const QList<double>& majorTicks,
+        int maxMinorSteps, double stepSize,
+        QList<double> &minorTicks, QList<double> &mediumTicks ) const;
 };

trunk/BNC/qwt/qwt_scale_map.cpp

-              r4271
+              r8127
 #include "qwt_scale_map.h"
+#include "qwt_math.h"
 #include <qrect.h>
-#include <qalgorithms.h>
-#include <qmath.h>
 #include <qdebug.h>
-#if QT_VERSION < 0x040601
-#define qExp(x) ::exp(x)
-#endif
-//! Smallest allowed value for logarithmic scales: 1.0e-150
-QT_STATIC_CONST_IMPL double QwtScaleMap::LogMin = 1.0e-150;
-//! Largest allowed value for logarithmic scales: 1.0e150
-QT_STATIC_CONST_IMPL double QwtScaleMap::LogMax = 1.0e150;
-//! Constructor for a linear transformation
-QwtScaleTransformation::QwtScaleTransformation( Type type ):
-    d_type( type )
+{
+}
-//! Destructor
-QwtScaleTransformation::~QwtScaleTransformation()
+{
+}
-//! Create a clone of the transformation
-QwtScaleTransformation *QwtScaleTransformation::copy() const
+{
-    return new QwtScaleTransformation( d_type );
+}
-/*!
-  \brief Transform a value from the coordinate system of a scale
-         into the coordinate system of the paint device
-  \param s  Value related to the coordinate system of the scale
-  \param s1 First border of the coordinate system of the scale
-  \param s2 Second border of the coordinate system of the scale
-  \param p1 First border of the coordinate system of the paint device
-  \param p2 Second border of the coordinate system of the paint device
-  \return
-  <dl>
-  <dt>linear mapping:<dd>p1 + (p2 - p1) / (s2 - s1) * (s - s1);</dd>
-  </dl>
-  <dl>
-  <dt>log10 mapping: <dd>p1 + (p2 - p1) / log(s2 / s1) * log(s / s1);</dd>
-  </dl>
-*/
-double QwtScaleTransformation::xForm(
-    double s, double s1, double s2, double p1, double p2 ) const
+{
-    if ( d_type == Log10 )
-        return p1 + ( p2 - p1 ) / log( s2 / s1 ) * log( s / s1 );
-    else
-        return p1 + ( p2 - p1 ) / ( s2 - s1 ) * ( s - s1 );
+}
-/*!
-  \brief Transform a value from the coordinate system of the paint device
-         into the coordinate system of a scale.
-  \param p Value related to the coordinate system of the paint device
-  \param p1 First border of the coordinate system of the paint device
-  \param p2 Second border of the coordinate system of the paint device
-  \param s1 First border of the coordinate system of the scale
-  \param s2 Second border of the coordinate system of the scale
-  \return
-  <dl>
-  <dt>linear mapping:<dd>s1 + ( s2 - s1 ) / ( p2 - p1 ) * ( p - p1 );</dd>
-  </dl>
-  <dl>
-  <dt>log10 mapping:<dd>exp((p - p1) / (p2 - p1) * log(s2 / s1)) * s1;</dd>
-  </dl>
-*/
-double QwtScaleTransformation::invXForm( double p, double p1, double p2,
-    double s1, double s2 ) const
+{
-    if ( d_type == Log10 )
-        return qExp( ( p - p1 ) / ( p2 - p1 ) * log( s2 / s1 ) ) * s1;
-    else
-        return s1 + ( s2 - s1 ) / ( p2 - p1 ) * ( p - p1 );
+}
 /*!
 …
     d_p1( 0.0 ),
     d_p2( 1.0 ),
     d_cnv( 1.0 )
+{
     d_transformation = new QwtScaleTransformation(
+        QwtScaleTransformation::Linear );
+    d_cnv( 1.0 ),
+    d_ts1( 0.0 ),
+    d_transform( NULL )
+{
+}
 …
     d_p1( other.d_p1 ),
     d_p2( other.d_p2 ),
+    d_cnv( other.d_cnv )
+{
+    d_transformation = other.d_transformation->copy();
+    d_cnv( other.d_cnv ),
+    d_ts1( other.d_ts1 ),
+    d_transform( NULL )
+{
+    if ( other.d_transform )
+        d_transform = other.d_transform->copy();
+}
 …
 QwtScaleMap::~QwtScaleMap()
+{
     delete d_transformation;
+    delete d_transform;
+}
 …
     d_p2 = other.d_p2;
     d_cnv = other.d_cnv;
+    delete d_transformation;
+    d_transformation = other.d_transformation->copy();
+    d_ts1 = other.d_ts1;
+    delete d_transform;
+    d_transform = NULL;
+    if ( other.d_transform )
+        d_transform = other.d_transform->copy();
     return *this;
 …
    Initialize the map with a transformation
 */
+void QwtScaleMap::setTransformation(
+    QwtScaleTransformation *transformation )
+{
+    if ( transformation == NULL )
+        return;
+    if ( transformation != d_transformation )
+void QwtScaleMap::setTransformation( QwtTransform *transform )
+{
+    if ( transform != d_transform )
+    {
         delete d_transformation;
         d_transformation = transformation;
+        delete d_transform;
+        d_transform = transform;
+    }
 …
 //! Get the transformation
 const QwtScaleTransformation *QwtScaleMap::transformation() const
+{
     return d_transformation;
+const QwtTransform *QwtScaleMap::transformation() const
+{
+    return d_transform;
+}
 …
   \param s1 first border
   \param s2 second border
+  \warning logarithmic scales might be aligned to [LogMin, LogMax]
+  \warning scales might be aligned to
+           transformation depending boundaries
 */
 void QwtScaleMap::setScaleInterval( double s1, double s2 )
+{
-    if ( d_transformation->type() == QwtScaleTransformation::Log10 )
+    {
-        if ( s1 < LogMin )
-            s1 = LogMin;
-        else if ( s1 > LogMax )
-            s1 = LogMax;
-        if ( s2 < LogMin )
-            s2 = LogMin;
-        else if ( s2 > LogMax )
-            s2 = LogMax;
+    }
     d_s1 = s1;
     d_s2 = s2;
+    if ( d_transformation->type() != QwtScaleTransformation::Other )
+        newFactor();
+    if ( d_transform )
+    {
+        d_s1 = d_transform->bounded( d_s1 );
+        d_s2 = d_transform->bounded( d_s2 );
+    }
+    updateFactor();
+}
 …
     d_p2 = p2;
+    if ( d_transformation->type() != QwtScaleTransformation::Other )
+        newFactor();
+}
+/*!
+  \brief Re-calculate the conversion factor.
+*/
+void QwtScaleMap::newFactor()
+{
+    d_cnv = 0.0;
+    switch ( d_transformation->type() )
+    updateFactor();
+}
+void QwtScaleMap::updateFactor()
+{
+    d_ts1 = d_s1;
+    double ts2 = d_s2;
+    if ( d_transform )
+    {
+        case QwtScaleTransformation::Linear:
+        {
+            if ( d_s2 != d_s1 )
+                d_cnv = ( d_p2 - d_p1 ) / ( d_s2 - d_s1 );
+            break;
+        }
+        case QwtScaleTransformation::Log10:
+        {
+            if ( d_s1 != 0 )
+                d_cnv = ( d_p2 - d_p1 ) / log( d_s2 / d_s1 );
+            break;
+        }
+        default:;
+        d_ts1 = d_transform->transform( d_ts1 );
+        ts2 = d_transform->transform( ts2 );
+    }
+    d_cnv = 1.0;
+    if ( d_ts1 != ts2 )
+        d_cnv = ( d_p2 - d_p1 ) / ( ts2 - d_ts1 );
+}
 …
+{
     debug.nospace() << "QwtScaleMap("
         << static_cast<int>( map.transformation()->type() )
+        << map.transformation()
         << ", s:" << map.s1() << "->" << map.s2()
         << ", p:" << map.p1() << "->" << map.p2()

trunk/BNC/qwt/qwt_scale_map.h

-              r4271
+              r8127
 #include "qwt_global.h"
+#include "qwt_math.h"
+#include "qwt_transform.h"
+#include <qrect.h>
 #ifndef QT_NO_DEBUG_STREAM
 #include <qdebug.h>
 …
 class QRectF;
-/*!
-   \brief A transformation between coordinate systems
-   QwtScaleTransformation offers transformations from the coordinate system
-   of a scale into the linear coordinate system of a paint device
-   and vice versa.
-*/
-class QWT_EXPORT QwtScaleTransformation
+{
-public:
-    //! Transformation type
-    enum Type
+    {
-        //! Transformation between 2 linear scales
-        Linear,
-        //! Transformation between a linear and a logarithmic ( base 10 ) scale
-        Log10,
-        //! Any other type of transformation
-        Other
-    };
-    QwtScaleTransformation( Type type );
-    virtual ~QwtScaleTransformation();
-    virtual double xForm( double x, double s1, double s2,
-        double p1, double p2 ) const;
-    virtual double invXForm( double x, double p1, double p2,
-        double s1, double s2 ) const;
-    Type type() const;
-    virtual QwtScaleTransformation *copy() const;
-private:
-    QwtScaleTransformation();
-    QwtScaleTransformation &operator=( const QwtScaleTransformation );
-    const Type d_type;
-};
-//! \return Transformation type
-inline QwtScaleTransformation::Type QwtScaleTransformation::type() const
+{
-    return d_type;
+}
 /*!
 …
     QwtScaleMap &operator=( const QwtScaleMap & );
     void setTransformation( QwtScaleTransformation * );
     const QwtScaleTransformation *transformation() const;
+    void setTransformation( QwtTransform * );
+    const QwtTransform *transformation() const;
     void setPaintInterval( double p1, double p2 );
 …
     double sDist() const;
-    QT_STATIC_CONST double LogMin;
-    QT_STATIC_CONST double LogMax;
     static QRectF transform( const QwtScaleMap &,
         const QwtScaleMap &, const QRectF & );
 …
 private:
     void newFactor();
+    void updateFactor();
     double d_s1, d_s2;     // scale interval boundaries
 …
     double d_cnv;       // conversion factor
+    double d_ts1;
     QwtScaleTransformation *d_transformation;
+    QwtTransform *d_transform;
 };
 …
   \param s Value relative to the coordinates of the scale
+  \return Transformed value
+  \sa invTransform()
 */
 inline double QwtScaleMap::transform( double s ) const
+{
+    // try to inline code from QwtScaleTransformation
+    if ( d_transform )
+        s = d_transform->transform( s );
+    if ( d_transformation->type() == QwtScaleTransformation::Linear )
+        return d_p1 + ( s - d_s1 ) * d_cnv;
+    if ( d_transformation->type() == QwtScaleTransformation::Log10 )
+        return d_p1 + log( s / d_s1 ) * d_cnv;
+    return d_transformation->xForm( s, d_s1, d_s2, d_p1, d_p2 );
+    return d_p1 + ( s - d_ts1 ) * d_cnv;
+}
 …
   \param p Value relative to the coordinates of the paint device
+  \return Transformed value
   \sa transform()
 */
 inline double QwtScaleMap::invTransform( double p ) const
+{
+    return d_transformation->invXForm( p, d_p1, d_p2, d_s1, d_s2 );
+    double s = d_ts1 + ( p - d_p1 ) / d_cnv;
+    if ( d_transform )
+        s = d_transform->invTransform( s );
+    return s;
+}

trunk/BNC/qwt/qwt_scale_widget.cpp

-              r4271
+              r8127
 #include "qwt_scale_div.h"
 #include "qwt_text.h"
+#include "qwt_scale_engine.h"
 #include <qpainter.h>
 #include <qevent.h>
 …
     d_data->scaleDraw->setLength( 10 );
+    d_data->scaleDraw->setScaleDiv(
+        QwtLinearScaleEngine().divideScale( 0.0, 100.0, 10, 5 ) );
     d_data->colorBar.colorMap = new QwtLinearColorMap();
     d_data->colorBar.isEnabled = false;
 …
 void QwtScaleWidget::setAlignment( QwtScaleDraw::Alignment alignment )
+{
+    if ( d_data->scaleDraw )
+        d_data->scaleDraw->setAlignment( alignment );
     if ( !testAttribute( Qt::WA_WState_OwnSizePolicy ) )
+    {
 …
         if ( d_data->scaleDraw->orientation() == Qt::Vertical )
             policy.transpose();
         setSizePolicy( policy );
 …
+    }
-    if ( d_data->scaleDraw )
-        d_data->scaleDraw->setAlignment( alignment );
     layoutScale();
+}
 …
 /*!
   Set a scale draw
+  sd has to be created with new and will be deleted in
+  scaleDraw has to be created with new and will be deleted in
   ~QwtScaleWidget() or the next call of setScaleDraw().
+  \param sd ScaleDraw object
+  scaleDraw will be initialized with the attributes of
+  the previous scaleDraw object.
+  \param scaleDraw ScaleDraw object
   \sa scaleDraw()
 */
 void QwtScaleWidget::setScaleDraw( QwtScaleDraw *sd )
+{
     if ( sd == NULL || sd == d_data->scaleDraw )
+void QwtScaleWidget::setScaleDraw( QwtScaleDraw *scaleDraw )
+{
+    if ( ( scaleDraw == NULL ) || ( scaleDraw == d_data->scaleDraw ) )
         return;
+    if ( d_data->scaleDraw )
+        sd->setAlignment( d_data->scaleDraw->alignment() );
+    const QwtScaleDraw* sd = d_data->scaleDraw;
+    if ( sd )
+    {
+        scaleDraw->setAlignment( sd->alignment() );
+        scaleDraw->setScaleDiv( sd->scaleDiv() );
+        QwtTransform *transform = NULL;
+        if ( sd->scaleMap().transformation() )
+            transform = sd->scaleMap().transformation()->copy();
+        scaleDraw->setTransformation( transform );
+    }
     delete d_data->scaleDraw;
     d_data->scaleDraw = sd;
+    d_data->scaleDraw = scaleDraw;
     layoutScale();
 …
 /*!
     scaleDraw of this scale
+    \return scaleDraw of this scale
     \sa setScaleDraw(), QwtScaleDraw::setScaleDraw()
 */
 …
 /*!
     scaleDraw of this scale
+    \return scaleDraw of this scale
     \sa QwtScaleDraw::setScaleDraw()
 */
 …
   \param rect Bounding rectangle for all components of the scale
   \return Rectabgle for the color bar
+  \return Rectangle for the color bar
 */
 QRectF QwtScaleWidget::colorBarRect( const QRectF& rect ) const
 …
 /*!
   Event handler for resize event
+  Event handler for resize events
   \param event Resize event
 */
 …
 /*!
   Recalculate the scale's geometry and layout based on
   the current rect and fonts.
+  the current geometry and fonts.
   \param update_geometry Notify the layout system and call update
 …
     QwtText title = d_data->title;
     title.setRenderFlags( flags );
     title.draw( painter, QRect( 0, 0, r.width(), r.height() ) );
+    title.draw( painter, QRectF( 0.0, 0.0, r.width(), r.height() ) );
     painter->restore();
 …
 int QwtScaleWidget::titleHeightForWidth( int width ) const
+{
     return d_data->title.heightForWidth( width, font() );
+    return qCeil( d_data->title.heightForWidth( width, font() ) );
+}
 …
   is returned.
+  \param start Return parameter for the border width at
+               the beginning of the scale
+  \param end Return parameter for the border width at the
+             end of the scale
   \warning
   <ul> <li>The minimum border distance depends on the font.</ul>
 …
   the widget borders.
+  \param start Return parameter for the border width at
+               the beginning of the scale
+  \param end Return parameter for the border width at the
+             end of the scale
   \sa setMinBorderDist(), getBorderDistHint()
 */
 …
   The scale division determines where to set the tick marks.
-  \param transformation Transformation, needed to translate between
-                        scale and pixal values
   \param scaleDiv Scale Division
   \sa For more information about scale divisions, see QwtScaleDiv.
 */
+void QwtScaleWidget::setScaleDiv(
+    QwtScaleTransformation *transformation,
+    const QwtScaleDiv &scaleDiv )
+void QwtScaleWidget::setScaleDiv( const QwtScaleDiv &scaleDiv )
+{
     QwtScaleDraw *sd = d_data->scaleDraw;
+    if ( sd->scaleDiv() != scaleDiv ||
+        sd->scaleMap().transformation()->type() != transformation->type() )
+    {
+        sd->setTransformation( transformation );
+    if ( sd->scaleDiv() != scaleDiv )
+    {
         sd->setScaleDiv( scaleDiv );
         layoutScale();
 …
         Q_EMIT scaleDivChanged();
+    }
+    else
+    {
+        /*
+          The transformation doesn't anything different as the
+          previous one. So we better throw it silently away instead of
+          initiating heavy updates
+         */
+        delete transformation;
+    }
+}
+/*!
+  Set the transformation
+  \param transformation Transformation
+  \sa QwtAbstractScaleDraw::scaleDraw(), QwtScaleMap
+ */
+void QwtScaleWidget::setTransformation( QwtTransform *transformation )
+{
+    d_data->scaleDraw->setTransformation( transformation );
+    layoutScale();
+}

trunk/BNC/qwt/qwt_scale_widget.h

-              r4271
+              r8127
 class QPainter;
 class QwtScaleTransformation;
+class QwtTransform;
 class QwtScaleDiv;
 class QwtColorMap;
 …
 Q_SIGNALS:
     //! Signal emitted, whenever the scale divison changes
+    //! Signal emitted, whenever the scale division changes
     void scaleDivChanged();
 …
     int spacing() const;
+    void setScaleDiv( QwtScaleTransformation *, const QwtScaleDiv &sd );
+    void setScaleDiv( const QwtScaleDiv &sd );
+    void setTransformation( QwtTransform * );
     void setScaleDraw( QwtScaleDraw * );

trunk/BNC/qwt/qwt_series_data.cpp

-              r4271
+              r8127
 static inline QRectF qwtBoundingRect( const QwtSetSample &sample )
+{
     double minX = sample.set[0];
     double maxX = sample.set[0];
     for ( int i = 1; i < ( int )sample.set.size(); i++ )
+    double minY = sample.set[0];
+    double maxY = sample.set[0];
+    for ( int i = 1; i < sample.set.size(); i++ )
+    {
         if ( sample.set[i] < minX )
             minX = sample.set[i];
         if ( sample.set[i] > maxX )
             maxX = sample.set[i];
+        if ( sample.set[i] < minY )
+            minY = sample.set[i];
+        if ( sample.set[i] > maxY )
+            maxY = sample.set[i];
+    }
     double minY = sample.value;
     double maxY = sample.value;
+    double minX = sample.value;
+    double maxX = sample.value;
     return QRectF( minX, minY, maxX - minX, maxY - minY );
+}
+/*!
+  \brief Calculate the bounding rect of a series subset
+static inline QRectF qwtBoundingRect( const QwtOHLCSample &sample )
+{
+    const QwtInterval interval = sample.boundingInterval();
+    return QRectF( interval.minValue(), sample.time, interval.width(), 0.0 );
+}
+/*!
+  \brief Calculate the bounding rectangle of a series subset
   Slow implementation, that iterates over the series.
 …
 template <class T>
 QRectF qwtBoundingRectT(
+QRectF qwtBoundingRectT(
     const QwtSeriesData<T>& series, int from, int to )
+{
 …
 /*!
   \brief Calculate the bounding rect of a series subset
   Slow implementation, that iterates over the series.
   \param series Series
   \param from Index of the first sample, <= 0 means from the beginning
   \param to Index of the last sample, < 0 means to the end
   \return Bounding rectangle
 */
 QRectF qwtBoundingRect(
+  \brief Calculate the bounding rectangle of a series subset
+  Slow implementation, that iterates over the series.
+  \param series Series
+  \param from Index of the first sample, <= 0 means from the beginning
+  \param to Index of the last sample, < 0 means to the end
+  \return Bounding rectangle
+*/
+QRectF qwtBoundingRect(
     const QwtSeriesData<QPointF> &series, int from, int to )
+{
 …
 /*!
   \brief Calculate the bounding rect of a series subset
   Slow implementation, that iterates over the series.
   \param series Series
   \param from Index of the first sample, <= 0 means from the beginning
   \param to Index of the last sample, < 0 means to the end
   \return Bounding rectangle
 */
 QRectF qwtBoundingRect(
+  \brief Calculate the bounding rectangle of a series subset
+  Slow implementation, that iterates over the series.
+  \param series Series
+  \param from Index of the first sample, <= 0 means from the beginning
+  \param to Index of the last sample, < 0 means to the end
+  \return Bounding rectangle
+*/
+QRectF qwtBoundingRect(
     const QwtSeriesData<QwtPoint3D> &series, int from, int to )
+{
 …
 /*!
   \brief Calculate the bounding rect of a series subset
+  \brief Calculate the bounding rectangle of a series subset
   The horizontal coordinates represent the azimuth, the
 …
   \return Bounding rectangle
 */
 QRectF qwtBoundingRect(
+QRectF qwtBoundingRect(
     const QwtSeriesData<QwtPointPolar> &series, int from, int to )
+{
 …
 /*!
   \brief Calculate the bounding rect of a series subset
   Slow implementation, that iterates over the series.
   \param series Series
   \param from Index of the first sample, <= 0 means from the beginning
   \param to Index of the last sample, < 0 means to the end
   \return Bounding rectangle
 */
 QRectF qwtBoundingRect(
+  \brief Calculate the bounding rectangle of a series subset
+  Slow implementation, that iterates over the series.
+  \param series Series
+  \param from Index of the first sample, <= 0 means from the beginning
+  \param to Index of the last sample, < 0 means to the end
+  \return Bounding rectangle
+*/
+QRectF qwtBoundingRect(
     const QwtSeriesData<QwtIntervalSample>& series, int from, int to )
+{
 …
 /*!
+  \brief Calculate the bounding rect of a series subset
+  Slow implementation, that iterates over the series.
+  \param series Series
+  \param from Index of the first sample, <= 0 means from the beginning
+  \param to Index of the last sample, < 0 means to the end
+  \return Bounding rectangle
+*/
+QRectF qwtBoundingRect(
+  \brief Calculate the bounding rectangle of a series subset
+  Slow implementation, that iterates over the series.
+  \param series Series
+  \param from Index of the first sample, <= 0 means from the beginning
+  \param to Index of the last sample, < 0 means to the end
+  \return Bounding rectangle
+*/
+QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtOHLCSample>& series, int from, int to )
+{
+    return qwtBoundingRectT<QwtOHLCSample>( series, from, to );
+}
+/*!
+  \brief Calculate the bounding rectangle of a series subset
+  Slow implementation, that iterates over the series.
+  \param series Series
+  \param from Index of the first sample, <= 0 means from the beginning
+  \param to Index of the last sample, < 0 means to the end
+  \return Bounding rectangle
+*/
+QRectF qwtBoundingRect(
     const QwtSeriesData<QwtSetSample>& series, int from, int to )
+{
 …
 /*!
   \brief Calculate the bounding rect
+  \brief Calculate the bounding rectangle
   The bounding rectangle is calculated once by iterating over all
 …
 /*!
   \brief Calculate the bounding rect
+  \brief Calculate the bounding rectangle
   The bounding rectangle is calculated once by iterating over all
 …
 /*!
   \brief Calculate the bounding rect
+  \brief Calculate the bounding rectangle
   The bounding rectangle is calculated once by iterating over all
 …
 /*!
   \brief Calculate the bounding rect
+  \brief Calculate the bounding rectangle
   The bounding rectangle is calculated once by iterating over all
 …
 /*!
+  Constructor
+  \param x Array of x values
+  \param y Array of y values
+  \sa QwtPlotCurve::setData(), QwtPlotCurve::setSamples()
+*/
+QwtPointArrayData::QwtPointArrayData(
+        const QVector<double> &x, const QVector<double> &y ):
+    d_x( x ),
+    d_y( y )
+{
+}
+/*!
+  Constructor
+  \param x Array of x values
+  \param y Array of y values
+  \param size Size of the x and y arrays
+  \sa QwtPlotCurve::setData(), QwtPlotCurve::setSamples()
+*/
+QwtPointArrayData::QwtPointArrayData( const double *x,
+        const double *y, size_t size )
+{
+    d_x.resize( size );
+    qMemCopy( d_x.data(), x, size * sizeof( double ) );
+    d_y.resize( size );
+    qMemCopy( d_y.data(), y, size * sizeof( double ) );
+}
+/*!
+  \brief Calculate the bounding rect
+  The bounding rectangle is calculated once by iterating over all
+  points and is stored for all following requests.
+  \return Bounding rectangle
+*/
+QRectF QwtPointArrayData::boundingRect() const
+{
+    if ( d_boundingRect.width() < 0 )
+        d_boundingRect = qwtBoundingRect( *this );
+    return d_boundingRect;
+}
+//! \return Size of the data set
+size_t QwtPointArrayData::size() const
+{
+    return qMin( d_x.size(), d_y.size() );
+}
+/*!
+  Return the sample at position i
+  \param i Index
+  \return Sample at position i
+*/
+QPointF QwtPointArrayData::sample( size_t i ) const
+{
+    return QPointF( d_x[int( i )], d_y[int( i )] );
+}
+//! \return Array of the x-values
+const QVector<double> &QwtPointArrayData::xData() const
+{
+    return d_x;
+}
+//! \return Array of the y-values
+const QVector<double> &QwtPointArrayData::yData() const
+{
+    return d_y;
+}
+/*!
+  Constructor
+  \param x Array of x values
+  \param y Array of y values
+  \param size Size of the x and y arrays
+  \warning The programmer must assure that the memory blocks referenced
+           by the pointers remain valid during the lifetime of the
+           QwtPlotCPointer object.
+  \sa QwtPlotCurve::setData(), QwtPlotCurve::setRawSamples()
+*/
+QwtCPointerData::QwtCPointerData(
+        const double *x, const double *y, size_t size ):
+    d_x( x ),
+    d_y( y ),
+    d_size( size )
+{
+}
+/*!
+  \brief Calculate the bounding rect
+  The bounding rectangle is calculated once by iterating over all
+  points and is stored for all following requests.
+  \return Bounding rectangle
+*/
+QRectF QwtCPointerData::boundingRect() const
+{
+    if ( d_boundingRect.width() < 0 )
+        d_boundingRect = qwtBoundingRect( *this );
+    return d_boundingRect;
+}
+//! \return Size of the data set
+size_t QwtCPointerData::size() const
+{
+    return d_size;
+}
+/*!
+  Return the sample at position i
+  \param i Index
+  \return Sample at position i
+*/
+QPointF QwtCPointerData::sample( size_t i ) const
+{
+    return QPointF( d_x[int( i )], d_y[int( i )] );
+}
+//! \return Array of the x-values
+const double *QwtCPointerData::xData() const
+{
+    return d_x;
+}
+//! \return Array of the y-values
+const double *QwtCPointerData::yData() const
+{
+    return d_y;
+}
+/*!
+   Constructor
+   \param size Number of points
+   \param interval Bounding interval for the points
+   \sa setInterval(), setSize()
+*/
+QwtSyntheticPointData::QwtSyntheticPointData(
+        size_t size, const QwtInterval &interval ):
+    d_size( size ),
+    d_interval( interval )
+{
+}
+/*!
+  Change the number of points
+  \param size Number of points
+  \sa size(), setInterval()
+*/
+void QwtSyntheticPointData::setSize( size_t size )
+{
+    d_size = size;
+}
+/*!
+  \return Number of points
+  \sa setSize(), interval()
+*/
+size_t QwtSyntheticPointData::size() const
+{
+    return d_size;
+}
+/*!
+   Set the bounding interval
+   \param interval Interval
+   \sa interval(), setSize()
+*/
+void QwtSyntheticPointData::setInterval( const QwtInterval &interval )
+{
+    d_interval = interval.normalized();
+}
+/*!
+   \return Bounding interval
+   \sa setInterval(), size()
+*/
+QwtInterval QwtSyntheticPointData::interval() const
+{
+    return d_interval;
+}
+/*!
+   Set a the "rect of interest"
+   QwtPlotSeriesItem defines the current area of the plot canvas
+   as "rect of interest" ( QwtPlotSeriesItem::updateScaleDiv() ).
+   If interval().isValid() == false the x values are calculated
+   in the interval rect.left() -> rect.right().
+   \sa rectOfInterest()
+*/
+void QwtSyntheticPointData::setRectOfInterest( const QRectF &rect )
+{
+    d_rectOfInterest = rect;
+    d_intervalOfInterest = QwtInterval(
+        rect.left(), rect.right() ).normalized();
+}
+/*!
+   \return "rect of interest"
+   \sa setRectOfInterest()
+*/
+QRectF QwtSyntheticPointData::rectOfInterest() const
+{
+    return d_rectOfInterest;
+}
+/*!
+  \brief Calculate the bounding rect
+  This implementation iterates over all points, what could often
+  be implemented much faster using the characteristics of the series.
+  When there are many points it is recommended to overload and
+  reimplement this method using the characteristics of the series
+  ( if possible ).
+  \return Bounding rectangle
+*/
+QRectF QwtSyntheticPointData::boundingRect() const
+{
+    if ( d_size == 0 ||
+        !( d_interval.isValid() || d_intervalOfInterest.isValid() ) )
+    {
+        return QRectF(1.0, 1.0, -2.0, -2.0); // something invalid
+    }
+    return qwtBoundingRect( *this );
+}
+/*!
+   Calculate the point from an index
+   \param index Index
+   \return QPointF(x(index), y(x(index)));
+   \warning For invalid indices ( index < 0 || index >= size() )
+            (0, 0) is returned.
+*/
+QPointF QwtSyntheticPointData::sample( size_t index ) const
+{
+    if ( index >= d_size )
+        return QPointF( 0, 0 );
+    const double xValue = x( index );
+    const double yValue = y( xValue );
+    return QPointF( xValue, yValue );
+}
+/*!
+   Calculate a x-value from an index
+   x values are calculated by deviding an interval into
+   equidistant steps. If !interval().isValid() the
+   interval is calculated from the "rect of interest".
+   \sa interval(), rectOfInterest(), y()
+*/
+double QwtSyntheticPointData::x( uint index ) const
+{
+    const QwtInterval &interval = d_interval.isValid() ?
+        d_interval : d_intervalOfInterest;
+    if ( !interval.isValid() || d_size == 0 || index >= d_size )
+        return 0.0;
+    const double dx = interval.width() / d_size;
+    return interval.minValue() + index * dx;
+}
+   Constructor
+   \param samples Samples
+*/
+QwtTradingChartData::QwtTradingChartData(
+        const QVector<QwtOHLCSample> &samples ):
+    QwtArraySeriesData<QwtOHLCSample>( samples )
+{
+}
+/*!
+  \brief Calculate the bounding rectangle
+  The bounding rectangle is calculated once by iterating over all
+  points and is stored for all following requests.
+  \return Bounding rectangle
+*/
+QRectF QwtTradingChartData::boundingRect() const
+{
+    if ( d_boundingRect.width() < 0.0 )
+        d_boundingRect = qwtBoundingRect( *this );
+    return d_boundingRect;
+}

trunk/BNC/qwt/qwt_series_data.h

-              r4271
+              r8127
 #include "qwt_global.h"
 #include "qwt_interval.h"
+#include "qwt_samples.h"
 #include "qwt_point_3d.h"
 #include "qwt_point_polar.h"
 …
 #include <qrect.h>
-//! \brief A sample of the types (x1-x2, y) or (x, y1-y2)
-class QWT_EXPORT QwtIntervalSample
+{
-public:
-    QwtIntervalSample();
-    QwtIntervalSample( double, const QwtInterval & );
-    QwtIntervalSample( double value, double min, double max );
-    bool operator==( const QwtIntervalSample & ) const;
-    bool operator!=( const QwtIntervalSample & ) const;
-    //! Value
-    double value;
-    //! Interval
-    QwtInterval interval;
-};
-/*!
-  Constructor
-  The value is set to 0.0, the interval is invalid
-*/
-inline QwtIntervalSample::QwtIntervalSample():
-    value( 0.0 )
+{
+}
-//! Constructor
-inline QwtIntervalSample::QwtIntervalSample(
-        double v, const QwtInterval &intv ):
-    value( v ),
-    interval( intv )
+{
+}
-//! Constructor
-inline QwtIntervalSample::QwtIntervalSample(
-        double v, double min, double max ):
-    value( v ),
-    interval( min, max )
+{
+}
-//! Compare operator
-inline bool QwtIntervalSample::operator==(
-    const QwtIntervalSample &other ) const
+{
-    return value == other.value && interval == other.interval;
+}
-//! Compare operator
-inline bool QwtIntervalSample::operator!=(
-    const QwtIntervalSample &other ) const
+{
-    return !( *this == other );
+}
-//! \brief A sample of the types (x1...xn, y) or (x, y1..yn)
-class QWT_EXPORT QwtSetSample
+{
-public:
-    QwtSetSample();
-    bool operator==( const QwtSetSample &other ) const;
-    bool operator!=( const QwtSetSample &other ) const;
-    //! value
-    double value;
-    //! Vector of values associated to value
-    QVector<double> set;
-};
-/*!
-  Constructor
-  The value is set to 0.0
-*/
-inline QwtSetSample::QwtSetSample():
-    value( 0.0 )
+{
+}
-//! Compare operator
-inline bool QwtSetSample::operator==( const QwtSetSample &other ) const
+{
-    return value == other.value && set == other.set;
+}
-//! Compare operator
-inline bool QwtSetSample::operator!=( const QwtSetSample &other ) const
+{
-    return !( *this == other );
+}
 /*!
    \brief Abstract interface for iterating over samples
 …
    needs to be displayed, without having to copy it, it is recommended
    to implement an individual data access.
+   A subclass of QwtSeriesData<QPointF> must implement:
+   - size()\n
+     Should return number of data points.
+   - sample()\n
+     Should return values x and y values of the sample at specific position
+     as QPointF object.
+   - boundingRect()\n
+     Should return the bounding rectangle of the data series.
+     It is used for autoscaling and might help certain algorithms for displaying
+     the data. You can use qwtBoundingRect() for an implementation
+     but often it is possible to implement a more efficient algorithm
+     depending on the characteristics of the series.
+     The member d_boundingRect is intended for caching the calculated rectangle.
 */
 template <typename T>
 …
+{
 public:
+    //! Constructor
     QwtSeriesData();
+    //! Destructor
     virtual ~QwtSeriesData();
 …
        qwtBoundingRect(...) offers slow implementations iterating
        over the samples. For large sets it is recommended to implement
+       something faster f.e. by caching the bounding rect.
+       something faster f.e. by caching the bounding rectangle.
+       \return Bounding rectangle
      */
     virtual QRectF boundingRect() const = 0;
+    virtual void setRectOfInterest( const QRectF & );
+    /*!
+       Set a the "rect of interest"
+       QwtPlotSeriesItem defines the current area of the plot canvas
+       as "rectangle of interest" ( QwtPlotSeriesItem::updateScaleDiv() ).
+       It can be used to implement different levels of details.
+       The default implementation does nothing.
+       \param rect Rectangle of interest
+    */
+    virtual void setRectOfInterest( const QRectF &rect );
 protected:
 …
 };
-//! Constructor
 template <typename T>
 QwtSeriesData<T>::QwtSeriesData():
 …
+}
-//! Destructor
 template <typename T>
 QwtSeriesData<T>::~QwtSeriesData()
 …
+}
-/*!
-   Set a the "rect of interest"
-   QwtPlotSeriesItem defines the current area of the plot canvas
-   as "rect of interest" ( QwtPlotSeriesItem::updateScaleDiv() ).
-   It can be used to implement different levels of details.
-   The default implementation does nothing.
-*/
 template <typename T>
 void QwtSeriesData<T>::setRectOfInterest( const QRectF & )
 …
+{
 public:
+    //! Constructor
     QwtArraySeriesData();
+    QwtArraySeriesData( const QVector<T> & );
+    void setSamples( const QVector<T> & );
+    /*!
+       Constructor
+       \param samples Array of samples
+    */
+    QwtArraySeriesData( const QVector<T> &samples );
+    /*!
+      Assign an array of samples
+      \param samples Array of samples
+    */
+    void setSamples( const QVector<T> &samples );
+    //! \return Array of samples
     const QVector<T> samples() const;
+    //! \return Number of samples
     virtual size_t size() const;
+    virtual T sample( size_t ) const;
+    /*!
+      \return Sample at a specific position
+      \param index Index
+      \return Sample at position index
+    */
+    virtual T sample( size_t index ) const;
 protected:
 …
 };
-//! Constructor
 template <typename T>
 QwtArraySeriesData<T>::QwtArraySeriesData()
 …
+}
-/*!
-   Constructor
-   \param samples Array of samples
-*/
 template <typename T>
 QwtArraySeriesData<T>::QwtArraySeriesData( const QVector<T> &samples ):
 …
+}
-/*!
-  Assign an array of samples
-  \param samples Array of samples
-*/
 template <typename T>
 void QwtArraySeriesData<T>::setSamples( const QVector<T> &samples )
 …
+}
-//! \return Array of samples
 template <typename T>
 const QVector<T> QwtArraySeriesData<T>::samples() const
 …
+}
-//! \return Number of samples
 template <typename T>
 size_t QwtArraySeriesData<T>::size() const
 …
+}
-/*!
-  Return a sample
-  \param i Index
-  \return Sample at position i
-*/
 template <typename T>
 T QwtArraySeriesData<T>::sample( size_t i ) const
+{
     return d_samples[i];
+    return d_samples[ static_cast<int>( i ) ];
+}
 …
 /*!
   \brief Interface for iterating over two QVector<double> objects.
+    Interface for iterating over an array of OHLC samples
 */
+class QWT_EXPORT QwtPointArrayData: public QwtSeriesData<QPointF>
+{
+public:
+    QwtPointArrayData( const QVector<double> &x, const QVector<double> &y );
+    QwtPointArrayData( const double *x, const double *y, size_t size );
+    virtual QRectF boundingRect() const;
+    virtual size_t size() const;
+    virtual QPointF sample( size_t i ) const;
+    const QVector<double> &xData() const;
+    const QVector<double> &yData() const;
+private:
+    QVector<double> d_x;
+    QVector<double> d_y;
+};
+class QWT_EXPORT QwtTradingChartData: public QwtArraySeriesData<QwtOHLCSample>
+{
+public:
+    QwtTradingChartData(
+        const QVector<QwtOHLCSample> & = QVector<QwtOHLCSample>() );
+    virtual QRectF boundingRect() const;
+};
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QPointF> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtPoint3D> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtPointPolar> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtIntervalSample> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtSetSample> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtOHLCSample> &, int from = 0, int to = -1 );
 /*!
+  \brief Data class containing two pointers to memory blocks of doubles.
+ */
+class QWT_EXPORT QwtCPointerData: public QwtSeriesData<QPointF>
+{
+public:
+    QwtCPointerData( const double *x, const double *y, size_t size );
+    virtual QRectF boundingRect() const;
+    virtual size_t size() const;
+    virtual QPointF sample( size_t i ) const;
+    const double *xData() const;
+    const double *yData() const;
+private:
+    const double *d_x;
+    const double *d_y;
+    size_t d_size;
+};
+/*!
+  \brief Synthetic point data
+  QwtSyntheticPointData provides a fixed number of points for an interval.
+  The points are calculated in equidistant steps in x-direction.
+  If the interval is invalid, the points are calculated for
+  the "rect of interest", what normally is the displayed area on the
+  plot canvas. In this mode you get different levels of detail, when
+  zooming in/out.
+    Binary search for a sorted series of samples
+    qwtUpperSampleIndex returns the index of sample that is the upper bound
+    of value. Is the the value smaller than the smallest value the return
+    value will be 0. Is the value greater or equal than the largest
+    value the return value will be -1.
   \par Example
   The following example shows how to implement a sinus curve.
+    The following example shows finds a point of curve from an x
+    coordinate
   \verbatim
-#include <cmath>
 #include <qwt_series_data.h>
 #include <qwt_plot_curve.h>
+#include <qwt_plot.h>
+#include <qapplication.h>
+class SinusData: public QwtSyntheticPointData
+{
+public:
+    SinusData():
+        QwtSyntheticPointData(100)
+struct compareX
+{
+    inline bool operator()( const double x, const QPointF &pos ) const
+    {
+        return ( x < pos.x() );
+    }
+    virtual double y(double x) const
+};
+QLineF curveLineAt( const QwtPlotCurve *curve, double x )
+{
+    int index = qwtUpperSampleIndex<QPointF>(
+        *curve->data(), x, compareX() );
+    if ( index == -1 &&
+        x == curve->sample( curve->dataSize() - 1 ).x() )
+    {
+        // the last sample is excluded from qwtUpperSampleIndex
+        index = curve->dataSize() - 1;
+    }
+    QLineF line; // invalid
+    if ( index > 0 )
+    {
+        return qSin(x);
+        line.setP1( curve->sample( index - 1 ) );
+        line.setP2( curve->sample( index ) );
+    }
+};
+int main(int argc, char **argv)
+{
+    QApplication a(argc, argv);
+    QwtPlot plot;
+    plot.setAxisScale(QwtPlot::xBottom, 0.0, 10.0);
+    plot.setAxisScale(QwtPlot::yLeft, -1.0, 1.0);
+    QwtPlotCurve *curve = new QwtPlotCurve("y = sin(x)");
+    curve->setData(SinusData());
+    curve->attach(&plot);
+    plot.show();
+    return a.exec();
+}
+   \endverbatim
+*/
+class QWT_EXPORT QwtSyntheticPointData: public QwtSeriesData<QPointF>
+{
+public:
+    QwtSyntheticPointData( size_t size,
+        const QwtInterval & = QwtInterval() );
+    void setSize( size_t size );
+    size_t size() const;
+    void setInterval( const QwtInterval& );
+    QwtInterval interval() const;
+    virtual QRectF boundingRect() const;
+    virtual QPointF sample( size_t i ) const;
+    /*!
+       Calculate a y value for a x value
+       \param x x value
+       \return Corresponding y value
+     */
+    virtual double y( double x ) const = 0;
+    virtual double x( uint index ) const;
+    virtual void setRectOfInterest( const QRectF & );
+    QRectF rectOfInterest() const;
+private:
+    size_t d_size;
+    QwtInterval d_interval;
+    QRectF d_rectOfInterest;
+    QwtInterval d_intervalOfInterest;
+};
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QPointF> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtPoint3D> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtPointPolar> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtIntervalSample> &, int from = 0, int to = -1 );
+QWT_EXPORT QRectF qwtBoundingRect(
+    const QwtSeriesData<QwtSetSample> &, int from = 0, int to = -1 );
+#endif
+    return line;
+}
+\endverbatim
+    \param series Series of samples
+    \param value Value
+    \param lessThan Compare operation
+    \note The samples must be sorted according to the order specified
+          by the lessThan object
+of the range [begin, end) and returns the position of the one-past-the-last occurrence of value. If no such item is found, returns the position where the item should be inserted.
+ */
+template <typename T, typename LessThan>
+inline int qwtUpperSampleIndex( const QwtSeriesData<T> &series,
+    double value, LessThan lessThan  )
+{
+    const int indexMax = series.size() - 1;
+    if ( indexMax < 0 || !lessThan( value, series.sample( indexMax ) )  )
+        return -1;
+    int indexMin = 0;
+    int n = indexMax;
+    while ( n > 0 )
+    {
+        const int half = n >> 1;
+        const int indexMid = indexMin + half;
+        if ( lessThan( value, series.sample( indexMid ) ) )
+        {
+            n = half;
+        }
+        else
+        {
+            indexMin = indexMid + 1;
+            n -= half + 1;
+        }
+    }
+    return indexMin;
+}
+#endif

trunk/BNC/qwt/qwt_spline.cpp

-              r4271
+              r8127
 /*!
    Copy constructor
    \param other Spline used for initilization
+   \param other Spline used for initialization
 */
 QwtSpline::QwtSpline( const QwtSpline& other )
 …
 /*!
    Assignment operator
+   \param other Spline used for initilization
+   \param other Spline used for initialization
+   \return *this
 */
 QwtSpline &QwtSpline::operator=( const QwtSpline & other )
 …
 /*!
    Return points passed by setPoints
+   \return Points, that have been by setPoints()
 */
 QPolygonF QwtSpline::points() const
 …
   Calculate the interpolated function value corresponding
   to a given argument x.
+  \param x Coordinate
+  \return Interpolated coordinate
 */
 double QwtSpline::value( double x ) const

trunk/BNC/qwt/qwt_symbol.cpp

-              r4271
+              r8127
 #include "qwt_symbol.h"
 #include "qwt_painter.h"
+#include "qwt_graphic.h"
 #include <qapplication.h>
 #include <qpainter.h>
+#include <qpainterpath.h>
+#include <qpixmap.h>
+#include <qpaintengine.h>
 #include <qmath.h>
+#ifndef QWT_NO_SVG
+#include <qsvgrenderer.h>
+#endif
 namespace QwtTriangle
 …
         Down
     };
+}
+static QwtGraphic qwtPathGraphic( const QPainterPath &path,
+    const QPen &pen, const QBrush& brush )
+{
+    QwtGraphic graphic;
+    graphic.setRenderHint( QwtGraphic::RenderPensUnscaled );
+    QPainter painter( &graphic );
+    painter.setPen( pen );
+    painter.setBrush( brush );
+    painter.drawPath( path );
+    painter.end();
+    return graphic;
+}
+static inline QRectF qwtScaledBoundingRect(
+    const QwtGraphic &graphic, const QSizeF size )
+{
+    QSizeF scaledSize = size;
+    if ( scaledSize.isEmpty() )
+        scaledSize = graphic.defaultSize();
+    const QSizeF sz = graphic.controlPointRect().size();
+    double sx = 1.0;
+    if ( sz.width() > 0.0 )
+        sx = scaledSize.width() / sz.width();
+    double sy = 1.0;
+    if ( sz.height() > 0.0 )
+        sy = scaledSize.height() / sz.height();
+    return graphic.scaledBoundingRect( sx, sy );
+}
+static inline void qwtDrawPixmapSymbols( QPainter *painter,
+    const QPointF *points, int numPoints, const QwtSymbol &symbol )
+{
+    QSize size = symbol.size();
+    if ( size.isEmpty() )
+        size = symbol.pixmap().size();
+    const QTransform transform = painter->transform();
+    if ( transform.isScaling() )
+    {
+        const QRect r( 0, 0, size.width(), size.height() );
+        size = transform.mapRect( r ).size();
+    }
+    QPixmap pm = symbol.pixmap();
+    if ( pm.size() != size )
+        pm = pm.scaled( size );
+    QPointF pinPoint( 0.5 * size.width(), 0.5 * size.height() );
+    if ( symbol.isPinPointEnabled() )
+        pinPoint = symbol.pinPoint();
+    painter->resetTransform();
+    for ( int i = 0; i < numPoints; i++ )
+    {
+        const QPointF pos = transform.map( points[i] ) - pinPoint;
+        QwtPainter::drawPixmap( painter,
+            QRect( pos.toPoint(), pm.size() ), pm );
+    }
+}
+#ifndef QWT_NO_SVG
+static inline void qwtDrawSvgSymbols( QPainter *painter,
+    const QPointF *points, int numPoints,
+    QSvgRenderer *renderer, const QwtSymbol &symbol )
+{
+    if ( renderer == NULL || !renderer->isValid() )
+        return;
+    const QRectF viewBox = renderer->viewBoxF();
+    if ( viewBox.isEmpty() )
+        return;
+    QSizeF sz = symbol.size();
+    if ( !sz.isValid() )
+        sz = viewBox.size();
+    const double sx = sz.width() / viewBox.width();
+    const double sy = sz.height() / viewBox.height();
+    QPointF pinPoint = viewBox.center();
+    if ( symbol.isPinPointEnabled() )
+        pinPoint = symbol.pinPoint();
+    const double dx = sx * ( pinPoint.x() - viewBox.left() );
+    const double dy = sy * ( pinPoint.y() - viewBox.top() );
+    for ( int i = 0; i < numPoints; i++ )
+    {
+        const double x = points[i].x() - dx;
+        const double y = points[i].y() - dy;
+        renderer->render( painter,
+            QRectF( x, y, sz.width(), sz.height() ) );
+    }
+}
+#endif
+static inline void qwtDrawGraphicSymbols( QPainter *painter,
+    const QPointF *points, int numPoints, const QwtGraphic &graphic,
+    const QwtSymbol &symbol )
+{
+    const QRectF pointRect = graphic.controlPointRect();
+    if ( pointRect.isEmpty() )
+        return;
+    double sx = 1.0;
+    double sy = 1.0;
+    const QSize sz = symbol.size();
+    if ( sz.isValid() )
+    {
+        sx = sz.width() / pointRect.width();
+        sy = sz.height() / pointRect.height();
+    }
+    QPointF pinPoint = pointRect.center();
+    if ( symbol.isPinPointEnabled() )
+        pinPoint = symbol.pinPoint();
+    const QTransform transform = painter->transform();
+    for ( int i = 0; i < numPoints; i++ )
+    {
+        QTransform tr = transform;
+        tr.translate( points[i].x(), points[i].y() );
+        tr.scale( sx, sy );
+        tr.translate( -pinPoint.x(), -pinPoint.y() );
+        painter->setTransform( tr );
+        graphic.render( painter );
+    }
+    painter->setTransform( transform );
+}
 …
         size( sz ),
         brush( br ),
+        pen( pn )
+    {
+    }
+    bool operator==( const PrivateData &other ) const
+    {
+        return ( style == other.style )
+            && ( size == other.size )
+            && ( brush == other.brush )
+            && ( pen == other.pen );
+    }
+        pen( pn ),
+        isPinPointEnabled( false )
+    {
+        cache.policy = QwtSymbol::AutoCache;
+#ifndef QWT_NO_SVG
+        svg.renderer = NULL;
+#endif
+    }
+    ~PrivateData()
+    {
+#ifndef QWT_NO_SVG
+        delete svg.renderer;
+#endif
+    }
     Style style;
 …
     QBrush brush;
     QPen pen;
+    bool isPinPointEnabled;
+    QPointF pinPoint;
+    struct Path
+    {
+        QPainterPath path;
+        QwtGraphic graphic;
+    } path;
+    struct Pixmap
+    {
+        QPixmap pixmap;
+    } pixmap;
+    struct Graphic
+    {
+        QwtGraphic graphic;
+    } graphic;
+#ifndef QWT_NO_SVG
+    struct SVG
+    {
+        QSvgRenderer *renderer;
+    } svg;
+#endif
+    struct PaintCache
+    {
+        QwtSymbol::CachePolicy policy;
+        QPixmap pixmap;
+    } cache;
 };
 …
+{
     d_data = new PrivateData( style, QBrush( Qt::gray ),
         QPen( Qt::black ), QSize( 0.0, 0.0 ) );
+        QPen( Qt::black, 0 ), QSize() );
+}
 …
 /*!
+  \brief Copy constructor
+  \param other Symbol
+  \brief Constructor
+  The symbol gets initialized by a painter path. The style is
+  set to QwtSymbol::Path, the size is set to empty ( the path
+  is displayed unscaled ).
+  \param path painter path
+  \param brush brush to fill the interior
+  \param pen outline pen
+  \sa setPath(), setBrush(), setPen(), setSize()
 */
+QwtSymbol::QwtSymbol( const QwtSymbol &other )
+{
+    d_data = new PrivateData( other.style(), other.brush(),
+        other.pen(), other.size() );
+};
+QwtSymbol::QwtSymbol( const QPainterPath &path,
+    const QBrush &brush, const QPen &pen )
+{
+    d_data = new PrivateData( QwtSymbol::Path, brush, pen, QSize() );
+    setPath( path );
+}
 //! Destructor
 …
+}
+//! \brief Assignment operator
+QwtSymbol &QwtSymbol::operator=( const QwtSymbol &other )
+{
+    *d_data = *other.d_data;
+    return *this;
+}
+//! \brief Compare two symbols
+bool QwtSymbol::operator==( const QwtSymbol &other ) const
+{
+    return *d_data == *other.d_data;
+}
+//! \brief Compare two symbols
+bool QwtSymbol::operator!=( const QwtSymbol &other ) const
+{
+    return !( *d_data == *other.d_data );
+}
+/*!
+  Change the cache policy
+  The default policy is AutoCache
+  \param policy Cache policy
+  \sa CachePolicy, cachePolicy()
+*/
+void QwtSymbol::setCachePolicy(
+    QwtSymbol::CachePolicy policy )
+{
+    if ( d_data->cache.policy != policy )
+    {
+        d_data->cache.policy = policy;
+        invalidateCache();
+    }
+}
+/*!
+  \return Cache policy
+  \sa CachePolicy, setCachePolicy()
+*/
+QwtSymbol::CachePolicy QwtSymbol::cachePolicy() const
+{
+    return d_data->cache.policy;
+}
+/*!
+  \brief Set a painter path as symbol
+  The symbol is represented by a painter path, where the
+  origin ( 0, 0 ) of the path coordinate system is mapped to
+  the position of the symbol.
+  When the symbol has valid size the painter path gets scaled
+  to fit into the size. Otherwise the symbol size depends on
+  the bounding rectangle of the path.
+  The following code defines a symbol drawing an arrow:
+  \verbatim
+#include <qwt_symbol.h>
+QwtSymbol *symbol = new QwtSymbol();
+QPen pen( Qt::black, 2 );
+pen.setJoinStyle( Qt::MiterJoin );
+symbol->setPen( pen );
+symbol->setBrush( Qt::red );
+QPainterPath path;
+path.moveTo( 0, 8 );
+path.lineTo( 0, 5 );
+path.lineTo( -3, 5 );
+path.lineTo( 0, 0 );
+path.lineTo( 3, 5 );
+path.lineTo( 0, 5 );
+QTransform transform;
+transform.rotate( -30.0 );
+path = transform.map( path );
+symbol->setPath( path );
+symbol->setPinPoint( QPointF( 0.0, 0.0 ) );
+setSize( 10, 14 );
+\endverbatim
+  \param path Painter path
+  \note The style is implicitely set to QwtSymbol::Path.
+  \sa path(), setSize()
+ */
+void QwtSymbol::setPath( const QPainterPath &path )
+{
+    d_data->style = QwtSymbol::Path;
+    d_data->path.path = path;
+    d_data->path.graphic.reset();
+}
+/*!
+   \return Painter path for displaying the symbol
+   \sa setPath()
+*/
+const QPainterPath &QwtSymbol::path() const
+{
+    return d_data->path.path;
+}
+/*!
+  Set a pixmap as symbol
+  \param pixmap Pixmap
+  \sa pixmap(), setGraphic()
+  \note the style() is set to QwtSymbol::Pixmap
+  \note brush() and pen() have no effect
+ */
+void QwtSymbol::setPixmap( const QPixmap &pixmap )
+{
+    d_data->style = QwtSymbol::Pixmap;
+    d_data->pixmap.pixmap = pixmap;
+}
+/*!
+  \return Assigned pixmap
+  \sa setPixmap()
+ */
+const QPixmap &QwtSymbol::pixmap() const
+{
+    return d_data->pixmap.pixmap;
+}
+/*!
+  Set a graphic as symbol
+  \param graphic Graphic
+  \sa graphic(), setPixmap()
+  \note the style() is set to QwtSymbol::Graphic
+  \note brush() and pen() have no effect
+ */
+void QwtSymbol::setGraphic( const QwtGraphic &graphic )
+{
+    d_data->style = QwtSymbol::Graphic;
+    d_data->graphic.graphic = graphic;
+}
+/*!
+  \return Assigned graphic
+  \sa setGraphic()
+ */
+const QwtGraphic &QwtSymbol::graphic() const
+{
+    return d_data->graphic.graphic;
+}
+#ifndef QWT_NO_SVG
+/*!
+  Set a SVG icon as symbol
+  \param svgDocument SVG icon
+  \sa setGraphic(), setPixmap()
+  \note the style() is set to QwtSymbol::SvgDocument
+  \note brush() and pen() have no effect
+ */
+void QwtSymbol::setSvgDocument( const QByteArray &svgDocument )
+{
+    d_data->style = QwtSymbol::SvgDocument;
+    if ( d_data->svg.renderer == NULL )
+        d_data->svg.renderer = new QSvgRenderer();
+    d_data->svg.renderer->load( svgDocument );
+}
+#endif
 /*!
 …
   and the 'w' parameter is greater than or equal to 0,
   the symbol size will be set to (w,w).
   \param width Width
   \param height Height (defaults to -1)
 …
         height = width;
     d_data->size = QSize( width, height );
+    setSize( QSize( width, height ) );
+}
 …
 void QwtSymbol::setSize( const QSize &size )
+{
+    if ( size.isValid() )
+    if ( size.isValid() && size != d_data->size )
+    {
         d_data->size = size;
+        invalidateCache();
+    }
+}
 …
 void QwtSymbol::setBrush( const QBrush &brush )
+{
+    d_data->brush = brush;
+    if ( brush != d_data->brush )
+    {
+        d_data->brush = brush;
+        invalidateCache();
+        if ( d_data->style == QwtSymbol::Path )
+            d_data->path.graphic.reset();
+    }
+}
 …
 /*!
+  Build and assign a pen
+  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 )
+  what makes it non cosmetic ( see QPen::isCosmetic() ).
+  This method has been introduced to hide this incompatibility.
+  \param color Pen color
+  \param width Pen width
+  \param style Pen style
+  \sa pen(), brush()
+ */
+void QwtSymbol::setPen( const QColor &color,
+    qreal width, Qt::PenStyle style )
+{
+    setPen( QPen( color, width, style ) );
+}
+/*!
   Assign a pen
 …
 void QwtSymbol::setPen( const QPen &pen )
+{
+    d_data->pen = pen;
+    if ( pen != d_data->pen )
+    {
+        d_data->pen = pen;
+        invalidateCache();
+        if ( d_data->style == QwtSymbol::Path )
+            d_data->path.graphic.reset();
+    }
+}
 …
         case QwtSymbol::Hexagon:
+        {
+            d_data->brush.setColor( color );
+            if ( d_data->brush.color() != color )
+            {
+                d_data->brush.setColor( color );
+                invalidateCache();
+            }
             break;
+        }
 …
         case QwtSymbol::Star1:
+        {
+            d_data->pen.setColor( color );
+            if ( d_data->pen.color() != color )
+            {
+                d_data->pen.setColor( color );
+                invalidateCache();
+            }
             break;
+        }
         default:
+        {
+            if ( d_data->brush.color() != color ||
+                d_data->pen.color() != color )
+            {
+                invalidateCache();
+            }
             d_data->brush.setColor( color );
             d_data->pen.setColor( color );
 …
 /*!
+  Draw an array of symbols
+  \brief Set and enable a pin point
+  The position of a complex symbol is not always aligned to its center
+  ( f.e an arrow, where the peak points to a position ). The pin point
+  defines the position inside of a Pixmap, Graphic, SvgDocument
+  or PainterPath symbol where the represented point has to
+  be aligned to.
+  \param pos Position
+  \param enable En/Disable the pin point alignment
+  \sa pinPoint(), setPinPointEnabled()
+ */
+void QwtSymbol::setPinPoint( const QPointF &pos, bool enable )
+{
+    if ( d_data->pinPoint != pos )
+    {
+        d_data->pinPoint = pos;
+        if ( d_data->isPinPointEnabled )
+        {
+            invalidateCache();
+        }
+    }
+    setPinPointEnabled( enable );
+}
+/*!
+  \return Pin point
+  \sa setPinPoint(), setPinPointEnabled()
+ */
+QPointF QwtSymbol::pinPoint() const
+{
+    return d_data->pinPoint;
+}
+/*!
+  En/Disable the pin point alignment
+  \param on Enabled, when on is true
+  \sa setPinPoint(), isPinPointEnabled()
+ */
+void QwtSymbol::setPinPointEnabled( bool on )
+{
+    if ( d_data->isPinPointEnabled != on )
+    {
+        d_data->isPinPointEnabled = on;
+        invalidateCache();
+    }
+}
+/*!
+  \return True, when the pin point translation is enabled
+  \sa setPinPoint(), setPinPointEnabled()
+ */
+bool QwtSymbol::isPinPointEnabled() const
+{
+    return d_data->isPinPointEnabled;
+}
+/*!
+  Render an array of symbols
   Painting several symbols is more effective than drawing symbols
 …
         return;
+    painter->save();
+    bool useCache = false;
+    // Don't use the pixmap, when the paint device
+    // could generate scalable vectors
+    if ( QwtPainter::roundingAlignment( painter ) &&
+        !painter->transform().isScaling() )
+    {
+        if ( d_data->cache.policy == QwtSymbol::Cache )
+        {
+            useCache = true;
+        }
+        else if ( d_data->cache.policy == QwtSymbol::AutoCache )
+        {
+            if ( painter->paintEngine()->type() == QPaintEngine::Raster )
+            {
+                useCache = true;
+            }
+            else
+            {
+                switch( d_data->style )
+                {
+                    case QwtSymbol::XCross:
+                    case QwtSymbol::HLine:
+                    case QwtSymbol::VLine:
+                    case QwtSymbol::Cross:
+                        break;
+                    case QwtSymbol::Pixmap:
+                    {
+                        if ( !d_data->size.isEmpty() &&
+                            d_data->size != d_data->pixmap.pixmap.size() )
+                        {
+                            useCache = true;
+                        }
+                        break;
+                    }
+                    default:
+                        useCache = true;
+                }
+            }
+        }
+    }
+    if ( useCache )
+    {
+        const QRect br = boundingRect();
+        const QRect rect( 0, 0, br.width(), br.height() );
+        if ( d_data->cache.pixmap.isNull() )
+        {
+            d_data->cache.pixmap = QwtPainter::backingStore( NULL, br.size() );
+            d_data->cache.pixmap.fill( Qt::transparent );
+            QPainter p( &d_data->cache.pixmap );
+            p.setRenderHints( painter->renderHints() );
+            p.translate( -br.topLeft() );
+            const QPointF pos;
+            renderSymbols( &p, &pos, 1 );
+        }
+        const int dx = br.left();
+        const int dy = br.top();
+        for ( int i = 0; i < numPoints; i++ )
+        {
+            const int left = qRound( points[i].x() ) + dx;
+            const int top = qRound( points[i].y() ) + dy;
+            painter->drawPixmap( left, top, d_data->cache.pixmap );
+        }
+    }
+    else
+    {
+        painter->save();
+        renderSymbols( painter, points, numPoints );
+        painter->restore();
+    }
+}
+/*!
+  \brief Draw the symbol into a rectangle
+  The symbol is painted centered and scaled into the target rectangle.
+  It is always painted uncached and the pin point is ignored.
+  This method is primarily intended for drawing a symbol to
+  the legend.
+  \param painter Painter
+  \param rect Target rectangle for the symbol
+*/
+void QwtSymbol::drawSymbol( QPainter *painter, const QRectF &rect ) const
+{
+    if ( d_data->style == QwtSymbol::NoSymbol )
+        return;
+    if ( d_data->style == QwtSymbol::Graphic )
+    {
+        d_data->graphic.graphic.render(
+            painter, rect, Qt::KeepAspectRatio );
+    }
+    else if ( d_data->style == QwtSymbol::Path )
+    {
+        if ( d_data->path.graphic.isNull() )
+        {
+            d_data->path.graphic = qwtPathGraphic(
+                d_data->path.path, d_data->pen, d_data->brush );
+        }
+        d_data->path.graphic.render(
+            painter, rect, Qt::KeepAspectRatio );
+        return;
+    }
+    else if ( d_data->style == QwtSymbol::SvgDocument )
+    {
+#ifndef QWT_NO_SVG
+        if ( d_data->svg.renderer )
+        {
+            QRectF scaledRect;
+            QSizeF sz = d_data->svg.renderer->viewBoxF().size();
+            if ( !sz.isEmpty() )
+            {
+                sz.scale( rect.size(), Qt::KeepAspectRatio );
+                scaledRect.setSize( sz );
+                scaledRect.moveCenter( rect.center() );
+            }
+            else
+            {
+                scaledRect = rect;
+            }
+            d_data->svg.renderer->render(
+                painter, scaledRect );
+        }
+#endif
+    }
+    else
+    {
+        const QRect br = boundingRect();
+        // scale the symbol size to fit into rect.
+        const double ratio = qMin( rect.width() / br.width(),
+            rect.height() / br.height() );
+        painter->save();
+        painter->translate( rect.center() );
+        painter->scale( ratio, ratio );
+        const bool isPinPointEnabled = d_data->isPinPointEnabled;
+        d_data->isPinPointEnabled = false;
+        const QPointF pos;
+        renderSymbols( painter, &pos, 1 );
+        d_data->isPinPointEnabled = isPinPointEnabled;
+        painter->restore();
+    }
+}
+/*!
+  Render the symbol to series of points
+  \param painter Qt painter
+  \param points Positions of the symbols
+  \param numPoints Number of points
+ */
+void QwtSymbol::renderSymbols( QPainter *painter,
+    const QPointF *points, int numPoints ) const
+{
     switch ( d_data->style )
+    {
 …
             break;
+        }
+        case QwtSymbol::Path:
+        {
+            if ( d_data->path.graphic.isNull() )
+            {
+                d_data->path.graphic = qwtPathGraphic( d_data->path.path,
+                    d_data->pen, d_data->brush );
+            }
+            qwtDrawGraphicSymbols( painter, points, numPoints,
+                d_data->path.graphic, *this );
+            break;
+        }
+        case QwtSymbol::Pixmap:
+        {
+            qwtDrawPixmapSymbols( painter, points, numPoints, *this );
+            break;
+        }
+        case QwtSymbol::Graphic:
+        {
+            qwtDrawGraphicSymbols( painter, points, numPoints,
+                d_data->graphic.graphic, *this );
+            break;
+        }
+        case QwtSymbol::SvgDocument:
+        {
+#ifndef QWT_NO_SVG
+            qwtDrawSvgSymbols( painter, points, numPoints,
+                d_data->svg.renderer, *this );
+#endif
+            break;
+        }
         default:;
+    }
+    painter->restore();
+}
+//!  \return Size of the bounding rectangle of a symbol
+QSize QwtSymbol::boundingSize() const
+{
+    QSize size;
+}
+/*!
+  Calculate the bounding rectangle for a symbol
+  at position (0,0).
+  \return Bounding rectangle
+ */
+QRect QwtSymbol::boundingRect() const
+{
+    QRectF rect;
+    bool pinPointTranslation = false;
     switch ( d_data->style )
 …
                 pw = qMax( d_data->pen.widthF(), qreal( 1.0 ) );
+            size = d_data->size + QSize( pw, pw );
+            rect.setSize( d_data->size + QSizeF( pw, pw ) );
+            rect.moveCenter( QPointF( 0.0, 0.0 ) );
             break;
 …
                 pw = qMax( d_data->pen.widthF(), qreal( 1.0 ) );
+            size = d_data->size + QSize( 2 * pw, 2 * pw );
+            break;
+        }
+            rect.setSize( d_data->size + QSizeF( 2 * pw, 2 * pw ) );
+            rect.moveCenter( QPointF( 0.0, 0.0 ) );
+            break;
+        }
+        case QwtSymbol::Path:
+        {
+            if ( d_data->path.graphic.isNull() )
+            {
+                d_data->path.graphic = qwtPathGraphic(
+                    d_data->path.path, d_data->pen, d_data->brush );
+            }
+            rect = qwtScaledBoundingRect(
+                d_data->path.graphic, d_data->size );
+            pinPointTranslation = true;
+            break;
+        }
+        case QwtSymbol::Pixmap:
+        {
+            if ( d_data->size.isEmpty() )
+                rect.setSize( d_data->pixmap.pixmap.size() );
+            else
+                rect.setSize( d_data->size );
+            pinPointTranslation = true;
+            break;
+        }
+        case QwtSymbol::Graphic:
+        {
+            rect = qwtScaledBoundingRect(
+                d_data->graphic.graphic, d_data->size );
+            pinPointTranslation = true;
+            break;
+        }
+#ifndef QWT_NO_SVG
+        case QwtSymbol::SvgDocument:
+        {
+            if ( d_data->svg.renderer )
+                rect = d_data->svg.renderer->viewBoxF();
+            if ( d_data->size.isValid() && !rect.isEmpty() )
+            {
+                QSizeF sz = rect.size();
+                const double sx = d_data->size.width() / sz.width();
+                const double sy = d_data->size.height() / sz.height();
+                QTransform transform;
+                transform.scale( sx, sy );
+                rect = transform.mapRect( rect );
+            }
+            pinPointTranslation = true;
+            break;
+        }
+#endif
         default:
+        {
+            size = d_data->size;
+        }
+    }
+    return size + QSize( 1, 1 ); // for antialiasing
+            rect.setSize( d_data->size );
+            rect.moveCenter( QPointF( 0.0, 0.0 ) );
+        }
+    }
+    if ( pinPointTranslation )
+    {
+        QPointF pinPoint( 0.0, 0.0 );
+        if ( d_data->isPinPointEnabled )
+            pinPoint = rect.center() - d_data->pinPoint;
+        rect.moveCenter( pinPoint );
+    }
+    QRect r;
+    r.setLeft( qFloor( rect.left() ) );
+    r.setTop( qFloor( rect.top() ) );
+    r.setRight( qCeil( rect.right() ) );
+    r.setBottom( qCeil( rect.bottom() ) );
+    if ( d_data->style != QwtSymbol::Pixmap )
+        r.adjust( -1, -1, 1, 1 ); // for antialiasing
+    return r;
+}
+/*!
+  Invalidate the cached symbol pixmap
+  The symbol invalidates its cache, whenever an attribute is changed
+  that has an effect ob how to display a symbol. In case of derived
+  classes with individual styles ( >= QwtSymbol::UserStyle ) it
+  might be necessary to call invalidateCache() for attributes
+  that are relevant for this style.
+  \sa CachePolicy, setCachePolicy(), drawSymbols()
+ */
+void QwtSymbol::invalidateCache()
+{
+    if ( !d_data->cache.pixmap.isNull() )
+        d_data->cache.pixmap = QPixmap();
+}
 …
 void QwtSymbol::setStyle( QwtSymbol::Style style )
+{
+    d_data->style = style;
+    if ( d_data->style != style )
+    {
+        d_data->style = style;
+        invalidateCache();
+    }
+}

trunk/BNC/qwt/qwt_symbol.h

-              r4271
+              r8127
 #include "qwt_global.h"
 #include <QPolygonF>
+#include <qpolygon.h>
 class QPainter;
 …
 class QColor;
 class QPointF;
+class QPolygonF;
+class QPainterPath;
+class QPixmap;
+class QByteArray;
+class QwtGraphic;
 //! A class for drawing symbols
 …
         /*!
+          The symbol is represented by a painter path, where the
+          origin ( 0, 0 ) of the path coordinate system is mapped to
+          the position of the symbol.
+          \sa setPath(), path()
+         */
+        Path,
+        /*!
+          The symbol is represented by a pixmap. The pixmap is centered
+          or aligned to its pin point.
+          \sa setPinPoint()
+         */
+        Pixmap,
+        /*!
+          The symbol is represented by a graphic. The graphic is centered
+          or aligned to its pin point.
+          \sa setPinPoint()
+         */
+        Graphic,
+        /*!
+          The symbol is represented by a SVG graphic. The graphic is centered
+          or aligned to its pin point.
+          \sa setPinPoint()
+         */
+        SvgDocument,
+        /*!
          Styles >= QwtSymbol::UserSymbol are reserved for derived
          classes of QwtSymbol that overload drawSymbols() with
 …
     };
+    /*!
+      Depending on the render engine and the complexity of the
+      symbol shape it might be faster to render the symbol
+      to a pixmap and to paint this pixmap.
+      F.e. the raster paint engine is a pure software renderer
+      where in cache mode a draw operation usually ends in
+      raster operation with the the backing store, that are usually
+      faster, than the algorithms for rendering polygons.
+      But the opposite can be expected for graphic pipelines
+      that can make use of hardware acceleration.
+      The default setting is AutoCache
+      \sa setCachePolicy(), cachePolicy()
+      \note The policy has no effect, when the symbol is painted
+            to a vector graphics format ( PDF, SVG ).
+      \warning Since Qt 4.8 raster is the default backend on X11
+     */
+    enum CachePolicy
+    {
+        //! Don't use a pixmap cache
+        NoCache,
+        //! Always use a pixmap cache
+        Cache,
+        /*!
+           Use a cache when one of the following conditions is true:
+           - The symbol is rendered with the software
+             renderer ( QPaintEngine::Raster )
+         */
+        AutoCache
+    };
 public:
     QwtSymbol( Style = NoSymbol );
     QwtSymbol( Style, const QBrush &, const QPen &, const QSize & );
+    QwtSymbol( const QwtSymbol & );
+    QwtSymbol( const QPainterPath &, const QBrush &, const QPen & );
     virtual ~QwtSymbol();
+    QwtSymbol &operator=( const QwtSymbol & );
+    bool operator==( const QwtSymbol & ) const;
+    bool operator!=( const QwtSymbol & ) const;
+    void setCachePolicy( CachePolicy );
+    CachePolicy cachePolicy() const;
     void setSize( const QSize & );
 …
     const QSize& size() const;
+    void setPinPoint( const QPointF &pos, bool enable = true );
+    QPointF pinPoint() const;
+    void setPinPointEnabled( bool );
+    bool isPinPointEnabled() const;
     virtual void setColor( const QColor & );
 …
     const QBrush& brush() const;
+    void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setPen( const QPen & );
     const QPen& pen() const;
 …
     Style style() const;
+    void setPath( const QPainterPath & );
+    const QPainterPath &path() const;
+    void setPixmap( const QPixmap & );
+    const QPixmap &pixmap() const;
+    void setGraphic( const QwtGraphic & );
+    const QwtGraphic &graphic() const;
+#ifndef QWT_NO_SVG
+    void setSvgDocument( const QByteArray & );
+#endif
+    void drawSymbol( QPainter *, const QRectF & ) const;
     void drawSymbol( QPainter *, const QPointF & ) const;
     void drawSymbols( QPainter *, const QPolygonF & ) const;
+    virtual QSize boundingSize() const;
+    void drawSymbols( QPainter *,
+        const QPointF *, int numPoints ) const;
+    virtual QRect boundingRect() const;
+    void invalidateCache();
 protected:
     virtual void drawSymbols( QPainter *,
+    virtual void renderSymbols( QPainter *,
         const QPointF *, int numPoints ) const;
 private:
+    // Disabled copy constructor and operator=
+    QwtSymbol( const QwtSymbol & );
+    QwtSymbol &operator=( const QwtSymbol & );
     class PrivateData;
     PrivateData *d_data;

trunk/BNC/qwt/qwt_system_clock.cpp

-              r4271
+              r8127
 #include "qwt_system_clock.h"
+#if QT_VERSION >= 0x040800
+#define USE_ELAPSED_TIMER 1
+#endif
+#if USE_ELAPSED_TIMER
+#include <qelapsedtimer.h>
+class QwtSystemClock::PrivateData
+{
+public:
+    QElapsedTimer timer;
+};
+QwtSystemClock::QwtSystemClock()
+{
+    d_data = new PrivateData();
+}
+QwtSystemClock::~QwtSystemClock()
+{
+    delete d_data;
+}
+bool QwtSystemClock::isNull() const
+{
+    return d_data->timer.isValid();
+}
+void QwtSystemClock::start()
+{
+    d_data->timer.start();
+}
+double QwtSystemClock::restart()
+{
+    const qint64 nsecs = d_data->timer.restart();
+    return nsecs / 1e6;
+}
+double QwtSystemClock::elapsed() const
+{
+    const qint64 nsecs = d_data->timer.nsecsElapsed();
+    return nsecs / 1e6;
+}
+#else // !USE_ELAPSED_TIMER
 #include <qdatetime.h>
 …
         kern_return_t err = mach_timebase_info( &info );
         //Convert the timebase into ms
+        // convert the timebase into ms
         if ( err == 0  )
             conversion = 1e-6 * ( double ) info.numer / ( double ) info.denom;
 …
 /*!
+  The start time to the current time and
+  return the time, that is elapsed since the
+  previous start time.
+  Set the start time to the current time
+  \return Time, that is elapsed since the previous start time.
 */
 double QwtSystemClock::restart()
 …
+}
+/*!
+  \return Accuracy of the system clock in milliseconds.
+*/
+double QwtSystemClock::precision()
+{
+    static double prec = 0.0;
+    if ( prec <= 0.0 )
+    {
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+        prec = QwtHighResolutionClock::precision();
+#endif
+        if ( prec <= 0.0 )
+            prec = 1.0; // QTime offers 1 ms
+    }
+    return prec;
+}
+#endif

trunk/BNC/qwt/qwt_system_clock.h

r4271	r8127
40	40	double elapsed() const;
41	41
42		~~static double precision();~~
43
44	42	private:
45	43	class PrivateData;

trunk/BNC/qwt/qwt_text.cpp

-              r4271
+              r8127
  * Qwt Widget Library
  * Copyright (C) 1997   Josef Wilgen
  * Copyright (C) 2003   Uwe Rathmann
+ * Copyright (C) 2002   Uwe Rathmann
+ *
  * This library is free software; you can redistribute it and/or
 …
     PrivateData():
         renderFlags( Qt::AlignCenter ),
+        backgroundPen( Qt::NoPen ),
+        borderRadius( 0 ),
+        borderPen( Qt::NoPen ),
         backgroundBrush( Qt::NoBrush ),
         paintAttributes( 0 ),
 …
     QFont font;
     QColor color;
+    QPen backgroundPen;
+    double borderRadius;
+    QPen borderPen;
     QBrush backgroundBrush;
 …
         d_data->font == other.d_data->font &&
         d_data->color == other.d_data->color &&
+        d_data->backgroundPen == other.d_data->backgroundPen &&
+        d_data->borderRadius == other.d_data->borderRadius &&
+        d_data->borderPen == other.d_data->borderPen &&
         d_data->backgroundBrush == other.d_data->backgroundBrush &&
         d_data->paintAttributes == other.d_data->paintAttributes &&
 …
 /*!
    Return the text.
+   \return Text as QString.
    \sa setText()
 */
 …
    The default setting is Qt::AlignCenter
    \param renderFlags Bitwise OR of the flags used like in QPainter::drawText
+   \param renderFlags Bitwise OR of the flags used like in QPainter::drawText()
    \sa renderFlags(), QwtTextEngine::draw()
 …
 /*!
+  Return the font of the text, if it has one.
+  Otherwise return defaultFont.
+  \param defaultFont Default font
+  \sa setFont(), font(), PaintAttributes
+   Return the font of the text, if it has one.
+   Otherwise return defaultFont.
+   \param defaultFont Default font
+   \return Font used for drawing the text
+   \sa setFont(), font(), PaintAttributes
 */
 QFont QwtText::usedFont( const QFont &defaultFont ) const
 …
 /*!
    Set the pen color used for painting the text.
+   Set the pen color used for drawing the text.
    \param color Color
 …
   \param defaultColor Default color
+  \return Color used for drawing the text
   \sa setColor(), color(), PaintAttributes
 */
 …
 /*!
+  Set the radius for the corners of the border frame
+  \param radius Radius of a rounded corner
+  \sa borderRadius(), setBorderPen(), setBackgroundBrush()
+*/
+void QwtText::setBorderRadius( double radius )
+{
+    d_data->borderRadius = qMax( 0.0, radius );
+}
+/*!
+  \return Radius for the corners of the border frame
+  \sa setBorderRadius(), borderPen(), backgroundBrush()
+*/
+double QwtText::borderRadius() const
+{
+    return d_data->borderRadius;
+}
+/*!
    Set the background pen
    \param pen Background pen
    \sa backgroundPen(), setBackgroundBrush()
 */
 void QwtText::setBackgroundPen( const QPen &pen )
+{
     d_data->backgroundPen = pen;
+   \sa borderPen(), setBackgroundBrush()
+*/
+void QwtText::setBorderPen( const QPen &pen )
+{
+    d_data->borderPen = pen;
     setPaintAttribute( PaintBackground );
+}
 …
 /*!
    \return Background pen
    \sa setBackgroundPen(), backgroundBrush()
 */
 QPen QwtText::backgroundPen() const
+{
     return d_data->backgroundPen;
+   \sa setBorderPen(), backgroundBrush()
+*/
+QPen QwtText::borderPen() const
+{
+    return d_data->borderPen;
+}
 …
    \param brush Background brush
    \sa backgroundBrush(), setBackgroundPen()
+   \sa backgroundBrush(), setBorderPen()
 */
 void QwtText::setBackgroundBrush( const QBrush &brush )
 …
 /*!
    \return Background brush
    \sa setBackgroundBrush(), backgroundPen()
+   \sa setBackgroundBrush(), borderPen()
 */
 QBrush QwtText::backgroundBrush() const
 …
    \note Used by setFont(), setColor(),
          setBackgroundPen() and setBackgroundBrush()
+         setBorderPen() and setBackgroundBrush()
    \sa testPaintAttribute()
 */
 …
 /*!
-   Find the height for a given width
-   \param defaultFont Font, used for the calculation if the text has no font
-   \return Calculated height
-*/
-/*!
    Returns the size, that is needed to render text
    \param defaultFont Font of the text
    \return Caluclated size
+   \return Calculated size
 */
 QSizeF QwtText::textSize( const QFont &defaultFont ) const
 …
     if ( d_data->paintAttributes & PaintBackground )
+    {
         if ( d_data->backgroundPen != Qt::NoPen ||
+        if ( d_data->borderPen != Qt::NoPen ||
             d_data->backgroundBrush != Qt::NoBrush )
+        {
             painter->save();
+            painter->setPen( d_data->backgroundPen );
+            painter->setPen( d_data->borderPen );
             painter->setBrush( d_data->backgroundBrush );
+            QwtPainter::drawRect( painter, rect );
+            if ( d_data->borderRadius == 0 )
+            {
+                QwtPainter::drawRect( painter, rect );
+            }
+            else
+            {
+                painter->setRenderHint( QPainter::Antialiasing, true );
+                painter->drawRoundedRect( rect,
+                    d_data->borderRadius, d_data->borderRadius );
+            }
             painter->restore();
+        }
 …
    In case of QwtText::AutoText the first text engine
    (beside QwtPlainTextEngine) is returned, where QwtTextEngine::mightRender
    returns true. If there is none QwtPlainTextEngine is returnd.
+   returns true. If there is none QwtPlainTextEngine is returned.
    If no text engine is registered for the format QwtPlainTextEngine
 …
    \param text Text, needed in case of AutoText
    \param format Text format
+   \return Corresponding text engine
 */
 const QwtTextEngine *QwtText::textEngine( const QString &text,

trunk/BNC/qwt/qwt_text.h

-              r4271
+              r8127
  * Qwt Widget Library
  * Copyright (C) 1997   Josef Wilgen
  * Copyright (C) 2003   Uwe Rathmann
+ * Copyright (C) 2002   Uwe Rathmann
+ *
  * This library is free software; you can redistribute it and/or
 …
 #include <qsize.h>
 #include <qfont.h>
+#include <qmetatype.h>
 class QColor;
 …
     how to render it. Each format (f.e MathML, TeX, Qt Rich Text)
     has its own set of control sequences, that can be handles by
     a QwtTextEngine for this format.
+    a special QwtTextEngine for this format.
   - Background\n
     A text might have a background, defined by a QPen and QBrush
+    to improve its visibility.
+    to improve its visibility. The corners of the background might
+    be rounded.
   - Font\n
     A text might have an individual font.
 …
   - Render Flags\n
     Flags from Qt::AlignmentFlag and Qt::TextFlag used like in
     QPainter::drawText.
+    QPainter::drawText().
   \sa QwtTextEngine, QwtTextLabel
 …
+    {
         /*!
           The text format is determined using QwtTextEngine::mightRender for
+          The text format is determined using QwtTextEngine::mightRender() for
           all available text engines in increasing order > PlainText.
           If none of the text engines can render the text is rendered
 …
     QColor usedColor( const QColor & ) const;
+    void setBackgroundPen( const QPen & );
+    QPen backgroundPen() const;
+    void setBorderRadius( double );
+    double borderRadius() const;
+    void setBorderPen( const QPen & );
+    QPen borderPen() const;
     void setBackgroundBrush( const QBrush & );
 …
 Q_DECLARE_OPERATORS_FOR_FLAGS( QwtText::LayoutAttributes )
+Q_DECLARE_METATYPE( QwtText )
 #endif

trunk/BNC/qwt/qwt_text_engine.cpp

-              r4271
+              r8127
  * Qwt Widget Library
  * Copyright (C) 1997   Josef Wilgen
  * Copyright (C) 2003   Uwe Rathmann
+ * Copyright (C) 2002   Uwe Rathmann
+ *
  * This library is free software; you can redistribute it and/or
 …
             option.setWrapMode( QTextOption::NoWrap );
         option.setAlignment( ( Qt::Alignment ) flags );
+        option.setAlignment( static_cast<Qt::Alignment>( flags ) );
         setDefaultTextOption( option );
 …
         for ( row = 0; row < img.height(); row++ )
+        {
+            const QRgb *line = ( const QRgb * )img.scanLine( row );
+            const QRgb *line = reinterpret_cast<const QRgb *>(
+                img.scanLine( row ) );
             const int w = pm.width();
 …
   \param text Text to be rendered
   \return Caluclated size
+  \return Calculated size
 */
 QSizeF QwtPlainTextEngine::textSize( const QFont &font,
 …
    \param font Font of the text
    \param flags Bitwise OR of the flags used like in QPainter::drawText
+   \param flags Bitwise OR of the flags used like in QPainter::drawText()
    \param text Text to be rendered
    \param width Width
 …
   \param font Font of the text
   \param flags Bitwise OR of the flags used like in QPainter::drawText
+  \param flags Bitwise OR of the flags used like in QPainter::drawText()
   \param text Text to be rendered
   \return Caluclated size
+  \return Calculated size
 */
 …
   \param painter Painter
   \param rect Clipping rectangle
   \param flags Bitwise OR of the flags like in for QPainter::drawText
+  \param flags Bitwise OR of the flags like in for QPainter::drawText()
   \param text Text to be rendered
 */
 …
    \param text Text
    \param flags Bitwise OR of the flags like in for QPainter::drawText
+   \param flags Bitwise OR of the flags like in for QPainter::drawText()
    \return Tagged text
 …
   \param text Text to be tested
   \return QStyleSheet::mightBeRichText(text);
+  \return Qt::mightBeRichText(text);
 */
 bool QwtRichTextEngine::mightRender( const QString &text ) const

trunk/BNC/qwt/qwt_text_engine.h

-              r4271
+              r8127
  * Qwt Widget Library
  * Copyright (C) 1997   Josef Wilgen
  * Copyright (C) 2003   Uwe Rathmann
+ * Copyright (C) 2002   Uwe Rathmann
+ *
  * This library is free software; you can redistribute it and/or
 …
       \param text Text to be rendered
       \return Caluclated size
+      \return Calculated size
      */
     virtual QSizeF textSize( const QFont &font, int flags,
 …
       The textSize might include margins around the
       text, like QFontMetrics::descent. In situations
       where texts need to be aligend in detail, knowing
+      text, like QFontMetrics::descent(). In situations
+      where texts need to be aligned in detail, knowing
       these margins might improve the layout calculations.
 …
       \param painter Painter
       \param rect Clipping rectangle
       \param flags Bitwise OR of the flags like in for QPainter::drawText
+      \param flags Bitwise OR of the flags like in for QPainter::drawText()
       \param text Text to be rendered
      */

trunk/BNC/qwt/qwt_text_label.cpp

-              r4271
+              r8127
 /*!
+   Interface for the designer plugin - does the same as setText()
+   \sa plainText()
+ */
+void QwtTextLabel::setPlainText( const QString &text )
+{
+    setText( QwtText( text ) );
+}
+/*!
+   Interface for the designer plugin
+   \return Text as plain text
+   \sa setPlainText(), text()
+ */
+QString QwtTextLabel::plainText() const
+{
+    return d_data->text.text();
+}
+/*!
    Change the label's text, keeping all other QwtText attributes
    \param text New text
 …
   \sa QwtText
 */
+void QwtTextLabel::setText( const QString &text, QwtText::TextFormat textFormat )
+void QwtTextLabel::setText( const QString &text,
+    QwtText::TextFormat textFormat )
+{
     d_data->text.setText( text, textFormat );
 …
+}
 //! Return label's text indent in pixels
+//! Return label's text margin in pixels
 int QwtTextLabel::margin() const
+{
 …
+}
 //! Return label's margin in pixels
+//! Return a size hint
 QSize QwtTextLabel::sizeHint() const
+{
 …
 /*!
-   Returns the preferred height for this widget, given the width.
    \param width Width
+   \return Preferred height for this widget, given the width.
 */
 int QwtTextLabel::heightForWidth( int width ) const
 …
         width -= indent;
     int height = d_data->text.heightForWidth( width, font() );
     if ( renderFlags & Qt::AlignTop || renderFlags & Qt::AlignBottom )
+    int height = qCeil( d_data->text.heightForWidth( width, font() ) );
+    if ( ( renderFlags & Qt::AlignTop ) || ( renderFlags & Qt::AlignBottom ) )
         height += indent;
 …
     painter->setPen( palette().color( QPalette::Active, QPalette::Text ) );
     drawText( painter, r );
+    drawText( painter, QRectF( r ) );
     if ( hasFocus() )
+    {
+        const int margin = 2;
+        QRect focusRect = contentsRect();
+        focusRect.setRect( focusRect.x() + margin, focusRect.y() + margin,
+            focusRect.width() - 2 * margin - 2,
+            focusRect.height() - 2 * margin - 2 );
+        const int m = 2;
+        QRect focusRect = contentsRect().adjusted( m, m, -m + 1, -m + 1);
         QwtPainter::drawFocusRect( painter, this, focusRect );
 …
 //! Redraw the text
 void QwtTextLabel::drawText( QPainter *painter, const QRect &textRect )
+void QwtTextLabel::drawText( QPainter *painter, const QRectF &textRect )
+{
     d_data->text.draw( painter, textRect );
 …
 /*!
   Calculate the rect for the text in widget coordinates
   \return Text rect
+  Calculate geometry for the text in widget coordinates
+  \return Geometry for the text
 */
 QRect QwtTextLabel::textRect() const

trunk/BNC/qwt/qwt_text_label.h

-              r4271
+              r8127
     Q_PROPERTY( int indent READ indent WRITE setIndent )
     Q_PROPERTY( int margin READ margin WRITE setMargin )
+    Q_PROPERTY( QString plainText READ plainText WRITE setPlainText )
 public:
 …
     explicit QwtTextLabel( const QwtText &, QWidget *parent = NULL );
     virtual ~QwtTextLabel();
+    void setPlainText( const QString & );
+    QString plainText() const;
 public Q_SLOTS:
 …
     QRect textRect() const;
+    virtual void drawText( QPainter *, const QRectF & );
 protected:
     virtual void paintEvent( QPaintEvent *e );
     virtual void drawContents( QPainter * );
-    virtual void drawText( QPainter *, const QRect & );
 private:

trunk/BNC/qwtpolar/qwt_polar_canvas.cpp

-              r4272
+              r8127
 #include "qwt_polar_canvas.h"
 #include "qwt_polar_plot.h"
+#include <qwt_painter.h>
 #include <qpainter.h>
 #include <qevent.h>
 …
+                {
                     QWidget *bgWidget = qwtBackgroundWidget( plot() );
+                    bs.fill( bgWidget, mapTo( bgWidget, rect().topLeft() ) );
+                                        QwtPainter::fillPixmap( bgWidget, bs,
+                                                mapTo( bgWidget, rect().topLeft() ) );
                     p.begin( &bs );
+                }

trunk/BNC/qwtpolar/qwt_polar_curve.cpp

-              r7990
+              r8127
 #include <qwt_symbol.h>
 #include <qwt_legend.h>
-#include <qwt_legend_item.h>
 #include <qwt_curve_fitter.h>
 #include <qwt_clipper.h>
 …
   \sa symbol()
 */
 void QwtPolarCurve::setSymbol( const QwtSymbol *symbol )
+void QwtPolarCurve::setSymbol( QwtSymbol *symbol )
+{
     if ( symbol != d_data->symbol )
 …
     if ( !clipRect.isEmpty() )
+    {
         double off = qCeil( qMax(qreal(1.0), painter->pen().widthF() ) );
+        double off = qCeil( qMax( qreal( 1.0 ), painter->pen().widthF() ) );
         clipRect = clipRect.toRect().adjusted( -off, -off, off, off );
         polyline = QwtClipper::clipPolygonF( clipRect, polyline );
 …
+}
+//!  Update the widget that represents the curve on the legend
+void QwtPolarCurve::updateLegend( QwtLegend *legend ) const
+{
+    if ( legend && testItemAttribute( QwtPolarCurve::Legend )
+            && ( d_data->legendAttributes & QwtPolarCurve::LegendShowSymbol )
+            && d_data->symbol
+            && d_data->symbol->style() != QwtSymbol::NoSymbol )
+    {
+        QWidget *lgdItem = legend->find( this );
+        if ( lgdItem == NULL )
+        {
+            lgdItem = legendItem();
+            if ( lgdItem )
+                legend->insert( this, lgdItem );
+        }
+        QwtLegendItem *l = qobject_cast<QwtLegendItem *>( lgdItem );
+        if ( l )
+        {
+            QSize sz = d_data->symbol->boundingSize();
+            sz += QSize( 2, 2 ); // margin
+            if ( d_data->legendAttributes & QwtPolarCurve::LegendShowLine )
+            {
+                // Avoid, that the line is completely covered by the symbol
+                int w = qCeil( 1.5 * sz.width() );
+                if ( w % 2 )
+                    w++;
+                sz.setWidth( qMax( 8, w ) );
+            }
+            l->setIdentifierSize( sz );
+        }
+    }
+    QwtPolarItem::updateLegend( legend );
+}
+/*!
+  \brief Draw the identifier representing the curve on the legend
+  \param painter Qt Painter
+  \param rect Bounding rectangle for the identifier
+  \sa setLegendAttribute
+*/
+void QwtPolarCurve::drawLegendIdentifier(
+    QPainter *painter, const QRectF &rect ) const
+{
+    if ( rect.isEmpty() )
+        return;
+    const double dim = qMin( rect.width(), rect.height() );
+    QSizeF size( dim, dim );
+    QRectF r( 0, 0, size.width(), size.height() );
+    r.moveCenter( rect.center() );
+/*!
+   \return Icon representing the curve on the legend
+   \param index Index of the legend entry
+                ( ignored as there is only one )
+   \param size Icon size
+   \sa QwtPolarItem::setLegendIconSize(), QwtPolarItem::legendData()
+ */
+QwtGraphic QwtPolarCurve::legendIcon( int index,
+    const QSizeF &size ) const
+{
+    Q_UNUSED( index );
+    if ( size.isEmpty() )
+        return QwtGraphic();
+    QwtGraphic graphic;
+    graphic.setDefaultSize( size );
+    graphic.setRenderHint( QwtGraphic::RenderPensUnscaled, true );
+    QPainter painter( &graphic );
+    painter.setRenderHint( QPainter::Antialiasing,
+        testRenderHint( QwtPolarItem::RenderAntialiased ) );
     if ( d_data->legendAttributes == 0 )
+    {
         QBrush brush;
         if ( style() != QwtPolarCurve::NoCurve )
+        {
             brush = QBrush( pen().color() );
+        }
         else if ( d_data->symbol &&
             ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
 …
             brush = QBrush( d_data->symbol->pen().color() );
+        }
         if ( brush.style() != Qt::NoBrush )
+            painter->fillRect( r, brush );
+    }
+        {
+            QRectF r( 0, 0, size.width(), size.height() );
+            painter.fillRect( r, brush );
+        }
+    }
     if ( d_data->legendAttributes & QwtPolarCurve::LegendShowLine )
+    {
         if ( pen() != Qt::NoPen )
+        {
+            painter->setPen( pen() );
+            QwtPainter::drawLine( painter, rect.left(), rect.center().y(),
+                rect.right() - 1.0, rect.center().y() );
+        }
+    }
+            QPen pn = pen();
+            pn.setCapStyle( Qt::FlatCap );
+            painter.setPen( pn );
+            const double y = 0.5 * size.height();
+            QwtPainter::drawLine( &painter, 0.0, y, size.width(), y );
+        }
+    }
     if ( d_data->legendAttributes & QwtPolarCurve::LegendShowSymbol )
+    {
+        if ( d_data->symbol &&
+            ( d_data->symbol->style() != QwtSymbol::NoSymbol ) )
+        {
+            QSize symbolSize = d_data->symbol->boundingSize();
+            symbolSize -= QSize( 2, 2 );
+            // scale the symbol size down if it doesn't fit into rect.
+            double xRatio = 1.0;
+            if ( rect.width() < symbolSize.width() )
+                xRatio = rect.width() / symbolSize.width();
+            double yRatio = 1.0;
+            if ( rect.height() < symbolSize.height() )
+                yRatio = rect.height() / symbolSize.height();
+            const double ratio = qMin( xRatio, yRatio );
+            painter->save();
+            painter->scale( ratio, ratio );
+            d_data->symbol->drawSymbol( painter, rect.center() / ratio );
+            painter->restore();
+        }
+    }
+        if ( d_data->symbol )
+        {
+            QRectF r( 0, 0, size.width(), size.height() );
+            d_data->symbol->drawSymbol( &painter, r );
+        }
+    }
+    return graphic;
+}
 …
     return QwtInterval();
+}

trunk/BNC/qwtpolar/qwt_polar_curve.h

-              r4272
+              r8127
         In the default setting all attributes are off.
+        \sa setLegendAttribute(), testLegendAttribute(),
+            drawLegendIdentifier()
+        \sa setLegendAttribute(), testLegendAttribute()
      */
 …
     CurveStyle style() const;
     void setSymbol( const QwtSymbol * );
+    void setSymbol( QwtSymbol * );
     const QwtSymbol *symbol() const;
 …
         const QPointF &pole, int from, int to ) const;
-    virtual void updateLegend( QwtLegend * ) const;
     virtual QwtInterval boundingInterval( int scaleId ) const;
     virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF & ) const;
 protected:

trunk/BNC/qwtpolar/qwt_polar_global.h

-              r4272
+              r8127
 // QWT_POLAR_VERSION is (major << 16) + (minor << 8) + patch.
+#define QWT_POLAR_VERSION       0x010000
+#define QWT_POLAR_VERSION_STR   "1.0.0"
+#if defined(Q_WS_WIN) || defined(Q_WS_S60)
+#define QWT_POLAR_VERSION       0x010101
+#define QWT_POLAR_VERSION_STR   "1.1.1"
 #if defined(_MSC_VER) /* MSVC Compiler */
 …
 #ifdef QWT_POLAR_DLL
 #if defined(QWT_POLAR_MAKEDLL)     // create a Qwt DLL library
 #define QWT_POLAR_EXPORT  __declspec(dllexport)
+#if defined(QWT_POLAR_MAKEDLL)     // create DLL library
+#define QWT_POLAR_EXPORT  Q_DECL_EXPORT
 #define QWT_POLAR_TEMPLATEDLL
 #else                        // use a Qwt DLL library
 #define QWT_POLAR_EXPORT  __declspec(dllimport)
+#else                        // use DLL library
+#define QWT_POLAR_EXPORT  Q_DECL_IMPORT
 #endif
+#endif // QWT_POLAR_MAKEDLL
+#endif // Q_WS_WIN
+#endif // QWT_POLAR_DLL
 #ifndef QWT_POLAR_EXPORT

trunk/BNC/qwtpolar/qwt_polar_grid.cpp

-              r4272
+              r8127
             scaleDraw->setAngleRange( from, from - 360.0 );
+            scaleDraw->setTransformation( azimuthMap.transformation()->copy() );
+            const QwtTransform *transform = azimuthMap.transformation();
+            if ( transform )
+                scaleDraw->setTransformation( transform->copy() );
+            else
+                scaleDraw->setTransformation( NULL );
+        }
         else
 …
+                }
+            }
+            scaleDraw->setTransformation( radialMap.transformation()->copy() );
+            const QwtTransform *transform = radialMap.transformation();
+            if ( transform )
+                scaleDraw->setTransformation( transform->copy() );
+            else
+                scaleDraw->setTransformation( NULL );
+        }
+    }
 …
                 QwtScaleDiv sd = radialGrid.scaleDiv;
+                QList<double> &ticks =
+                    const_cast<QList<double> &>( sd.ticks( QwtScaleDiv::MajorTick ) );
+                QList<double> ticks = sd.ticks( QwtScaleDiv::MajorTick );
                 if ( testDisplayFlag( SmartOriginLabel ) )
 …
+                }
+                sd.setTicks( QwtScaleDiv::MajorTick, ticks );
                 axis.scaleDraw->setScaleDiv( sd );
 …
 const QwtScaleDraw *QwtPolarGrid::scaleDraw( int axisId ) const
+{
     if ( axisId >= QwtPolar::AxisLeft || axisId <= QwtPolar::AxisBottom )
+    if ( axisId >= QwtPolar::AxisLeft && axisId <= QwtPolar::AxisBottom )
         return static_cast<QwtScaleDraw *>( d_data->axisData[axisId].scaleDraw );
 …
 QwtScaleDraw *QwtPolarGrid::scaleDraw( int axisId )
+{
     if ( axisId >= QwtPolar::AxisLeft || axisId <= QwtPolar::AxisBottom )
+    if ( axisId >= QwtPolar::AxisLeft && axisId <= QwtPolar::AxisBottom )
         return static_cast<QwtScaleDraw *>( d_data->axisData[axisId].scaleDraw );

trunk/BNC/qwtpolar/qwt_polar_item.cpp

-              r4272
+              r8127
 #include "qwt_polar_item.h"
 #include <qwt_legend.h>
-#include <qwt_legend_item.h>
 #include <qwt_scale_div.h>
 #include <qpainter.h>
 …
         attributes( 0 ),
         renderHints( 0 ),
+        z( 0.0 )
+        renderThreadCount( 1 ),
+        z( 0.0 ),
+        legendIconSize( 8, 8 )
+    {
+    }
 …
     QwtPolarItem::ItemAttributes attributes;
     QwtPolarItem::RenderHints renderHints;
+    uint renderThreadCount;
     double z;
     QwtText title;
+    QSize legendIconSize;
 };
 …
         return;
-    // remove the item from the previous plot
     if ( d_data->plot )
+    {
-        if ( d_data->plot->legend() )
-            d_data->plot->legend()->remove( this );
         d_data->plot->attachItem( this, false );
-        if ( d_data->plot->autoReplot() )
-            d_data->plot->update();
+    }
     d_data->plot = plot;
     if ( d_data->plot )
+    {
-        // insert the item into the current plot
         d_data->plot->attachItem( this, true );
+        itemChanged();
+    }
+}
+/*!
+   \brief This method detaches a QwtPolarItem from the QwtPolarPlot it
+          has been associated with.
+   detach() is equivalent to calling attach( NULL )
+   \sa attach()
+*/
+void QwtPolarItem::detach()
+{
+    attach( NULL );
+}
 …
+}
+/*!
+   On multi core systems rendering of certain plot item
+   ( f.e QwtPolarSpectrogram ) can be done in parallel in
+   several threads.
+   The default setting is set to 1.
+   \param numThreads Number of threads to be used for rendering.
+                     If numThreads is set to 0, the system specific
+                     ideal thread count is used.
+   The default thread count is 1 ( = no additional threads )
+*/
+void QwtPolarItem::setRenderThreadCount( uint numThreads )
+{
+    d_data->renderThreadCount = numThreads;
+}
+/*!
+   \return Number of threads to be used for rendering.
+           If numThreads() is set to 0, the system specific
+           ideal thread count is used.
+*/
+uint QwtPolarItem::renderThreadCount() const
+{
+    return d_data->renderThreadCount;
+}
+/*!
+   Set the size of the legend icon
+   The default setting is 8x8 pixels
+   \param size Size
+   \sa legendIconSize(), legendIcon()
+*/
+void QwtPolarItem::setLegendIconSize( const QSize &size )
+{
+    if ( d_data->legendIconSize != size )
+    {
+        d_data->legendIconSize = size;
+        legendChanged();
+    }
+}
+/*!
+   \return Legend icon size
+   \sa setLegendIconSize(), legendIcon()
+*/
+QSize QwtPolarItem::legendIconSize() const
+{
+    return d_data->legendIconSize;
+}
 //! Show the item
 void QwtPolarItem::show()
 …
+{
     if ( d_data->plot )
+    {
-        if ( d_data->plot->legend() )
-            updateLegend( d_data->plot->legend() );
         d_data->plot->autoRefresh();
+    }
+}
+/*!
+   Update the legend of the parent plot.
+   \sa QwtPolarPlot::updateLegend(), itemChanged()
+*/
+void QwtPolarItem::legendChanged()
+{
+    if ( testItemAttribute( QwtPolarItem::Legend ) && d_data->plot )
+        d_data->plot->updateLegend( this );
+}
 …
 /*!
+   \brief Update the widget that represents the item on the legend
+   updateLegend() is called from itemChanged() to adopt the widget
+   representing the item on the legend to its new configuration.
+   The default implementation is made for QwtPolarCurve and updates a
+   QwtLegendItem(), but an item could be represented by any type of widget,
+   by overloading legendItem() and updateLegend().
+   \sa legendItem(), itemChanged(), QwtLegend()
+*/
+void QwtPolarItem::updateLegend( QwtLegend *legend ) const
+{
+    if ( legend == NULL )
+        return;
+    QWidget *lgdItem = legend->find( this );
+    if ( testItemAttribute( QwtPolarItem::Legend ) )
+    {
+        if ( lgdItem == NULL )
+        {
+            lgdItem = legendItem();
+            if ( lgdItem )
+                legend->insert( this, lgdItem );
+        }
+        QwtLegendItem* label = qobject_cast<QwtLegendItem *>( lgdItem );
+        if ( label )
+        {
+            // paint the identifier
+            const QSize sz = label->identifierSize();
+            QPixmap identifier( sz.width(), sz.height() );
+            identifier.fill( Qt::transparent );
+            QPainter painter( &identifier );
+            painter.setRenderHint( QPainter::Antialiasing,
+                testRenderHint( QwtPolarItem::RenderAntialiased ) );
+            drawLegendIdentifier( &painter,
+                QRect( 0, 0, sz.width(), sz.height() ) );
+            painter.end();
+            const bool doUpdate = label->updatesEnabled();
+            if ( doUpdate )
+                label->setUpdatesEnabled( false );
+            label->setText( title() );
+            label->setIdentifier( identifier );
+            label->setItemMode( legend->itemMode() );
+            if ( doUpdate )
+                label->setUpdatesEnabled( true );
+            label->update();
+        }
+    }
+    else
+    {
+        if ( lgdItem )
+        {
+            lgdItem->hide();
+            lgdItem->deleteLater();
+        }
+    }
+}
+/*!
+   \brief Allocate the widget that represents the item on the legend
+   The default implementation is made for QwtPolarCurve and returns a
+   QwtLegendItem(), but an item could be represented by any type of widget,
+   by overloading legendItem() and updateLegend().
+   \return QwtLegendItem()
+   \sa updateLegend() QwtLegend()
+*/
+QWidget *QwtPolarItem::legendItem() const
+{
+    QwtLegendItem *item = new QwtLegendItem;
+    if ( d_data->plot )
+    {
+        QObject::connect( item, SIGNAL( clicked() ),
+            d_data->plot, SLOT( legendItemClicked() ) );
+        QObject::connect( item, SIGNAL( checked( bool ) ),
+            d_data->plot, SLOT( legendItemChecked( bool ) ) );
+    }
+    return item;
+   \brief Return all information, that is needed to represent
+          the item on the legend
+   Most items are represented by one entry on the legend
+   showing an icon and a text.
+   QwtLegendData is basically a list of QVariants that makes it
+   possible to overload and reimplement legendData() to
+   return almost any type of information, that is understood
+   by the receiver that acts as the legend.
+   The default implementation returns one entry with
+   the title() of the item and the legendIcon().
+   \sa title(), legendIcon(), QwtLegend
+ */
+QList<QwtLegendData> QwtPolarItem::legendData() const
+{
+    QwtLegendData data;
+    QwtText label = title();
+    label.setRenderFlags( label.renderFlags() & Qt::AlignLeft );
+    QVariant titleValue;
+    qVariantSetValue( titleValue, label );
+    data.setValue( QwtLegendData::TitleRole, titleValue );
+    const QwtGraphic graphic = legendIcon( 0, legendIconSize() );
+    if ( !graphic.isNull() )
+    {
+        QVariant iconValue;
+        qVariantSetValue( iconValue, graphic );
+        data.setValue( QwtLegendData::IconRole, iconValue );
+    }
+    QList<QwtLegendData> list;
+    list += data;
+    return list;
+}
+/*!
+   \return Icon representing the item on the legend
+   The default implementation returns an invalid icon
+   \param index Index of the legend entry
+                ( usually there is only one )
+   \param size Icon size
+   \sa setLegendIconSize(), legendData()
+ */
+QwtGraphic QwtPolarItem::legendIcon(
+    int index, const QSizeF &size ) const
+{
+    Q_UNUSED( index )
+    Q_UNUSED( size )
+    return QwtGraphic();
+}

trunk/BNC/qwtpolar/qwt_polar_item.h

-              r4272
+              r8127
 #include "qwt_polar_global.h"
 #include <qwt_text.h>
+#include <qwt_legend_itemmanager.h>
+#include <qwt_legend_data.h>
+#include <qwt_graphic.h>
 #include <qwt_interval.h>
 …
   types of items.
 */
 class QWT_POLAR_EXPORT QwtPolarItem: public QwtLegendItemManager
+class QWT_POLAR_EXPORT QwtPolarItem
+{
 public:
 …
     void attach( QwtPolarPlot *plot );
+    /*!
+       \brief This method detaches a QwtPolarItem from any QwtPolarPlot it
+              has been associated with.
+       detach() is equivalent to calling attach( NULL )
+       \sa attach( QwtPolarPlot* plot )
+    */
+    void detach() { attach( NULL ); }
+    void detach();
     QwtPolarPlot *plot() const;
 …
     bool testRenderHint( RenderHint ) const;
+    void setRenderThreadCount( uint numThreads );
+    uint renderThreadCount() const;
     double z() const;
     void setZ( double z );
 …
     virtual void itemChanged();
+    virtual void legendChanged();
     /*!
 …
     virtual QwtInterval boundingInterval( int scaleId ) const;
-    virtual QWidget *legendItem() const;
-    virtual void updateLegend( QwtLegend * ) const;
     virtual void updateScaleDiv( const QwtScaleDiv &,
         const QwtScaleDiv &, const QwtInterval & );
     virtual int marginHint() const;
+    void setLegendIconSize( const QSize & );
+    QSize legendIconSize() const;
+    virtual QList<QwtLegendData> legendData() const;
+    virtual QwtGraphic legendIcon( int index, const QSizeF  & ) const;
 private:
 …
 Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarItem::RenderHints )
+Q_DECLARE_METATYPE( QwtPolarItem * )
 #endif

trunk/BNC/qwtpolar/qwt_polar_itemdict.cpp

-              r4272
+              r8127
 /*!
    Attach/Detach a plot item
+  Insert a plot item
+   Attached items will be deleted in the destructor,
+   if auto deletion is enabled (default). Manually detached
+   items are not deleted.
+  \param item PlotItem
+  \sa removeItem()
+ */
+void QwtPolarItemDict::insertItem( QwtPolarItem *item )
+{
+    d_data->itemList.insertItem( item );
+}
+   \param item Plot item to attach/detach
    \ on If true attach, else detach the item
+/*!
+  Remove a plot item
+   \sa setAutoDelete, ~QwtPolarItemDict
+*/
+void QwtPolarItemDict::attachItem( QwtPolarItem *item, bool on )
+  \param item PlotItem
+  \sa insertItem()
+ */
+void QwtPolarItemDict::removeItem( QwtPolarItem *item )
+{
+    if ( on )
+        d_data->itemList.insertItem( item );
+    else
+        d_data->itemList.removeItem( item );
+    d_data->itemList.removeItem( item );
+}

trunk/BNC/qwtpolar/qwt_polar_itemdict.h

-              r4272
+              r8127
         bool autoDelete = true );
+protected:
+    void insertItem( QwtPolarItem * );
+    void removeItem( QwtPolarItem * );
 private:
-    friend class QwtPolarItem;
-    void attachItem( QwtPolarItem *, bool );
     class PrivateData;
     PrivateData *d_data;

trunk/BNC/qwtpolar/qwt_polar_layout.cpp

-              r7990
+              r8127
+    {
         int frameWidth;
         int vScrollBarWidth;
         int hScrollBarHeight;
+        int hScrollExtent;
+        int vScrollExtent;
         QSizeF hint;
     } legend;
 …
+    {
         legend.frameWidth = plot->legend()->frameWidth();
         legend.vScrollBarWidth =
             plot->legend()->verticalScrollBar()->sizeHint().width();
         legend.hScrollBarHeight =
             plot->legend()->horizontalScrollBar()->sizeHint().height();
+        legend.hScrollExtent =
+            plot->legend()->scrollExtent( Qt::Horizontal );
+        legend.vScrollExtent =
+            plot->legend()->scrollExtent( Qt::Vertical );
         const QSizeF hint = plot->legend()->sizeHint();
 …
         if ( h > rect.height() )
             w += legend.vScrollBarWidth;
+            w += legend.hScrollExtent;
         legend.hint = QSizeF( w, h );
 …
         // half of the available space.
         dim = qMin( hint.width(), qreal(rect.width() * d_data->legendRatio) );
+        dim = qMin( double( hint.width() ), rect.width() * d_data->legendRatio );
         if ( !( options & IgnoreScrollbars ) )
 …
                 // space for the vertical scrollbar.
                 dim += d_data->layoutData.legend.vScrollBarWidth;
+                dim += d_data->layoutData.legend.hScrollExtent;
+            }
+        }
 …
     else
+    {
         dim = qMin( hint.width(), qreal(rect.width() * d_data->legendRatio) );
         dim = qMax( dim, d_data->layoutData.legend.hScrollBarHeight );
+        dim = qMin( double( hint.height() ), rect.height() * d_data->legendRatio );
+        dim = qMax( dim, d_data->layoutData.legend.vScrollExtent );
+    }

trunk/BNC/qwtpolar/qwt_polar_plot.cpp

-              r4272
+              r8127
 #include <qwt_round_scale_draw.h>
 #include <qwt_legend.h>
-#include <qwt_legend_item.h>
 #include <qwt_dyngrid_layout.h>
 #include <qpointer.h>
 …
 public:
     ScaleData():
+        isValid( false ),
         scaleEngine( NULL )
+    {
 …
     int maxMinor;
+    bool isValid;
     QwtScaleDiv scaleDiv;
     QwtScaleEngine *scaleEngine;
 …
     QPointer<QwtTextLabel> titleLabel;
     QPointer<QwtPolarCanvas> canvas;
     QPointer<QwtLegend> legend;
+    QPointer<QwtAbstractLegend> legend;
     double azimuthOrigin;
 …
       QwtPolarLayout::setLegendPosition()
 */
 void QwtPolarPlot::insertLegend( QwtLegend *legend,
+void QwtPolarPlot::insertLegend( QwtAbstractLegend *legend,
     QwtPolarPlot::LegendPosition pos, double ratio )
+{
     d_data->layout->setLegendPosition( pos, ratio );
     if ( legend != d_data->legend )
+    {
 …
         if ( d_data->legend )
+        {
+            if ( pos != ExternalLegend )
+            connect( this,
+                SIGNAL( legendDataChanged(
+                    const QVariant &, const QList<QwtLegendData> & ) ),
+                d_data->legend,
+                SLOT( updateLegend(
+                    const QVariant &, const QList<QwtLegendData> & ) )
+            );
+            if ( d_data->legend->parent() != this )
+                d_data->legend->setParent( this );
+            updateLegend();
+            QwtLegend *lgd = qobject_cast<QwtLegend *>( legend );
+            if ( lgd )
+            {
+                if ( d_data->legend->parent() != this )
+                    d_data->legend->setParent( this );
+            }
+            const QwtPolarItemList& itmList = itemList();
+            for ( QwtPolarItemIterator it = itmList.begin();
+                    it != itmList.end(); ++it )
+            {
+                ( *it )->updateLegend( d_data->legend );
+            }
+            QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
+                d_data->legend->contentsWidget()->layout() );
+            if ( tl )
+            {
+                switch( d_data->layout->legendPosition() )
+                switch ( d_data->layout->legendPosition() )
+                {
                     case LeftLegend:
                     case RightLegend:
+                        tl->setMaxCols( 1 ); // 1 column: align vertical
+                    {
+                        if ( lgd->maxColumns() == 0     )
+                            lgd->setMaxColumns( 1 ); // 1 column: align vertical
                         break;
+                    }
                     case TopLegend:
                     case BottomLegend:
+                        tl->setMaxCols( 0 ); // unlimited
+                    {
+                        lgd->setMaxColumns( 0 ); // unlimited
                         break;
                     case ExternalLegend:
+                    }
+                    default:
                         break;
+                }
+            }
+        }
+    }
+        }
+    }
     updateLayout();
+}
+/*!
+  Emit legendDataChanged() for all plot item
+  \sa QwtPlotItem::legendData(), legendDataChanged()
+ */
+void QwtPolarPlot::updateLegend()
+{
+    const QwtPolarItemList& itmList = itemList();
+    for ( QwtPolarItemIterator it = itmList.begin();
+        it != itmList.end(); ++it )
+    {
+        updateLegend( *it );
+    }
+}
+/*!
+  Emit legendDataChanged() for a plot item
+  \param plotItem Plot item
+  \sa QwtPlotItem::legendData(), legendDataChanged()
+ */
+void QwtPolarPlot::updateLegend( const QwtPolarItem *plotItem )
+{
+    if ( plotItem == NULL )
+        return;
+    QList<QwtLegendData> legendData;
+    if ( plotItem->testItemAttribute( QwtPolarItem::Legend ) )
+        legendData = plotItem->legendData();
+    const QVariant itemInfo = itemToInfo( const_cast< QwtPolarItem *>( plotItem) );
+    Q_EMIT legendDataChanged( itemInfo, legendData );
+}
 …
   \sa insertLegend()
 */
 QwtLegend *QwtPolarPlot::legend()
+QwtAbstractLegend *QwtPolarPlot::legend()
+{
     return d_data->legend;
 …
   \sa insertLegend()
 */
 const QwtLegend *QwtPolarPlot::legend() const
+const QwtAbstractLegend *QwtPolarPlot::legend() const
+{
     return d_data->legend;
+}
-/*!
-  Called internally when the legend has been clicked on.
-  Emits a legendClicked() signal.
-*/
-void QwtPolarPlot::legendItemClicked()
+{
-    if ( d_data->legend && sender()->isWidgetType() )
+    {
-        QwtPolarItem *plotItem = static_cast< QwtPolarItem* >(
-            d_data->legend->find( qobject_cast<const QWidget *>( sender() ) ) );
-        if ( plotItem )
-            Q_EMIT legendClicked( plotItem );
+    }
+}
-/*!
-  Called internally when the legend has been checked
-  Emits a legendClicked() signal.
-*/
-void QwtPolarPlot::legendItemChecked( bool on )
+{
-    if ( d_data->legend && sender()->isWidgetType() )
+    {
-        QwtPolarItem *plotItem = static_cast< QwtPolarItem* >(
-            d_data->legend->find( qobject_cast<const QWidget *>( sender() ) ) );
-        if ( plotItem )
-            Q_EMIT legendChecked( plotItem, on );
+    }
+}
 …
         return;
+    if ( maxMinor < 0 )
+        maxMinor = 0;
+    if ( maxMinor > 100 )
+        maxMinor = 100;
+    maxMinor = qBound( 0, maxMinor, 100 );
     ScaleData &scaleData = d_data->scaleData[scaleId];
 …
+    {
         scaleData.maxMinor = maxMinor;
         scaleData.scaleDiv.invalidate();
+        scaleData.isValid = false;
         autoRefresh();
+    }
 …
         return;
+    if ( maxMajor < 1 )
+        maxMajor = 1;
+    if ( maxMajor > 1000 )
+        maxMajor = 10000;
+    maxMajor = qBound( 1, maxMajor, 10000 );
     ScaleData &scaleData = d_data->scaleData[scaleId];
 …
+    {
         scaleData.maxMajor = maxMajor;
         scaleData.scaleDiv.invalidate();
+        scaleData.isValid = false;
         autoRefresh();
+    }
 …
     scaleData.scaleEngine = scaleEngine;
     scaleData.scaleDiv.invalidate();
+    scaleData.isValid = false;
     autoRefresh();
 …
     ScaleData &scaleData = d_data->scaleData[scaleId];
     scaleData.scaleDiv.invalidate();
+    scaleData.isValid = false;
     scaleData.minValue = min;
 …
     scaleData.scaleDiv = scaleDiv;
+    scaleData.isValid = true;
     scaleData.doAutoScale = false;
 …
+    {
         map.setPaintInterval( d_data->azimuthOrigin,
             d_data->azimuthOrigin + M_2PI );
+            d_data->azimuthOrigin + 2 * M_PI );
+    }
     else
 …
         scaleData.maxMajor = 8;
+        scaleData.isValid = false;
         scaleData.scaleEngine = new QwtLinearScaleEngine;
-        scaleData.scaleDiv.invalidate();
+    }
     d_data->zoomFactor = 1.0;
 …
+    }
+    if ( d_data->legend &&
+        d_data->layout->legendPosition() != ExternalLegend )
+    {
+        if ( d_data->legend->itemCount() > 0 )
+        {
+            d_data->legend->setGeometry( d_data->layout->legendRect().toRect() );
+    if ( d_data->legend )
+    {
+        if ( d_data->legend->isEmpty() )
+        {
+            d_data->legend->hide();
+        }
+        else
+        {
+            const QRectF legendRect = d_data->layout->legendRect();
+            d_data->legend->setGeometry( legendRect.toRect() );
             d_data->legend->show();
+        }
-        else
-            d_data->legend->hide();
+    }
 …
         d.scaleEngine->autoScale( d.maxMajor,
                                   minValue, maxValue, stepSize );
         d.scaleDiv.invalidate();
+    }
     if ( !d.scaleDiv.isValid() )
+        d.isValid = false;
+    }
+    if ( !d.isValid )
+    {
         d.scaleDiv = d.scaleEngine->divideScale(
             minValue, maxValue, d.maxMajor, d.maxMinor, stepSize );
+        d.isValid = true;
+    }
 …
     return d_data->layout;
+}
+/*!
+  \brief Attach/Detach a plot item
+  \param plotItem Plot item
+  \param on When true attach the item, otherwise detach it
+ */
+void QwtPolarPlot::attachItem( QwtPolarItem *plotItem, bool on )
+{
+    if ( on )
+        insertItem( plotItem );
+    else
+        removeItem( plotItem );
+    Q_EMIT itemAttached( plotItem, on );
+    if ( plotItem->testItemAttribute( QwtPolarItem::Legend ) )
+    {
+        // the item wants to be represented on the legend
+        if ( on )
+        {
+            updateLegend( plotItem );
+        }
+        else
+        {
+            const QVariant itemInfo = itemToInfo( plotItem );
+            Q_EMIT legendDataChanged( itemInfo, QList<QwtLegendData>() );
+        }
+    }
+    if ( autoReplot() )
+        update();
+}
+/*!
+  \brief Build an information, that can be used to identify
+         a plot item on the legend.
+  The default implementation simply wraps the plot item
+  into a QVariant object. When overloading itemToInfo()
+  usually infoToItem() needs to reimplemeted too.
+\code
+    QVariant itemInfo;
+    qVariantSetValue( itemInfo, plotItem );
+\endcode
+  \param plotItem Plot item
+  \sa infoToItem()
+ */
+QVariant QwtPolarPlot::itemToInfo( QwtPolarItem *plotItem ) const
+{
+    QVariant itemInfo;
+    qVariantSetValue( itemInfo, plotItem );
+    return itemInfo;
+}
+/*!
+  \brief Identify the plot item according to an item info object,
+         that has bee generated from itemToInfo().
+  The default implementation simply tries to unwrap a QwtPlotItem
+  pointer:
+\code
+    if ( itemInfo.canConvert<QwtPlotItem *>() )
+        return qvariant_cast<QwtPlotItem *>( itemInfo );
+\endcode
+  \param itemInfo Plot item
+  \return A plot item, when successful, otherwise a NULL pointer.
+  \sa itemToInfo()
+*/
+QwtPolarItem *QwtPolarPlot::infoToItem( const QVariant &itemInfo ) const
+{
+    if ( itemInfo.canConvert<QwtPolarItem *>() )
+        return qvariant_cast<QwtPolarItem *>( itemInfo );
+    return NULL;
+}

trunk/BNC/qwtpolar/qwt_polar_plot.h

-              r4272
+              r8127
 class QwtPolarCanvas;
 class QwtPolarLayout;
+class QwtAbstractLegend;
 /*!
 …
     // Legend
     void insertLegend( QwtLegend *,
+    void insertLegend( QwtAbstractLegend *,
         LegendPosition = RightLegend, double ratio = -1.0 );
+    QwtLegend *legend();
+    const QwtLegend *legend() const;
+    QwtAbstractLegend *legend();
+    const QwtAbstractLegend *legend() const;
+    void updateLegend();
+    void updateLegend( const QwtPolarItem * );
     // Layout
 …
     int plotMarginHint() const;
+    virtual QVariant itemToInfo( QwtPolarItem * ) const;
+    virtual QwtPolarItem *infoToItem( const QVariant & ) const;
 Q_SIGNALS:
     /*!
+      A signal which is emitted when the user has clicked on
+      a legend item, which is in QwtLegend::ClickableItem mode.
+      \param plotItem Corresponding plot item of the
+                 selected legend item
+      \note clicks are disabled as default
+      \sa QwtLegend::setItemMode, QwtLegend::itemMode
+     */
+    void legendClicked( QwtPolarItem *plotItem );
+    /*!
+      A signal which is emitted when the user has clicked on
+      a legend item, which is in QwtLegend::CheckableItem mode
+      \param plotItem Corresponding plot item of the
+                 selected legend item
+      \param on True when the legen item is checked
+      \note clicks are disabled as default
+      \sa QwtLegend::setItemMode, QwtLegend::itemMode
+     */
+    void legendChecked( QwtPolarItem *plotItem, bool on );
+      A signal indicating, that an item has been attached/detached
+      \param plotItem Plot item
+      \param on Attached/Detached
+     */
+    void itemAttached( QwtPolarItem *plotItem, bool on );
+    /*!
+      A signal with the attributes how to update
+      the legend entries for a plot item.
+      \param itemInfo Info about a plot, build from itemToInfo()
+      \sa itemToInfo(), infoToItem(), QwtAbstractLegend::updateLegend()
+     */
+    void legendDataChanged( const QVariant &itemInfo,
+        const QList<QwtLegendData> &data );
     /*!
 …
     void setAzimuthOrigin( double );
-protected Q_SLOTS:
-    virtual void legendItemClicked();
-    virtual void legendItemChecked( bool );
 protected:
     virtual bool event( QEvent * );
 …
 private:
+    friend class QwtPolarItem;
+    void attachItem( QwtPolarItem *, bool );
     void initPlot( const QwtText & );

trunk/BNC/qwtpolar/qwt_polar_renderer.cpp

-              r4272
+              r8127
 #include "qwt_polar_layout.h"
 #include <qwt_legend.h>
-#include <qwt_legend_item.h>
 #include <qwt_dyngrid_layout.h>
 #include <qwt_text_label.h>
 …
 #include <qpainter.h>
 #include <qprinter.h>
+#include <qprintdialog.h>
+#include <qfiledialog.h>
 #include <qimagewriter.h>
 #include <qfileinfo.h>
 …
     const QString fmt = format.toLower();
+    if ( format == "pdf" || format == "ps" )
+    {
+    if ( format == "pdf" )
+    {
+#ifndef QT_NO_PRINTER
         QPrinter printer;
+        printer.setColorMode( QPrinter::Color );
         printer.setFullPage( true );
         printer.setPaperSize( sizeMM, QPrinter::Millimeter );
         printer.setDocName( title );
         printer.setOutputFileName( fileName );
+        printer.setOutputFormat( ( format == "pdf" )
+            ? QPrinter::PdfFormat : QPrinter::PostScriptFormat );
+        printer.setOutputFormat( QPrinter::PdfFormat );
         printer.setResolution( resolution );
         QPainter painter( &printer );
         render( plot, &painter, documentRect );
+#endif
+    }
+    else if ( format == "ps" )
+    {
+#if QT_VERSION < 0x050000
+#ifndef QT_NO_PRINTER
+        QPrinter printer;
+        printer.setColorMode( QPrinter::Color );
+        printer.setFullPage( true );
+        printer.setPaperSize( sizeMM, QPrinter::Millimeter );
+        printer.setDocName( title );
+        printer.setOutputFileName( fileName );
+        printer.setOutputFormat( QPrinter::PostScriptFormat );
+        printer.setResolution( resolution );
+        QPainter painter( &printer );
+        render( plot, &painter, documentRect );
+#endif
+#endif
+    }
 #ifndef QWT_NO_POLAR_SVG
 …
     painter->save();
     renderLegend( painter, layout->legendRect() );
+    renderLegend( plot, painter, layout->legendRect() );
     painter->restore();
 …
   Render the legend into a given rectangle.
+  \param plot Plot widget
   \param painter Painter
   \param rect Bounding rectangle
 */
+void QwtPolarRenderer::renderLegend(
+void QwtPolarRenderer::renderLegend( const QwtPolarPlot *plot,
     QPainter *painter, const QRectF &rect ) const
+{
+    QwtLegend *legend = d_data->plot->legend();
+    if ( legend == NULL || legend->isEmpty() )
+        return;
+    const QwtDynGridLayout *legendLayout = qobject_cast<QwtDynGridLayout *>(
+        legend->contentsWidget()->layout() );
+    if ( legendLayout == NULL )
+        return;
+    uint numCols = legendLayout->columnsForWidth( rect.width() );
+    const QList<QRect> itemRects =
+        legendLayout->layoutItems( rect.toRect(), numCols );
+    int index = 0;
+    for ( int i = 0; i < legendLayout->count(); i++ )
+    {
+        QLayoutItem *item = legendLayout->itemAt( i );
+        QWidget *w = item->widget();
+        if ( w )
+    if ( plot->legend() )
+        plot->legend()->renderLegend( painter, rect, true );
+}
+/*!
+   \brief Execute a file dialog and render the plot to the selected file
+   The document will be rendered in 85 dpi for a size 30x30 cm
+   \param plot Plot widget
+   \param documentName Default document name
+   \param sizeMM Size for the document in millimeters.
+   \param resolution Resolution in dots per Inch (dpi)
+   \sa renderDocument()
+*/
+bool QwtPolarRenderer::exportTo( QwtPolarPlot *plot,
+    const QString &documentName, const QSizeF &sizeMM, int resolution )
+{
+    if ( plot == NULL )
+        return false;
+    QString fileName = documentName;
+    // What about translation
+#ifndef QT_NO_FILEDIALOG
+    const QList<QByteArray> imageFormats =
+        QImageWriter::supportedImageFormats();
+    QStringList filter;
+#ifndef QT_NO_PRINTER
+    filter += QString( "PDF " ) + tr( "Documents" ) + " (*.pdf)";
+#endif
+#ifndef QWT_NO_SVG
+    filter += QString( "SVG " ) + tr( "Documents" ) + " (*.svg)";
+#endif
+#ifndef QT_NO_PRINTER
+    filter += QString( "Postscript " ) + tr( "Documents" ) + " (*.ps)";
+#endif
+    if ( imageFormats.size() > 0 )
+    {
+        QString imageFilter( tr( "Images" ) );
+        imageFilter += " (";
+        for ( int i = 0; i < imageFormats.size(); i++ )
+        {
+            painter->save();
+            painter->setClipRect( itemRects[index] );
+            renderLegendItem( painter, w, itemRects[index] );
+            index++;
+            painter->restore();
+            if ( i > 0 )
+                imageFilter += " ";
+            imageFilter += "*.";
+            imageFilter += imageFormats[i];
+        }
+    }
+}
+/*!
+  Print the legend item into a given rectangle.
+  \param painter Painter
+  \param widget Widget representing a legend item
+  \param rect Bounding rectangle
+  \note When widget is not derived from QwtLegendItem renderLegendItem
+        does nothing and needs to be overloaded
+*/
+void QwtPolarRenderer::renderLegendItem( QPainter *painter,
+    const QWidget *widget, const QRectF &rect ) const
+{
+    const QwtLegendItem *item = qobject_cast<const QwtLegendItem *>( widget );
+    if ( item )
+    {
+        const QSize sz = item->identifierSize();
+        const QRectF identifierRect( rect.x() + item->margin(),
+            rect.center().y() - 0.5 * sz.height(), sz.width(), sz.height() );
+        QwtLegendItemManager *itemManger = d_data->plot->legend()->find( item );
+        if ( itemManger )
+        {
+            painter->save();
+            painter->setClipRect( identifierRect, Qt::IntersectClip );
+            itemManger->drawLegendIdentifier( painter, identifierRect );
+            painter->restore();
+        }
+        // Label
+        QRectF titleRect = rect;
+        titleRect.setX( identifierRect.right() + 2 * item->spacing() );
+        painter->setFont( item->font() );
+        item->text().draw( painter, titleRect );
+    }
+}
+        imageFilter += ")";
+        filter += imageFilter;
+    }
+    fileName = QFileDialog::getSaveFileName(
+        NULL, tr( "Export File Name" ), fileName,
+        filter.join( ";;" ), NULL, QFileDialog::DontConfirmOverwrite );
+#endif
+    if ( fileName.isEmpty() )
+        return false;
+    renderDocument( plot, fileName, sizeMM, resolution );
+    return true;
+}

trunk/BNC/qwtpolar/qwt_polar_renderer.h

-              r4272
+              r8127
 #include "qwt_polar_global.h"
 #include <qobject.h>
+#include <qsize.h>
 class QwtPolarPlot;
-class QSizeF;
 class QRectF;
 class QPainter;
 …
 #endif
     void renderTo( QwtPolarPlot *, QPrinter & ) const;
     void renderTo( QwtPolarPlot *, QPaintDevice &p ) const;
+    void renderTo( QwtPolarPlot *, QPaintDevice & ) const;
     virtual void render( QwtPolarPlot *,
         QPainter *, const QRectF &rect ) const;
+protected:
+    bool exportTo( QwtPolarPlot *, const QString &documentName,
+        const QSizeF &sizeMM = QSizeF( 200, 200 ), int resolution = 85 );
     virtual void renderTitle( QPainter *, const QRectF & ) const;
-    virtual void renderLegend( QPainter *, const QRectF & ) const;
     virtual void renderLegendItem( QPainter *,
         const QWidget *, const QRectF & ) const;
+    virtual void renderLegend(
+        const QwtPolarPlot *, QPainter *, const QRectF & ) const;
 private:

trunk/BNC/qwtpolar/qwt_polar_spectrogram.cpp

-              r4272
+              r8127
 public:
     PrivateData():
+        data( NULL ),
+        renderThreadCount( 1 )
+        data( NULL )
+    {
         colorMap = new QwtLinearColorMap();
 …
     QwtRasterData *data;
     QwtColorMap *colorMap;
-    uint renderThreadCount;
     QwtPolarSpectrogram::PaintAttributes paintAttributes;
 …
+{
     return ( d_data->paintAttributes & attribute );
+}
-/*!
-   Rendering an image from the raster data can often be done
-   parallel on a multicore system.
-   \param numThreads Number of threads to be used for rendering.
-                     If numThreads is set to 0, the system specific
-                     ideal thread count is used.
-   The default thread count is 1 ( = no additional threads )
-   \warning Rendering in multiple threads is only supported for Qt >= 4.4
-   \sa renderThreadCount(), renderImage(), renderTile()
-*/
-void QwtPolarSpectrogram::setRenderThreadCount( uint numThreads )
+{
-    d_data->renderThreadCount = numThreads;
+}
-/*!
-   \return Number of threads to be used for rendering.
-           If numThreads is set to 0, the system specific
-           ideal thread count is used.
-   \warning Rendering in multiple threads is only supported for Qt >= 4.4
-   \sa setRenderThreadCount(), renderImage(), renderTile()
-*/
-uint QwtPolarSpectrogram::renderThreadCount() const
+{
-    return d_data->renderThreadCount;
+}
 …
 #if QT_VERSION >= 0x040400 && !defined(QT_NO_QFUTURE)
     uint numThreads = d_data->renderThreadCount;
+    uint numThreads = renderThreadCount();
     if ( numThreads <= 0 )

trunk/BNC/qwtpolar/qwt_polar_spectrogram.h

-              r4272
+              r8127
     bool testPaintAttribute( PaintAttribute ) const;
-    void setRenderThreadCount( uint numThreads );
-    uint renderThreadCount() const;
     virtual int rtti() const;

trunk/BNC/qwtpolar/qwtpolar.pro

-              r5182
+              r8127
 CONFIG += release
 DEFINES += QWT_POLAR_NO_SVG
+greaterThan(QT_MAJOR_VERSION, 4) {
+    QT += printsupport
+    QT += concurrent
+}
 INCLUDEPATH += ../qwt
 …
     qwt_polar_renderer.cpp \
     qwt_polar_plot.cpp

trunk/BNC/src/PPP_SSR_I/pppFilter.h

r7929	r8127
90	90	double lkB;
91	91	unsigned obsIndex;
92		char system() const {return prn.to~~Ascii~~()[0];}
	92	char system() const {return prn.toLatin1()[0];}
93	93	};
94	94

trunk/BNC/src/bnccaster.cpp

-              r8119
+              r8127
           emit( newMessage(QString("%1: Old epoch %2 thrown away")
                  .arg(staID.data()).arg(string(obs._time).c_str())
                .toAscii(), true) );
+               .toLatin1(), true) );
+        }
+      }
 …
   _sockets->push_back( _server->nextPendingConnection() );
   emit( newMessage(QString("New client connection on sync port: # %1")
                    .arg(_sockets->size()).toAscii(), true) );
+                   .arg(_sockets->size()).toLatin1(), true) );
+}
 …
   _uSockets->push_back( _uServer->nextPendingConnection() );
   emit( newMessage(QString("New client connection on usync port: # %1")
                    .arg(_uSockets->size()).toAscii(), true) );
+                   .arg(_uSockets->size()).toLatin1(), true) );
+}
 …
   _staIDs.removeAll(staID);
   emit( newMessage(
            QString("Decoding %1 stream(s)").arg(_staIDs.size()).toAscii(), true) );
+           QString("Decoding %1 stream(s)").arg(_staIDs.size()).toLatin1(), true) );
   if (_staIDs.size() == 0) {
     emit(newMessage("bncCaster: Last get thread terminated", true));
 …
     // ----------------
     if (!existFlg) {
       QByteArray format    = hlp[1].toAscii();
       QByteArray latitude  = hlp[3].toAscii();
       QByteArray longitude = hlp[4].toAscii();
       QByteArray nmea      = hlp[5].toAscii();
       QByteArray ntripVersion = hlp[6].toAscii();
+      QByteArray format    = hlp[1].toLatin1();
+      QByteArray latitude  = hlp[3].toLatin1();
+      QByteArray longitude = hlp[4].toLatin1();
+      QByteArray nmea      = hlp[5].toLatin1();
+      QByteArray ntripVersion = hlp[6].toLatin1();
       bncGetThread* getThread = new bncGetThread(url, format, latitude,
 …
                            + BNC_CORE->confFileName()
                            + ", %1 stream(s)")
                             .arg(_threads.count()).toAscii(), true) );
+                            .arg(_threads.count()).toLatin1(), true) );
   // (Re-) Start the configuration timer
 …
   _miscSockets->push_back( _miscServer->nextPendingConnection() );
   emit( newMessage(QString("New client connection on Miscellaneous Output Port: # %1")
                    .arg(_miscSockets->size()).toAscii(), true) );
+}
+                   .arg(_miscSockets->size()).toLatin1(), true) );
+}

trunk/BNC/src/bnccore.cpp

-              r7999
+              r8127
       expandEnvVar(logFileName);
       _logFile = new QFile(logFileName + "_" +
                           currDate.toString("yyMMdd").toAscii().data());
+                          currDate.toString("yyMMdd").toLatin1().data());
       _fileDate = currDate;
       if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
 …
       msgLocal = msg.mid(1);
+    }
     *_logStream << currentDateAndTimeGPS().toString("yy-MM-dd hh:mm:ss ").toAscii().data();
+    *_logStream << currentDateAndTimeGPS().toString("yy-MM-dd hh:mm:ss ").toLatin1().data();
     *_logStream << msgLocal.data() << endl;
     _logStream->flush();
 …
   t_irc ircPut = _ephUser.putNewEph(eph, true);
   if      (eph->checkState() == t_eph::bad) {
     messagePrivate("WRONG EPHEMERIS\n" + eph->toString(3.0).toAscii());
+    messagePrivate("WRONG EPHEMERIS\n" + eph->toString(3.0).toLatin1());
     return failure;
+  }
   else if (eph->checkState() == t_eph::outdated) {
     messagePrivate("OUTDATED EPHEMERIS\n" + eph->toString(3.0).toAscii());
+    messagePrivate("OUTDATED EPHEMERIS\n" + eph->toString(3.0).toLatin1());
     return failure;
+  }
 …
     comments.append("Source: " + decoder +
                     " " + url.encodedHost() +
                     "/" + url.path().mid(1).toAscii());
+                    "/" + url.path().mid(1).toLatin1());
+  }
 …
         line.sprintf(
           "%9.2f%11sN: GNSS NAV DATA    M: Mixed%12sRINEX VERSION / TYPE\n",
           t_rnxNavFile::defaultRnxNavVersion3, "", "");
+          defaultRnxNavVersion3, "", "");
         *_ephStreamGPS << line;
         QString hlp = currentDateAndTimeGPS().toString("yyyyMMdd hhmmss UTC").leftJustified(20, ' ', true);
         *_ephStreamGPS << _pgmName.toAscii().data()
                        << _userName.toAscii().data()
                        << hlp.toAscii().data()
+        *_ephStreamGPS << _pgmName.toLatin1().data()
+                       << _userName.toLatin1().data()
+                       << hlp.toLatin1().data()
                        << "PGM / RUN BY / DATE" << endl;
 …
         QString line;
         line.sprintf("%9.2f%11sN: GPS NAV DATA%25sRINEX VERSION / TYPE\n",
                      t_rnxNavFile::defaultRnxNavVersion2, "", "");
+                     defaultRnxNavVersion2, "", "");
         *_ephStreamGPS << line;
         QString hlp = currentDateAndTimeGPS().date().toString("dd-MMM-yyyy").leftJustified(20, ' ', true);
         *_ephStreamGPS << _pgmName.toAscii().data()
                        << _userName.toAscii().data()
                        << hlp.toAscii().data()
+        *_ephStreamGPS << _pgmName.toLatin1().data()
+                       << _userName.toLatin1().data()
+                       << hlp.toLatin1().data()
                        << "PGM / RUN BY / DATE" << endl;
 …
         QString line;
         line.sprintf("%9.2f%11sG: GLONASS NAV DATA%21sRINEX VERSION / TYPE\n",
                      t_rnxNavFile::defaultRnxNavVersion2, "", "");
+                     defaultRnxNavVersion2, "", "");
         *_ephStreamGlonass << line;
         QString hlp = currentDateAndTimeGPS().date().toString("dd-MMM-yyyy").leftJustified(20, ' ', true);
         *_ephStreamGlonass << _pgmName.toAscii().data()
                            << _userName.toAscii().data()
                            << hlp.toAscii().data()
+        *_ephStreamGlonass << _pgmName.toLatin1().data()
+                           << _userName.toLatin1().data()
+                           << hlp.toLatin1().data()
                            << "PGM / RUN BY / DATE" << endl;
 …
 void t_bncCore::printEph(const t_eph& eph, bool printFile) {
   QString strV2 = eph.toString(t_rnxNavFile::defaultRnxNavVersion2);
   QString strV3 = eph.toString(t_rnxObsHeader::defaultRnxObsVersion3);
+  QString strV2 = eph.toString(defaultRnxNavVersion2);
+  QString strV3 = eph.toString(defaultRnxObsVersion3);
   if     (_rinexVers == 2 && eph.type() == t_eph::GLONASS) {
 …
   if (printFile && stream) {
     if (_rinexVers == 2) {
       *stream << strV2.toAscii();
+      *stream << strV2.toLatin1();
+    }
     else {
       *stream << strV3.toAscii();
+      *stream << strV3.toLatin1();
+    }
     stream->flush();
 …
       QTcpSocket* sock = is.next();
       if (sock->state() == QAbstractSocket::ConnectedState) {
         if (sock->write(strV3.toAscii()) == -1) {
+        if (sock->write(strV3.toLatin1()) == -1) {
           delete sock;
           is.remove();

trunk/BNC/src/bncfigureppp.h

r6730	r8127
43	43
44	44	private:
45		~~const static double _tRange = 300~~;
	45	enum {_tRange = 300};
46	46
47	47	class pppPos {

trunk/BNC/src/bncgetthread.cpp

-              r8123
+              r8127
 #include <sstream>
+#include <QComboBox>
+#include <QDialog>
 #include <QFile>
 #include <QTextStream>
 #include <QMutex>
 #include <QtNetwork>
+#include <QPushButton>
+#include <QTableWidget>
 #include <QTime>
 …
   _rawFile = 0;
   _mountPoint = mountPoint;
   _staID = mountPoint.path().mid(1).toAscii();
+  _staID = mountPoint.path().mid(1).toLatin1();
   _format = format;
   _latitude = latitude;
 …
       continue;
+    }
     QByteArray mp = hlp[0].toAscii();
+    QByteArray mp = hlp[0].toLatin1();
     if (_staID == mp) {
       nmeaPort = hlp[9].toInt();
 …
         hlp = "0.0";
+      }
       QByteArray _serialHeightNMEA = hlp.toAscii();
+      QByteArray _serialHeightNMEA = hlp.toLatin1();
       _manualNMEAString = ggaString(_latitude, _longitude, _serialHeightNMEA,
           nmeaMode);
 …
             QString prn(obs._prn.toString().c_str());
             emit(newMessage(
                 _staID + " (" + prn.toAscii() + ")"
+                _staID + " (" + prn.toLatin1() + ")"
                     + ": Wrong observation epoch(s)", false));
             continue;
 …
             long oldTime = it.value();
             if (obsTime < oldTime) {
               emit(newMessage(_staID + ": old observation " + prn.toAscii(),
+              emit(newMessage(_staID + ": old observation " + prn.toLatin1(),
                   false));
               continue;
 …
               emit(newMessage(
                   _staID + ": observation coming more than once "
                       + prn.toAscii(), false));
+                      + prn.toLatin1(), false));
               continue;
+            }
 …
       for (int ii = 0; ii < decoder()->_typeList.size(); ii++) {
         QString type = QString("%1 ").arg(decoder()->_typeList[ii]);
         emit(newMessage(_staID + ": Received message type " + type.toAscii(),
+        emit(newMessage(_staID + ": Received message type " + type.toLatin1(),
             true));
+      }
 …
             str << " " << rnxTypes[iType];
+          }
           emit(newMessage(_staID + ": Observation Types: " + msg.toAscii(),
+          emit(newMessage(_staID + ": Observation Types: " + msg.toLatin1(),
               true));
+        }
 …
       for (int ii = 0; ii < decoder()->_antType.size(); ii++) {
         QString ant1 = QString("%1 ").arg(decoder()->_antType[ii]);
         emit(newMessage(_staID + ": Antenna descriptor " + ant1.toAscii(), true));
+        emit(newMessage(_staID + ": Antenna descriptor " + ant1.toLatin1(), true));
+      }
 …
         QByteArray ant1, ant2, ant3;
         ant1 =
             QString("%1 ").arg(decoder()->_antList[ii].xx, 0, 'f', 4).toAscii();
+            QString("%1 ").arg(decoder()->_antList[ii].xx, 0, 'f', 4).toLatin1();
         ant2 =
             QString("%1 ").arg(decoder()->_antList[ii].yy, 0, 'f', 4).toAscii();
+            QString("%1 ").arg(decoder()->_antList[ii].yy, 0, 'f', 4).toLatin1();
         ant3 =
             QString("%1 ").arg(decoder()->_antList[ii].zz, 0, 'f', 4).toAscii();
+            QString("%1 ").arg(decoder()->_antList[ii].zz, 0, 'f', 4).toLatin1();
         emit(newMessage(_staID + ": " + antT + " (ITRF) X " + ant1 + "m", true));
         emit(newMessage(_staID + ": " + antT + " (ITRF) Y " + ant2 + "m", true));
 …
         if (decoder()->_antList[ii].height_f) {
           hh = decoder()->_antList[ii].height;
           QByteArray ant4 = QString("%1 ").arg(hh, 0, 'f', 4).toAscii();
+          QByteArray ant4 = QString("%1 ").arg(hh, 0, 'f', 4).toLatin1();
           emit(newMessage(
               _staID + ": Antenna height above marker " + ant4 + "m", true));
 …
           _gloSlots.sort();
           emit(newMessage(
               _staID + ": GLONASS Slot:Freq " + _gloSlots.join(" ").toAscii(),
+              _staID + ": GLONASS Slot:Freq " + _gloSlots.join(" ").toLatin1(),
               true));
+        }
 …
   _nmeaSockets->push_back(_nmeaServer->nextPendingConnection());
   emit(newMessage(
       QString("New PPP client on port: # %1").arg(_nmeaSockets->size()).toAscii(),
+      QString("New PPP client on port: # %1").arg(_nmeaSockets->size()).toLatin1(),
       true));
+}

trunk/BNC/src/bncmap_svg.cpp

r7667	r8127
247	247	QwtPlotRenderer renderer;
248	248	renderer.setDiscardFlag(QwtPlotRenderer::DiscardBackground, false);
249		renderer.setLayoutFlag(QwtPlotRenderer::KeepFrames, true);
	249	//renderer.setLayoutFlag(QwtPlotRenderer::KeepFrames, true);
250	250	renderer.renderTo(_mapPlot, printer);
251	251	}

trunk/BNC/src/bncrinex.cpp

-              r7878
+              r8127
       QStringList tags = line.split(";");
       if (tags.size() > 7) {
         if (tags.at(1) == _mountPoint.path().mid(1).toAscii()) {
+        if (tags.at(1) == _mountPoint.path().mid(1).toLatin1()) {
           net = tags.at(7);
           break;
 …
+  }
   _fName = path.toAscii();
+  _fName = path.toLatin1();
+}

trunk/BNC/src/bnctabledlg.cpp

-              r7680
+              r8127
 #include <iostream>
+#include <QHeaderView>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QVBoxLayout>
 #include "bnctabledlg.h"
 …
     if (url.host() == newHost) {
       _casterUserLineEdit->setText(
                 QUrl::fromPercentEncoding(url.userName().toAscii()));
+                QUrl::fromPercentEncoding(url.userName().toLatin1()));
       _casterPasswordLineEdit->setText(
                 QUrl::fromPercentEncoding(url.password().toAscii()));
+                QUrl::fromPercentEncoding(url.password().toLatin1()));
       if (url.port() > 0) {
         _casterPortLineEdit->setText(QString("%1").arg(url.port()));

trunk/BNC/src/bnctabledlg.h

-              r4658
+              r8127
 #include <QtCore>
 #include <QtGui>
+#include <QComboBox>
+#include <QDialog>
+#include <QPushButton>
+#include <QTableWidget>
 #include <QWhatsThis>

trunk/BNC/src/bncwindow.cpp

-              r8119
+              r8127
 #include <iostream>
+#include <QAction>
+#include <QApplication>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDialog>
+#include <QFontDialog>
+#include <QGridLayout>
+#include <QHeaderView>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMenu>
+#include <QMenuBar>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QSpinBox>
+#include <QTableWidgetItem>
+#include <QTextEdit>
+#include <QToolBar>
 #include <unistd.h>
 …
   _mountPointsTable->horizontalHeader()->resizeSection(6,5*ww);
   _mountPointsTable->horizontalHeader()->resizeSection(7,5*ww);
+#if QT_VERSION < 0x050000
   _mountPointsTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
+#else
+  _mountPointsTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
+#endif
   _mountPointsTable->horizontalHeader()->setStretchLastSection(true);
   _mountPointsTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
 …
   _cmbTable->horizontalHeader()->resizeSection(1,8*ww);
   _cmbTable->horizontalHeader()->resizeSection(2,8*ww);
+#if QT_VERSION < 0x050000
   _cmbTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
+#else
+  _cmbTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
+#endif
   _cmbTable->horizontalHeader()->setStretchLastSection(true);
   _cmbTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
 …
   _uploadTable->horizontalHeader()->resizeSection(10, 4*ww);
   _uploadTable->horizontalHeader()->resizeSection(11,12*ww);
+#if QT_VERSION < 0x050000
   _uploadTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
+#else
+  _uploadTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
+#endif
   _uploadTable->horizontalHeader()->setStretchLastSection(true);
   _uploadTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
 …
   _uploadEphTable->horizontalHeader()->resizeSection( 4,10*ww);
   _uploadEphTable->horizontalHeader()->resizeSection( 5,12*ww);
+#if QT_VERSION < 0x050000
   _uploadEphTable->horizontalHeader()->setResizeMode(QHeaderView::Interactive);
+#else
+  _uploadEphTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
+#endif
   _uploadEphTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
 …
            this, SLOT(slotMountPointsRead(QList<bncGetThread*>)));
   BNC_CORE->slotMessage("========== Start BNC v" BNCVERSION" ("BNC_OS") ==========", true);
+  BNC_CORE->slotMessage("========== Start BNC v" BNCVERSION " (" BNC_OS ") ==========", true);
   bncSettings settings;
 …
   img->setPixmap(QPixmap(":ntrip-logo.png"));
   dlgLayout->addWidget(img, 0,0);
   dlgLayout->addWidget(new QLabel("BKG Ntrip Client (BNC) Version "BNCVERSION), 0,1);
+  dlgLayout->addWidget(new QLabel("BKG Ntrip Client (BNC) Version " BNCVERSION), 0,1);
   dlgLayout->addWidget(tb,1,0,1,2);
   dlgLayout->addWidget(_closeButton,2,1,Qt::AlignRight);

trunk/BNC/src/bncwindow.h

r7889	r8127
27	27
28	28	#include <QtGui>
	29	#include <QMainWindow>
29	30	#include <QWhatsThis>
30	31

trunk/BNC/src/rinex/availplot.cpp

-              r6542
+              r8127
   setCanvasBackground(QColor(Qt::white));
   canvas()->setFrameStyle(QFrame::NoFrame | QFrame::Plain);
+  ((QwtPlotCanvas *)canvas())->setFrameStyle(QFrame::NoFrame | QFrame::Plain);
   // Axes
 …
                                     const QVector<double>& yData) {
   QwtPlotCurve* curve = new QwtPlotCurve(name);
+  curve->setSymbol(new QwtSymbol(symbol));
+  QwtSymbol *s = new QwtSymbol(symbol.style());
+  s->setSize(symbol.size());
+  s->setBrush(symbol.brush());
+  s->setPen(symbol.pen());
+  curve->setSymbol(s);
   curve->setStyle(QwtPlotCurve::NoCurve);
   curve->setXAxis(QwtPlot::xBottom);

trunk/BNC/src/rinex/dopplot.cpp

r6537	r8127
65	65
66	66	setCanvasBackground(QColor(Qt::white));
67		~~canvas(~~)->setFrameStyle(QFrame::NoFrame \| QFrame::Plain);
	67	((QwtPlotCanvas *)canvas())->setFrameStyle(QFrame::NoFrame \| QFrame::Plain);
68	68
69	69	// Axes

trunk/BNC/src/rinex/eleplot.cpp

-              r6537
+              r8127
   setCanvasBackground(QColor(Qt::white));
   canvas()->setFrameStyle(QFrame::NoFrame | QFrame::Plain);
+  ((QwtPlotCanvas *)canvas())->setFrameStyle(QFrame::NoFrame | QFrame::Plain);
   // Axes
 …
                                     const QVector<double>& yData) {
   QwtPlotCurve* curve = new QwtPlotCurve(name);
+  curve->setSymbol(new QwtSymbol(symbol));
+  QwtSymbol *s = new QwtSymbol(symbol.style());
+  s->setSize(symbol.size());
+  s->setBrush(symbol.brush());
+  s->setPen(symbol.pen());
+  curve->setSymbol(s);
   curve->setStyle(QwtPlotCurve::NoCurve);
   curve->setXAxis(QwtPlot::xBottom);

trunk/BNC/src/rinex/graphwin.cpp

-              r6262
+              r8127
      QwtLinearScaleEngine scaleEngine;
      _colorScale->setScaleDiv(scaleEngine.transformation(),
                               scaleEngine.divideScale(scaleInterval->minValue(),
+     _colorScale->setTransformation(scaleEngine.transformation());
+     _colorScale->setScaleDiv(scaleEngine.divideScale(scaleInterval->minValue(),
                                                       scaleInterval->maxValue(),
 , 5));

trunk/BNC/src/rinex/polarplot.cpp

-              r6262
+              r8127
   t_colorMap colorMap;
   for (int ii = from; ii <= to; ii++) {
+    QwtSymbol ss(symbol);
+    QwtSymbol ss(symbol.style());
+    ss.setSize(symbol.size());
     const QwtPointPolar& point = sample(ii);
     const QColor color = colorMap.color(_scaleInterval, point._value);

trunk/BNC/src/rinex/polarplot.h

r4356	r8127
51	51	virtual QwtPointPolar sample(size_t ii) const {
52	52	const t_polarPoint* point = _data->at(ii);
53		QwtPointPolar qp(point->_az, point->_zen); qp._value = point->_value;
	53	QwtPointPolar qp(point->_az, point->_zen); qp._value = point->_value;
54	54	return qp;
55	55	}

trunk/BNC/src/rinex/reqcedit.cpp

-              r7999
+              r8127
   int version     = settings.value("reqcRnxVersion").toInt();
   if (version < 3) {
     _rnxVersion = t_rnxObsHeader::defaultRnxObsVersion2;
+    _rnxVersion = defaultRnxObsVersion2;
+  }
   else {
     _rnxVersion = t_rnxObsHeader::defaultRnxObsVersion3;
+    _rnxVersion = defaultRnxObsVersion3;
+  }
   _samplingRate   = settings.value("reqcSampling").toInt();
 …
   if ( (haveGPS && haveGlonass) || _rnxVersion >= 3.0) {
     outNavFile.setVersion(t_rnxNavFile::defaultRnxNavVersion3);
+    outNavFile.setVersion(defaultRnxNavVersion3);
+  }
   else {
     outNavFile.setVersion(t_rnxNavFile::defaultRnxNavVersion2);
+    outNavFile.setVersion(defaultRnxNavVersion2);
+  }

trunk/BNC/src/rinex/rnxnavfile.h

-              r7999
+              r8127
 class t_eph;
+#define defaultRnxNavVersion2 2.11
+#define defaultRnxNavVersion3 3.03
 class t_rnxNavFile {
  public:
   enum e_inpOut {input, output};
-  static const double defaultRnxNavVersion2 = 2.11;
-  static const double defaultRnxNavVersion3 = 3.03;
  private:
   class t_rnxNavHeader {

trunk/BNC/src/rinex/rnxobsfile.cpp

-              r8112
+              r8127
     else if (key == "# / TYPES OF OBSERV") {
       if (_version == 0.0) {
         _version = t_rnxObsHeader::defaultRnxObsVersion2;
+        _version = defaultRnxObsVersion2;
+      }
       QTextStream* in = new QTextStream(value.toAscii(), QIODevice::ReadOnly);
 …
     else if (key == "SYS / # / OBS TYPES") {
       if (_version == 0.0) {
         _version = t_rnxObsHeader::defaultRnxObsVersion3;
+        _version = defaultRnxObsVersion3;
+      }
       QTextStream* in = new QTextStream(value.toAscii(), QIODevice::ReadOnly);
 …
   if (version <= 2) {
     _version = t_rnxObsHeader::defaultRnxObsVersion2;
+    _version = defaultRnxObsVersion2;
+  }
   else {
     _version = t_rnxObsHeader::defaultRnxObsVersion3;
+    _version = defaultRnxObsVersion3;
+  }
 …
   if (version <= 2) {
     _version = t_rnxObsHeader::defaultRnxObsVersion2;
+    _version = defaultRnxObsVersion2;
+  }
   else {
     _version = t_rnxObsHeader::defaultRnxObsVersion3;
+    _version = defaultRnxObsVersion3;
+  }
   _interval        = header._interval;

trunk/BNC/src/rinex/rnxobsfile.h

-              r7980
+              r8127
 #include "satObs.h"
+#define defaultRnxObsVersion2 2.11
+#define defaultRnxObsVersion3 3.03
 class t_rnxObsHeader {
 …
  public:
-  static const double  defaultRnxObsVersion2 = 2.11;
-  static const double  defaultRnxObsVersion3 = 3.03;
   static const QString defaultSystems;

Context Navigation

Changeset 8127 in ntrip for trunk/BNC

Legend: