Changeset 9383 for trunk/BNC – RTCM-Ntrip

trunk/BNC/qwt/qwt_abstract_legend.h

-              r8127
+              r9383
   Legends, that need to be under control of the QwtPlot layout system
   need to be derived from QwtAbstractLegend.
+  need to be derived from QwtAbstractLegend.
   \note Other type of legends can be implemented by connecting to
 …
       \param painter Painter
       \param rect Bounding rectangle
       \param fillBackground When true, fill rect with the widget background
+      \param fillBackground When true, fill rect with the widget background
       \sa renderLegend() is used by QwtPlotRenderer
     */
     virtual void renderLegend( QPainter *painter,
+    virtual void renderLegend( QPainter *painter,
         const QRectF &rect, bool fillBackground ) const = 0;
 …
       \param data List of legend entry attributes for the  item
      */
     virtual void updateLegend( const QVariant &itemInfo,
+    virtual void updateLegend( const QVariant &itemInfo,
         const QList<QwtLegendData> &data ) = 0;
 };
 #endif
+#endif

trunk/BNC/qwt/qwt_abstract_scale.cpp

-              r8127
+              r9383
   \sa lowerBound(), setScale(), setUpperBound()
   \note For inverted scales the lower bound
+  \note For inverted scales the lower bound
         is greater than the upper bound
 */
 …
   \sa upperBound(), setScale(), setLowerBound()
   \note For inverted scales the lower bound
+  \note For inverted scales the lower bound
         is greater than the upper bound
 */
 …
   \brief Specify a scale.
   Define a scale by an interval
   The ticks are calculated using scaleMaxMinor(),
+  Define a scale by an interval
+  The ticks are calculated using scaleMaxMinor(),
   scaleMaxMajor() and scaleStepSize().
 …
   \param upperBound upper limit of the scale interval
   \note For inverted scales the lower bound
+  \note For inverted scales the lower bound
         is greater than the upper bound
 */
 …
   Define a scale by an interval
   The ticks are calculated using scaleMaxMinor(),
+  The ticks are calculated using scaleMaxMinor(),
   scaleMaxMajor() and scaleStepSize().
 …
   The scale division might have been assigned explicitly
   or calculated implicitly by rescale().
+  or calculated implicitly by rescale().
  */
 const QwtScaleDiv &QwtAbstractScale::scaleDiv() const
 …
   Translate a scale value into a widget coordinate
   \param value Scale value
+  \param value Scale value
   \return Corresponding widget coordinate for value
   \sa scaleMap(), invTransform()
 …
   \sa scaleChange()
 */
 void QwtAbstractScale::rescale(
+void QwtAbstractScale::rescale(
     double lowerBound, double upperBound, double stepSize )
+{

trunk/BNC/qwt/qwt_abstract_scale.h

-              r8127
+              r9383
   The scale division might be assigned explicitly - but usually
   it is calculated from the boundaries using a QwtScaleEngine.
+  it is calculated from the boundaries using a QwtScaleEngine.
   The scale engine also decides the type of transformation of the scale
+  The scale engine also decides the type of transformation of the scale
   ( linear, logarithmic ... ).
 */
 …
 protected:
     void rescale( double lowerBound,
+    void rescale( double lowerBound,
         double upperBound, double stepSize );

trunk/BNC/qwt/qwt_abstract_scale_draw.cpp

-              r8127
+              r9383
         minExtent( 0.0 )
+    {
         components = QwtAbstractScaleDraw::Backbone
             | QwtAbstractScaleDraw::Ticks
+        components = QwtAbstractScaleDraw::Backbone
+            | QwtAbstractScaleDraw::Ticks
             | QwtAbstractScaleDraw::Labels;
 …
         painter->save();
         QPen pen = painter->pen();
+        pen = painter->pen();
         pen.setColor( palette.color( QPalette::WindowText ) );
         pen.setCapStyle( Qt::FlatCap );
 …
         painter->save();
         QPen pen = painter->pen();
+        pen = painter->pen();
         pen.setColor( palette.color( QPalette::WindowText ) );
         pen.setCapStyle( Qt::FlatCap );
 …
     const QFont &font, double value ) const
+{
+    QMap<double, QwtText>::const_iterator it = d_data->labelCache.find( value );
+    if ( it == d_data->labelCache.end() )
+    {
+        QwtText lbl = label( value );
+        lbl.setRenderFlags( 0 );
+        lbl.setLayoutAttribute( QwtText::MinimumLayout );
+        ( void )lbl.textSize( font ); // initialize the internal cache
+        it = d_data->labelCache.insert( value, lbl );
+    }
+    return ( *it );
+    QMap<double, QwtText>::const_iterator it1 = d_data->labelCache.constFind( value );
+    if ( it1 != d_data->labelCache.constEnd() )
+        return *it1;
+    QwtText lbl = label( value );
+    lbl.setRenderFlags( 0 );
+    lbl.setLayoutAttribute( QwtText::MinimumLayout );
+    ( void )lbl.textSize( font ); // initialize the internal cache
+    QMap<double, QwtText>::iterator it2 = d_data->labelCache.insert( value, lbl );
+    return *it2;
+}

trunk/BNC/qwt/qwt_abstract_scale_draw.h

-              r8127
+              r9383
     virtual ~QwtAbstractScaleDraw();
     void setScaleDiv( const QwtScaleDiv &s );
+    void setScaleDiv( const QwtScaleDiv & );
     const QwtScaleDiv& scaleDiv() const;
 …
     double maxTickLength() const;
     void setSpacing( double margin );
+    void setSpacing( double );
     double spacing() const;

trunk/BNC/qwt/qwt_abstract_slider.cpp

-              r8127
+              r9383
 #endif
 static double qwtAlignToScaleDiv(
+static double qwtAlignToScaleDiv(
     const QwtAbstractSlider *slider, double value )
+{
 …
         return sd.lowerBound();
     if ( tValue == slider->transform( sd.lowerBound() ) )
+    if ( tValue == slider->transform( sd.upperBound() ) )
         return sd.upperBound();
 …
+}
 /*!
+/*!
   Set the value to be valid/invalid
 …
         Q_EMIT valueChanged( d_data->value );
+    }
+}
+    }
+}
 //! \return True, when the value is invalid
 …
+{
     return d_data->isValid;
+}
+}
 /*!
 …
   \brief Enables or disables tracking.
   If tracking is enabled, the slider emits the valueChanged()
   signal while the movable part of the slider is being dragged.
   If tracking is disabled, the slider emits the valueChanged() signal
+  If tracking is enabled, the slider emits the valueChanged()
+  signal while the movable part of the slider is being dragged.
+  If tracking is disabled, the slider emits the valueChanged() signal
   only when the user releases the slider.
 …
    Wheel Event handler
    In/decreases the value by s number of steps. The direction
+   In/decreases the value by s number of steps. The direction
    depends on the invertedControls() property.
 …
   The range of the slider is divided into a number of steps from
   which the value increments according to user inputs depend.
+  which the value increments according to user inputs depend.
   The default setting is 100.
 …
   The range of the slider is divided into a number of steps from
   which the value increments according to user inputs depend.
+  which the value increments according to user inputs depend.
   \param stepCount Number of steps
 …
+{
     d_data->singleSteps = stepCount;
+}
+}
 /*!
 …
+{
     return d_data->singleSteps;
+}
 /*!
+}
+/*!
   \brief Set the number of steps for a page increment
   The range of the slider is divided into a number of steps from
   which the value increments according to user inputs depend.
+  which the value increments according to user inputs depend.
   \param stepCount Number of steps
 …
 */
 void QwtAbstractSlider::setStepAlignment( bool on )
+{
+{
     if ( on != d_data->stepAlignment )
+    {
         d_data->stepAlignment = on;
+    }
+}
+}
 /*!
   \return True, when step alignment is enabled
 …
 /*!
   If wrapping is true stepping up from upperBound() value will
   take you to the minimum() value and vice versa.
+  If wrapping is true stepping up from upperBound() value will
+  take you to the minimum() value and vice versa.
   \param on En/Disable wrapping
 …
+{
     d_data->wrapping = on;
+}
+}
 /*!
   \return True, when wrapping is set
   \sa setWrapping()
  */
+ */
 bool QwtAbstractSlider::wrapping() const
+{
 …
   Invert wheel and key events
   Usually scrolling the mouse wheel "up" and using keys like page
   up will increase the slider's value towards its maximum.
+  Usually scrolling the mouse wheel "up" and using keys like page
+  up will increase the slider's value towards its maximum.
   When invertedControls() is enabled the value is scrolled
   towards its minimum.
 …
 void QwtAbstractSlider::incrementValue( int stepCount )
+{
     const double value = incrementedValue(
+    const double value = incrementedValue(
         d_data->value, stepCount );
 …
 /*!
   Increment a value
   \param value Value
+  Increment a value
+  \param value Value
   \param stepCount Number of steps
   \return Incremented value
  */
 double QwtAbstractSlider::incrementedValue(
+double QwtAbstractSlider::incrementedValue(
     double value, int stepCount ) const
+{
 …
         // we need equidant steps according to
         // paint device coordinates
         const double range = transformation->transform( maximum() )
+        const double range = transformation->transform( maximum() )
             - transformation->transform( minimum() );
 …
         double v = transformation->transform( value );
         v = qRound( v / stepSize ) * stepSize;
+        v = qRound( v / stepSize ) * stepSize;
         v += stepCount * range / d_data->totalSteps;
 …
         if ( stepSize > 0.0 )
+        {
             value = lowerBound() +
+            value = lowerBound() +
                 qRound( ( value - lowerBound() ) / stepSize ) * stepSize;
+        }

trunk/BNC/qwt/qwt_abstract_slider.h

-              r8127
+              r9383
   A slider widget displays a value according to a scale.
   The class is designed as a common super class for widgets like
+  The class is designed as a common super class for widgets like
   QwtKnob, QwtDial and QwtSlider.
   When the slider is nor readOnly() its value can be modified
   by keyboard, mouse and wheel inputs.
+  When the slider is nor readOnly() its value can be modified
+  by keyboard, mouse and wheel inputs.
   The range of the slider is divided into a number of steps from
   which the value increments according to user inputs depend.
+  which the value increments according to user inputs depend.
   Only for linear scales the number of steps correspond with
   a fixed step size.
 …
     uint pageSteps() const;
     void setStepAlignment( bool );
+    void setStepAlignment( bool );
     bool stepAlignment() const;
 …
 public Q_SLOTS:
     void setValue( double val );
+    void setValue( double value );
 Q_SIGNALS:
 …
       \brief Notify a change of value.
       When tracking is enabled (default setting),
       this signal will be emitted every time the value changes.
+      When tracking is enabled (default setting),
+      this signal will be emitted every time the value changes.
       \param value New value
 …
     virtual double scrolledTo( const QPoint &pos ) const = 0;
     void incrementValue( int numSteps );
+    void incrementValue( int stepCount );
     virtual void scaleChange();
 …
     virtual void sliderChange();
     double incrementedValue(
+    double incrementedValue(
         double value, int stepCount ) const;

trunk/BNC/qwt/qwt_analog_clock.cpp

-              r8127
+              r9383
     setTotalSteps( 60 );
     const int secondsPerHour = 60.0 * 60.0;
+    const int secondsPerHour = 60.0 * 60.0;
     QList<double> majorTicks;
 …
     QColor knobColor = palette().color( QPalette::Active, QPalette::Text );
     knobColor = knobColor.dark( 120 );
+    knobColor = knobColor.darker( 120 );
     QColor handColor;
 …
+        {
             width = 2;
             handColor = knobColor.dark( 120 );
+            handColor = knobColor.darker( 120 );
+        }
         else
 …
+    {
         const double hours = value() / ( 60.0 * 60.0 );
         const double minutes =
+        const double minutes =
             ( value() - qFloor(hours) * 60.0 * 60.0 ) / 60.0;
         const double seconds = value() - qFloor(hours) * 60.0 * 60.0
 …
+        {
             const double d = 360.0 - angle[hand] - origin();
             drawHand( painter, static_cast<Hand>( hand ),
+            drawHand( painter, static_cast<Hand>( hand ),
                 center, radius, d, colorGroup );
+        }

trunk/BNC/qwt/qwt_analog_clock.h

r8127	r9383
22	22
23	23	\par Example
24		\code
	24	\code
25	25	#include <qwt_analog_clock.h>
26	26

trunk/BNC/qwt/qwt_arrow_button.h

r8127	r9383
36	36	virtual void paintEvent( QPaintEvent *event );
37	37
38		virtual void drawButtonLabel( QPainter *p );
	38	virtual void drawButtonLabel( QPainter * );
39	39	virtual void drawArrow( QPainter *,
40	40	const QRect &, Qt::ArrowType ) const;

trunk/BNC/qwt/qwt_clipper.cpp

-              r8127
+              r9383
+    }
     inline void reset()
+    {
         m_size = 0;
+    }
     inline int size() const
+    {
         return m_size;
+    }
     inline Point *data() const
+    {
         return m_buffer;
+    }
     inline Point &operator[]( int i )
+    {
         return m_buffer[i];
+    }
     inline const Point &operator[]( int i ) const
+    {
         return m_buffer[i];
+    inline void reset()
+    {
+        m_size = 0;
+    }
+    inline int size() const
+    {
+        return m_size;
+    }
+    inline Point *data() const
+    {
+        return m_buffer;
+    }
+    inline Point &operator[]( int i )
+    {
+        return m_buffer[i];
+    }
+    inline const Point &operator[]( int i ) const
+    {
+        return m_buffer[i];
+    }
 …
             m_capacity *= 2;
         m_buffer = static_cast<Point *>(
+        m_buffer = static_cast<Point *>(
             ::realloc( m_buffer, m_capacity * sizeof( Point ) ) );
+    }

trunk/BNC/qwt/qwt_clipper.h

-              r8127
+              r9383
+{
 public:
     static QPolygon clipPolygon( const QRect &,
+    static QPolygon clipPolygon( const QRect &,
         const QPolygon &, bool closePolygon = false );
     static QPolygon clipPolygon( const QRectF &,
+    static QPolygon clipPolygon( const QRectF &,
         const QPolygon &, bool closePolygon = false );
     static QPolygonF clipPolygonF( const QRectF &,
+    static QPolygonF clipPolygonF( const QRectF &,
         const QPolygonF &, bool closePolygon = false );

trunk/BNC/qwt/qwt_color_map.cpp

r8127	r9383
47	47	a = qAlpha( rgb );
48	48
49		/*
50		when mapping a value to rgb we will have to calcualate:
	49	/*
	50	when mapping a value to rgb we will have to calcualate:
51	51	- const int v = int( ( s1.v0 + ratio * s1.vStep ) + 0.5 );
52	52
…	…
346	346	QColor QwtLinearColorMap::color1() const
347	347	{
348		return QColor( d_data->colorStops.rgb( d_data->mode, 0.0 ) );
	348	return QColor::fromRgba( d_data->colorStops.rgb( d_data->mode, 0.0 ) );
349	349	}
350	350
…	…
355	355	QColor QwtLinearColorMap::color2() const
356	356	{
357		return QColor( d_data->colorStops.rgb( d_data->mode, 1.0 ) );
	357	return QColor::fromRgba( d_data->colorStops.rgb( d_data->mode, 1.0 ) );
358	358	}
359	359

trunk/BNC/qwt/qwt_color_map.h

r8127	r9383
107	107
108	108	QwtLinearColorMap( QwtColorMap::Format = QwtColorMap::RGB );
109		QwtLinearColorMap( const QColor &~~from, const QColor &to~~,
	109	QwtLinearColorMap( const QColor &color1, const QColor &color2,
110	110	QwtColorMap::Format = QwtColorMap::RGB );
111	111
…	…
185	185	{
186	186	const unsigned int index = colorIndex( interval, value );
187		return colorTable( interval )[index]; // slow
	187
	188	const QVector<QRgb> rgbTable = colorTable( interval );
	189	return rgbTable[index]; // slow
188	190	}
189	191	}

trunk/BNC/qwt/qwt_column_symbol.cpp

-              r8127
+              r9383
         style( QwtColumnSymbol::Box ),
         frameStyle( QwtColumnSymbol::Raised ),
+        palette( Qt::gray ),
         lineWidth( 2 )
+    {
-        palette = QPalette( Qt::gray );
+    }
 …
         default:
+        {
             painter->fillRect( r, d_data->palette.window() );
+        }
+    }
+}
+            painter->fillRect( r.adjusted( 0, 0, 1, 1 ), d_data->palette.window() );
+        }
+    }
+}

trunk/BNC/qwt/qwt_column_symbol.h

r8127	r9383
137	137	virtual ~QwtColumnSymbol();
138	138
139		void setFrameStyle( FrameStyle ~~style~~ );
	139	void setFrameStyle( FrameStyle );
140	140	FrameStyle frameStyle() const;
141	141

trunk/BNC/qwt/qwt_compass.cpp

-              r8127
+              r9383
 #include <qevent.h>
 /*!
+/*!
   \brief Constructor
 …
+}
 /*!
+/*!
   \brief Constructor
 …
   or returns an null text.
   \return Label, or QString::null
+  \return Label
   \sa labelMap(), setLabelMap()
 */

trunk/BNC/qwt/qwt_compass_rose.cpp

-              r8127
+              r9383
 #include "qwt_painter.h"
 #include <qpainter.h>
+static QPointF qwtIntersection(
+#include <qpainterpath.h>
+static QPointF qwtIntersection(
     QPointF p11, QPointF p12, QPointF p21, QPointF p22 )
+{
 …
+}
 /*!
+/*!
   \return Width of the rose
   \sa setWidth()

trunk/BNC/qwt/qwt_compass_rose.h

-              r8127
+              r9383
         \param colorGroup Color group
      */
     virtual void draw( QPainter *painter,
+    virtual void draw( QPainter *painter,
         const QPointF &center, double radius, double north,
         QPalette::ColorGroup colorGroup = QPalette::Active ) const = 0;
 …
     virtual ~QwtSimpleCompassRose();
     void setWidth( double w );
+    void setWidth( double );
     double width() const;
     void setNumThorns( int count );
+    void setNumThorns( int );
     int numThorns() const;
     void setNumThornLevels( int count );
+    void setNumThornLevels( int );
     int numThornLevels() const;
 …
     static void drawRose( QPainter *, const QPalette &,
         const QPointF &center, double radius, double origin, double width,
+        const QPointF &center, double radius, double north, double width,
         int numThorns, int numThornLevels, double shrinkFactor );
 …
 };
 #endif
+#endif

trunk/BNC/qwt/qwt_counter.cpp

-              r8127
+              r9383
 /*!
   The counter is initialized with a range is set to [0.0, 1.0] with
+  The counter is initialized with a range is set to [0.0, 1.0] with
 .01 as single step size. The value is invalid.
 …
         layout->addWidget( btn );
         connect( btn, SIGNAL( released() ), SLOT( btnReleased() ) );
         connect( btn, SIGNAL( clicked() ), SLOT( btnClicked() ) );
+        connect( btn, SIGNAL(released()), SLOT(btnReleased()) );
+        connect( btn, SIGNAL(clicked()), SLOT(btnClicked()) );
         d_data->buttonDown[i] = btn;
 …
     layout->addWidget( d_data->valueEdit );
+    connect( d_data->valueEdit, SIGNAL( editingFinished() ),
+         SLOT( textChanged() ) );
+    connect( d_data->valueEdit, SIGNAL(editingFinished()), SLOT(textChanged()) );
     layout->setStretchFactor( d_data->valueEdit, 10 );
 …
         layout->addWidget( btn );
         connect( btn, SIGNAL( released() ), SLOT( btnReleased() ) );
         connect( btn, SIGNAL( clicked() ), SLOT( btnClicked() ) );
+        connect( btn, SIGNAL(released()), SLOT(btnReleased()) );
+        connect( btn, SIGNAL(clicked()), SLOT(btnClicked()) );
         d_data->buttonUp[i] = btn;
 …
+}
 /*!
+/*!
   Set the counter to be in valid/invalid state
 …
   the buttons are disabled.
   \param on If true the counter will be set as valid
+  \param on If true the counter will be set as valid
   \sa setValue(), isValid()
 …
         else
+        {
             d_data->valueEdit->setText( QString::null );
+        }
+    }
+}
 /*!
+            d_data->valueEdit->setText( QString() );
+        }
+    }
+}
+/*!
   \return True, if the value is valid
   \sa setValid(), setValue()
 …
+{
     return d_data->isValid;
+}
+}
 /*!
 …
+}
 /*!
+/*!
    \return True, when the line line edit is read only. (default is no)
   \sa setReadOnly()
 …
   \brief En/Disable wrapping
   If wrapping is true stepping up from maximum() value will take
   you to the minimum() value and vice versa.
+  If wrapping is true stepping up from maximum() value will take
+  you to the minimum() value and vice versa.
   \param on En/Disable wrapping

trunk/BNC/qwt/qwt_counter.h

-              r8127
+              r9383
   and a step size. When the wrapping property is set
   the counter is circular.
   The number of steps by which a button increments or decrements the value
   can be specified using setIncSteps(). The number of buttons can be
+  The number of steps by which a button increments or decrements the value
+  can be specified using setIncSteps(). The number of buttons can be
   changed with setNumButtons().
 …
     void setReadOnly( bool );
     void setNumButtons( int n );
+    void setNumButtons( int );
     int numButtons() const;
     void setIncSteps( QwtCounter::Button btn, int nSteps );
     int incSteps( QwtCounter::Button btn ) const;
+    void setIncSteps( QwtCounter::Button, int numSteps );
+    int incSteps( QwtCounter::Button ) const;
     virtual QSize sizeHint() const;
     double singleStep() const;
     void setSingleStep( double s );
+    void setSingleStep( double stepSize );
     void setRange( double min, double max );
     double minimum() const;
     void setMinimum( double min );
+    void setMinimum( double );
     double maximum() const;
     void setMaximum( double max );
+    void setMaximum( double );
     void setStepButton1( int nSteps );

trunk/BNC/qwt/qwt_curve_fitter.cpp

-              r8127
+              r9383
 /*!
+  \return Maximum for the number of points passed to a run
+  \return Maximum for the number of points passed to a run
           of the algorithm - or 0, when unlimited
   \sa setChunkSize()
 …
 QPolygonF QwtWeedingCurveFitter::fitCurve( const QPolygonF &points ) const
+{
+    if ( points.isEmpty() )
+        return points;
     QPolygonF fittedPoints;
     if ( d_data->chunkSize == 0 )
+    {

trunk/BNC/qwt/qwt_curve_fitter.h

r8127	r9383
78	78	QwtSpline &spline();
79	79
80		void setSplineSize( int ~~size~~ );
	80	void setSplineSize( int );
81	81	int splineSize() const;
82	82

trunk/BNC/qwt/qwt_date.cpp

-              r8127
+              r9383
 #endif
 static QString qwtExpandedFormat( const QString & format,
+static QString qwtExpandedFormat( const QString & format,
     const QDateTime &dateTime, QwtDate::Week0Type week0Type )
+{
 …
+}
 static inline void qwtFloorTime(
+static inline void qwtFloorTime(
     QwtDate::IntervalType intervalType, QDateTime &dt )
+{
 …
             dt.setTime( QTime( t.hour(), 0, 0 ) );
             break;
+        }
+        }
         default:
             break;
 …
+}
 static inline QDateTime qwtToTimeSpec(
+static inline QDateTime qwtToTimeSpec(
     const QDateTime &dt, Qt::TimeSpec spec )
+{
 …
+}
+#if 0
 static inline double qwtToJulianDay( int year, int month, int day )
+{
 …
     if ( a < 0 )
         a -= b - 1;
     return a / b;
+}
+}
+#endif
 static inline QDate qwtToDate( int year, int month = 1, int day = 1 )
 …
   Translate from double to QDateTime
   \param value Number of milliseconds since the epoch,
+  \param value Number of milliseconds since the epoch,
 -01-01T00:00:00 UTC
   \param timeSpec Time specification
 …
     const QTime time = dt.time();
     const double secs = 3600.0 * time.hour() +
+    const double secs = 3600.0 * time.hour() +
 .0 * time.minute() + time.second();
 …
   \param dateTime Datetime value
   \param intervalType Interval type, how to ceil.
+  \param intervalType Interval type, how to ceil.
                       F.e. when intervalType = QwtDate::Months, the result
                       will be ceiled to the next beginning of a month
 …
+        {
             dt.setTime( QTime( 0, 0 ) );
             dt.setDate( qwtToDate( dateTime.date().year(),
+            dt.setDate( qwtToDate( dateTime.date().year(),
                 dateTime.date().month() ) );
 …
   \param dateTime Datetime value
   \param intervalType Interval type, how to ceil.
+  \param intervalType Interval type, how to ceil.
                       F.e. when intervalType = QwtDate::Months,
                       the result will be ceiled to the next
+                      the result will be ceiled to the next
                       beginning of a month
   \return Floored datetime
   \sa floor()
  */
 QDateTime QwtDate::floor( const QDateTime &dateTime,
+QDateTime QwtDate::floor( const QDateTime &dateTime,
     IntervalType intervalType )
+{
 …
             dt.setTime( QTime( 0, 0 ) );
             const QDate date = qwtToDate( dt.date().year(),
+            const QDate date = qwtToDate( dt.date().year(),
                 dt.date().month() );
             dt.setDate( date );
 …
   Minimum for the supported date range
   The range of valid dates depends on how QDate stores the
+  The range of valid dates depends on how QDate stores the
   Julian day internally.
 …
   Maximum for the supported date range
   The range of valid dates depends on how QDate stores the
+  The range of valid dates depends on how QDate stores the
   Julian day internally.
 …
   The first day of a week depends on the current locale
   ( QLocale::firstDayOfWeek() ).
+  ( QLocale::firstDayOfWeek() ).
   \param year Year
 …
   \sa QLocale::firstDayOfWeek(), weekNumber()
  */
+ */
 QDate QwtDate::dateOfWeek0( int year, Week0Type type )
+{
 …
+    {
         // according to ISO 8601 the first week is defined
         // by the first thursday.
+        // by the first thursday.
         int d = Qt::Thursday - firstDayOfWeek;
 …
   - QwtDate::FirstThursday\n
     Corresponding to ISO 8601 ( see QDate::weekNumber() ).
+    Corresponding to ISO 8601 ( see QDate::weekNumber() ).
   - QwtDate::FirstDay\n
 …
     week number with a leading zero ( 01 - 53 )
   As week 1 usually starts in the previous year a special rule
+  As week 1 usually starts in the previous year a special rule
   is applied for formats, where the year is expected to match the
   week number - even if the date belongs to the previous year.

trunk/BNC/qwt/qwt_date.h

-              r8127
+              r9383
   A double is interpreted as the number of milliseconds since
 -01-01T00:00:00 Universal Coordinated Time - also known
   as "The Epoch".
+  as "The Epoch".
   While the range of the Julian day in Qt4 is limited to [0, MAX_INT],
   Qt5 stores it as qint64 offering a huge range of valid dates.
   As the significance of a double is below this ( assuming a
   fraction of 52 bits ) the translation is not
   bijective with rounding errors for dates very far from Epoch.
   For a resolution of 1 ms those start to happen for dates above the
   year 144683.
+  While the range of the Julian day in Qt4 is limited to [0, MAX_INT],
+  Qt5 stores it as qint64 offering a huge range of valid dates.
+  As the significance of a double is below this ( assuming a
+  fraction of 52 bits ) the translation is not
+  bijective with rounding errors for dates very far from Epoch.
+  For a resolution of 1 ms those start to happen for dates above the
+  year 144683.
   An axis for a date/time interval is expected to be aligned
 …
+{
 public:
     /*!
+    /*!
        How to identify the first week of year differs between
        countries.
+       countries.
      */
     enum Week0Type
 …
         /*!
             "The week with January 1.1 in it."
             In the U.S. this definition is more common than
             FirstThursday.
 …
     };
     /*!
+    /*!
       Classification of an time interval
 …
     static QDate maxDate();
     static QDateTime toDateTime( double value,
+    static QDateTime toDateTime( double value,
         Qt::TimeSpec = Qt::UTC );
 …
     static int utcOffset( const QDateTime & );
     static QString toString( const QDateTime &,
+    static QString toString( const QDateTime &,
         const QString & format, Week0Type );
 };

trunk/BNC/qwt/qwt_date_scale_draw.cpp

-              r8127
+              r9383
   \brief Constructor
   The default setting is to display tick labels for the
+  The default setting is to display tick labels for the
   given time specification. The first week of a year is defined like
   for QwtDate::FirstThursday.
 …
   \sa week0Type().
   \note week0Type has no effect beside for intervals classified as
         QwtDate::Week.
+        QwtDate::Week.
  */
 void QwtDateScaleDraw::setWeek0Type( QwtDate::Week0Type week0Type )
 …
 /*!
   \return Setting how to identify the first week of a year.
+  \return Setting how to identify the first week of a year.
   \sa setWeek0Type()
  */
 …
   \sa dateFormat(), dateFormatOfDate(), QwtDate::toString()
  */
 void QwtDateScaleDraw::setDateFormat(
+void QwtDateScaleDraw::setDateFormat(
     QwtDate::IntervalType intervalType, const QString &format )
+{
     if ( intervalType >= QwtDate::Millisecond &&
+    if ( intervalType >= QwtDate::Millisecond &&
         intervalType <= QwtDate::Year )
+    {
 …
   \sa setDateFormat(), dateFormatOfDate()
  */
 QString QwtDateScaleDraw::dateFormat(
+QString QwtDateScaleDraw::dateFormat(
     QwtDate::IntervalType intervalType ) const
+{
     if ( intervalType >= QwtDate::Millisecond &&
+    if ( intervalType >= QwtDate::Millisecond &&
         intervalType <= QwtDate::Year )
+    {
 …
+    }
     return QString::null;
+    return QString();
+}
 …
     Q_UNUSED( dateTime )
     if ( intervalType >= QwtDate::Millisecond &&
+    if ( intervalType >= QwtDate::Millisecond &&
         intervalType <= QwtDate::Year )
+    {
 …
+{
     const QDateTime dt = toDateTime( value );
     const QString fmt = dateFormatOfDate(
+    const QString fmt = dateFormatOfDate(
         dt, intervalType( scaleDiv() ) );
 …
   \sa dateFormatOfDate()
  */
 QwtDate::IntervalType QwtDateScaleDraw::intervalType(
+QwtDate::IntervalType QwtDateScaleDraw::intervalType(
     const QwtScaleDiv &scaleDiv ) const
+{
 …
         for ( int j = QwtDate::Second; j <= intvType; j++ )
+        {
             const QDateTime dt0 = QwtDate::floor( dt,
+            const QDateTime dt0 = QwtDate::floor( dt,
                 static_cast<QwtDate::IntervalType>( j ) );

trunk/BNC/qwt/qwt_date_scale_draw.h

r8127	r9383
73	73
74	74	protected:
75		virtual QwtDate::IntervalType
	75	virtual QwtDate::IntervalType
76	76	intervalType( const QwtScaleDiv & ) const;
77	77

trunk/BNC/qwt/qwt_date_scale_engine.cpp

-              r8127
+              r9383
 #include <limits.h>
 static inline double qwtMsecsForType( QwtDate::IntervalType type )
+static inline double qwtMsecsForType( int type )
+{
     static const double msecs[] =
 …
 static double qwtIntervalWidth( const QDateTime &minDate,
     const QDateTime &maxDate, QwtDate::IntervalType intervalType )
+    const QDateTime &maxDate, QwtDate::IntervalType intervalType )
+{
     switch( intervalType )
 …
         case QwtDate::Month:
+        {
             const double years =
+            const double years =
                 double( maxDate.date().year() ) - minDate.date().year();
 …
         case QwtDate::Year:
+        {
             double years =
+            double years =
                 double( maxDate.date().year() ) - minDate.date().year();
 …
+}
 static double qwtRoundedIntervalWidth(
     const QDateTime &minDate, const QDateTime &maxDate,
     QwtDate::IntervalType intervalType )
+static double qwtRoundedIntervalWidth(
+    const QDateTime &minDate, const QDateTime &maxDate,
+    QwtDate::IntervalType intervalType )
+{
     const QDateTime minD = QwtDate::floor( minDate, intervalType );
 …
+}
 static int qwtStepSize( int intervalSize, int maxSteps, uint base )
+static int qwtStepSize( int intervalSize, int maxSteps, uint base )
+{
     if ( maxSteps <= 0 )
 …
+}
 static int qwtDivideInterval( double intervalSize, int numSteps,
+static int qwtDivideInterval( double intervalSize, int numSteps,
     const int limits[], size_t numLimits )
+{
 …
     if ( intervalType != QwtDate::Day )
+    {
         if ( ( intervalSize > numSteps ) &&
+        if ( ( intervalSize > numSteps ) &&
             ( intervalSize <= 2 * numSteps ) )
+        {
 …
+        {
             static int limits[] = { 1, 2, 5, 10, 15, 20, 30, 60 };
             stepSize = qwtDivideInterval( intervalSize, numSteps,
                 limits, sizeof( limits ) / sizeof( int ) );
 …
+        {
             static int limits[] = { 1, 2, 3, 4, 6, 12, 24 };
             stepSize = qwtDivideInterval( intervalSize, numSteps,
                 limits, sizeof( limits ) / sizeof( int ) );
 …
             if ( stepSize > maxMinSteps )
+            {
                 numSteps = qwtStepCount( stepSize, maxMinSteps,
+                numSteps = qwtStepCount( stepSize, maxMinSteps,
                     limits, sizeof( limits ) / sizeof( int ) );
 …
             else
+            {
                 numSteps = qwtStepCount( stepSize * 60, maxMinSteps,
+                numSteps = qwtStepCount( stepSize * 60, maxMinSteps,
                     limits, sizeof( limits ) / sizeof( int ) );
+            }
 …
                 else
+                {
                     minStepSize = QwtScaleArithmetic::divideInterval(
+                    minStepSize = QwtScaleArithmetic::divideInterval(
                         stepSizeInWeeks, maxMinSteps, 10 );
+                }
 …
                     minStepSize = double( stepSize ) / numSteps;
+            }
             break;
+        }
 …
+}
 static QwtScaleDiv qwtDivideToSeconds(
+static QwtScaleDiv qwtDivideToSeconds(
     const QDateTime &minDate, const QDateTime &maxDate,
     double stepSize, int maxMinSteps,
     QwtDate::IntervalType intervalType )
+    QwtDate::IntervalType intervalType )
+{
     // calculate the min step size
     double minStepSize = 0;
     if ( maxMinSteps > 1 )
+    {
         minStepSize = qwtDivideMajorStep( stepSize,
+    if ( maxMinSteps > 1 )
+    {
+        minStepSize = qwtDivideMajorStep( stepSize,
             maxMinSteps, intervalType );
+    }
 …
     const int secondsMajor = static_cast<int>( stepSize * s );
     const double secondsMinor = minStepSize * s;
     // UTC excludes daylight savings. So from the difference
     // of a date and its UTC counterpart we can find out
 …
     QList<double> minorTicks;
     for ( QDateTime dt = minDate; dt <= maxDate;
+    for ( QDateTime dt = minDate; dt <= maxDate;
         dt = dt.addSecs( secondsMajor ) )
+    {
 …
                 // we add some minor ticks for the DST hour,
                 // otherwise the ticks will be unaligned: 0, 2, 3, 5 ...
                 minorTicks += qwtDstTicks(
+                minorTicks += qwtDstTicks(
                     dt, secondsMajor, qRound( secondsMinor ) );
+            }
 …
             for ( int i = 1; i < numMinorSteps; i++ )
+            {
                 const QDateTime mt = dt.addMSecs(
+                const QDateTime mt = dt.addMSecs(
                     qRound64( i * secondsMinor * 1000 ) );
 …
                 if ( minorTicks.isEmpty() || minorTicks.last() != minorValue )
+                {
                     const bool isMedium = ( numMinorSteps % 2 == 0 )
+                    const bool isMedium = ( numMinorSteps % 2 == 0 )
                         && ( i != 1 ) && ( i == numMinorSteps / 2 );
 …
+}
 static QwtScaleDiv qwtDivideToMonths(
+static QwtScaleDiv qwtDivideToMonths(
     QDateTime &minDate, const QDateTime &maxDate,
     double stepSize, int maxMinSteps )
+{
     // months are intervals with non
     // equidistant ( in ms ) steps: we have to build the
+    double stepSize, int maxMinSteps )
+{
+    // months are intervals with non
+    // equidistant ( in ms ) steps: we have to build the
     // scale division manually
     int minStepDays = 0;
     int minStepSize = 0.0;
+    int minStepSize = 0.0;
     if ( maxMinSteps > 1 )
 …
         else
+        {
             minStepSize = qwtDivideMajorStep(
+            minStepSize = qwtDivideMajorStep(
                 stepSize, maxMinSteps, QwtDate::Month );
+        }
 …
     QList<double> minorTicks;
     for ( QDateTime dt = minDate;
+    for ( QDateTime dt = minDate;
         dt <= maxDate; dt = dt.addMonths( stepSize ) )
+    {
 …
         if ( minStepDays > 0 )
+        {
             for ( int days = minStepDays;
+            for ( int days = minStepDays;
                 days < 30; days += minStepDays )
+            {
 …
+}
 static QwtScaleDiv qwtDivideToYears(
+static QwtScaleDiv qwtDivideToYears(
     const QDateTime &minDate, const QDateTime &maxDate,
     double stepSize, int maxMinSteps )
+    double stepSize, int maxMinSteps )
+{
     QList<double> majorTicks;
 …
     if ( maxMinSteps > 1 )
+    {
         minStepSize = qwtDivideMajorStep(
+        minStepSize = qwtDivideMajorStep(
             stepSize, maxMinSteps, QwtDate::Year );
+    }
 …
             break;
+        }
+    }
+    }
     QwtScaleDiv scaleDiv;
 …
     QwtDate::Week0Type week0Type;
     int maxWeeks;
 };
+};
 …
   \brief Constructor
   The engine is initialized to build scales for the
+  The engine is initialized to build scales for the
   given time specification. It classifies intervals > 4 weeks
   as >= Qt::Month. The first week of a year is defined like
 …
   \sa week0Type(), setMaxWeeks()
   \note week0Type has no effect beside for intervals classified as
         QwtDate::Week.
+        QwtDate::Week.
  */
 void QwtDateScaleEngine::setWeek0Type( QwtDate::Week0Type week0Type )
 …
 /*!
   \return Setting how to identify the first week of a year.
+  \return Setting how to identify the first week of a year.
   \sa setWeek0Type(), maxWeeks()
  */
 …
   \param weeks Upper limit for the number of weeks
   \note In business charts a year is often devided
+  \note In business charts a year is often divided
         into weeks [1-52]
   \sa maxWeeks(), setWeek0Type()
+  \sa maxWeeks(), setWeek0Type()
  */
 void QwtDateScaleEngine::setMaxWeeks( int weeks )
 …
   \return Interval classification
  */
 QwtDate::IntervalType QwtDateScaleEngine::intervalType(
     const QDateTime &minDate, const QDateTime &maxDate,
+QwtDate::IntervalType QwtDateScaleEngine::intervalType(
+    const QDateTime &minDate, const QDateTime &maxDate,
     int maxSteps ) const
+{
 …
   Align and divide an interval
   The algorithm aligns and divides the interval into steps.
+  The algorithm aligns and divides the interval into steps.
   Datetime interval divisions are usually not equidistant and the
   calculated stepSize can only be used as an approximation
   for the steps calculated by divideScale().
+  for the steps calculated by divideScale().
   \param maxNumSteps Max. number of steps
 …
             maxNumSteps = 1;
         const QwtDate::IntervalType intvType =
+        const QwtDate::IntervalType intvType =
             intervalType( from, to, maxNumSteps );
 …
+    }
     const QwtDate::IntervalType intvType =
+    const QwtDate::IntervalType intvType =
         intervalType( from, to, maxMajorSteps );
 …
         const QDateTime maxDate = QwtDate::ceil( to, intvType );
         scaleDiv = buildScaleDiv( minDate, maxDate,
+        scaleDiv = buildScaleDiv( minDate, maxDate,
             maxMajorSteps, maxMinorSteps, intvType );
 …
+}
 QwtScaleDiv QwtDateScaleEngine::buildScaleDiv(
+QwtScaleDiv QwtDateScaleEngine::buildScaleDiv(
     const QDateTime &minDate, const QDateTime &maxDate,
     int maxMajorSteps, int maxMinorSteps,
 …
+{
     // calculate the step size
     const double stepSize = qwtDivideScale(
         qwtIntervalWidth( minDate, maxDate, intervalType ),
+    const double stepSize = qwtDivideScale(
+        qwtIntervalWidth( minDate, maxDate, intervalType ),
         maxMajorSteps, intervalType );
 …
     if ( !dt0.isValid() )
+    {
         // the floored date is out of the range of a
+        // the floored date is out of the range of a
         // QDateTime - we ceil instead.
         dt0 = alignDate( minDate, stepSize, intervalType, true );
 …
     if ( intervalType <= QwtDate::Week )
+    {
         scaleDiv = qwtDivideToSeconds( dt0, maxDate,
+        scaleDiv = qwtDivideToSeconds( dt0, maxDate,
             stepSize, maxMinorSteps, intervalType );
+    }
 …
   For Qt::Day alignments there is no "natural day 0" -
   instead the first day of the year is used to avoid jumping
+  instead the first day of the year is used to avoid jumping
   major ticks positions when panning a scale. For other alignments
   ( f.e according to the first day of the month ) alignDate()
 …
   \return Aligned date/time value
  */
 QDateTime QwtDateScaleEngine::alignDate(
     const QDateTime &dateTime, double stepSize,
+QDateTime QwtDateScaleEngine::alignDate(
+    const QDateTime &dateTime, double stepSize,
     QwtDate::IntervalType intervalType, bool up ) const
+{
 …
         case QwtDate::Millisecond:
+        {
             const int ms = qwtAlignValue(
+            const int ms = qwtAlignValue(
                 dt.time().msec(), stepSize, up ) ;
 …
     if ( !dt.isValid() )
+    {
         const QDate date = ( value <= 0.0 )
+        const QDate date = ( value <= 0.0 )
             ? QwtDate::minDate() : QwtDate::maxDate();

trunk/BNC/qwt/qwt_date_scale_engine.h

-              r8127
+              r9383
   QwtDateScaleEngine supports representations depending
   on Qt::TimeSpec specifications. The valid range for scales
   is limited by the range of QDateTime, that differs
+  is limited by the range of QDateTime, that differs
   between Qt4 and Qt5.
   Datetime values are expected as the number of milliseconds since
 -01-01T00:00:00 Universal Coordinated Time - also known
   as "The Epoch", that can be converted to QDateTime using
+  as "The Epoch", that can be converted to QDateTime using
   QwtDate::toDateTime().
 …
     void setWeek0Type( QwtDate::Week0Type );
     QwtDate::Week0Type week0Type() const;
     void setMaxWeeks( int );
     int maxWeeks() const;
 …
         double &x1, double &x2, double &stepSize ) const;
     virtual QwtScaleDiv divideScale(
+    virtual QwtScaleDiv divideScale(
         double x1, double x2,
         int maxMajorSteps, int maxMinorSteps,
         double stepSize = 0.0 ) const;
     virtual QwtDate::IntervalType intervalType(
+    virtual QwtDate::IntervalType intervalType(
         const QDateTime &, const QDateTime &, int maxSteps ) const;
 …
 private:
     QwtScaleDiv buildScaleDiv( const QDateTime &, const QDateTime &,
         int maxMajorSteps, int maxMinorSteps,
+        int maxMajorSteps, int maxMinorSteps,
         QwtDate::IntervalType ) const;

trunk/BNC/qwt/qwt_dial.cpp

-              r8127
+              r9383
     const QRect cr = contentsRect();
     const double dim = qMin( cr.width(), cr.height() );
+    const int dim = qMin( cr.width(), cr.height() );
     QRect inner( 0, 0, dim, dim );
 …
         p.setRenderHint( QPainter::Antialiasing, true );
         p.translate( -r.topLeft() );
         if ( d_data->mode != QwtDial::RotateScale )
             drawContents( &p );
 …
   \param radius Radius of the scale
 */
 void QwtDial::drawScale( QPainter *painter,
+void QwtDial::drawScale( QPainter *painter,
     const QPointF &center, double radius ) const
+{
 …
   The motivation for setting a scale draw is often
   to overload QwtRoundScaleDraw::label() to return
+  to overload QwtRoundScaleDraw::label() to return
   individual tick labels.
   \param scaleDraw Scale draw
   \warning The previous scale draw is deleted
 …
         maxScaleArc = minScaleArc + 360.0;
     if ( ( minScaleArc != d_data->minScaleArc ) ||
+    if ( ( minScaleArc != d_data->minScaleArc ) ||
         ( maxScaleArc != d_data->maxScaleArc ) )
+    {
 …
+}
 /*!
+/*!
   Set the lower limit for the scale arc
 …
+}
 /*!
+/*!
   \return Lower limit of the scale arc
   \sa setScaleArc()
 …
+}
 /*!
+/*!
   Set the upper limit for the scale arc
 …
+}
 /*!
+/*!
   \return Upper limit of the scale arc
   \sa setScaleArc()
 …
     const int d = 6 * sh + 2 * lineWidth();
     QSize hint( d, d );
+    QSize hint( d, d );
     if ( !isReadOnly() )
         hint = hint.expandedTo( QApplication::globalStrut() );
 …
   \param pos Mouse position
   \retval True, when the inner circle contains pos
+  \retval True, when the inner circle contains pos
   \sa scrolledTo()
 */
 …
             angle = 360.0 - angle;
         double valueAngle =
+        double valueAngle =
             qwtNormalizeDegrees( 90.0 - scaleMap().transform( value() ) );
 …
             if ( qAbs( arc ) > 180.0 )
+            {
                 boundedAngle = ( arc > 0 )
+                boundedAngle = ( arc > 0 )
                     ? scaleMap().p1() : scaleMap().p2();
+            }
 …
             break;
+    }
     QwtAbstractSlider::changeEvent( event );
+}
 …
 /*!
   Invalidate the internal caches and call
+  Invalidate the internal caches and call
   QwtAbstractSlider::scaleChange()
  */

trunk/BNC/qwt/qwt_dial.h

-              r8127
+              r9383
     Mode mode() const;
     void setScaleArc( double min, double max );
+    void setScaleArc( double minArc, double maxArc );
     void setMinScaleArc( double min );
+    void setMinScaleArc( double );
     double minScaleArc() const;
     void setMaxScaleArc( double min );
+    void setMaxScaleArc( double );
     double maxScaleArc() const;
 …
     virtual void changeEvent( QEvent * );
     virtual void drawFrame( QPainter *p );
+    virtual void drawFrame( QPainter * );
     virtual void drawContents( QPainter * ) const;
     virtual void drawFocusIndicator( QPainter * ) const;
 …
     void invalidateCache();
     virtual void drawScale( QPainter *,
+    virtual void drawScale( QPainter *,
         const QPointF &center, double radius ) const;
     virtual void drawScaleContents( QPainter *painter,
+    virtual void drawScaleContents( QPainter *painter,
         const QPointF &center, double radius ) const;

trunk/BNC/qwt/qwt_dial_needle.cpp

-              r8127
+              r9383
 #include <qapplication.h>
 #include <qpainter.h>
+#include <qpainterpath.h>
 #if QT_VERSION < 0x040601
 …
+}
 static void qwtDrawShadedPointer( QPainter *painter,
+static void qwtDrawShadedPointer( QPainter *painter,
     const QColor &lightColor, const QColor &darkColor,
     double length, double width )
 …
     QColor color[4];
     color[0] = darkColor.light( 100 + colorOffset );
     color[1] = darkColor.dark( 100 + colorOffset );
     color[2] = lightColor.light( 100 + colorOffset );
     color[3] = lightColor.dark( 100 + colorOffset );
+    color[0] = darkColor.lighter( 100 + colorOffset );
+    color[1] = darkColor.darker( 100 + colorOffset );
+    color[2] = lightColor.lighter( 100 + colorOffset );
+    color[3] = lightColor.darker( 100 + colorOffset );
     painter->setPen( Qt::NoPen );
 …
   \param colorGroup Color group, used for painting
 */
 void QwtDialNeedle::draw( QPainter *painter,
     const QPointF &center, double length, double direction,
+void QwtDialNeedle::draw( QPainter *painter,
+    const QPointF &center, double length, double direction,
     QPalette::ColorGroup colorGroup ) const
+{
 …
  \param colorGroup Color group, used for painting
 */
 void QwtDialSimpleNeedle::drawNeedle( QPainter *painter,
+void QwtDialSimpleNeedle::drawNeedle( QPainter *painter,
     double length, QPalette::ColorGroup colorGroup ) const
+{
 …
             width = qMax(length * 0.06, 6.0);
         qwtDrawArrowNeedle( painter,
+        qwtDrawArrowNeedle( painter,
             palette(), colorGroup, length, width );
 …
         if ( width <= 0.0 )
             width = 5.0;
         QPen pen ( palette().brush( colorGroup, QPalette::Mid ), width );
         pen.setCapStyle( Qt::FlatCap );
         painter->setPen( pen );
         painter->drawLine( QPointF( 0.0, 0.0 ), QPointF( length, 0.0 ) );
 …
     \param colorGroup Color group, used for painting
 */
 void QwtCompassMagnetNeedle::drawNeedle( QPainter *painter,
+void QwtCompassMagnetNeedle::drawNeedle( QPainter *painter,
     double length, QPalette::ColorGroup colorGroup ) const
+{
 …
         qwtDrawShadedPointer( painter,
             dark.light( 100 + colorOffset ),
             dark.dark( 100 + colorOffset ),
+            dark.lighter( 100 + colorOffset ),
+            dark.darker( 100 + colorOffset ),
             length, width );
         painter->rotate( 180.0 );
         qwtDrawShadedPointer( painter,
             light.light( 100 + colorOffset ),
             light.dark( 100 + colorOffset ),
+            light.lighter( 100 + colorOffset ),
+            light.darker( 100 + colorOffset ),
             length, width );
         const QBrush baseBrush = palette().brush( colorGroup, QPalette::Base );
         drawKnob( painter, width, baseBrush, true );
 …
  \param colorGroup Color group, used for painting
 */
 void QwtCompassWindArrow::drawNeedle( QPainter *painter,
+void QwtCompassWindArrow::drawNeedle( QPainter *painter,
     double length, QPalette::ColorGroup colorGroup ) const
+{

trunk/BNC/qwt/qwt_dial_needle.h

-              r8127
+              r9383
     virtual void draw( QPainter *painter, const QPointF &center,
         double length, double direction,
+        double length, double direction,
         QPalette::ColorGroup = QPalette::Active ) const;
 …
       The origin of the needle is at position (0.0, 0.0 )
       pointing in direction 0.0 ( = east ).
+      pointing in direction 0.0 ( = east ).
       The painter is already initialized with translation and
+      The painter is already initialized with translation and
       rotation.
 …
       \sa setPalette(), palette()
     */
     virtual void drawNeedle( QPainter *painter,
+    virtual void drawNeedle( QPainter *painter,
         double length, QPalette::ColorGroup colorGroup ) const = 0;
     virtual void drawKnob( QPainter *, double width,
+    virtual void drawKnob( QPainter *, double width,
         const QBrush &, bool sunken ) const;
 …
         TriangleStyle,
         //! A thin needle
+        //! A thin needle
         ThinStyle
     };
 …
 protected:
     virtual void drawNeedle( QPainter *,
+    virtual void drawNeedle( QPainter *,
         double length, QPalette::ColorGroup ) const;
 …
 protected:
     virtual void drawNeedle( QPainter *,
+    virtual void drawNeedle( QPainter *,
         double length, QPalette::ColorGroup ) const;
 …
 };
 #endif
+#endif

trunk/BNC/qwt/qwt_dyngrid_layout.cpp

-              r8127
+              r9383
+}
 /*!
+/*!
   \brief Add an item to the next free position.
   \param item Layout item
 …
 /*!
   \brief Calculate the number of columns for a given width.
   The calculation tries to use as many columns as possible
+  \brief Calculate the number of columns for a given width.
+  The calculation tries to use as many columns as possible
   ( limited by maxColumns() )
 …
     uint maxColumns = itemCount();
     if ( d_data->maxColumns > 0 )
+    if ( d_data->maxColumns > 0 )
         maxColumns = qMin( d_data->maxColumns, maxColumns );

trunk/BNC/qwt/qwt_dyngrid_layout.h

-              r8127
+              r9383
     Q_OBJECT
 public:
     explicit QwtDynGridLayout( QWidget *, int margin = 0, int space = -1 );
     explicit QwtDynGridLayout( int space = -1 );
+    explicit QwtDynGridLayout( QWidget *, int margin = 0, int spacing = -1 );
+    explicit QwtDynGridLayout( int spacing = -1 );
     virtual ~QwtDynGridLayout();
 …
     virtual void invalidate();
     void setMaxColumns( uint maxCols );
+    void setMaxColumns( uint maxColumns );
     uint maxColumns() const;
 …
     void setExpandingDirections( Qt::Orientations );
     virtual Qt::Orientations expandingDirections() const;
     QList<QRect> layoutItems( const QRect &, uint numCols ) const;
+    QList<QRect> layoutItems( const QRect &, uint numColumns ) const;
     virtual int maxItemWidth() const;
 …
 protected:
     void layoutGrid( uint numCols,
+    void layoutGrid( uint numColumns,
         QVector<int>& rowHeight, QVector<int>& colWidth ) const;
     void stretchGrid( const QRect &rect, uint numCols,
+    void stretchGrid( const QRect &rect, uint numColumns,
         QVector<int>& rowHeight, QVector<int>& colWidth ) const;
 private:
     void init();
     int maxRowWidth( int numCols ) const;
+    int maxRowWidth( int numColumns ) const;
     class PrivateData;

trunk/BNC/qwt/qwt_event_pattern.cpp

-              r8127
+              r9383
   \sa QMouseEvent
 */
 void QwtEventPattern::setMousePattern( MousePatternCode pattern,
+void QwtEventPattern::setMousePattern( MousePatternCode pattern,
     Qt::MouseButton button, Qt::KeyboardModifiers modifiers )
+{
 …
   \sa QKeyEvent
 */
 void QwtEventPattern::setKeyPattern( KeyPatternCode pattern,
+void QwtEventPattern::setKeyPattern( KeyPatternCode pattern,
     int key, Qt::KeyboardModifiers modifiers )
+{
 …
   \sa keyMatch()
 */
 bool QwtEventPattern::mouseMatch( MousePatternCode code,
+bool QwtEventPattern::mouseMatch( MousePatternCode code,
     const QMouseEvent *event ) const
+{
 …
   \sa mouseMatch()
 */
 bool QwtEventPattern::keyMatch( KeyPatternCode code,
+bool QwtEventPattern::keyMatch( KeyPatternCode code,
     const QKeyEvent *event ) const
+{

trunk/BNC/qwt/qwt_event_pattern.h

-              r8127
+              r9383
     enum MousePatternCode
+    {
         /*!
           The default setting for 1, 2 and 3 button mice is:
           - Qt::LeftButton
           - Qt::LeftButton
           - Qt::LeftButton
+        /*!
+          The default setting for 1, 2 and 3 button mice is:
+          - Qt::LeftButton
+          - Qt::LeftButton
+          - Qt::LeftButton
          */
         MouseSelect1,
 …
     public:
         //! Constructor
         MousePattern( Qt::MouseButton btn = Qt::NoButton,
+        MousePattern( Qt::MouseButton btn = Qt::NoButton,
                 Qt::KeyboardModifiers modifierCodes = Qt::NoModifier ):
             button( btn ),
 …
+        }
         //! Button
+        //! Button
         Qt::MouseButton button;
 …
     public:
         //! Constructor
         KeyPattern( int keyCode = Qt::Key_unknown,
+        KeyPattern( int keyCode = Qt::Key_unknown,
                 Qt::KeyboardModifiers modifierCodes = Qt::NoModifier ):
             key( keyCode ),
 …
     void initKeyPattern();
     void setMousePattern( MousePatternCode, Qt::MouseButton button,
+    void setMousePattern( MousePatternCode, Qt::MouseButton button,
         Qt::KeyboardModifiers = Qt::NoModifier );
     void setKeyPattern( KeyPatternCode, int keyCode,
         Qt::KeyboardModifiers modifierCodes = Qt::NoModifier );
+    void setKeyPattern( KeyPatternCode, int key,
+        Qt::KeyboardModifiers modifiers = Qt::NoModifier );
     void setMousePattern( const QVector<MousePattern> & );

trunk/BNC/qwt/qwt_global.h

-              r8127
+              r9383
 // QWT_VERSION is (major << 16) + (minor << 8) + patch.
 #define QWT_VERSION       0x060104
 #define QWT_VERSION_STR   "6.1.4"
+#define QWT_VERSION       0x060106
+#define QWT_VERSION_STR   "6.1.6"
 #if defined(_MSC_VER) /* MSVC Compiler */
 …
 #ifdef QWT_DLL
 #if defined(QWT_MAKEDLL)     // create a Qwt DLL library
+#if defined(QWT_MAKEDLL)     // create a Qwt DLL library
 #define QWT_EXPORT Q_DECL_EXPORT
 #else                        // use a Qwt DLL library
 #define QWT_EXPORT Q_DECL_IMPORT
+#define QWT_EXPORT Q_DECL_IMPORT
 #endif
 …
 #endif
 #endif
+#endif

trunk/BNC/qwt/qwt_graphic.cpp

-              r8127
+              r9383
+}
 static QRectF qwtStrokedPathRect(
+static QRectF qwtStrokedPathRect(
     const QPainter *painter, const QPainterPath &path )
+{
 …
+}
 static inline void qwtExecCommand(
     QPainter *painter, const QwtPainterCommand &cmd,
+static inline void qwtExecCommand(
+    QPainter *painter, const QwtPainterCommand &cmd,
     QwtGraphic::RenderHints renderHints,
     const QTransform &transform,
 …
+        {
             const QwtPainterCommand::ImageData *data = cmd.imageData();
             painter->drawImage( data->rect, data->image,
+            painter->drawImage( data->rect, data->image,
                 data->subRect, data->flags );
             break;
 …
             const QwtPainterCommand::StateData *data = cmd.stateData();
             if ( data->flags & QPaintEngine::DirtyPen )
+            if ( data->flags & QPaintEngine::DirtyPen )
                 painter->setPen( data->pen );
             if ( data->flags & QPaintEngine::DirtyBrush )
+            if ( data->flags & QPaintEngine::DirtyBrush )
                 painter->setBrush( data->brush );
             if ( data->flags & QPaintEngine::DirtyBrushOrigin )
+            if ( data->flags & QPaintEngine::DirtyBrushOrigin )
                 painter->setBrushOrigin( data->brushOrigin );
             if ( data->flags & QPaintEngine::DirtyFont )
+            if ( data->flags & QPaintEngine::DirtyFont )
                 painter->setFont( data->font );
             if ( data->flags & QPaintEngine::DirtyBackground )
+            if ( data->flags & QPaintEngine::DirtyBackground )
+            {
                 painter->setBackgroundMode( data->backgroundMode );
 …
+            }
             if ( data->flags & QPaintEngine::DirtyTransform )
+            if ( data->flags & QPaintEngine::DirtyTransform )
+            {
                 painter->setTransform( data->transform * transform );
+            }
             if ( data->flags & QPaintEngine::DirtyClipEnabled )
+            if ( data->flags & QPaintEngine::DirtyClipEnabled )
                 painter->setClipping( data->isClipEnabled );
             if ( data->flags & QPaintEngine::DirtyClipRegion)
+            if ( data->flags & QPaintEngine::DirtyClipRegion)
+            {
                 painter->setClipRegion( data->clipRegion,
+                painter->setClipRegion( data->clipRegion,
                     data->clipOperation );
+            }
             if ( data->flags & QPaintEngine::DirtyClipPath )
+            if ( data->flags & QPaintEngine::DirtyClipPath )
+            {
                 painter->setClipPath( data->clipPath, data->clipOperation );
+            }
             if ( data->flags & QPaintEngine::DirtyHints)
+            if ( data->flags & QPaintEngine::DirtyHints)
+            {
                 const QPainter::RenderHints hints = data->renderHints;
 …
+            }
             if ( data->flags & QPaintEngine::DirtyCompositionMode)
+            if ( data->flags & QPaintEngine::DirtyCompositionMode)
                 painter->setCompositionMode( data->compositionMode );
             if ( data->flags & QPaintEngine::DirtyOpacity)
+            if ( data->flags & QPaintEngine::DirtyOpacity)
                 painter->setOpacity( data->opacity );
 …
+    }
     PathInfo( const QRectF &pointRect,
+    PathInfo( const QRectF &pointRect,
             const QRectF &boundingRect, bool scalablePen ):
         d_pointRect( pointRect ),
 …
+    }
     inline double scaleFactorX( const QRectF& pathRect,
+    inline double scaleFactorX( const QRectF& pathRect,
         const QRectF &targetRect, bool scalePens ) const
+    {
 …
         const double r = qAbs( pathRect.right() - p0.x() );
         const double w = 2.0 * qMin( l, r )
+        const double w = 2.0 * qMin( l, r )
             * targetRect.width() / pathRect.width();
 …
         else
+        {
             const double pw = qMax(
+            const double pw = qMax(
                 qAbs( d_boundingRect.left() - d_pointRect.left() ),
                 qAbs( d_boundingRect.right() - d_pointRect.right() ) );
 …
+    }
     inline double scaleFactorY( const QRectF& pathRect,
+    inline double scaleFactorY( const QRectF& pathRect,
         const QRectF &targetRect, bool scalePens ) const
+    {
 …
         const double b = qAbs( pathRect.bottom() - p0.y() );
         const double h = 2.0 * qMin( t, b )
+        const double h = 2.0 * qMin( t, b )
             * targetRect.height() / pathRect.height();
 …
         else
+        {
             const double pw =
+            const double pw =
                 qMax( qAbs( d_boundingRect.top() - d_pointRect.top() ),
                 qAbs( d_boundingRect.bottom() - d_pointRect.bottom() ) );
 …
   \brief Copy constructor
   \param other Source
+  \param other Source
   \sa operator=()
  */
 …
   \brief Assignment operator
   \param other Source
+  \param other Source
   \return A reference of this object
  */
 …
 /*!
   \brief Clear all stored commands
+  \brief Clear all stored commands
   \sa isNull()
  */
 void QwtGraphic::reset()
+void QwtGraphic::reset()
+{
     d_data->commands.clear();
 …
 /*!
   The control point rectangle is the bounding rectangle
+  The control point rectangle is the bounding rectangle
   of all control points of the paths and the target
   rectangles of the images/pixmaps.
 …
   \brief Calculate the target rectangle for scaling the graphic
   \param sx Horizontal scaling factor
   \param sy Vertical scaling factor
   \note In case of paths that are painted with a cosmetic pen
+  \param sx Horizontal scaling factor
+  \param sy Vertical scaling factor
+  \note In case of paths that are painted with a cosmetic pen
         ( see QPen::isCosmetic() ) the target rectangle is different to
         multiplying the bounding rectangle.
 …
     for ( int i = 0; i < d_data->pathInfos.size(); i++ )
+    {
         rect |= d_data->pathInfos[i].scaledBoundingRect( sx, sy,
+        rect |= d_data->pathInfos[i].scaledBoundingRect( sx, sy,
             !d_data->renderHints.testFlag( RenderPensUnscaled ) );
+    }
 …
   The default size is used in all methods rendering the graphic,
   where no size is explicitly specified. Assigning an empty size
   means, that the default size will be calculated from the bounding
+  means, that the default size will be calculated from the bounding
   rectangle.
   The default setting is an empty size.
   \param size Default size
 …
   The default size is used in all methods rendering the graphic,
   where no size is explicitly specified.
+  where no size is explicitly specified.
   \return Default size
 …
     for ( int i = 0; i < numCommands; i++ )
+    {
         qwtExecCommand( painter, commands[i],
+        qwtExecCommand( painter, commands[i],
             d_data->renderHints, transform, d_data->initialTransform );
+    }
 …
   \param aspectRatioMode Mode how to scale - See Qt::AspectRatioMode
  */
 void QwtGraphic::render( QPainter *painter, const QSizeF &size,
+void QwtGraphic::render( QPainter *painter, const QSizeF &size,
     Qt::AspectRatioMode aspectRatioMode ) const
+{
 …
   \param aspectRatioMode Mode how to scale - See Qt::AspectRatioMode
  */
 void QwtGraphic::render( QPainter *painter, const QRectF &rect,
+void QwtGraphic::render( QPainter *painter, const QRectF &rect,
     Qt::AspectRatioMode aspectRatioMode ) const
+{
 …
         return;
     double sx = 1.0;
+    double sx = 1.0;
     double sy = 1.0;
 …
         sy = rect.height() / d_data->pointRect.height();
     const bool scalePens =
+    const bool scalePens =
         !d_data->renderHints.testFlag( RenderPensUnscaled );
 …
         const PathInfo info = d_data->pathInfos[i];
         const double ssx = info.scaleFactorX(
+        const double ssx = info.scaleFactorX(
             d_data->pointRect, rect, scalePens );
 …
             sx = qMin( sx, ssx );
         const double ssy = info.scaleFactorY(
+        const double ssy = info.scaleFactorY(
             d_data->pointRect, rect, scalePens );
 …
+    {
         // we don't want to scale pens according to sx/sy,
         // but we want to apply the scaling from the
+        // but we want to apply the scaling from the
         // painter transformation later
 …
   \param painter Qt painter
   \param pos Reference point, where to render
   \param alignment Flags how to align the target rectangle
+  \param alignment Flags how to align the target rectangle
                    to pos.
  */
 void QwtGraphic::render( QPainter *painter,
+void QwtGraphic::render( QPainter *painter,
     const QPointF &pos, Qt::Alignment alignment ) const
+{
 …
 /*!
   \brief Convert the graphic to a QPixmap
   All pixels of the pixmap get initialized by Qt::transparent
   before the graphic is scaled and rendered on it.
   The size of the pixmap is the default size ( ceiled to integers )
   of the graphic.
 …
   \return The graphic as pixmap in default size
   \sa defaultSize(), toImage(), render()
  */
+ */
 QPixmap QwtGraphic::toPixmap() const
+{
 …
 /*!
   \brief Convert the graphic to a QImage
   All pixels of the image get initialized by 0 ( transparent )
   before the graphic is scaled and rendered on it.
 …
   The size of the image is the default size ( ceiled to integers )
   of the graphic.
   \return The graphic as image in default size
   \sa defaultSize(), toPixmap(), render()
 …
         QRectF boundingRect = pointRect;
         if ( painter->pen().style() != Qt::NoPen
+        if ( painter->pen().style() != Qt::NoPen
             && painter->pen().brush().style() != Qt::NoBrush )
+        {
 …
         updateBoundingRect( boundingRect );
         d_data->pathInfos += PathInfo( pointRect,
+        d_data->pathInfos += PathInfo( pointRect,
             boundingRect, qwtHasScalablePen( painter ) );
+    }
 …
   \sa QPaintEngine::drawPixmap()
 */
 void QwtGraphic::drawPixmap( const QRectF &rect,
+void QwtGraphic::drawPixmap( const QRectF &rect,
     const QPixmap &pixmap, const QRectF &subRect )
+{
 …
         return;
     // to calculate a proper bounding rectangle we don't simply copy
     // the commands.
+    // to calculate a proper bounding rectangle we don't simply copy
+    // the commands.
     const QwtPainterCommand *cmds = commands.constData();

trunk/BNC/qwt/qwt_graphic.h

-              r8127
+              r9383
     - QSvgRenderer/QSvgGenerator\n
       Unfortunately QSvgRenderer hides to much information about
       its nodes in internal APIs, that are necessary for proper
       layout calculations. Also it is derived from QObject and
+      its nodes in internal APIs, that are necessary for proper
+      layout calculations. Also it is derived from QObject and
       can't be copied like QImage/QPixmap.
     QwtGraphic maps all scalable drawing primitives to a QPainterPath
     and stores them together with the painter state changes
     ( pen, brush, transformation ... ) in a list of QwtPaintCommands.
     For being a complete QPaintDevice it also stores pixmaps or images,
     what is somehow against the idea of the class, because these objects
+    and stores them together with the painter state changes
+    ( pen, brush, transformation ... ) in a list of QwtPaintCommands.
+    For being a complete QPaintDevice it also stores pixmaps or images,
+    what is somehow against the idea of the class, because these objects
     can't be scaled without a loss in quality.
     The main issue about scaling a QwtGraphic object are the pens used for
     drawing the outlines of the painter paths. While non cosmetic pens
     ( QPen::isCosmetic() ) are scaled with the same ratio as the path,
     cosmetic pens have a fixed width. A graphic might have paths with
+    drawing the outlines of the painter paths. While non cosmetic pens
+    ( QPen::isCosmetic() ) are scaled with the same ratio as the path,
+    cosmetic pens have a fixed width. A graphic might have paths with
     different pens - cosmetic and non-cosmetic.
 …
     - control point rectangle\n
       The control point rectangle is the bounding rectangle of all
       control point rectangles of the painter paths, or the target
+      control point rectangles of the painter paths, or the target
       rectangle of the pixmaps/images.
 …
       what is needed for rendering the outline with an unscaled pen.
     Because the offset for drawing the outline depends on the shape
     of the painter path ( the peak of a triangle is different than the flat side )
     scaling with a fixed aspect ratio always needs to be calculated from the
+    Because the offset for drawing the outline depends on the shape
+    of the painter path ( the peak of a triangle is different than the flat side )
+    scaling with a fixed aspect ratio always needs to be calculated from the
     control point rectangle.
 …
+{
 public:
     /*!
+    /*!
         Hint how to render a graphic
         \sa setRenderHint(), testRenderHint()
 …
+    {
         /*!
            When rendering a QwtGraphic a specific scaling between
+           When rendering a QwtGraphic a specific scaling between
            the controlPointRect() and the coordinates of the target rectangle
            is set up internally in render().
 …
     };
     /*!
+    /*!
         \brief Render hints
 …
     void render( QPainter * ) const;
     void render( QPainter *, const QSizeF &,
+    void render( QPainter *, const QSizeF &,
             Qt::AspectRatioMode = Qt::IgnoreAspectRatio  ) const;
     void render( QPainter *, const QRectF &,
+    void render( QPainter *, const QRectF &,
             Qt::AspectRatioMode = Qt::IgnoreAspectRatio  ) const;
 …
         Qt::Alignment = Qt::AlignTop | Qt::AlignLeft ) const;
     QPixmap toPixmap() const;
     QPixmap toPixmap( const QSize &,
+    QPixmap toPixmap() const;
+    QPixmap toPixmap( const QSize &,
         Qt::AspectRatioMode = Qt::IgnoreAspectRatio  ) const;
     QImage toImage() const;
     QImage toImage( const QSize &,
+    QImage toImage() const;
+    QImage toImage( const QSize &,
         Qt::AspectRatioMode = Qt::IgnoreAspectRatio  ) const;
 …
     void setDefaultSize( const QSizeF & );
     QSizeF defaultSize() const;
     void setRenderHint( RenderHint, bool on = true );
     bool testRenderHint( RenderHint ) const;

trunk/BNC/qwt/qwt_interval.cpp

-              r8127
+              r9383
+}
 /*!
+/*!
   \brief Intersect 2 intervals
   \param other Interval to be intersect with
   \return Intersection
 …
+}
 /*!
+/*!
   \brief Unite this interval with the given interval.
 …
+}
 /*!
+/*!
   \brief Intersect this interval with the given interval.

trunk/BNC/qwt/qwt_interval.h

-              r8127
+              r9383
 public:
     /*!
       Flag indicating if a border is included or excluded
+      Flag indicating if a border is included or excluded
       \sa setBorderFlags(), borderFlags()
     */
 …
     QwtInterval normalized() const;
     QwtInterval inverted() const;
     QwtInterval limited( double minValue, double maxValue ) const;
+    QwtInterval limited( double lowerBound, double upperBound ) const;
     bool operator==( const QwtInterval & ) const;
 …
 /*!
    \brief Intersection of two intervals
    \param other Interval to intersect with
    \return Intersection of this and other
 …
+}
 /*!
+/*!
    \brief Compare two intervals
 …
            ( d_borderFlags == other.d_borderFlags );
+}
 /*!
+/*!
    \brief Compare two intervals

trunk/BNC/qwt/qwt_interval_symbol.cpp

-              r8127
+              r9383
 //! \brief Assignment operator
 QwtIntervalSymbol &QwtIntervalSymbol::operator=(
+QwtIntervalSymbol &QwtIntervalSymbol::operator=(
     const QwtIntervalSymbol &other )
+{
 …
 //! \brief Compare two symbols
 bool QwtIntervalSymbol::operator==(
+bool QwtIntervalSymbol::operator==(
     const QwtIntervalSymbol &other ) const
+{
 …
 //! \brief Compare two symbols
 bool QwtIntervalSymbol::operator!=(
+bool QwtIntervalSymbol::operator!=(
     const QwtIntervalSymbol &other ) const
+{
 …
+}
 /*!
+/*!
   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
 …
   \param width Pen width
   \param style Pen style
   \sa pen(), brush()
  */
 void QwtIntervalSymbol::setPen( const QColor &color,
+ */
+void QwtIntervalSymbol::setPen( const QColor &color,
     qreal width, Qt::PenStyle style )
+{
+{
     setPen( QPen( color, width, style ) );
+}
 …
             if ( d_data->width > pw )
+            {
                 if ( ( orientation == Qt::Horizontal )
+                if ( ( orientation == Qt::Horizontal )
                     && ( p1.y() == p2.y() ) )
+                {
 …
                         p2.x(), y, p2.x(), y + sw );
+                }
                 else if ( ( orientation == Qt::Vertical )
+                else if ( ( orientation == Qt::Vertical )
                     && ( p1.x() == p2.x() ) )
+                {
 …
             else
+            {
                 if ( ( orientation == Qt::Horizontal )
+                if ( ( orientation == Qt::Horizontal )
                     && ( p1.y() == p2.y() ) )
+                {

trunk/BNC/qwt/qwt_interval_symbol.h

-              r8127
+              r9383
     int width() const;
     void setBrush( const QBrush& b );
+    void setBrush( const QBrush & );
     const QBrush& brush() const;
 …
 private:
     class PrivateData;
     PrivateData* d_data;

trunk/BNC/qwt/qwt_knob.cpp

-              r8127
+              r9383
     setValue( 0.0 );
     setSizePolicy( QSizePolicy::MinimumExpanding,
+    setSizePolicy( QSizePolicy::MinimumExpanding,
         QSizePolicy::MinimumExpanding );
+}
 …
 /*!
   \brief Set the knob type
+  \brief Set the knob type
   \param knobStyle Knob type
 …
   have to be set using setNumTurns().
   The default angle is 270 degrees.
+  The default angle is 270 degrees.
   \sa totalAngle(), setNumTurns()
 …
+}
 /*!
+/*!
   \return the total angle
   \sa setTotalAngle(), setNumTurns(), numTurns()
 …
   \sa numTurns(), totalAngle(), setTotalAngle()
 */
 void QwtKnob::setNumTurns( int numTurns )
+{
 …
 /*!
   \return Number of turns.
+  \return Number of turns.
   When the total angle is below 360° numTurns() is ceiled to 1.
 …
         r.moveBottom( cr.bottom() - d );
+    }
     else
+    else
+    {
         r.moveCenter( QPoint( r.center().x(), cr.center().y() ) );
 …
         if ( !wrapping() )
+        {
             const double boundedAngle =
+            const double boundedAngle =
                 qBound( scaleMap().p1(), angle, scaleMap().p2() );
 …
+}
 /*!
+/*!
   Handle QEvent::StyleChange and QEvent::FontChange;
   \param event Change event
 …
     drawKnob( &painter, knobRect );
     drawMarker( &painter, knobRect,
+    drawMarker( &painter, knobRect,
         qwtNormalizeDegrees( scaleMap().transform( value() ) ) );
 …
         gradient.setColorAt( 1.0, c2 );
         pen = QPen( gradient, d_data->borderWidth );
+        pen = QPen( gradient, d_data->borderWidth );
+    }
 …
             QRadialGradient gradient( knobRect.center(),
                 knobRect.width(), knobRect.topLeft() + QPointF( off, off ) );
             gradient.setColorAt( 0.0, palette().color( QPalette::Midlight ) );
             gradient.setColorAt( 1.0, palette().color( QPalette::Button ) );
 …
         case QwtKnob::Sunken:
+        {
             QLinearGradient gradient(
+            QLinearGradient gradient(
                 knobRect.topLeft(), knobRect.bottomRight() );
             gradient.setColorAt( 0.0, palette().color( QPalette::Mid ) );
 …
   \param painter Painter
   \param rect Bounding rectangle of the knob without scale
   \param angle Angle of the marker in degrees
+  \param angle Angle of the marker in degrees
                ( clockwise, 0 at the 12 o'clock position )
 */
 void QwtKnob::drawMarker( QPainter *painter,
+void QwtKnob::drawMarker( QPainter *painter,
     const QRectF &rect, double angle ) const
+{
 …
         case Nub:
+        {
             const double dotWidth =
+            const double dotWidth =
                 qMin( double( markerSize ), radius);
 …
             if ( dotCenterDist > 0.0 )
+            {
                 const QPointF center( xm - sinA * dotCenterDist,
+                const QPointF center( xm - sinA * dotCenterDist,
                     ym - cosA * dotCenterDist );
 …
                     qSwap( c1, c2 );
                 QLinearGradient gradient(
+                QLinearGradient gradient(
                     ellipse.topLeft(), ellipse.bottomRight() );
                 gradient.setColorAt( 0.0, c1 );
 …
         case Dot:
+        {
             const double dotWidth =
+            const double dotWidth =
                 qMin( double( markerSize ), radius);
 …
             if ( dotCenterDist > 0.0 )
+            {
                 const QPointF center( xm - sinA * dotCenterDist,
+                const QPointF center( xm - sinA * dotCenterDist,
                     ym - cosA * dotCenterDist );
 …
             painter->translate( rect.center() );
             painter->rotate( angle - 90.0 );
             QPolygonF polygon;
             polygon += QPointF( re, 0.0 );
 …
 */
 void QwtKnob::drawFocusIndicator( QPainter *painter ) const
+{
+{
     const QRect cr = contentsRect();
 …
     QwtPainter::drawFocusRect( painter, this, focusRect );
+}
+}
 /*!
 …
   Similar to a QLabel::alignment() the flags decide how
   to align the knob inside of contentsRect().
+  to align the knob inside of contentsRect().
   The default setting is Qt::AlignCenter
 …
   \brief Change the knob's width.
   Setting a fixed value for the diameter of the knob
+  Setting a fixed value for the diameter of the knob
   is helpful for aligning several knobs in a row.
 …
   \sa knobWidth(), setAlignment()
   \note Modifies the sizePolicy()
+  \note Modifies the sizePolicy()
 */
 void QwtKnob::setKnobWidth( int width )
 …
+}
 /*!
+/*!
   \return Marker size
   \sa setMarkerSize()

trunk/BNC/qwt/qwt_knob.h

-              r8127
+              r9383
   The layout of the knob depends on the knobWidth().
   - width > 0
+  - width > 0
     The diameter of the knob is fixed and the knob is aligned
     according to the alignment() flags inside of the contentsRect().
+    according to the alignment() flags inside of the contentsRect().
   - width <= 0
 …
   Setting a fixed knobWidth() is helpful to align several knobs with different
   scale labels.
   \image html knob.png
 */
 …
 public:
     /*!
+    /*!
        \brief Style of the knob surface
 …
         Raised,
         /*!
+        /*!
           Build a gradient from QPalette::Midlight, QPalette::Button
           and QPalette::Midlight
 …
         Sunken,
         /*!
+        /*!
           Build a radial gradient from QPalette::Button
           like it is used for QDial in various Qt styles.
 …
     /*!
         \brief Marker type
         The marker indicates the current value on the knob
         The default setting is a Notch marker.
 …
         \sa setMarkerStyle(), setMarkerSize()
     */
     enum MarkerStyle
+    {
+    enum MarkerStyle
+    {
         //! Don't paint any marker
         NoMarker = -1,
         //! Paint a single tick in QPalette::ButtonText color
         Tick,
+        Tick,
         //! Paint a triangle in QPalette::ButtonText color
         Triangle,
+        Triangle,
         //! Paint a circle in QPalette::ButtonText color
         Dot,
+        Dot,
         /*!
+        /*!
           Draw a raised ellipse with a gradient build from
           QPalette::Light and QPalette::Mid
          */
         Nub,
+         */
+        Nub,
         /*!
+        /*!
           Draw a sunken ellipse with a gradient build from
           QPalette::Light and QPalette::Mid
          */
         Notch
+         */
+        Notch
     };
 …
     KnobStyle knobStyle() const;
     void setBorderWidth( int bw );
+    void setBorderWidth( int );
     int borderWidth() const;
 …
     virtual void drawFocusIndicator( QPainter * ) const;
     virtual void drawMarker( QPainter *,
         const QRectF &, double arc ) const;
+    virtual void drawMarker( QPainter *,
+        const QRectF &, double angle ) const;
     virtual double scrolledTo( const QPoint & ) const;

trunk/BNC/qwt/qwt_legend.cpp

-              r8127
+              r9383
 };
 void QwtLegendMap::insert( const QVariant &itemInfo,
+void QwtLegendMap::insert( const QVariant &itemInfo,
     const QList<QWidget *> &widgets )
+{
 …
+{
 public:
     LegendView( QWidget *parent ):
+    explicit LegendView( QWidget *parent ):
         QScrollArea( parent )
+    {
 …
     if ( tl )
         tl->setMaxColumns( numColums );
+    updateGeometry();
+}
 …
 /*!
   The contents widget is the only child of the viewport of
+  The contents widget is the only child of the viewport of
   the internal QScrollArea and the parent widget of all legend items.
 …
 /*!
   The contents widget is the only child of the viewport of
+  The contents widget is the only child of the viewport of
   the internal QScrollArea and the parent widget of all legend items.
 …
   \param itemInfo Info for an item
   \param data List of legend entry attributes for the item
+  \param legendData List of legend entry attributes for the item
  */
 void QwtLegend::updateLegend( const QVariant &itemInfo,
     const QList<QwtLegendData> &data )
+void QwtLegend::updateLegend( const QVariant &itemInfo,
+    const QList<QwtLegendData> &legendData )
+{
     QList<QWidget *> widgetList = legendWidgets( itemInfo );
     if ( widgetList.size() != data.size() )
+    if ( widgetList.size() != legendData.size() )
+    {
         QLayout *contentsLayout = d_data->view->contentsWidget->layout();
         while ( widgetList.size() > data.size() )
+        while ( widgetList.size() > legendData.size() )
+        {
             QWidget *w = widgetList.takeLast();
 …
+        }
+        for ( int i = widgetList.size(); i < data.size(); i++ )
+        {
+            QWidget *widget = createWidget( data[i] );
+#if QT_VERSION >= 0x040700
+        widgetList.reserve( legendData.size() );
+#endif
+        for ( int i = widgetList.size(); i < legendData.size(); i++ )
+        {
+            QWidget *widget = createWidget( legendData[i] );
             if ( contentsLayout )
 …
         updateTabOrder();
+    }
     for ( int i = 0; i < data.size(); i++ )
         updateWidget( widgetList[i], data[i] );
+    for ( int i = 0; i < legendData.size(); i++ )
+        updateWidget( widgetList[i], legendData[i] );
+}
 …
   The default implementation returns a QwtLegendLabel.
   \param data Attributes of the legend entry
+  \param legendData 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 );
+QWidget *QwtLegend::createWidget( const QwtLegendData &legendData ) const
+{
+    Q_UNUSED( legendData );
     QwtLegendLabel *label = new QwtLegendLabel();
     label->setItemMode( defaultItemMode() );
     connect( label, SIGNAL( clicked() ), SLOT( itemClicked() ) );
     connect( label, SIGNAL( checked( bool ) ), SLOT( itemChecked( bool ) ) );
+    connect( label, SIGNAL(clicked()), SLOT(itemClicked()) );
+    connect( label, SIGNAL(checked(bool)), SLOT(itemChecked(bool)) );
     return label;
 …
 /*!
   \brief Update the widget
+  \brief Update the widget
   \param widget Usually a QwtLegendLabel
   \param data Attributes to be displayed
+  \param legendData Attributes to be displayed
   \sa createWidget()
   \note When widget is no QwtLegendLabel updateWidget() does nothing.
  */
 void QwtLegend::updateWidget( QWidget *widget, const QwtLegendData &data )
+void QwtLegend::updateWidget( QWidget *widget, const QwtLegendData &legendData )
+{
     QwtLegendLabel *label = qobject_cast<QwtLegendLabel *>( widget );
     if ( label )
+    {
         label->setData( data );
         if ( !data.value( QwtLegendData::ModeRole ).isValid() )
+        label->setData( legendData );
+        if ( !legendData.value( QwtLegendData::ModeRole ).isValid() )
+        {
             // use the default mode, when there is no specific
 …
 /*!
   Handle QEvent::ChildRemoved andQEvent::LayoutRequest events
+  Handle QEvent::ChildRemoved andQEvent::LayoutRequest events
   for the contentsWidget().
 …
             case QEvent::ChildRemoved:
+            {
                 const QChildEvent *ce =
+                const QChildEvent *ce =
                     static_cast<const QChildEvent *>(event);
                 if ( ce->child()->isWidgetType() )
+                {
+                    QWidget *w = static_cast< QWidget * >( ce->child() );
+                    /*
+                        We are called from the ~QObject and ce->child() is
+                        no widget anymore. But all we need is the address
+                        to remove it from the map.
+                     */
+                    QWidget *w = reinterpret_cast< QWidget * >( ce->child() );
                     d_data->itemMap.removeWidget( w );
+                }
 …
                     QApplication::postEvent( parentWidget(),
                         new QEvent( QEvent::LayoutRequest ) );
+                }
+                }
                 break;
+            }
 …
   \param painter Painter
   \param rect Bounding rectangle
   \param fillBackground When true, fill rect with the widget background
+  \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,
+void QwtLegend::renderLegend( QPainter *painter,
     const QRectF &rect, bool fillBackground ) const
+{
 …
+    }
     const QwtDynGridLayout *legendLayout =
+    const QwtDynGridLayout *legendLayout =
         qobject_cast<QwtDynGridLayout *>( contentsWidget()->layout() );
     if ( legendLayout == NULL )
 …
     getContentsMargins( &left, &top, &right, &bottom );
     QRect layoutRect;
+    QRect layoutRect;
     layoutRect.setLeft( qCeil( rect.left() ) + left );
     layoutRect.setTop( qCeil( rect.top() ) + top );
 …
     uint numCols = legendLayout->columnsForWidth( layoutRect.width() );
     QList<QRect> itemRects =
+    const QList<QRect> itemRects =
         legendLayout->layoutItems( layoutRect, numCols );
 …
   \param widget Widget representing a legend entry
   \param rect Bounding rectangle
   \param fillBackground When true, fill rect with the widget background
+  \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,
+void QwtLegend::renderItem( QPainter *painter,
     const QWidget *widget, const QRectF &rect, bool fillBackground ) const
+{
 …
         const QRectF iconRect( rect.x() + label->margin(),
             rect.center().y() - 0.5 * sz.height(),
+            rect.center().y() - 0.5 * sz.height(),
             sz.width(), sz.height() );
 …
         titleRect.setX( iconRect.right() + 2 * label->spacing() );
+        painter->setFont( label->font() );
+        QFont labelFont = label->font();
+        labelFont.resolve( QFont::AllPropertiesResolved );
+        painter->setFont( labelFont );
         painter->setPen( label->palette().color( QPalette::Text ) );
         const_cast< QwtLegendLabel *>( label )->drawText( painter, titleRect );
+    }
 …
     Return the extent, that is needed for the scrollbars
     \param orientation Orientation (
+    \param orientation Orientation
     \return The width of the vertical scrollbar for Qt::Horizontal and v.v.
  */

trunk/BNC/qwt/qwt_legend.h

-              r8127
+              r9383
     virtual QSize sizeHint() const;
     virtual int heightForWidth( int w ) const;
+    virtual int heightForWidth( int width ) const;
     QScrollBar *horizontalScrollBar() const;
     QScrollBar *verticalScrollBar() const;
     virtual void renderLegend( QPainter *,
+    virtual void renderLegend( QPainter *,
         const QRectF &, bool fillBackground ) const;
     virtual void renderItem( QPainter *,
+    virtual void renderItem( QPainter *,
         const QWidget *, const QRectF &, bool fillBackground ) const;
 …
 protected:
     virtual QWidget *createWidget( const QwtLegendData & ) const;
     virtual void updateWidget( QWidget *widget, const QwtLegendData &data );
+    virtual void updateWidget( QWidget *widget, const QwtLegendData & );
 private:
 …
 };
 #endif
+#endif

trunk/BNC/qwt/qwt_legend_data.cpp

r8127	r9383
124	124	return static_cast<QwtLegendData::Mode>( mode );
125	125	}
126
	126
127	127	return QwtLegendData::ReadOnly;
128	128	}

trunk/BNC/qwt/qwt_legend_data.h

-              r8127
+              r9383
   QwtLegendData is an abstract container ( like QAbstractModel )
   to exchange attributes, that are only known between to
   the plot item and the legend.
+  to exchange attributes, that are only known between to
+  the plot item and the legend.
   By overloading QwtPlotItem::legendData() any other set of attributes
   could be used, that can be handled by a modified ( or completely
+  could be used, that can be handled by a modified ( or completely
   different ) implementation of a legend.
 …
+    {
         // The value is a Mode
         ModeRole,
+        ModeRole,
         // The value is a title
         TitleRole,
+        TitleRole,
         // The value is an icon
         IconRole,
+        IconRole,
         // Values < UserRole are reserved for internal use

trunk/BNC/qwt/qwt_legend_label.cpp

r8127	r9383
140	140	d_data->isDown = false;
141	141
142		setFocusPolicy( ( mode != QwtLegendData::ReadOnly )
	142	setFocusPolicy( ( mode != QwtLegendData::ReadOnly )
143	143	? Qt::TabFocus : Qt::NoFocus );
144	144	setMargin( ButtonFrame + Margin );

trunk/BNC/qwt/qwt_legend_label.h

r8127	r9383
78	78	};
79	79
80		#endif
	80	#endif

trunk/BNC/qwt/qwt_magnifier.cpp

-              r8127
+              r9383
    \sa getMouseButton()
 */
 void QwtMagnifier::setMouseButton(
+void QwtMagnifier::setMouseButton(
     Qt::MouseButton button, Qt::KeyboardModifiers modifiers )
+{
 …
    \sa getZoomInKey(), setZoomOutKey()
 */
 void QwtMagnifier::setZoomInKey( int key,
+void QwtMagnifier::setZoomInKey( int key,
     Qt::KeyboardModifiers modifiers )
+{
 …
+}
 /*!
+/*!
    \brief Retrieve the settings of the zoom in key
 …
    \sa setZoomInKey()
 */
 void QwtMagnifier::getZoomInKey( int &key,
+void QwtMagnifier::getZoomInKey( int &key,
     Qt::KeyboardModifiers &modifiers ) const
+{
 …
    \sa getZoomOutKey(), setZoomOutKey()
 */
 void QwtMagnifier::setZoomOutKey( int key,
+void QwtMagnifier::setZoomOutKey( int key,
     Qt::KeyboardModifiers modifiers )
+{
 …
+}
 /*!
+/*!
    \brief Retrieve the settings of the zoom out key
 …
    \sa setZoomOutKey()
 */
 void QwtMagnifier::getZoomOutKey( int &key,
+void QwtMagnifier::getZoomOutKey( int &key,
     Qt::KeyboardModifiers &modifiers ) const
+{
 …
             of 120 (== 15 * 8).
          */
         double f = qPow( d_data->wheelFactor,
+        double f = qPow( d_data->wheelFactor,
             qAbs( wheelEvent->delta() / 120.0 ) );

trunk/BNC/qwt/qwt_math.h

r8127	r9383
28	28
29	29	#ifndef M_PI_2
30		// For Qt <= 4.8.4 M_PI_2 is not known by MinGW-w64
	30	// For Qt <= 4.8.4 M_PI_2 is not known by MinGW-w64
31	31	// when compiling with -std=c++11
32	32	#define M_PI_2 (1.57079632679489661923)

trunk/BNC/qwt/qwt_matrix_raster_data.cpp

-              r8127
+              r9383
    \param axis X, Y or Z axis
    \param interval Interval
    \sa QwtRasterData::interval(), setValueMatrix()
 */
 void QwtMatrixRasterData::setInterval(
+void QwtMatrixRasterData::setInterval(
     Qt::Axis axis, const QwtInterval &interval )
+{
 …
    The positions of the values are calculated by dividing
    the bounding rectangle of the X/Y intervals into equidistant
    rectangles ( pixels ). Each value corresponds to the center of
+   rectangles ( pixels ). Each value corresponds to the center of
    a pixel.
 …
    \sa valueMatrix(), numColumns(), numRows(), setInterval()()
 */
 void QwtMatrixRasterData::setValueMatrix(
+void QwtMatrixRasterData::setValueMatrix(
     const QVector<double> &values, int numColumns )
+{
 …
    \brief Calculate the pixel hint
    pixelHint() returns the geometry of a pixel, that can be used
+   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.
+   representing the data.
    - NearestNeighbour\n
      pixelHint() returns the surrounding pixel of the top left value
+     pixelHint() returns the surrounding pixel of the top left value
      in the matrix.
    - BilinearInterpolation\n
      Returns an empty rectangle recommending
      to render in target device ( f.e. screen ) resolution.
+     to render in target device ( f.e. screen ) resolution.
    \param area Requested area, ignored
 …
             const double v22 = d_data->value( row2, col2 );
             const double x2 = xInterval.minValue() +
+            const double x2 = xInterval.minValue() +
                 ( col2 + 0.5 ) * d_data->dx;
             const double y2 = yInterval.minValue() +
+            const double y2 = yInterval.minValue() +
                 ( row2 + 0.5 ) * d_data->dy;
             const double rx = ( x2 - x ) / d_data->dx;
             const double ry = ( y2 - y ) / d_data->dy;

trunk/BNC/qwt/qwt_matrix_raster_data.h

-              r8127
+              r9383
   QwtMatrixRasterData implements an interface for a matrix of
   equidistant values, that can be used by a QwtPlotRasterItem.
+  equidistant values, that can be used by a QwtPlotRasterItem.
   It implements a couple of resampling algorithms, to provide
   values for positions, that or not on the value matrix.
 …
         /*!
           Interpolate the value from the distances and values of the
+          Interpolate the value from the distances and values of the
 surrounding values in the matrix,
          */

trunk/BNC/qwt/qwt_null_paintdevice.cpp

-              r8127
+              r9383
 #include "qwt_null_paintdevice.h"
 #include <qpaintengine.h>
+#include <qpainterpath.h>
 #include <qpixmap.h>
 …
     virtual void drawPolygon(const QPoint *, int , PolygonDrawMode );
     virtual void drawPixmap(const QRectF &,
+    virtual void drawPixmap(const QRectF &,
         const QPixmap &, const QRectF &);
     virtual void drawTextItem(const QPointF &, const QTextItem &);
     virtual void drawTiledPixmap(const QRectF &,
+    virtual void drawTiledPixmap(const QRectF &,
         const QPixmap &, const QPointF &s);
     virtual void drawImage(const QRectF &,
+    virtual void drawImage(const QRectF &,
         const QImage &, const QRectF &, Qt::ImageConversionFlags );
 …
     QwtNullPaintDevice *nullDevice();
 };
 QwtNullPaintDevice::PaintEngine::PaintEngine():
     QPaintEngine( QPaintEngine::AllFeatures )
 …
+}
 void QwtNullPaintDevice::PaintEngine::drawPixmap(
+void QwtNullPaintDevice::PaintEngine::drawPixmap(
     const QRectF &rect, const QPixmap &pm, const QRectF &subRect )
+{
 …
 void QwtNullPaintDevice::PaintEngine::drawTiledPixmap(
     const QRectF &rect, const QPixmap &pixmap,
+    const QRectF &rect, const QPixmap &pixmap,
     const QPointF &subRect)
+{
 …
         QPaintEngine::drawTiledPixmap( rect, pixmap, subRect );
         return;
+    }
+    }
     device->drawTiledPixmap( rect, pixmap, subRect );
 …
 void QwtNullPaintDevice::PaintEngine::drawImage(
     const QRectF &rect, const QImage &image,
+    const QRectF &rect, const QImage &image,
     const QRectF &subRect, Qt::ImageConversionFlags flags)
+{
 …
 void QwtNullPaintDevice::PaintEngine::updateState(
     const QPaintEngineState &state)
+{
     QwtNullPaintDevice *device = nullDevice();
     if ( device == NULL )
         return;
     device->updateState( state );
+    const QPaintEngineState &engineState)
+{
+    QwtNullPaintDevice *device = nullDevice();
+    if ( device == NULL )
+        return;
+    device->updateState( engineState );
+}
 …
+}
 /*!
+/*!
     \return Render mode
     \sa setMode()
 …
     if ( d_engine == NULL )
+    {
         QwtNullPaintDevice *that =
+        QwtNullPaintDevice *that =
             const_cast< QwtNullPaintDevice * >( this );
 …
+}
 /*!
+/*!
     See QPaintDevice::metric()
 …
     int value;
     switch ( deviceMetric )
+    switch ( deviceMetric )
+    {
         case PdmWidth:
 …
 //! See QPaintEngine::drawPolygon()
 void QwtNullPaintDevice::drawPolygon(
     const QPointF *points, int pointCount,
+    const QPointF *points, int pointCount,
     QPaintEngine::PolygonDrawMode mode)
+{
 …
 //! See QPaintEngine::drawPolygon()
 void QwtNullPaintDevice::drawPolygon(
     const QPoint *points, int pointCount,
+    const QPoint *points, int pointCount,
     QPaintEngine::PolygonDrawMode mode)
+{
 …
 //! See QPaintEngine::drawPixmap()
 void QwtNullPaintDevice::drawPixmap( const QRectF &rect,
+void QwtNullPaintDevice::drawPixmap( const QRectF &rect,
     const QPixmap &pm, const QRectF &subRect )
+{
 …
 //! See QPaintEngine::drawTiledPixmap()
 void QwtNullPaintDevice::drawTiledPixmap(
     const QRectF &rect, const QPixmap &pixmap,
+    const QRectF &rect, const QPixmap &pixmap,
     const QPointF &subRect)
+{
 …
 //! See QPaintEngine::drawImage()
 void QwtNullPaintDevice::drawImage(
     const QRectF &rect, const QImage &image,
+    const QRectF &rect, const QImage &image,
     const QRectF &subRect, Qt::ImageConversionFlags flags)
+{
 …
 //! See QPaintEngine::updateState()
 void QwtNullPaintDevice::updateState(
+void QwtNullPaintDevice::updateState(
     const QPaintEngineState &state )
+{

trunk/BNC/qwt/qwt_null_paintdevice.h

-              r8127
+              r9383
   \brief A null paint device doing nothing
   Sometimes important layout/rendering geometries are not
   available or changeable from the public Qt class interface.
+  Sometimes important layout/rendering geometries are not
+  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
+  QwtNullPaintDevice can be used to manipulate or filter out
   this information by analyzing the stream of paint primitives.
 …
            the corresponding draw methods
          */
         NormalMode,
+        NormalMode,
         /*!
 …
     virtual QPaintEngine *paintEngine() const;
     virtual int metric( PaintDeviceMetric metric ) const;
+    virtual int metric( PaintDeviceMetric ) const;
     virtual void drawRects(const QRect *, int );
 …
     virtual void drawTiledPixmap(const QRectF &,
         const QPixmap &, const QPointF &s);
+        const QPixmap &, const QPointF & );
     virtual void drawImage(const QRectF &,
         const QImage &, const QRectF &, Qt::ImageConversionFlags );
     virtual void updateState( const QPaintEngineState &state );
+    virtual void updateState( const QPaintEngineState & );
 protected:

trunk/BNC/qwt/qwt_painter.cpp

-              r8127
+              r9383
 #include <qpalette.h>
 #include <qpaintdevice.h>
+#include <qpainterpath.h>
 #include <qpixmap.h>
 #include <qstyle.h>
 …
 #endif
 #if QT_VERSION < 0x050000
+#if QT_VERSION < 0x050000
 #ifdef Q_WS_X11
 …
 bool QwtPainter::d_roundingAlignment = true;
 static inline bool qwtIsClippingNeeded(
+static inline bool qwtIsClippingNeeded(
     const QPainter *painter, QRectF &clipRect )
+{
 …
 bool QwtPainter::isX11GraphicsSystem()
+{
+    /*
+        The X11 paint engine has been removed with Qt 5.0, but
+        reintroduced with Qt 5.10. It can be enabled with
+        "export QT_XCB_NATIVE_PAINTING=1".
+     */
     static int onX11 = -1;
     if ( onX11 < 0 )
 …
+        }
         const QTransform tr = painter->transform();
+        const QTransform &tr = painter->transform();
         if ( tr.isRotating() || tr.isScaling() )
+        {
 …
   to a paint engine that floors to integer values. For other paint engines
   ( PDF, SVG ) this flag has no effect.
   QwtPainter stores this flag only, the rounding itself is done in
+  QwtPainter stores this flag only, the rounding itself is done in
   the painting code ( f.e the plot items ).
   The default setting is true.
+  The default setting is true.
   \sa roundingAlignment(), isAligning()
 …
   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.
+  Also the raster paint engine has a nasty bug in many versions ( Qt 4.8 - ... )
+  for short lines ( https://codereview.qt-project.org/#/c/99456 ), that is worked
+  around in this mode.
   The default setting is true.
 …
             unscaledRect = transform.inverted().mapRect(rect);
+        }
+    }
+    }
     txt->setDefaultFont( painter->font() );
 …
     QPolygonF cpa = polygon;
     if ( deviceClipping )
         cpa = QwtClipper::clipPolygonF( clipRect, polygon );
+        cpa = QwtClipper::clipPolygonF( clipRect, polygon, true );
     painter->drawPolygon( cpa );
 …
     QPolygon cpa = polygon;
     if ( deviceClipping )
         cpa = QwtClipper::clipPolygon( clipRect, polygon );
+        cpa = QwtClipper::clipPolygon( clipRect, polygon, true );
     painter->drawPolygon( cpa );
 …
+    }
     else
+    {
         qwtDrawPolyline<QPoint>( painter, points, pointCount, d_polylineSplitting );
+    }
+}
 …
         const int maxY = qFloor( clipRect.bottom() );
         if ( pos.x() < minX || pos.x() > maxX
+        if ( pos.x() < minX || pos.x() > maxX
             || pos.y() < minY || pos.y() > maxY )
+        {
 …
 //! Wrapper for QPainter::drawPoints()
 void QwtPainter::drawPoints( QPainter *painter,
+void QwtPainter::drawPoints( QPainter *painter,
     const QPoint *points, int pointCount )
+{
 …
 //! Wrapper for QPainter::drawPoints()
 void QwtPainter::drawPoints( QPainter *painter,
+void QwtPainter::drawPoints( QPainter *painter,
     const QPointF *points, int pointCount )
+{
 …
 /*!
   Draw a round frame
+  Draw a round frame
   \param painter Painter
 …
 */
 void QwtPainter::drawRoundFrame( QPainter *painter,
     const QRectF &rect, const QPalette &palette,
+    const QRectF &rect, const QPalette &palette,
     int lineWidth, int frameStyle )
+{
 …
+    {
         const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 );
         const QRectF innerRect = outerRect.adjusted(
+        const QRectF innerRect = outerRect.adjusted(
             frameWidth, frameWidth, -frameWidth, -frameWidth );
 …
+        {
             const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 );
             const QRectF midRect1 = outerRect.adjusted(
+            const QRectF midRect1 = outerRect.adjusted(
                 frameWidth, frameWidth, -frameWidth, -frameWidth );
             const QRectF midRect2 = midRect1.adjusted(
+            const QRectF midRect2 = midRect1.adjusted(
                 midLineWidth, midLineWidth, -midLineWidth, -midLineWidth );
             const QRectF innerRect = midRect2.adjusted(
+            const QRectF innerRect = midRect2.adjusted(
                 frameWidth, frameWidth, -frameWidth, -frameWidth );
 …
+        {
             const QRectF outerRect = rect.adjusted( 0.0, 0.0, -1.0, -1.0 );
             const QRectF innerRect = outerRect.adjusted(
                 frameWidth - 1.0, frameWidth - 1.0,
+            const QRectF innerRect = outerRect.adjusted(
+                frameWidth - 1.0, frameWidth - 1.0,
                 -( frameWidth - 1.0 ), -( frameWidth - 1.0 ) );
 …
 */
 void QwtPainter::drawRoundedFrame( QPainter *painter,
     const QRectF &rect, double xRadius, double yRadius,
+void QwtPainter::drawRoundedFrame( QPainter *painter,
+    const QRectF &rect, double xRadius, double yRadius,
     const QPalette &palette, int lineWidth, int frameStyle )
+{
 …
     double lw2 = lineWidth * 0.5;
     QRectF r = rect.adjusted( lw2, lw2, -lw2, -lw2 );
+    QRectF innerRect = rect.adjusted( lw2, lw2, -lw2, -lw2 );
     QPainterPath path;
     path.addRoundedRect( r, xRadius, yRadius );
+    path.addRoundedRect( innerRect, xRadius, yRadius );
     enum Style
 …
         // move + 4 * ( cubicTo + lineTo )
         QPainterPath pathList[8];
         for ( int i = 0; i < 4; i++ )
+        {
             const int j = i * 4 + 1;
             pathList[ 2 * i ].moveTo(
                 path.elementAt(j - 1).x, path.elementAt( j - 1 ).y
             );
+            );
             pathList[ 2 * i ].cubicTo(
                 path.elementAt(j + 0).x, path.elementAt(j + 0).y,
                 path.elementAt(j + 1).x, path.elementAt(j + 1).y,
                 path.elementAt(j + 2).x, path.elementAt(j + 2).y );
             pathList[ 2 * i + 1 ].moveTo(
                 path.elementAt(j + 2).x, path.elementAt(j + 2).y
             );
+            );
             pathList[ 2 * i + 1 ].lineTo(
                 path.elementAt(j + 3).x, path.elementAt(j + 3).y
             );
+        }
+            );
+        }
         QColor c1( palette.color( QPalette::Dark ) );
 …
         for ( int i = 0; i < 4; i++ )
+        {
             QRectF r = pathList[2 * i].controlPointRect();
+            const QRectF r = pathList[2 * i].controlPointRect();
             QPen arcPen;
 …
+}
 static inline void qwtFillRect( const QWidget *widget, QPainter *painter,
+static inline void qwtFillRect( const QWidget *widget, QPainter *painter,
     const QRect &rect, const QBrush &brush)
+{
     if ( brush.style() == Qt::TexturePattern )
+    if ( brush.style() == Qt::TexturePattern )
+    {
         painter->save();
 …
         painter->restore();
+    }
+    }
     else if ( brush.gradient() )
+    {
 …
         painter->setClipRect( rect );
         painter->fillRect(0, 0, widget->width(),
+        painter->fillRect(0, 0, widget->width(),
             widget->height(), brush);
         painter->restore();
+    }
     else
+    }
+    else
+    {
         painter->fillRect(rect, brush);
 …
   In Qt >= 5.0 QPixmap::fill() is a nop, in Qt 4.x it is buggy
   for backgrounds with gradients. Thus fillPixmap() offers
+  for backgrounds with gradients. Thus fillPixmap() offers
   an alternative implementation.
   \param widget Widget
   \param pixmap Pixmap to be filled
   \param offset Offset
+  \param offset Offset
   \sa QPixmap::fill()
  */
 void QwtPainter::fillPixmap( const QWidget *widget,
+void QwtPainter::fillPixmap( const QWidget *widget,
     QPixmap &pixmap, const QPoint &offset )
+{
 …
     painter.translate( -offset );
     const QBrush autoFillBrush =
+    const QBrush autoFillBrush =
         widget->palette().brush( widget->backgroundRole() );
     if ( !( widget->autoFillBackground() && autoFillBrush.isOpaque() ) )
+    if ( !( widget->autoFillBackground() && autoFillBrush.isOpaque() ) )
+    {
         const QBrush bg = widget->palette().brush( QPalette::Window );
 …
         qwtFillRect( widget, &painter, rect, autoFillBrush);
     if ( widget->testAttribute(Qt::WA_StyledBackground) )
+    if ( widget->testAttribute(Qt::WA_StyledBackground) )
+    {
         painter.setClipRegion( rect );
 …
         QStyleOption opt;
         opt.initFrom( widget );
         widget->style()->drawPrimitive( QStyle::PE_Widget,
+        widget->style()->drawPrimitive( QStyle::PE_Widget,
             &opt, &painter, widget );
+    }
 …
 #endif
 #if QT_VERSION < 0x050000
+#if QT_VERSION < 0x050000
 #ifdef Q_WS_X11
     if ( widget && isX11GraphicsSystem() )

trunk/BNC/qwt/qwt_painter.h

-              r8127
+              r9383
     static void drawText( QPainter *, double x, double y, double w, double h,
         int flags, const QString & );
     static void drawText( QPainter *, const QRectF &,
+    static void drawText( QPainter *, const QRectF &,
         int flags, const QString & );
 …
     static void drawEllipse( QPainter *, const QRectF & );
     static void drawPie( QPainter *, const QRectF & r, int a, int alen );
+    static void drawPie( QPainter *, const QRectF &, int a, int alen );
     static void drawLine( QPainter *, double x1, double y1, double x2, double y2 );
 …
         const QRectF &, const QPalette &, int lineWidth, int frameStyle );
     static void drawRoundedFrame( QPainter *,
+    static void drawRoundedFrame( QPainter *,
         const QRectF &, double xRadius, double yRadius,
         const QPalette &, int lineWidth, int frameStyle );
 …
     static void drawFrame( QPainter *, const QRectF &rect,
         const QPalette &palette, QPalette::ColorRole foregroundRole,
         int lineWidth, int midLineWidth, int frameStyle );
+        int frameWidth, int midLineWidth, int frameStyle );
     static void drawFocusRect( QPainter *, const QWidget * );
 …
     static bool isX11GraphicsSystem();
     static void fillPixmap( const QWidget *,
+    static void fillPixmap( const QWidget *,
         QPixmap &, const QPoint &offset = QPoint() );

trunk/BNC/qwt/qwt_painter_command.cpp

-              r8127
+              r9383
+}
 /*!
+/*!
   Constructor for State paint operation
   \param state Paint engine state
  */
+ */
 QwtPainterCommand::QwtPainterCommand( const QPaintEngineState &state ):
     d_type( State )
 …
     d_stateData->flags = state.state();
     if ( d_stateData->flags & QPaintEngine::DirtyPen )
+    if ( d_stateData->flags & QPaintEngine::DirtyPen )
         d_stateData->pen = state.pen();
     if ( d_stateData->flags & QPaintEngine::DirtyBrush )
+    if ( d_stateData->flags & QPaintEngine::DirtyBrush )
         d_stateData->brush = state.brush();
     if ( d_stateData->flags & QPaintEngine::DirtyBrushOrigin )
+    if ( d_stateData->flags & QPaintEngine::DirtyBrushOrigin )
         d_stateData->brushOrigin = state.brushOrigin();
     if ( d_stateData->flags & QPaintEngine::DirtyFont )
+    if ( d_stateData->flags & QPaintEngine::DirtyFont )
         d_stateData->font = state.font();
     if ( d_stateData->flags & QPaintEngine::DirtyBackground )
+    if ( d_stateData->flags & QPaintEngine::DirtyBackground )
+    {
         d_stateData->backgroundMode = state.backgroundMode();
 …
+    }
     if ( d_stateData->flags & QPaintEngine::DirtyTransform )
+    if ( d_stateData->flags & QPaintEngine::DirtyTransform )
         d_stateData->transform = state.transform();
     if ( d_stateData->flags & QPaintEngine::DirtyClipEnabled )
+    if ( d_stateData->flags & QPaintEngine::DirtyClipEnabled )
         d_stateData->isClipEnabled = state.isClipEnabled();
     if ( d_stateData->flags & QPaintEngine::DirtyClipRegion )
+    if ( d_stateData->flags & QPaintEngine::DirtyClipRegion )
+    {
         d_stateData->clipRegion = state.clipRegion();
 …
+    }
     if ( d_stateData->flags & QPaintEngine::DirtyClipPath )
+    if ( d_stateData->flags & QPaintEngine::DirtyClipPath )
+    {
         d_stateData->clipPath = state.clipPath();
 …
+    }
     if ( d_stateData->flags & QPaintEngine::DirtyHints )
+    if ( d_stateData->flags & QPaintEngine::DirtyHints )
         d_stateData->renderHints = state.renderHints();
     if ( d_stateData->flags & QPaintEngine::DirtyCompositionMode )
+    if ( d_stateData->flags & QPaintEngine::DirtyCompositionMode )
         d_stateData->compositionMode = state.compositionMode();
     if ( d_stateData->flags & QPaintEngine::DirtyOpacity )
+    if ( d_stateData->flags & QPaintEngine::DirtyOpacity )
         d_stateData->opacity = state.opacity();
+}
 …
   Copy constructor
   \param other Command to be copied
  */
 QwtPainterCommand::QwtPainterCommand(const QwtPainterCommand &other)
 …
 //! \return Painter path to be painted
 QPainterPath *QwtPainterCommand::path()
+QPainterPath *QwtPainterCommand::path()
+{
     return d_path;
 …
 //! \return Attributes how to paint a QPixmap
 QwtPainterCommand::PixmapData* QwtPainterCommand::pixmapData()
+QwtPainterCommand::PixmapData* QwtPainterCommand::pixmapData()
+{
     return d_pixmapData;
 …
 //! \return Attributes how to paint a QImage
 QwtPainterCommand::ImageData* QwtPainterCommand::imageData()
+QwtPainterCommand::ImageData* QwtPainterCommand::imageData()
+{
     return d_imageData;
 …
 //! \return Attributes of a state change
 QwtPainterCommand::StateData* QwtPainterCommand::stateData()
+QwtPainterCommand::StateData* QwtPainterCommand::stateData()
+{
     return d_stateData;

trunk/BNC/qwt/qwt_painter_command.h

-              r8127
+              r9383
 #include <qimage.h>
 #include <qpolygon.h>
+#include <qpainterpath.h>
 class QPainterPath;
 …
   \sa QwtGraphic::commands()
  */
 class QWT_EXPORT QwtPainterCommand
+{
 …
     };
     //! Attributes how to paint a QPixmap
+    //! Attributes how to paint a QPixmap
     struct PixmapData
+    {
 …
     };
     //! Attributes how to paint a QImage
+    //! Attributes how to paint a QImage
     struct ImageData
+    {
 …
 //! \return Attributes how to paint a QPixmap
 inline const QwtPainterCommand::PixmapData*
+inline const QwtPainterCommand::PixmapData *
 QwtPainterCommand::pixmapData() const
+{
 …
 //! \return Attributes how to paint a QImage
 inline const QwtPainterCommand::ImageData *
+inline const QwtPainterCommand::ImageData *
 QwtPainterCommand::imageData() const
+{
 …
 //! \return Attributes of a state change
 inline const QwtPainterCommand::StateData *
+inline const QwtPainterCommand::StateData *
 QwtPainterCommand::stateData() const
+{

trunk/BNC/qwt/qwt_panner.cpp

-              r8127
+              r9383
    \param modifiers Keyboard modifiers
 */
 void QwtPanner::setAbortKey( int key,
+void QwtPanner::setAbortKey( int key,
     Qt::KeyboardModifiers modifiers )
+{
 …
 //! Get the abort key and modifiers
 void QwtPanner::getAbortKey( int &key,
+void QwtPanner::getAbortKey( int &key,
     Qt::KeyboardModifiers &modifiers ) const
+{
 …
    fill the empty spaces by the background of the parent widget.
    \param pe Paint event
 */
 void QwtPanner::paintEvent( QPaintEvent *pe )
+   \param event Paint event
+*/
+void QwtPanner::paintEvent( QPaintEvent *event )
+{
     int dx = d_data->pos.x() - d_data->initialPos.x();
     int dy = d_data->pos.y() - d_data->initialPos.y();
+    QRect r( 0, 0, d_data->pixmap.width(), d_data->pixmap.height() );
+    r.moveCenter( QPoint( r.center().x() + dx, r.center().y() + dy ) );
+    QPixmap pm( size() );
+    QRectF r;
+    r.setSize( d_data->pixmap.size() );
+#if QT_VERSION >= 0x050000
+    r.setSize( r.size() / d_data->pixmap.devicePixelRatio() );
+#endif
+    r.moveCenter( QPointF( r.center().x() + dx, r.center().y() + dy ) );
+    QPixmap pm = QwtPainter::backingStore( this, size() );
     QwtPainter::fillPixmap( parentWidget(), pm );
 …
         QPixmap masked = d_data->pixmap;
         masked.setMask( d_data->contentsMask );
         painter.drawPixmap( r, masked );
+        painter.drawPixmap( r.toRect(), masked );
+    }
     else
+    {
         painter.drawPixmap( r, d_data->pixmap );
+        painter.drawPixmap( r.toRect(), d_data->pixmap );
+    }
 …
     painter.begin( this );
     painter.setClipRegion( pe->region() );
+    painter.setClipRegion( event->region() );
     painter.drawPixmap( 0, 0, pm );
+}

trunk/BNC/qwt/qwt_panner.h

-              r8127
+              r9383
     bool isEnabled() const;
     void setMouseButton( Qt::MouseButton,
+    void setMouseButton( Qt::MouseButton,
         Qt::KeyboardModifiers = Qt::NoModifier );
     void getMouseButton( Qt::MouseButton &button,
+    void getMouseButton( Qt::MouseButton &button,
         Qt::KeyboardModifiers & ) const;

trunk/BNC/qwt/qwt_picker.cpp

-              r8127
+              r9383
     if ( l.x1() == l.x2() )
+    {
         region += QRect( l.x1() - pw2, l.y1(),
+        region += QRect( l.x1() - pw2, l.y1(),
             pw, l.y2() ).normalized();
+    }
     else if ( l.y1() == l.y2() )
+    {
         region += QRect( l.x1(), l.y1() - pw2,
+        region += QRect( l.x1(), l.y1() - pw2,
             l.x2(), pw ).normalized();
+    }
 …
 class QwtPickerTracker: public QwtWidgetOverlay
+{
+{
 public:
     QwtPickerTracker( QwtPicker *, QWidget * );
 protected:
     virtual void drawOverlay( QPainter * ) const;
     virtual QRegion maskHint() const;
     QwtPicker *d_picker;
 };
+};
 …
+    {
+    }
     bool enabled;
 …
                 case VLineRubberBand:
+                {
                     mask += qwtMaskRegion( QLine( pos.x(), pRect.top(),
+                    mask += qwtMaskRegion( QLine( pos.x(), pRect.top(),
                         pos.x(), pRect.bottom() ), pw );
                     break;
 …
                 case HLineRubberBand:
+                {
                     mask += qwtMaskRegion( QLine( pRect.left(), pos.y(),
+                    mask += qwtMaskRegion( QLine( pRect.left(), pos.y(),
                         pRect.right(), pos.y() ), pw );
                     break;
 …
                 case CrossRubberBand:
+                {
                     mask += qwtMaskRegion( QLine( pos.x(), pRect.top(),
+                    mask += qwtMaskRegion( QLine( pos.x(), pRect.top(),
                         pos.x(), pRect.bottom() ), pw );
                     mask += qwtMaskRegion( QLine( pRect.left(), pos.y(),
+                    mask += qwtMaskRegion( QLine( pRect.left(), pos.y(),
                         pRect.right(), pos.y() ), pw );
                     break;
 …
    depends on the application requirements. F.e. :
    - A rectangular selection might need to have a specific aspect ratio only.\n
    - A selection could accept non intersecting polygons only.\n
    - ...\n
+     - A rectangular selection might need to have a specific aspect ratio only.
+     - A selection could accept non intersecting polygons only.
+     - ...
    The example below is for a rectangular selection, where the first
    point is the center of the selected rectangle.
   \par Example
+  \verbatim QPolygon MyPicker::adjustedPoints(const QPolygon &points) const
+{
+    QPolygon adjusted;
+    if ( points.size() == 2 )
+    {
+        const int width = qAbs(points[1].x() - points[0].x());
+        const int height = qAbs(points[1].y() - points[0].y());
+        QRect rect(0, 0, 2 * width, 2 * height);
+        rect.moveCenter(points[0]);
+        adjusted += rect.topLeft();
+        adjusted += rect.bottomRight();
+    }
+    return adjusted;
+}\endverbatim\n
+  \code
+    QPolygon MyPicker::adjustedPoints( const QPolygon &points ) const
+    {
+        QPolygon adjusted;
+        if ( points.size() == 2 )
+        {
+            const int width = qAbs( points[1].x() - points[0].x() );
+            const int height = qAbs( points[1].y() - points[0].y() );
+            QRect rect( 0, 0, 2 * width, 2 * height );
+            rect.moveCenter( points[0] );
+            adjusted += rect.topLeft();
+            adjusted += rect.bottomRight();
+        }
+        return adjusted;
+    }
+  \endcode
+  \endpar
   \param points Selected points
 …
+    {
         const QPoint last =
             d_data->pickedPoints[int( d_data->pickedPoints.count() ) - 2];
+            d_data->pickedPoints[ d_data->pickedPoints.count() - 2 ];
         alignment |= ( pos.x() >= last.x() ) ? Qt::AlignRight : Qt::AlignLeft;
 …
         case QEvent::MouseMove:
+        {
             const QMouseEvent *me =
+            const QMouseEvent *me =
                 static_cast< const QMouseEvent * >( event );
             pos = me->pos();
 …
         return;
     d_data->pickedPoints.resize( 0 );
+    d_data->pickedPoints.clear();
     d_data->isActive = true;
     Q_EMIT activated( true );
 …
             Q_EMIT selected( d_data->pickedPoints );
         else
             d_data->pickedPoints.resize( 0 );
+            d_data->pickedPoints.clear();
         updateDisplay();
 …
     if ( d_data->isActive )
+    {
+        const int idx = d_data->pickedPoints.count();
+        d_data->pickedPoints.resize( idx + 1 );
+        d_data->pickedPoints[idx] = pos;
+        d_data->pickedPoints += pos;
         updateDisplay();
 …
 void QwtPicker::move( const QPoint &pos )
+{
+    if ( d_data->isActive )
+    {
+        const int idx = d_data->pickedPoints.count() - 1;
+        if ( idx >= 0 )
+        {
+            if ( d_data->pickedPoints[idx] != pos )
+            {
+                d_data->pickedPoints[idx] = pos;
+                updateDisplay();
+                Q_EMIT moved( pos );
+            }
+    if ( d_data->isActive && !d_data->pickedPoints.isEmpty() )
+    {
+        QPoint &point = d_data->pickedPoints.last();
+        if ( point != pos )
+        {
+            point = pos;
+            updateDisplay();
+            Q_EMIT moved( pos );
+        }
+    }
 …
 void QwtPicker::remove()
+{
+    if ( d_data->isActive )
+    {
+        const int idx = d_data->pickedPoints.count() - 1;
+        if ( idx > 0 )
+        {
+            const int idx = d_data->pickedPoints.count();
+            const QPoint pos = d_data->pickedPoints[idx - 1];
+            d_data->pickedPoints.resize( idx - 1 );
+            updateDisplay();
+            Q_EMIT removed( pos );
+        }
+    if ( d_data->isActive && !d_data->pickedPoints.isEmpty() )
+    {
+#if QT_VERSION >= 0x050100
+        const QPoint pos = d_data->pickedPoints.takeLast();
+#else
+        const QPoint pos = d_data->pickedPoints.last();
+        d_data->pickedPoints.resize( d_data->pickedPoints.count() - 1 );
+#endif
+        updateDisplay();
+        Q_EMIT removed( pos );
+    }
+}
 …
+    }
+    const double xRatio =
+        double( newSize.width() ) / double( oldSize.width() );
+    const double yRatio =
+        double( newSize.height() ) / double( oldSize.height() );
+    for ( int i = 0; i < int( d_data->pickedPoints.count() ); i++ )
+    const double xRatio = double( newSize.width() ) / double( oldSize.width() );
+    const double yRatio = double( newSize.height() ) / double( oldSize.height() );
+    for ( int i = 0; i < d_data->pickedPoints.count(); i++ )
+    {
         QPoint &p = d_data->pickedPoints[i];
 …
   Find the area of the observed widget, where selection might happen.
   \return parentWidget()->contentsRect()
+  \return parentWidget()->contentsRect()
 */
 QPainterPath QwtPicker::pickArea() const
 …
             ( trackerMode() == ActiveOnly && isActive() ) )
+        {
             if ( trackerPen() != Qt::NoPen
+            if ( trackerPen() != Qt::NoPen
                 && !trackerRect( QFont() ).isEmpty() )
+            {

trunk/BNC/qwt/qwt_picker.h

-              r8127
+              r9383
   \par Example
+  \verbatim #include <qwt_picker.h>
+#include <qwt_picker_machine.h>
+QwtPicker *picker = new QwtPicker(widget);
+picker->setStateMachine(new QwtPickerDragRectMachine);
+picker->setTrackerMode(QwtPicker::ActiveOnly);
+picker->setRubberBand(QwtPicker::RectRubberBand); \endverbatim\n
+  \code
+    #include <qwt_picker.h>
+    #include <qwt_picker_machine.h>
+    QwtPicker *picker = new QwtPicker(widget);
+    picker->setStateMachine(new QwtPickerDragRectMachine);
+    picker->setTrackerMode(QwtPicker::ActiveOnly);
+    picker->setRubberBand(QwtPicker::RectRubberBand);
+  \endcode
+  \endpar
   The state machine triggers the following commands:
 …
     virtual void widgetLeaveEvent( QEvent * );
     virtual void stretchSelection( const QSize &oldSize,
                                    const QSize &newSize );
+    virtual void stretchSelection(
+        const QSize &oldSize, const QSize &newSize );
     virtual void updateDisplay();

trunk/BNC/qwt/qwt_picker_machine.cpp

r8127	r9383
106	106	case QEvent::MouseButtonPress:
107	107	{
108		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
	108	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
109	109	static_cast<const QMouseEvent *>( event ) ) )
110	110	{
…	…
152	152	case QEvent::MouseButtonPress:
153	153	{
154		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
	154	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
155	155	static_cast<const QMouseEvent *>( event ) ) )
156	156	{
…	…
225	225	case QEvent::MouseButtonPress:
226	226	{
227		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
	227	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
228	228	static_cast<const QMouseEvent *>( event ) ) )
229	229	{
…	…
260	260	case QEvent::MouseButtonRelease:
261	261	{
262		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
	262	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
263	263	static_cast<const QMouseEvent *>( event ) ) )
264	264	{
…	…
324	324	case QEvent::MouseButtonPress:
325	325	{
326		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
	326	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
327	327	static_cast<const QMouseEvent *>( event ) ) )
328	328	{
…	…
355	355	case QEvent::KeyPress:
356	356	{
357		if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1,
	357	if ( eventPattern.keyMatch( QwtEventPattern::KeySelect1,
358	358	static_cast<const QKeyEvent *> ( event ) ) )
359	359	{
…	…
396	396	case QEvent::MouseButtonPress:
397	397	{
398		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
	398	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect1,
399	399	static_cast<const QMouseEvent *>( event ) ) )
400	400	{
…	…
411	411	}
412	412	}
413		if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect2,
	413	if ( eventPattern.mouseMatch( QwtEventPattern::MouseSelect2,
414	414	static_cast<const QMouseEvent *>( event ) ) )
415	415	{

trunk/BNC/qwt/qwt_picker_machine.h

-              r8127
+              r9383
 /*!
   \brief A state machine for line selections
   Pressing QwtEventPattern::MouseSelect1 selects
   the first point, releasing it the second point.
 …
   A common use case of QwtPickerDragLineMachine are pickers for
   distance measurements.
   \sa QwtEventPattern::MousePatternCode, QwtEventPattern::KeyPatternCode
 */
+  \sa QwtEventPattern::MousePatternCode, QwtEventPattern::KeyPatternCode
+*/
 class QWT_EXPORT QwtPickerDragLineMachine: public QwtPickerMachine
+{

trunk/BNC/qwt/qwt_plot.cpp

-              r8127
+              r9383
     if ( on )
+    {
+        QObject::connect(
+            plot, SIGNAL( legendDataChanged(
+                const QVariant &, const QList<QwtLegendData> & ) ),
+            plot, SLOT( updateLegendItems(
+                const QVariant &, const QList<QwtLegendData> & ) ) );
+        QObject::connect(
+            plot, SIGNAL(legendDataChanged(QVariant,QList<QwtLegendData>)),
+            plot, SLOT(updateLegendItems(QVariant,QList<QwtLegendData>))
+        );
+    }
     else
+    {
+        QObject::disconnect(
+            plot, SIGNAL( legendDataChanged(
+                const QVariant &, const QList<QwtLegendData> & ) ),
+            plot, SLOT( updateLegendItems(
+                const QVariant &, const QList<QwtLegendData> & ) ) );
+    }
+}
+static void qwtSetTabOrder(
+        QObject::disconnect(
+            plot, SIGNAL(legendDataChanged(QVariant,QList<QwtLegendData>) ),
+            plot, SLOT( updateLegendItems(QVariant,QList<QwtLegendData>))
+        );
+    }
+}
+static void qwtSetTabOrder(
     QWidget *first, QWidget *second, bool withChildren )
+{
 …
   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
+  they allow to use canvas implementations that are derived from
   QWidget or QGLWidget.
 …
     it is o.k. not to implement this method.
   The default canvas is a QwtPlotCanvas
+  The default canvas is a QwtPlotCanvas
   \param canvas Canvas Widget
 …
+}
 /*!
+/*!
   \return true if the autoReplot option is set.
   \sa setAutoReplot()
 …
 /*!
   Change the text the footer
+  Change the text the footer
   \param text New text of the footer
 */
 …
 /*!
   Change the text the footer
+  Change the text the footer
   \param text New text of the footer
 */
 …
     if ( d_data->canvas )
+    {
         const bool ok = QMetaObject::invokeMethod(
+        const bool ok = QMetaObject::invokeMethod(
             d_data->canvas, "replot", Qt::DirectConnection );
         if ( !ok )
 …
     getCanvasMarginsHint( maps, canvas()->contentsRect(),
         margins[yLeft], margins[xTop], margins[yRight], margins[xBottom] );
     bool doUpdate = false;
     for ( int axisId = 0; axisId < axisCnt; axisId++ )
 …
   \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
+        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()
 */
 …
   insertLegend() will set the plot widget as parent for the legend.
   The legend will be deleted in the destructor of the plot or when
+  The legend will be deleted in the destructor of the plot or when
   another legend is inserted.
 …
         if ( d_data->legend )
+        {
+            connect( this,
+                SIGNAL( legendDataChanged(
+                    const QVariant &, const QList<QwtLegendData> & ) ),
+                d_data->legend,
+                SLOT( updateLegend(
+                    const QVariant &, const QList<QwtLegendData> & ) )
+            connect(
+                this, SIGNAL(legendDataChanged(QVariant,QList<QwtLegendData>)),
+                d_data->legend, SLOT(updateLegend(QVariant,QList<QwtLegendData>) )
             );
 …
 /*!
   \brief Attach/Detach a plot item
+  \brief Attach/Detach a plot item
   \param plotItem Plot item
 …
     if ( on )
         insertItem( plotItem );
     else
+    else
         removeItem( plotItem );
 …
          that has bee generated from itemToInfo().
   The default implementation simply tries to unwrap a QwtPlotItem
+  The default implementation simply tries to unwrap a QwtPlotItem
   pointer:

trunk/BNC/qwt/qwt_plot.h

-              r8127
+              r9383
   can be configured separately for each axis.
   The simpleplot example is a good starting point to see how to set up a
+  The simpleplot example is a good starting point to see how to set up a
   plot widget.
 …
   \par Example
+  The following example shows (schematically) the most simple
+  way to use QwtPlot. By default, only the left and bottom axes are
+  visible and their scales are computed automatically.
+  \verbatim
+#include <qwt_plot.h>
+#include <qwt_plot_curve.h>
+QwtPlot *myPlot = new QwtPlot("Two Curves", parent);
+// add curves
+QwtPlotCurve *curve1 = new QwtPlotCurve("Curve 1");
+QwtPlotCurve *curve2 = new QwtPlotCurve("Curve 2");
+// connect or copy the data to the curves
+curve1->setData(...);
+curve2->setData(...);
+curve1->attach(myPlot);
+curve2->attach(myPlot);
+// finally, refresh the plot
+myPlot->replot();
+\endverbatim
+    The following example shows (schematically) the most simple
+    way to use QwtPlot. By default, only the left and bottom axes are
+    visible and their scales are computed automatically.
+    \code
+      #include <qwt_plot.h>
+      #include <qwt_plot_curve.h>
+      QwtPlot *myPlot = new QwtPlot( "Two Curves", parent );
+      // add curves
+      QwtPlotCurve *curve1 = new QwtPlotCurve( "Curve 1" );
+      QwtPlotCurve *curve2 = new QwtPlotCurve( "Curve 2" );
+      // connect or copy the data to the curves
+      curve1->setData( ... );
+      curve2->setData( ... );
+      curve1->attach( myPlot );
+      curve2->attach( myPlot );
+      // finally, refresh the plot
+      myPlot->replot();
+    \endcode
+  \endpar
 */
 …
     Q_OBJECT
     Q_PROPERTY( QBrush canvasBackground
+    Q_PROPERTY( QBrush canvasBackground
         READ canvasBackground WRITE setCanvasBackground )
     Q_PROPERTY( bool autoReplot READ autoReplot WRITE setAutoReplot )
 …
         RightLegend,
         //! The legend will be below the footer
+        //! The legend will be below the footer
         BottomLegend,
 …
     void setTitle( const QString & );
     void setTitle( const QwtText &t );
+    void setTitle( const QwtText & );
     QwtText title() const;
 …
     void setFooter( const QString & );
     void setFooter( const QwtText &t );
+    void setFooter( const QwtText & );
     QwtText footer() const;
 …
     bool axisEnabled( int axisId ) const;
     void setAxisFont( int axisId, const QFont &f );
+    void setAxisFont( int axisId, const QFont & );
     QFont axisFont( int axisId ) const;
     void setAxisScale( int axisId, double min, double max, double step = 0 );
+    void setAxisScale( int axisId, double min, double max, double stepSize = 0 );
     void setAxisScaleDiv( int axisId, const QwtScaleDiv & );
     void setAxisScaleDraw( int axisId, QwtScaleDraw * );
 …
     // Legend
     void insertLegend( QwtAbstractLegend *,
+    void insertLegend( QwtAbstractLegend *,
         LegendPosition = QwtPlot::RightLegend, double ratio = -1.0 );
 …
     void updateCanvasMargins();
     virtual void getCanvasMarginsHint(
+    virtual void getCanvasMarginsHint(
         const QwtScaleMap maps[], const QRectF &canvasRect,
         double &left, double &top, double &right, double &bottom) const;
 …
     /*!
       A signal with the attributes how to update
+      A signal with the attributes how to update
       the legend entries for a plot item.
 …
       \sa itemToInfo(), infoToItem(), QwtAbstractLegend::updateLegend()
      */
     void legendDataChanged( const QVariant &itemInfo,
+    void legendDataChanged( const QVariant &itemInfo,
         const QList<QwtLegendData> &data );
 …
 private Q_SLOTS:
     void updateLegendItems( const QVariant &itemInfo,
         const QList<QwtLegendData> &data );
+        const QList<QwtLegendData> &legendData );
 private:

trunk/BNC/qwt/qwt_plot_abstract_barchart.cpp

-              r8127
+              r9383
    \brief Set the baseline
    The baseline is the origin for the chart. Each bar is
    painted from the baseline in the direction of the sample
+   The baseline is the origin for the chart. Each bar is
+   painted from the baseline in the direction of the sample
    value. In case of a horizontal orientation() the baseline
    is interpreted as x - otherwise as y - value.
 …
+}
 /*!
+/*!
    \return Value for the origin of the bar chart
    \sa setBaseline(), QwtPlotSeriesItem::orientation()
 …
        QwtPlot::getCanvasMarginsHint(), QwtPlot::updateCanvasMargins()
  */
 void QwtPlotAbstractBarChart::getCanvasMarginHint( const QwtScaleMap &xMap,
+void QwtPlotAbstractBarChart::getCanvasMarginHint( const QwtScaleMap &xMap,
     const QwtScaleMap &yMap, const QRectF &canvasRect,
     double &left, double &top, double &right, double &bottom ) const

trunk/BNC/qwt/qwt_plot_abstract_barchart.h

-              r8127
+              r9383
   \brief Abstract base class for bar chart items
   In opposite to almost all other plot items bar charts can't be
+  In opposite to almost all other plot items bar charts can't be
   displayed inside of their bounding rectangle and need a special
   API  how to calculate the width of the bars and how they affect
 …
     double baseline() const;
     virtual void getCanvasMarginHint(
+    virtual void getCanvasMarginHint(
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect,
 …
 protected:
     double sampleWidth( const QwtScaleMap &map,
         double canvasSize, double dataSize,
+        double canvasSize, double boundingSize,
         double value ) const;

trunk/BNC/qwt/qwt_plot_axis.cpp

-              r8127
+              r9383
         d.scaleEngine = new QwtLinearScaleEngine;
         d.scaleWidget->setTransformation(
+        d.scaleWidget->setTransformation(
             d.scaleEngine->transformation() );
 …
         d.scaleEngine = scaleEngine;
         d_axisData[axisId]->scaleWidget->setTransformation(
+        d_axisData[axisId]->scaleWidget->setTransformation(
             scaleEngine->transformation() );
 …
     else
         return false;
+}
 …
 /*!
   \brief Return the step size parameter that has been set in setAxisScale.
+  \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.
 …
   This is only a convenience function for axisScaleDiv( axisId )->interval();
   \param axisId Axis index
   \return Scale interval
 …
   \brief Disable autoscaling and specify a fixed scale for a selected axis.
   In updateAxes() the scale engine calculates a scale division from the
   specified parameters, that will be assigned to the scale widget. So
+  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.
 …
   The scale division will be stored locally only until the next call
   of updateAxes(). So updates of the scale widget usually happen delayed with
+  of updateAxes(). So updates of the scale widget usually happen delayed with
   the next replot.
 …
+}
 /*!
+/*!
   \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() )
+  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
+  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
+  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
+  The scale widget indicates modifications by emitting a
   QwtScaleWidget::scaleDivChanged() signal.
   updateAxes() is usually called by replot().
+  updateAxes() is usually called by replot().
   \sa setAxisAutoScale(), setAxisScale(), setAxisScaleDiv(), replot()

trunk/BNC/qwt/qwt_plot_barchart.cpp

-              r8127
+              r9383
+    {
+    }
     ~PrivateData()
+    {
 …
   The bar chart will take the ownership of the symbol, hence the previously
   set symbol will be delete by setting a new one. If \p symbol is
+  set symbol will be delete by setting a new one. If \p symbol is
   \c NULL no symbol will be drawn.
 …
 /*!
   Draw a bar
+  Draw a bar
   \param painter Painter
 …
  */
 void QwtPlotBarChart::drawBar( QPainter *painter,
     int sampleIndex, const QPointF &sample,
+    int sampleIndex, const QPointF &sample,
     const QwtColumnRect &rect ) const
+{
     const QwtColumnSymbol *specialSym =
+    const QwtColumnSymbol *specialSym =
         specialSymbol( sampleIndex, sample );
 …
+    {
         // we build a temporary default symbol
         QwtColumnSymbol sym( QwtColumnSymbol::Box );
         sym.setLineWidth( 1 );
         sym.setFrameStyle( QwtColumnSymbol::Plain );
         sym.draw( painter, rect );
+        QwtColumnSymbol columnSymbol( QwtColumnSymbol::Box );
+        columnSymbol.setLineWidth( 1 );
+        columnSymbol.setFrameStyle( QwtColumnSymbol::Plain );
+        columnSymbol.draw( painter, rect );
+    }
 …
 /*!
   Needs to be overloaded to return a
+  Needs to be overloaded to return a
   non default symbol for a specific sample
 …
   \return NULL, indicating to use the default symbol
  */
 QwtColumnSymbol *QwtPlotBarChart::specialSymbol(
+QwtColumnSymbol *QwtPlotBarChart::specialSymbol(
     int sampleIndex, const QPointF &sample ) const
+{
 …
    displays the default symbol.
    \param index Index of the legend entry
+   \param index Index of the legend entry
    \param size Icon size
    \sa setLegendMode(), drawBar(),
+   \sa setLegendMode(), drawBar(),
        QwtPlotItem::setLegendIconSize(), QwtPlotItem::legendData()
  */
 QwtGraphic QwtPlotBarChart::legendIcon(
+QwtGraphic QwtPlotBarChart::legendIcon(
     int index, const QSizeF &size ) const
+{
 …
     if ( d_data->legendMode == QwtPlotBarChart::LegendBarTitles )
         barIndex = index;
     drawBar( &painter, barIndex, QPointF(), column );

trunk/BNC/qwt/qwt_plot_barchart.h

-              r8127
+              r9383
   a specialSymbol(). Otherwise it is rendered using a default symbol.
   Depending on its orientation() the bars are displayed horizontally
   or vertically. The bars cover the interval between the baseline()
+  Depending on its orientation() the bars are displayed horizontally
+  or vertically. The bars cover the interval between the baseline()
   and the value.
 …
     enum LegendMode
+    {
         /*!
+        /*!
           One entry on the legend showing the default symbol
           and the title() of the chart
 …
     };
     explicit QwtPlotBarChart( const QString &title = QString::null );
+    explicit QwtPlotBarChart( const QString &title = QString() );
     explicit QwtPlotBarChart( const QwtText &title );
 …
     void setSamples( const QVector<QPointF> & );
     void setSamples( const QVector<double> & );
     void setSamples( QwtSeriesData<QPointF> *series );
+    void setSamples( QwtSeriesData<QPointF> * );
     void setSymbol( QwtColumnSymbol * );
 …
     virtual QRectF boundingRect() const;
     virtual QwtColumnSymbol *specialSymbol(
+    virtual QwtColumnSymbol *specialSymbol(
         int sampleIndex, const QPointF& ) const;
 …
     virtual void drawBar( QPainter *,
         int sampleIndex, const QPointF& point,
+        int sampleIndex, const QPointF& sample,
         const QwtColumnRect & ) const;

trunk/BNC/qwt/qwt_plot_canvas.cpp

r8127	r9383
49	49	}
50	50
	51	virtual void drawRects(const QRect *rects, int count )
	52	{
	53	// to silence -Woverloaded-virtual
	54	QwtNullPaintDevice::drawRects( rects, count );
	55	}
	56
51	57	virtual void drawPath( const QPainterPath &path )
52	58	{
…	…
73	79	for ( int i = 0; i < path.elementCount(); i++ )
74	80	{
75		QPainterPath::Element el = path.elementAt(i);
	81	QPainterPath::Element el = path.elementAt(i);
76	82	switch( el.type )
77	83	{
…	…
98	104	{
99	105	QRectF r = clipRects.last();
100		r.setCoords(
	106	r.setCoords(
101	107	qMin( r.left(), el.x ),
102	108	qMin( r.top(), el.y ),
…	…
170	176	painter->setClipPath( borderClip, Qt::IntersectClip );
171	177
172		const QBrush &brush =
	178	const QBrush &brush =
173	179	canvas->palette().brush( canvas->backgroundRole() );
174	180
…	…
186	192	{
187	193	rects += canvas->rect();
188		}
189		else
	194	}
	195	else
190	196	{
191	197	rects = painter->clipRegion().rects();
…	…
197	203	if ( painter->paintEngine()->type() == QPaintEngine::X11 )
198	204	{
199		// Qt 4.7.1: gradients on X11 are broken ( subrects +
	205	// Qt 4.7.1: gradients on X11 are broken ( subrects +
200	206	// QGradient::StretchToDeviceMode ) and horrible slow.
201	207	// As workaround we have to use the raster paintengine.
…	…
223	229	}
224	230	}
225
	231
226	232	QImage image( canvas->size(), format );
227	233
…	…
268	274	}
269	275
270		static QPainterPath qwtCombinePathList( const QRectF &rect,
	276	static QPainterPath qwtCombinePathList( const QRectF &rect,
271	277	const QList<QPainterPath> &pathList )
272	278	{
…	…
286	292	if ( br.center().y() < rect.center().y() )
287	293	{
288		if ( qAbs( br.top() - rect.top() ) <
	294	if ( qAbs( br.top() - rect.top() ) <
289	295	qAbs( br.left() - rect.left() ) )
290	296	{
…	…
298	304	else
299	305	{
300		if ( qAbs( br.bottom() - rect.bottom() ) <
	306	if ( qAbs( br.bottom() - rect.bottom() ) <
301	307	qAbs( br.left() - rect.left() ) )
302	308	{
…	…
316	322	if ( br.center().y() < rect.center().y() )
317	323	{
318		if ( qAbs( br.top() - rect.top() ) <
	324	if ( qAbs( br.top() - rect.top() ) <
319	325	qAbs( br.right() - rect.right() ) )
320	326	{
…	…
328	334	else
329	335	{
330		if ( qAbs( br.bottom() - rect.bottom() ) <
	336	if ( qAbs( br.bottom() - rect.bottom() ) <
331	337	qAbs( br.right() - rect.right() ) )
332	338	{
…	…
340	346	if ( subPath.currentPosition().y() < br.center().y() )
341	347	qwtRevertPath( subPath );
342		}
	348	}
343	349	ordered[index] = subPath;
344	350	}
…	…
381	387	}
382	388
383		static inline void qwtDrawStyledBackground(
	389	static inline void qwtDrawStyledBackground(
384	390	QWidget w, QPainter painter )
385	391	{
…	…
418	424	}
419	425
420		static void qwtFillBackground( QPainter *painter,
	426	static void qwtFillBackground( QPainter *painter,
421	427	QWidget *widget, const QVector<QRectF> &fillRects )
422	428	{
…	…
521	527	};
522	528
523		/*!
	529	/*!
524	530	\brief Constructor
525	531
…	…
595	601	*d_data->backingStore = grab( rect() );
596	602	#else
597		*d_data->backingStore =
	603	*d_data->backingStore =
598	604	QPixmap::grabWidget( this, rect() );
599	605	#endif
…	…
695	701	bool QwtPlotCanvas::event( QEvent *event )
696	702	{
697		if ( event->type() == QEvent::PolishRequest )
	703	if ( event->type() == QEvent::PolishRequest )
698	704	{
699	705	if ( testPaintAttribute( QwtPlotCanvas::Opaque ) )
700	706	{
701		// Setting a style sheet changes the
	707	// Setting a style sheet changes the
702	708	// Qt::WA_OpaquePaintEvent attribute, but we insist
703	709	// on painting the background.
704
	710
705	711	setAttribute( Qt::WA_OpaquePaintEvent, true );
706	712	}
707	713	}
708	714
709		if ( event->type() == QEvent::PolishRequest \|\|
	715	if ( event->type() == QEvent::PolishRequest \|\|
710	716	event->type() == QEvent::StyleChange )
711	717	{
…	…
729	735	{
730	736	QPixmap &bs = *d_data->backingStore;
731		if ( bs.size() != size() )
	737
	738	qreal pixelRatio = 1.0;
	739
	740	#if QT_VERSION >= 0x050000
	741	pixelRatio = bs.devicePixelRatio();
	742	#endif
	743
	744	if ( bs.size() != size() * pixelRatio )
732	745	{
733	746	bs = QwtPainter::backingStore( this, size() );
…	…
806	819	drawCanvas( &painter, false );
807	820
808		if ( frameWidth() > 0 )
	821	if ( frameWidth() > 0 )
809	822	drawBorder( &painter );
810	823	}
…	…
815	828	}
816	829
817		void QwtPlotCanvas::drawCanvas( QPainter *painter, bool withBackground )
	830	void QwtPlotCanvas::drawCanvas( QPainter *painter, bool withBackground )
818	831	{
819	832	bool hackStyledBackground = false;
820	833
821		if ( withBackground && testAttribute( Qt::WA_StyledBackground )
	834	if ( withBackground && testAttribute( Qt::WA_StyledBackground )
822	835	&& testPaintAttribute( HackStyledBackground ) )
823	836	{
824	837	// Antialiasing rounded borders is done by
825		// inserting pixels with colors between the
	838	// inserting pixels with colors between the
826	839	// border color and the color on the canvas,
827	840	// When the border is painted before the plot items
…	…
853	866
854	867	painter->setPen( Qt::NoPen );
855		painter->setBrush( d_data->styleSheet.background.brush );
	868	painter->setBrush( d_data->styleSheet.background.brush );
856	869	painter->setBrushOrigin( d_data->styleSheet.background.origin );
857	870	painter->setClipPath( d_data->styleSheet.borderPath );
…	…
894	907	if ( !d_data->styleSheet.borderPath.isEmpty() )
895	908	{
896		painter->setClipPath(
	909	painter->setClipPath(
897	910	d_data->styleSheet.borderPath, Qt::IntersectClip );
898	911	}
…	…
930	943	if ( frameWidth() > 0 )
931	944	{
932		QwtPainter::drawRoundedFrame( painter, QRectF( frameRect() ),
	945	QwtPainter::drawRoundedFrame( painter, QRectF( frameRect() ),
933	946	d_data->borderRadius, d_data->borderRadius,
934	947	palette(), frameWidth(), frameStyle() );
…	…
953	966	#endif
954	967
955		switch (frameShape)
	968	switch (frameShape)
956	969	{
957	970	case QFrame::Box:
…	…
963	976	opt.lineWidth = lineWidth();
964	977	opt.midLineWidth = midLineWidth();
965		break;
966		}
967		default:
	978	break;
	979	}
	980	default:
968	981	{
969	982	opt.lineWidth = frameWidth();
…	…
971	984	}
972	985	}
973
	986
974	987	if ( frameShadow == Sunken )
975	988	opt.state \|= QStyle::State_Sunken;
…	…
1030	1043
1031	1044	QwtStyleSheetRecorder recorder( size() );
1032
	1045
1033	1046	QPainter painter( &recorder );
1034
	1047
1035	1048	QStyleOption opt;
1036	1049	opt.initFrom(this);
1037	1050	style()->drawPrimitive( QStyle::PE_Widget, &opt, &painter, this);
1038
	1051
1039	1052	painter.end();
1040	1053
…	…
1046	1059	if ( !recorder.border.rectList.isEmpty() )
1047	1060	{
1048		d_data->styleSheet.borderPath =
	1061	d_data->styleSheet.borderPath =
1049	1062	qwtCombinePathList( rect(), recorder.border.pathList );
1050	1063	}
…	…
1097	1110	return path;
1098	1111	}
1099
	1112
1100	1113	return QPainterPath();
1101	1114	}

trunk/BNC/qwt/qwt_plot_canvas.h

-              r8127
+              r9383
 /*!
   \brief Canvas of a QwtPlot.
    Canvas is the widget where all plot items are displayed
 …
+    {
         /*!
           \brief Paint double buffered reusing the content
                  of the pixmap buffer when possible.
+          \brief Paint double buffered reusing the content
+                 of the pixmap buffer when possible.
           Using a backing store might improve the performance
 …
           When using styled backgrounds Qt assumes, that the
           canvas doesn't fill its area completely
+          canvas doesn't fill its area completely
           ( f.e because of rounded borders ) and fills the area
           below the canvas. When this is done with gradients it might
 …
           When the Opaque attribute is enabled the canvas tries to
           identify the gaps with some heuristics and to fill those only.
+          identify the gaps with some heuristics and to fill those only.
           \warning Will not work for semitransparent backgrounds
+          \warning Will not work for semitransparent backgrounds
          */
         Opaque       = 2,

trunk/BNC/qwt/qwt_plot_curve.cpp

-              r8127
+              r9383
 static void qwtUpdateLegendIconSize( QwtPlotCurve *curve )
+{
     if ( curve->symbol() &&
+    if ( curve->symbol() &&
         curve->testLegendAttribute( QwtPlotCurve::LegendShowSymbol ) )
+    {
 …
         symbol( NULL ),
         attributes( 0 ),
         paintAttributes(
+        paintAttributes(
             QwtPlotCurve::ClipPolygons | QwtPlotCurve::FilterPoints ),
         legendAttributes( 0 )
 …
   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
+  set symbol will be delete by setting a new one. If \p symbol is
   \c NULL no symbol will be drawn.
 …
         if ( !doFit && !doFill )
             doIntegers = true;
+            doIntegers = true;
+    }
 #endif
 …
     if ( doIntegers )
+    {
         QPolygon polyline = mapper.toPolygon(
+        QPolygon polyline = mapper.toPolygon(
             xMap, yMap, data(), from, to );
         if ( d_data->paintAttributes & ClipPolygons )
+        {
             polyline = QwtClipper::clipPolygon(
+            polyline = QwtClipper::clipPolygon(
                 clipRect.toAlignedRect(), polyline, false );
+        }
 …
                 if ( d_data->paintAttributes & ClipPolygons )
+                {
                     polyline = QwtClipper::clipPolygonF(
+                    polyline = QwtClipper::clipPolygonF(
                         clipRect, polyline, false );
+                }
 …
 void QwtPlotCurve::drawSticks( QPainter *painter,
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+    const QRectF &, int from, int to ) const
+{
+    const QRectF &canvasRect, int from, int to ) const
+{
+    Q_UNUSED( canvasRect )
     painter->save();
     painter->setRenderHint( QPainter::Antialiasing, false );
 …
         mapper.setFlag( QwtPointMapper::WeedOutPoints, false );
         QPolygonF points = mapper.toPointsF(
+        QPolygonF points = mapper.toPointsF(
             xMap, yMap, data(), from, to );
 …
+    {
         const QImage image = mapper.toImage( xMap, yMap,
             data(), from, to, d_data->pen,
+            data(), from, to, d_data->pen,
             painter->testRenderHint( QPainter::Antialiasing ),
             renderThreadCount() );
 …
+        {
             const QPolygon points = mapper.toPoints(
                 xMap, yMap, data(), from, to );
+                xMap, yMap, data(), from, to );
             QwtPainter::drawPoints( painter, points );
 …
         else
+        {
             const QPolygonF points = mapper.toPointsF(
+            const QPolygonF points = mapper.toPointsF(
                 xMap, yMap, data(), from, to );
 …
         qreal pw = qMax( qreal( 1.0 ), painter->pen().widthF());
         const QRectF clipRect = canvasRect.adjusted(-pw, -pw, pw, pw);
         const QPolygonF clipped = QwtClipper::clipPolygonF(
+        const QPolygonF clipped = QwtClipper::clipPolygonF(
             clipRect, polygon, false );
 …
 /*!
   \brief Complete a polygon to be a closed polygon including the
+  \brief Complete a polygon to be a closed polygon including the
          area between the original polygon and the baseline.
 …
     double baseline = d_data->baseline;
     if ( orientation() == Qt::Vertical )
+    {
 …
+{
     QwtPointMapper mapper;
     mapper.setFlag( QwtPointMapper::RoundPoints,
+    mapper.setFlag( QwtPointMapper::RoundPoints,
         QwtPainter::roundingAlignment( painter ) );
     mapper.setFlag( QwtPointMapper::WeedOutPoints,
+    mapper.setFlag( QwtPointMapper::WeedOutPoints,
         testPaintAttribute( QwtPlotCurve::FilterPoints ) );
     mapper.setBoundingRect( canvasRect );
 …
   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
+  With Qt::Vertical, the baseline is interpreted as a horizontal line
+  at y = baseline(), with Qt::Horizontal, it is interpreted as a vertical
   line at x = baseline().
 …
    \return Icon representing the curve on the legend
    \param index Index of the legend entry
+   \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,
+QwtGraphic QwtPlotCurve::legendIcon( int index,
     const QSizeF &size ) const
+{
 …
 /*!
   \brief Initialize the data by pointing to memory blocks which
+  \brief Initialize the data by pointing to memory blocks which
          are not managed by QwtPlotCurve.
   setRawSamples is provided for efficiency.
+  setRawSamples is provided for efficiency.
   It is important to keep the pointers
   during the lifetime of the underlying QwtCPointerData class.
 …
   \sa QwtCPointerData
 */
 void QwtPlotCurve::setRawSamples(
+void QwtPlotCurve::setRawSamples(
     const double *xData, const double *yData, int size )
+{
 …
   \sa QwtPointArrayData
 */
 void QwtPlotCurve::setSamples(
+void QwtPlotCurve::setSamples(
     const double *xData, const double *yData, int size )
+{

trunk/BNC/qwt/qwt_plot_curve.h

-              r8127
+              r9383
   <dl><dt>a) Assign curve properties</dt>
   <dd>When a curve is created, it is configured to draw black solid lines
   with in QwtPlotCurve::Lines style and no symbols.
+  with in QwtPlotCurve::Lines style and no symbols.
   You can change this by calling
   setPen(), setStyle() and setSymbol().</dd>
 …
   \sa QwtPointSeriesData, QwtSymbol, QwtScaleMap
 */
 class QWT_EXPORT QwtPlotCurve:
+class QWT_EXPORT QwtPlotCurve:
     public QwtPlotSeriesItem, public QwtSeriesStore<QPointF>
+{
 …
         /*!
            Draw vertical or horizontal sticks ( depending on the
+           Draw vertical or horizontal sticks ( depending on the
            orientation() ) from a baseline which is defined by setBaseline().
         */
 …
            Draw dots at the locations of the data points. Note:
            This is different from a dotted line (see setPen()), and faster
            as a curve in QwtPlotCurve::NoStyle style and a symbol
+           as a curve in QwtPlotCurve::NoStyle style and a symbol
            painting a point.
         */
 …
+    {
         /*!
            For QwtPlotCurve::Steps only.
+           For QwtPlotCurve::Steps only.
            Draws a step function from the right to the left.
          */
 …
+    {
         /*!
           QwtPlotCurve tries to find a color representing the curve
+          QwtPlotCurve tries to find a color representing the curve
           and paints a rectangle with it.
          */
 …
         /*!
           If the style() is not QwtPlotCurve::NoCurve a line
+          If the style() is not QwtPlotCurve::NoCurve a line
           is painted with the curve pen().
          */
 …
         /*!
           Minimize memory usage that is temporarily needed for the
+          Minimize memory usage that is temporarily needed for the
           translated points, before they get painted.
           This might slow down the performance of painting
+          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.
+          having a huge amount of points.
           With a reasonable number of points QPainter::drawPoints()
           will be faster.
 …
     typedef QFlags<PaintAttribute> PaintAttributes;
     explicit QwtPlotCurve( const QString &title = QString::null );
+    explicit QwtPlotCurve( const QString &title = QString() );
     explicit QwtPlotCurve( const QwtText &title );
 …
     void init();
     virtual void drawCurve( QPainter *p, int style,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;
     virtual void drawSymbols( QPainter *p, const QwtSymbol &,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;
     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,
+    virtual void drawCurve( QPainter *, int style,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawSymbols( QPainter *, const QwtSymbol &,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawLines( QPainter *,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawSticks( QPainter *,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawDots( QPainter *,
+        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+        const QRectF &canvasRect, int from, int to ) const;
+    virtual void drawSteps( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;
     virtual void fillCurve( QPainter *,
         const QwtScaleMap &, const QwtScaleMap &,
+        const QwtScaleMap &, const QwtScaleMap &,
         const QRectF &canvasRect, QPolygonF & ) const;

trunk/BNC/qwt/qwt_plot_dict.cpp

-              r8127
+              r9383
+{
     PrivateData::ItemList list = d_data->itemList;
     QwtPlotItemIterator it = list.begin();
     while ( it != list.end() )
+    QwtPlotItemIterator it = list.constBegin();
+    while ( it != list.constEnd() )
+    {
         QwtPlotItem *item = *it;
 …
     PrivateData::ItemList list = d_data->itemList;
     for ( QwtPlotItemIterator it = list.begin(); it != list.end(); ++it )
+    for ( QwtPlotItemIterator it = list.constBegin(); it != list.constEnd(); ++it )
+    {
         QwtPlotItem *item = *it;

trunk/BNC/qwt/qwt_plot_directpainter.cpp

-              r8127
+              r9383
 #include <qpixmap.h>
 static inline void qwtRenderItem(
+static inline void qwtRenderItem(
     QPainter *painter, const QRect &canvasRect,
     QwtPlotSeriesItem *seriesItem, int from, int to )
 …
 /*!
   En/Disables clipping
+  En/Disables clipping
   \param enable Enables clipping is true, disable it otherwise
 …
    \brief Assign a clip region and enable clipping
    Depending on the environment setting a proper clip region might improve
+   Depending on the environment setting a proper clip region might improve
    the performance heavily. F.e. on Qt embedded only the clipped part of
    the backing store will be copied to a ( maybe unaccelerated ) frame buffer
    device.
    \param region Clip region
    \sa clipRegion(), hasClipping(), setClipping()
 …
     bool immediatePaint = true;
     if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) )
+    if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) )
+    {
 #if QT_VERSION < 0x050000
 …
         if ( d_data->hasClipping )
+        {
             d_data->painter.setClipRegion(
+            d_data->painter.setClipRegion(
                 QRegion( canvasRect ) & d_data->clipRegion );
+        }
 …
             if ( doCopyCache )
+            {
                 QwtPlotCanvas *plotCanvas =
+                QwtPlotCanvas *plotCanvas =
                     qobject_cast<QwtPlotCanvas *>( canvas );
                 if ( plotCanvas )
 …
                     if ( doCopyCache )
+                    {
                         painter.drawPixmap( plotCanvas->rect().topLeft(),
+                        painter.drawPixmap( plotCanvas->rect().topLeft(),
                             *plotCanvas->backingStore() );
+                    }

trunk/BNC/qwt/qwt_plot_directpainter.h

-              r8127
+              r9383
     On certain environments it might be important to calculate a proper
     clip region before painting. F.e. for Qt Embedded only the clipped part
     of the backing store will be copied to a ( maybe unaccelerated )
+    of the backing store will be copied to a ( maybe unaccelerated )
     frame buffer.
 …
         /*!
           When QwtPlotCanvas::BackingStore is enabled the painter
           has to paint to the backing store and the widget. In certain
           situations/environments it might be faster to paint to
+          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 backing store to the canvas.
           This flag can also be useful for settings, where Qt fills the

trunk/BNC/qwt/qwt_plot_glcanvas.cpp

-              r8127
+              r9383
     for ( ; w->parentWidget() != NULL; w = w->parentWidget() )
+    {
         if ( w->autoFillBackground() ||
+        if ( w->autoFillBackground() ||
             w->testAttribute( Qt::WA_StyledBackground ) )
+        {
 …
 };
 /*!
+/*!
   \brief Constructor
 …
   Set the frame style
   \param style The bitwise OR between a shape and a shadow.
   \sa frameStyle(), QFrame::setFrameStyle(),
+  \param style The bitwise OR between a shape and a shadow.
+  \sa frameStyle(), QFrame::setFrameStyle(),
       setFrameShadow(), setFrameShape()
  */
 …
   \return Midline width of the frame
   \sa setMidLineWidth(), lineWidth()
  */
+ */
 int QwtPlotGLCanvas::midLineWidth() const
+{
 …
   \sa QwtPlot::drawCanvas()
 */
+*/
 void QwtPlotGLCanvas::drawItems( QPainter *painter )
+{
 …
   Draw the background of the canvas
   \param painter Painter
 */
+*/
 void QwtPlotGLCanvas::drawBackground( QPainter *painter )
+{
 …
         w->style()->drawPrimitive( QStyle::PE_Widget, &opt, painter, w);
+    }
     else
+    else
+    {
         painter->fillRect( fillRect,
 …
     if ( frameShadow() == QwtPlotGLCanvas::Plain )
+    {
         qDrawPlainRect( painter, frameRect(),
+        qDrawPlainRect( painter, frameRect(),
             palette().shadow().color(), lineWidth() );
+    }
 …
         else
+        {
             qDrawShadePanel( painter, frameRect(), palette(),
+            qDrawShadePanel( painter, frameRect(), palette(),
                 frameShadow() == Sunken, lineWidth() );
+        }

trunk/BNC/qwt/qwt_plot_glcanvas.h

-              r8127
+              r9383
 #include <qframe.h>
 #include <qgl.h>
+#include <qpainterpath.h>
 class QwtPlot;
 …
 /*!
   \brief An alternative canvas for a QwtPlot derived from QGLWidget
   QwtPlotGLCanvas implements the very basics to act as canvas
   inside of a QwtPlot widget. It might be extended to a full
 …
   \note With Qt4 you might want to use the QPaintEngine::OpenGL paint engine
         ( see QGL::setPreferredPaintEngine() ). On a Linux test system
+        ( see QGL::setPreferredPaintEngine() ). On a Linux test system
         QPaintEngine::OpenGL2 shows very basic problems like translated
         geometries.
 …
         to use QFrame::Shadow instead.
         \note QFrame::StyledPanel and QFrame::WinPanel are unsuported
+        \note QFrame::StyledPanel and QFrame::WinPanel are unsupported
               and will be displayed as QFrame::Panel.
      */

trunk/BNC/qwt/qwt_plot_grid.h

-              r8127
+              r9383
     virtual int rtti() const;
     void enableX( bool tf );
+    void enableX( bool );
     bool xEnabled() const;
     void enableY( bool tf );
+    void enableY( bool );
     bool yEnabled() const;
     void enableXMin( bool tf );
+    void enableXMin( bool );
     bool xMinEnabled() const;
     void enableYMin( bool tf );
+    void enableYMin( bool );
     bool yMinEnabled() const;
     void setXDiv( const QwtScaleDiv &sx );
+    void setXDiv( const QwtScaleDiv & );
     const QwtScaleDiv &xScaleDiv() const;
     void setYDiv( const QwtScaleDiv &sy );
+    void setYDiv( const QwtScaleDiv & );
     const QwtScaleDiv &yScaleDiv() const;
 …
     void setMinorPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setMinorPen( const QPen &p );
+    void setMinorPen( const QPen & );
     const QPen& minorPen() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
     virtual void updateScaleDiv(
         const QwtScaleDiv &xMap, const QwtScaleDiv &yMap );
+    virtual void updateScaleDiv(
+        const QwtScaleDiv &xScaleDiv, const QwtScaleDiv &yScaleDiv );
 private:
     void drawLines( QPainter *painter, const QRectF &,
         Qt::Orientation orientation, const QwtScaleMap &,
+    void drawLines( QPainter *, const QRectF &,
+        Qt::Orientation, const QwtScaleMap &,
         const QList<double> & ) const;

trunk/BNC/qwt/qwt_plot_histogram.cpp

-              r8127
+              r9383
 /*!
   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 ) );
+}
+}
 /*!
 …
 /*!
   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(
+void QwtPlotHistogram::setSamples(
     QwtSeriesData<QwtIntervalSample> *data )
+{
 …
 void QwtPlotHistogram::drawSeries( QPainter *painter,
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+    const QRectF &, int from, int to ) const
+{
+    const QRectF &canvasRect, int from, int to ) const
+{
+    Q_UNUSED( canvasRect )
     if ( !painter || dataSize() <= 0 )
         return;
 …
   A plain rectangle without pen using the brush()
   \param index Index of the legend entry
+  \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()
 */

trunk/BNC/qwt/qwt_plot_histogram.h

-              r8127
+              r9383
 */
 class QWT_EXPORT QwtPlotHistogram:
+class QWT_EXPORT QwtPlotHistogram:
     public QwtPlotSeriesItem, public QwtSeriesStore<QwtIntervalSample>
+{
 …
         /*!
            Draw a column for each interval. When a symbol() has been set
            the symbol is used otherwise the column is displayed as
+           the symbol is used otherwise the column is displayed as
            plain rectangle using pen() and brush().
          */
 …
     };
     explicit QwtPlotHistogram( const QString &title = QString::null );
+    explicit QwtPlotHistogram( const QString &title = QString() );
     explicit QwtPlotHistogram( const QwtText &title );
     virtual ~QwtPlotHistogram();
 …
     void setSamples( QwtSeriesData<QwtIntervalSample> * );
     void setBaseline( double reference );
+    void setBaseline( double );
     double baseline() const;
 …
     const QwtColumnSymbol *symbol() const;
     virtual void drawSeries( QPainter *p,
+    virtual void drawSeries( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;

trunk/BNC/qwt/qwt_plot_intervalcurve.cpp

-              r8127
+              r9383
 /*!
   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(
+void QwtPlotIntervalCurve::setSamples(
     QwtSeriesData<QwtIntervalSample> *data )
+{
 …
 /*!
   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 ) );
+}
+}
 /*!
 …
+{
     QRectF rect = QwtPlotSeriesItem::boundingRect();
     if ( rect.isValid() && orientation() == Qt::Vertical )
+    if ( orientation() == Qt::Vertical )
         rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
 …
   If a symbol is assigned it is scaled to size.
   \param index Index of the legend entry
+  \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(
+QwtGraphic QwtPlotIntervalCurve::legendIcon(
     int index, const QSizeF &size ) const
+{

trunk/BNC/qwt/qwt_plot_intervalcurve.h

-              r8127
+              r9383
   to display error bars or the area between 2 curves.
 */
 class QWT_EXPORT QwtPlotIntervalCurve:
+class QWT_EXPORT QwtPlotIntervalCurve:
     public QwtPlotSeriesItem, public QwtSeriesStore<QwtIntervalSample>
+{
 …
     typedef QFlags<PaintAttribute> PaintAttributes;
     explicit QwtPlotIntervalCurve( const QString &title = QString::null );
+    explicit QwtPlotIntervalCurve( const QString &title = QString() );
     explicit QwtPlotIntervalCurve( const QwtText &title );
 …
     const QwtIntervalSymbol *symbol() const;
     virtual void drawSeries( QPainter *p,
+    virtual void drawSeries( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasRect, int from, int to ) const;

trunk/BNC/qwt/qwt_plot_item.cpp

-              r8127
+              r9383
 /*!
    \brief This method detaches a QwtPlotItem from any
+   \brief This method detaches a QwtPlotItem from any
           QwtPlot it has been associated with.
 …
 /*!
    On multi core systems rendering of certain plot item
    ( f.e QwtPlotRasterItem ) can be done in parallel in
+   On multi core systems rendering of certain plot item
+   ( f.e QwtPlotRasterItem ) can be done in parallel in
    several threads.
 …
    The default implementation returns an invalid icon
    \param index Index of the legend entry
+   \param index Index of the legend entry
                 ( usually there is only one )
    \param size Icon size
 …
    \sa setLegendIconSize(), legendData()
  */
 QwtGraphic QwtPlotItem::legendIcon(
+QwtGraphic QwtPlotItem::legendIcon(
     int index, const QSizeF &size ) const
+{
 …
    \return A filled rectangle
  */
 QwtGraphic QwtPlotItem::defaultIcon(
+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
 …
    \param bottom Returns the bottom margin
    \return The default implementation returns 0 for all margins
+   The default implementation returns 0 for all margins
    \sa QwtPlot::getCanvasMarginsHint(), QwtPlot::updateCanvasMargins()
  */
 void QwtPlotItem::getCanvasMarginHint( const QwtScaleMap &xMap,
+void QwtPlotItem::getCanvasMarginHint( const QwtScaleMap &xMap,
     const QwtScaleMap &yMap, const QRectF &canvasRect,
     double &left, double &top, double &right, double &bottom ) const
 …
    QwtLegendData is basically a list of QVariants that makes it
    possible to overload and reimplement legendData() to
+   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 default implementation returns one entry with
    the title() of the item and the legendIcon().
 …
     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;
 …
          legendData() and legendIcon()
  */
 void QwtPlotItem::updateLegend( const QwtPlotItem *item,
+void QwtPlotItem::updateLegend( const QwtPlotItem *item,
     const QList<QwtLegendData> &data )
+{

trunk/BNC/qwt/qwt_plot_item.h

-              r8127
+              r9383
         Rtti_PlotZone,
         /*!
+        /*!
            Values >= Rtti_PlotUserItem are reserved for plot items
            not implemented in the Qwt library.
 …
        Various aspects of a plot widget depend on the attributes of
        the attached plot items. If and how a single plot item
+       the attached plot items. If and how a single plot item
        participates in these updates depends on its attributes.
        \sa setItemAttribute(), testItemAttribute(), ItemInterest
      */
 …
         /*!
            The item needs extra space to display something outside
            its bounding rectangle.
+           its bounding rectangle.
            \sa getCanvasMarginHint()
          */
 …
     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
 …
     virtual QRectF boundingRect() const;
     virtual void getCanvasMarginHint(
+    virtual void getCanvasMarginHint(
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &canvasSize,
+        const QRectF &canvasRect,
         double &left, double &top, double &right, double &bottom) const;
     virtual void updateScaleDiv(
+    virtual void updateScaleDiv(
         const QwtScaleDiv&, const QwtScaleDiv& );

trunk/BNC/qwt/qwt_plot_layout.cpp

-              r8127
+              r9383
     // canvas
     plot->canvas()->getContentsMargins(
         &canvas.contentsMargins[ QwtPlot::yLeft ],
+    plot->canvas()->getContentsMargins(
+        &canvas.contentsMargins[ QwtPlot::yLeft ],
         &canvas.contentsMargins[ QwtPlot::xTop ],
         &canvas.contentsMargins[ QwtPlot::yRight ],
 …
   \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.
+  \param dimAxes Expanded heights of the axis in axis orientation.
   \sa Options
 */
 void QwtPlotLayout::expandLineBreaks( Options options, const QRectF &rect,
     int &dimTitle, int &dimFooter, int dimAxis[QwtPlot::axisCnt] ) const
+    int &dimTitle, int &dimFooter, int dimAxes[QwtPlot::axisCnt] ) const
+{
     dimTitle = dimFooter = 0;
     for ( int axis = 0; axis < QwtPlot::axisCnt; axis++ )
         dimAxis[axis] = 0;
+        dimAxes[axis] = 0;
     int backboneOffset[QwtPlot::axisCnt];
 …
+            {
                 // center to the canvas
                 w -= dimAxis[QwtPlot::yLeft] + dimAxis[QwtPlot::yRight];
+                w -= dimAxes[QwtPlot::yLeft] + dimAxes[QwtPlot::yRight];
+            }
 …
+            {
                 // center to the canvas
                 w -= dimAxis[QwtPlot::yLeft] + dimAxis[QwtPlot::yRight];
+                w -= dimAxes[QwtPlot::yLeft] + dimAxes[QwtPlot::yRight];
+            }
 …
                 if ( axis == QwtPlot::xTop || axis == QwtPlot::xBottom )
+                {
                     length = rect.width() - dimAxis[QwtPlot::yLeft]
                         - dimAxis[QwtPlot::yRight];
+                    length = rect.width() - dimAxes[QwtPlot::yLeft]
+                        - dimAxes[QwtPlot::yRight];
                     length -= scaleData.start + scaleData.end;
                     if ( dimAxis[QwtPlot::yRight] > 0 )
+                    if ( dimAxes[QwtPlot::yRight] > 0 )
                         length -= 1;
                     length += qMin( dimAxis[QwtPlot::yLeft],
+                    length += qMin( dimAxes[QwtPlot::yLeft],
                         scaleData.start - backboneOffset[QwtPlot::yLeft] );
                     length += qMin( dimAxis[QwtPlot::yRight],
+                    length += qMin( dimAxes[QwtPlot::yRight],
                         scaleData.end - backboneOffset[QwtPlot::yRight] );
+                }
                 else // QwtPlot::yLeft, QwtPlot::yRight
+                {
                     length = rect.height() - dimAxis[QwtPlot::xTop]
                         - dimAxis[QwtPlot::xBottom];
+                    length = rect.height() - dimAxes[QwtPlot::xTop]
+                        - dimAxes[QwtPlot::xBottom];
                     length -= scaleData.start + scaleData.end;
                     length -= 1;
                     if ( dimAxis[QwtPlot::xBottom] <= 0 )
+                    if ( dimAxes[QwtPlot::xBottom] <= 0 )
                         length -= 1;
                     if ( dimAxis[QwtPlot::xTop] <= 0 )
+                    if ( dimAxes[QwtPlot::xTop] <= 0 )
                         length -= 1;
                     if ( dimAxis[QwtPlot::xBottom] > 0 )
+                    if ( dimAxes[QwtPlot::xBottom] > 0 )
+                    {
                         length += qMin(
 …
                             double( scaleData.start - backboneOffset[QwtPlot::xBottom] ) );
+                    }
                     if ( dimAxis[QwtPlot::xTop] > 0 )
+                    if ( dimAxes[QwtPlot::xTop] > 0 )
+                    {
                         length += qMin(
 …
                 if ( d > dimAxis[axis] )
+                {
                     dimAxis[axis] = d;
+                if ( d > dimAxes[axis] )
+                {
+                    dimAxes[axis] = d;
                     done = false;
+                }
 …
         if ( !( options & IgnoreFrames ) )
+        {
             backboneOffset[axis] +=
+            backboneOffset[axis] +=
                 d_data->layoutData.canvas.contentsMargins[axis];
+        }
 …
                     const double cRight = canvasRect.right(); // qreal -> double
                     canvasRect.setRight( qMin( cRight, axisRect.right() + dx ) );
+                }
+                }
                 const double maxRight = rightScaleRect.right();

trunk/BNC/qwt/qwt_plot_layout.h

-              r8127
+              r9383
         IgnoreScrollbars = 0x02,
         //! Ignore all frames.
+        //! Ignore all frames.
         IgnoreFrames = 0x04,
 …
     void setCanvasMargin( int margin, int axis = -1 );
     int canvasMargin( int axis ) const;
+    int canvasMargin( int axisId ) const;
     void setAlignCanvasToScales( bool );
 …
     virtual void activate( const QwtPlot *,
         const QRectF &rect, Options options = 0x00 );
+        const QRectF &plotRect, Options options = Options() );
     virtual void invalidate();

trunk/BNC/qwt/qwt_plot_legenditem.cpp

-              r8127
+              r9383
 };
 QwtLegendLayoutItem::QwtLegendLayoutItem(
+QwtLegendLayoutItem::QwtLegendLayoutItem(
         const QwtPlotLegendItem *legendItem, const QwtPlotItem *plotItem ):
     d_legendItem( legendItem ),
 …
 };
 //! Constructor
+//! Constructor
 QwtPlotLegendItem::QwtPlotLegendItem():
     QwtPlotItem( QwtText( "Legend" ) )
 …
   Alignment means the position of the legend relative
   to the geometry of the plot canvas.
+  to the geometry of the plot canvas.
   \param alignment Alignment flags
 …
   \sa alignment(), setMaxColumns()
   \note To align a legend with many items horizontally
+  \note To align a legend with many items horizontally
         the number of columns need to be limited
  */
 …
     if ( margin != this->margin() )
+    {
         d_data->layout->setContentsMargins(
+        d_data->layout->setContentsMargins(
             margin, margin, margin, margin );
 …
 /*!
   Set the radius for the border
   \param radius A value <= 0 defines a rectangular border
   \sa borderRadius(), setBorderPen()
 …
   \brief Set the background mode
   Depending on the mode the complete legend or each item
+  Depending on the mode the complete legend or each item
   might have an background.
 …
+}
 /*!
+/*!
   \return backgroundMode
   \sa setBackgroundMode(), backgroundBrush(), drawBackground()
 …
     if ( d_data->backgroundMode == QwtPlotLegendItem::LegendBackground )
         drawBackground( painter, d_data->layout->geometry() );
     for ( int i = 0; i <  d_data->layout->count(); i++ )
+    {
         const QwtLegendLayoutItem *layoutItem =
+        const QwtLegendLayoutItem *layoutItem =
             static_cast<QwtLegendLayoutItem *>( d_data->layout->itemAt( i ) );
 …
       setBackgroundBrush(), setBackgroundMode()
  */
 void QwtPlotLegendItem::drawBackground(
+void QwtPlotLegendItem::drawBackground(
     QPainter *painter, const QRectF &rect ) const
+{
 …
     painter->setPen( d_data->borderPen );
     painter->setBrush( d_data->backgroundBrush );
     const double radius = d_data->borderRadius;
     painter->drawRoundedRect( rect, radius, radius );
     painter->restore();
+}
 …
+    {
         int x = qRound( canvasRect.center().x() );
         rect.moveCenter( QPoint( x, rect.center().y() ) );
+        rect.moveCenter( QPoint( x, rect.center().y() ) );
+    }
     else if ( d_data->alignment & Qt::AlignRight )
 …
         rect.moveRight( qFloor( canvasRect.right() - margin ) );
+    }
     else
+    else
+    {
         rect.moveLeft( qCeil( canvasRect.left() + margin ) );
 …
         rect.moveBottom( qFloor( canvasRect.bottom() - margin ) );
+    }
     else
+    {
         rect.moveTop( qCeil( canvasRect.top() + margin ) );
+    else
+    {
+        rect.moveTop( qCeil( canvasRect.top() + margin ) );
+    }
 …
 /*!
   Update the legend items according to modifications of a
+  Update the legend items according to modifications of a
   plot item
 …
     QList<QwtLegendLayoutItem *> layoutItems;
     QMap<const QwtPlotItem *, QList<QwtLegendLayoutItem *> >::iterator it =
+    QMap<const QwtPlotItem *, QList<QwtLegendLayoutItem *> >::iterator it =
         d_data->map.find( plotItem );
     if ( it != d_data->map.end() )
 …
             for ( int i = 0; i < data.size(); i++ )
+            {
                 QwtLegendLayoutItem *layoutItem =
+                QwtLegendLayoutItem *layoutItem =
                     new QwtLegendLayoutItem( this, plotItem );
                 d_data->layout->addItem( layoutItem );
 …
  */
 void QwtPlotLegendItem::drawLegendData( QPainter *painter,
     const QwtPlotItem *plotItem, const QwtLegendData &data,
+    const QwtPlotItem *plotItem, const QwtLegendData &data,
     const QRectF &rect ) const
+{
 …
         QRectF iconRect( r.topLeft(), graphic.defaultSize() );
         iconRect.moveCenter(
+        iconRect.moveCenter(
             QPoint( iconRect.center().x(), rect.center().y() ) );
 …
   \param width Width
 */
 int QwtPlotLegendItem::heightForWidth(
+int QwtPlotLegendItem::heightForWidth(
     const QwtLegendData &data, int width ) const
+{
 …
+}
 /*!
+/*!
   \return All plot items with an entry on the legend
   \note A plot item might have more than one entry on the legend
 …
   \note Usually a plot item has only one entry on the legend
 */
 QList< QRect > QwtPlotLegendItem::legendGeometries(
+QList< QRect > QwtPlotLegendItem::legendGeometries(
     const QwtPlotItem *plotItem ) const
+{

trunk/BNC/qwt/qwt_plot_legenditem.h

-              r8127
+              r9383
   to have more space for the plot canvas.
   In opposite to QwtLegend the legend item is not interactive.
+  In opposite to QwtLegend the legend item is not interactive.
   To identify mouse clicks on a legend item an event filter
   needs to be installed catching mouse events ob the plot canvas.
   The geometries of the legend items are available using
   legendGeometries().
   The legend item is aligned to plot canvas according to
+  The legend item is aligned to plot canvas according to
   its alignment() flags. It might have a background for the
   complete legend ( usually semi transparent ) or for
   each legend item.
   \note An external QwtLegend with a transparent background
         on top the plot canvas might be another option
+  \note An external QwtLegend with a transparent background
+        on top the plot canvas might be another option
         with a similar effect.
 */
 …
       \brief Background mode
       Depending on the mode the complete legend or each item
+      Depending on the mode the complete legend or each item
       might have an background.
 …
     void setItemSpacing( int );
     int itemSpacing() const;
     void setFont( const QFont& );
     QFont font() const;
     void setBorderDistance( int numPixels );
+    void setBorderDistance( int );
     int borderDistance() const;
 …
     QPen textPen() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
     void clearLegend();
 …
     virtual QSize minimumSize( const QwtLegendData & ) const;
     virtual int heightForWidth( const QwtLegendData &, int w ) const;
+    virtual int heightForWidth( const QwtLegendData &, int width ) const;
     QList< const QwtPlotItem * > plotItems() const;
 …
 protected:
     virtual void drawLegendData( QPainter *painter,
+    virtual void drawLegendData( QPainter *painter,
         const QwtPlotItem *, const QwtLegendData &, const QRectF & ) const;

trunk/BNC/qwt/qwt_plot_marker.cpp

-              r8127
+              r9383
     const QRectF &canvasRect ) const
+{
     const QPointF pos( xMap.transform( d_data->xValue ),
+    const QPointF pos( xMap.transform( d_data->xValue ),
         yMap.transform( d_data->yValue ) );
 …
         const QSizeF sz = d_data->symbol->size();
         const QRectF clipRect = canvasRect.adjusted(
+        const QRectF clipRect = canvasRect.adjusted(
             -sz.width(), -sz.height(), sz.width(), sz.height() );
 …
 /*!
   \brief Set the line style
   \param style Line style.
+  \param style Line style.
   \sa lineStyle()
 */
 …
   In all other styles the alignment is relative to the marker's position.
   \param align Alignment.
+  \param align Alignment.
   \sa labelAlignment(), labelOrientation()
 */
 …
+}
 /*!
+/*!
   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 ) );
+}
 …
 QRectF QwtPlotMarker::boundingRect() const
+{
+    return QRectF( d_data->xValue, d_data->yValue, 0.0, 0.0 );
+    // width/height of -1 does not affect the autoscale calculation
+    switch (d_data->style)
+    {
+        case QwtPlotMarker::HLine:
+            return QRectF( d_data->xValue, d_data->yValue, -1.0, 0.0 );
+        case QwtPlotMarker::VLine:
+            return QRectF( d_data->xValue, d_data->yValue, 0.0, -1.0 );
+        default :
+            return QRectF( d_data->xValue, d_data->yValue, 0.0, 0.0 );
+    }
+}
 …
    \return Icon representing the marker on the legend
    \param index Index of the legend entry
+   \param index Index of the legend entry
                 ( usually there is only one )
    \param size Icon size
 …
             const double y = 0.5 * size.height();
             QwtPainter::drawLine( &painter,
+            QwtPainter::drawLine( &painter,
 .0, y, size.width(), y );
+        }
 …
             const double x = 0.5 * size.width();
             QwtPainter::drawLine( &painter,
+            QwtPainter::drawLine( &painter,
                 x, 0.0, x, size.height() );
+        }

trunk/BNC/qwt/qwt_plot_marker.h

-              r8127
+              r9383
   line style. The alignment refers to the center point of
   the marker, which means, for example, that the label would be printed
   left above the center point if the alignment was set to
+  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
+        according to the geometry of canvas
         ( unrelated to plot coordinates )
 */
 …
     };
     explicit QwtPlotMarker( const QString &title = QString::null );
+    explicit QwtPlotMarker( const QString &title = QString() );
     explicit QwtPlotMarker( const QwtText &title );
 …
     void setValue( const QPointF & );
     void setLineStyle( LineStyle st );
+    void setLineStyle( LineStyle );
     LineStyle lineStyle() const;
     void setLinePen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setLinePen( const QPen &p );
+    void setLinePen( const QPen & );
     const QPen &linePen() const;
 …
     int spacing() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF & ) const;
 …
 protected:
     virtual void drawLines( QPainter *,
+    virtual void drawLines( QPainter *,
         const QRectF &, const QPointF & ) const;
     virtual void drawLabel( QPainter *,
+    virtual void drawLabel( QPainter *,
         const QRectF &, const QPointF & ) const;

trunk/BNC/qwt/qwt_plot_multi_barchart.cpp

-              r8127
+              r9383
 /*!
   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 QwtPlotMultiBarChart::setSamples(
+*/
+void QwtPlotMultiBarChart::setSamples(
     QwtSeriesData<QwtSetSample> *data )
+{
+{
     setData( data );
+}
+}
 /*!
 …
+}
 /*!
+/*!
   \return Bar titles
   \sa setBarTitles(), legendData()
 …
         return;
     QMap<int, QwtColumnSymbol *>::iterator it =
+    QMap<int, QwtColumnSymbol *>::iterator it =
         d_data->symbolMap.find(valueIndex);
     if ( it == d_data->symbolMap.end() )
 …
+{
     QMap<int, QwtColumnSymbol *>::const_iterator it =
         d_data->symbolMap.find( valueIndex );
     return ( it == d_data->symbolMap.end() ) ? NULL : it.value();
+        d_data->symbolMap.constFind( valueIndex );
+    return ( it == d_data->symbolMap.constEnd() ) ? NULL : it.value();
+}
 …
   \sa setSymbol(), specialSymbol(), drawBar()
 */
 QwtColumnSymbol *QwtPlotMultiBarChart::symbol( int valueIndex )
+{
     QMap<int, QwtColumnSymbol *>::iterator it =
         d_data->symbolMap.find( valueIndex );
     return ( it == d_data->symbolMap.end() ) ? NULL : it.value();
+QwtColumnSymbol *QwtPlotMultiBarChart::symbol( int valueIndex )
+{
+    QMap<int, QwtColumnSymbol *>::const_iterator it =
+        d_data->symbolMap.constFind( valueIndex );
+    return ( it == d_data->symbolMap.constEnd() ) ? NULL : it.value();
+}
 …
 void QwtPlotMultiBarChart::resetSymbolMap()
+{
+    for ( QMap<int, QwtColumnSymbol *>::iterator it
+        = d_data->symbolMap.begin(); it != d_data->symbolMap.end(); ++it )
+    {
+        delete it.value();
+    }
+    qDeleteAll( d_data->symbolMap );
     d_data->symbolMap.clear();
+}
 …
   When no symbol ( NULL ) is returned, the value will be displayed
   with the standard symbol that is used for all symbols with the same
+  with the standard symbol that is used for all symbols with the same
   valueIndex.
 …
   \return NULL, meaning that the value is not special
  */
 QwtColumnSymbol *QwtPlotMultiBarChart::specialSymbol(
+QwtColumnSymbol *QwtPlotMultiBarChart::specialSymbol(
     int sampleIndex, int valueIndex ) const
+{
 …
   \param index Index of the sample to be painted
   \param sampleWidth Boundng width for all bars of the smaple
   \param sample Sample
+  \param sample Sample
   \sa drawSeries(), sampleWidth()
 …
   \param index Index of the sample to be painted
   \param sampleWidth Width of the bars
   \param sample Sample
+  \param sample Sample
   \sa drawSeries(), sampleWidth()
 …
 void QwtPlotMultiBarChart::drawStackedBars( QPainter *painter,
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     const QRectF &canvasRect, int index,
+    const QRectF &canvasRect, int index,
     double sampleWidth, const QwtSetSample& sample ) const
+{
 …
         double sum = baseline();
-        const int numBars = sample.set.size();
         for ( int i = 0; i < numBars; i++ )
+        {
 …
+    {
         // we build a temporary default symbol
         QwtColumnSymbol sym( QwtColumnSymbol::Box );
         sym.setLineWidth( 1 );
         sym.setFrameStyle( QwtColumnSymbol::Plain );
         sym.draw( painter, rect );
+        QwtColumnSymbol columnSymbol( QwtColumnSymbol::Box );
+        columnSymbol.setLineWidth( 1 );
+        columnSymbol.setFrameStyle( QwtColumnSymbol::Plain );
+        columnSymbol.draw( painter, rect );
+    }
 …
+        {
             QVariant iconValue;
             qVariantSetValue( iconValue,
+            qVariantSetValue( iconValue,
                 legendIcon( i, legendIconSize() ) );
 …
   \param index Index of the bar
   \param size Icon size
   \return An icon showing a bar
   \sa drawBar(), legendData()

trunk/BNC/qwt/qwt_plot_multi_barchart.h

-              r8127
+              r9383
 /*!
   \brief QwtPlotMultiBarChart displays a series of a samples that consist
          each of a set of values.
+         each of a set of values.
   Each value is displayed as a bar, the bars of each set can be organized
+  Each value is displayed as a bar, the bars of each set can be organized
   side by side or accumulated.
 …
   by overloading specialSymbol() or overloading drawBar().
   Depending on its orientation() the bars are displayed horizontally
   or vertically. The bars cover the interval between the baseline()
+  Depending on its orientation() the bars are displayed horizontally
+  or vertically. The bars cover the interval between the baseline()
   and the value.
   In opposite to most other plot items, QwtPlotMultiBarChart returns more
   than one entry for the legend - one for each symbol.
   \sa QwtPlotBarChart, QwtPlotHistogram
       QwtPlotSeriesItem::orientation(), QwtPlotAbstractBarChart::baseline()
  */
 class QWT_EXPORT QwtPlotMultiBarChart:
+class QWT_EXPORT QwtPlotMultiBarChart:
     public QwtPlotAbstractBarChart, public QwtSeriesStore<QwtSetSample>
+{
 …
     };
     explicit QwtPlotMultiBarChart( const QString &title = QString::null );
+    explicit QwtPlotMultiBarChart( const QString &title = QString() );
     explicit QwtPlotMultiBarChart( const QwtText &title );
 …
     ChartStyle style() const;
     void setSymbol( int barIndex, QwtColumnSymbol *symbol );
     const QwtColumnSymbol *symbol( int barIndex ) const;
+    void setSymbol( int valueIndex, QwtColumnSymbol * );
+    const QwtColumnSymbol *symbol( int valueIndex ) const;
     void resetSymbolMap();
 …
 protected:
     QwtColumnSymbol *symbol( int barIndex );
+    QwtColumnSymbol *symbol( int valueIndex );
     virtual QwtColumnSymbol *specialSymbol(
+    virtual QwtColumnSymbol *specialSymbol(
         int sampleIndex, int valueIndex ) const;
 …
     virtual void drawBar( QPainter *, int sampleIndex,
         int barIndex, const QwtColumnRect & ) const;
+        int valueIndex, const QwtColumnRect & ) const;
     void drawStackedBars( QPainter *painter,

trunk/BNC/qwt/qwt_plot_panner.cpp

-              r8127
+              r9383
 #include <qstyle.h>
 #include <qstyleoption.h>
+#include <qpainterpath.h>
+#if QT_VERSION >= 0x050000
+#if QT_VERSION < 0x050100
+#define QWT_USE_WINDOW_HANDLE 1
+#endif
+#endif
+#ifdef QWT_USE_WINDOW_HANDLE
+#include <qwindow.h>
+#endif
 static QBitmap qwtBorderMask( const QWidget *canvas, const QSize &size )
+{
+#if QT_VERSION >= 0x050000
+    qreal pixelRatio = 1.0;
+#ifdef QWT_USE_WINDOW_HANDLE
+    pixelRatio = canvas->windowHandle()->devicePixelRatio();
+#else
+    pixelRatio = canvas->devicePixelRatio();
+#endif
+#endif
     const QRect r( 0, 0, size.width(), size.height() );
     QPainterPath borderPath;
     ( void )QMetaObject::invokeMethod(
+    ( void )QMetaObject::invokeMethod(
         const_cast< QWidget *>( canvas ), "borderPath", Qt::DirectConnection,
         Q_RETURN_ARG( QPainterPath, borderPath ), Q_ARG( QRect, r ) );
 …
             return QBitmap();
+#if QT_VERSION >= 0x050000
+        QBitmap mask( size * pixelRatio );
+        mask.setDevicePixelRatio( pixelRatio );
+#else
         QBitmap mask( size );
+#endif
         mask.fill( Qt::color0 );
 …
+    }
+#if QT_VERSION >= 0x050000
+    QImage image( size * pixelRatio, QImage::Format_ARGB32_Premultiplied );
+    image.setDevicePixelRatio( pixelRatio );
+#else
     QImage image( size, QImage::Format_ARGB32_Premultiplied );
+#endif
     image.fill( Qt::color0 );
 …
         const QVariant frameWidth = canvas->property( "frameWidth" );
         if ( borderRadius.type() == QVariant::Double
+        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 )
+            {
 …
     d_data = new PrivateData();
     connect( this, SIGNAL( panned( int, int ) ),
         SLOT( moveCanvas( int, int ) ) );
+    connect( this, SIGNAL(panned(int,int)),
+        SLOT(moveCanvas(int,int)) );
+}
 …
  */
 QPixmap QwtPlotPanner::grab() const
+{
+{
     const QWidget *cv = canvas();
     if ( cv && cv->inherits( "QGLWidget" ) )
 …
     return QwtPanner::grab();
+}
+}

trunk/BNC/qwt/qwt_plot_picker.cpp

r8127	r9383
193	193	QwtText QwtPlotPicker::trackerText( const QPoint &pos ) const
194	194	{
	195	if ( plot() == NULL )
	196	return QwtText();
	197
195	198	return trackerTextF( invTransform( pos ) );
196	199	}

trunk/BNC/qwt/qwt_plot_rasteritem.cpp

-              r8127
+              r9383
     py0 += strippedRect.top() - paintRect.top();
+    QImage expanded(sz, image.format());
+    QImage expanded( sz, image.format() );
+    if ( image.format() == QImage::Format_Indexed8 )
+        expanded.setColorTable( image.colorTable() );
     switch( image.depth() )
 …
+                }
                 const quint32 *line1 =
+                const quint32 *line1 =
                     reinterpret_cast<const quint32 *>( image.scanLine( y1 ) );
 …
                     for ( int y2 = yy1; y2 < yy2; y2++ )
+                    {
                         quint32 *line2 = reinterpret_cast<quint32 *>(
+                        quint32 *line2 = reinterpret_cast<quint32 *>(
                             expanded.scanLine( y2 ) );
                         for ( int x2 = xx1; x2 < xx2; x2++ )
+                        for ( int x2 = xx1; x2 < xx2; x2++ )
                             line2[x2] = rgb;
+                    }
+                }
+            }
+                    }
+                }
+            }
             break;
+        }
 …
+                {
                     yy1 = 0;
+                }
+                }
                 else
+                {
                     yy1 = qRound( y1 * ph - py0 );
                     if ( yy1 < 0 )
                         yy1 = 0;
+                }
+                        yy1 = 0;
+                }
                 int yy2;
                 if ( y1 == h - 1 )
+                {
                     yy2 = sz.height();
+                }
+                }
                 else
+                {
 …
                         yy2 = sz.height();
+                }
                 const uchar *line1 = image.scanLine( y1 );
 …
                         uchar *line2 = expanded.scanLine( y2 );
                         memset( line2 + xx1, line1[x1], xx2 - xx1 );
+                    }
+                }
+                    }
+                }
+            }
             break;
 …
             expanded = image;
+    }
     return expanded;
+}
+}
 static QRectF qwtExpandToPixels(const QRectF &rect, const QRectF &pixelRect)
 …
+}
 static void qwtToRgba( const QImage* from, QImage* to,
+static void qwtToRgba( const QImage* from, QImage* to,
     const QRect& tile, int alpha )
+{
 …
    The geometry of a pixel is used to calculated the resolution and
    alignment of the rendered image.
    Width and height of the hint need to be the horizontal
    and vertical distances between 2 neighbored points.
    The center of the hint has to be the position of any point
+   alignment of the rendered image.
+   Width and height of the hint need to be the horizontal
+   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 ).
    Limiting the resolution of the image might significantly improve
    the performance and heavily reduce the amount of memory when rendering
    a QImage from the raster data.
+   a QImage from the raster data.
    The default implementation returns an empty rectangle (QRectF()),
 …
+        {
             /*
               If only one dimension is of the data pixel is higher
+              If only one dimension is of the data pixel is higher
               we expand the pixel rect to the resolution of the target device.
              */
 …
         // data pixels we render in resolution of the paint device.
         image = compose(xxMap, yyMap,
+        image = compose(xxMap, yyMap,
             area, paintRect, paintRect.size().toSize(), doCache);
         if ( image.isNull() )
 …
         // excluded in the intervals
         imageRect = qwtStripRect(paintRect, area,
+        imageRect = qwtStripRect(paintRect, area,
             xxMap, yyMap, xInterval, yInterval);
         if ( imageRect != paintRect )
+        {
             const QRect r(
+            const QRect r(
                 qRound( imageRect.x() - paintRect.x()),
                 qRound( imageRect.y() - paintRect.y() ),
                 qRound( imageRect.width() ),
                 qRound( imageRect.height() ) );
             image = image.copy(r);
+        }
+        }
+    }
     else
 …
         imageSize.setHeight( qRound( imageArea.height() / pixelRect.height() ) );
         image = compose(xxMap, yyMap,
+        image = compose(xxMap, yyMap,
             imageArea, paintRect, imageSize, doCache );
 …
             return;
         imageRect = qwtStripRect(paintRect, area,
+        imageRect = qwtStripRect(paintRect, area,
             xxMap, yyMap, xInterval, yInterval);
 …
             testPaintAttribute( PaintInDeviceResolution ) )
+        {
             // Because of rounding errors the pixels
             // need to be expanded manually to rectangles of
+            // Because of rounding errors the pixels
+            // need to be expanded manually to rectangles of
             // different sizes
             image = qwtExpandImage(image, xxMap, yyMap,
+            image = qwtExpandImage(image, xxMap, yyMap,
                 imageArea, area, paintRect, xInterval, yInterval );
+        }
 …
     painter->save();
     painter->setWorldTransform( QTransform() );
     QwtPainter::drawImage( painter, imageRect, image );
 …
    This method is intended to be reimplemented by derived classes.
    The default implementation returns an invalid interval.
    \param axis X, Y, or Z axis
 */
 …
+}
 QImage QwtPlotRasterItem::compose(
+QImage QwtPlotRasterItem::compose(
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     const QRectF &imageArea, const QRectF &paintRect,
+    const QRectF &imageArea, const QRectF &paintRect,
     const QSize &imageSize, bool doCache) const
+{
 …
             dx = imageArea.width() / imageSize.width();
         const QwtScaleMap xxMap =
+        const QwtScaleMap xxMap =
             imageMap(Qt::Horizontal, xMap, imageArea, imageSize, dx);
         double dy = 0.0;
         if ( paintRect.toRect().height() > imageSize.height() )
             dy = imageArea.height() / imageSize.height();
         const QwtScaleMap yyMap =
+        const QwtScaleMap yyMap =
             imageMap(Qt::Vertical, yMap, imageArea, imageSize, dy);
 …
+    }
     if ( pixelSize > 0.0 )
+    if ( pixelSize > 0.0 || p2 == 1.0 )
+    {
         double off = 0.5 * pixelSize;

trunk/BNC/qwt/qwt_plot_rasteritem.h

-              r8127
+              r9383
         /*!
           renderImage() is called, whenever the image cache is not valid,
           or the scales, or the size of the canvas has changed.
+          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.
+          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.
          */
 …
           When the image is rendered according to the data pixels
           ( QwtRasterData::pixelHint() ) it can be expanded to paint
           device resolution before it is passed to QPainter.
           The expansion algorithm rounds the pixel borders in the same
+          device resolution before it is passed to QPainter.
+          The expansion algorithm rounds the pixel borders in the same
           way as the axis ticks, what is usually better than the
           scaling algorithm implemented in Qt.
           Disabling this flag might make sense, to reduce the size of a
+          Disabling this flag might make sense, to reduce the size of a
           document/file. If this is possible for a document format
           depends on the implementation of the specific QPaintEngine.
 …
     typedef QFlags<PaintAttribute> PaintAttributes;
     explicit QwtPlotRasterItem( const QString& title = QString::null );
+    explicit QwtPlotRasterItem( const QString& title = QString() );
     explicit QwtPlotRasterItem( const QwtText& title );
     virtual ~QwtPlotRasterItem();
 …
     void invalidateCache();
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
     virtual QRectF pixelHint( const QRectF & ) const;
 …
 protected:
     /*!
       \brief Render an image
+      \brief Render an image
       An implementation of render() might iterate over all
       pixels of imageRect. Each pixel has to be translated into
+      pixels of imageRect. Each pixel has to be translated into
       the corresponding position in scale coordinates using the maps.
       This position can be used to look up a value in a implementation
 …
       \param area Requested area for the image in scale coordinates
       \param imageSize Requested size of the image
       \return Rendered image
      */

trunk/BNC/qwt/qwt_plot_renderer.cpp

-              r8127
+              r9383
 #include "qwt_scale_widget.h"
 #include "qwt_scale_engine.h"
+#include "qwt_scale_map.h"
 #include "qwt_text.h"
 #include "qwt_text_label.h"
 #include "qwt_math.h"
 #include <qpainter.h>
 #include <qpaintengine.h>
+#include <qpainterpath.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 <qvariant.h>
 #ifndef QWT_NO_SVG
 #ifdef QT_SVG_LIB
+#if QT_VERSION >= 0x040500
+#define QWT_FORMAT_SVG 1
+#endif
+#endif
+#endif
+#ifndef QT_NO_PRINTER
+#define QWT_FORMAT_PDF 1
+#endif
+#ifndef QT_NO_PDF
+// QPdfWriter::setResolution() has been introduced with
+// Qt 5.3. Guess it is o.k. to stay with QPrinter for older
+// versions.
+#if QT_VERSION >= 0x050300
+#ifndef QWT_FORMAT_PDF
+#define QWT_FORMAT_PDF 1
+#endif
+#define QWT_PDF_WRITER 1
+#endif
+#endif
+#ifndef QT_NO_PRINTER
+// postscript support has been dropped in Qt5
+#if QT_VERSION < 0x050000
+#define QWT_FORMAT_POSTSCRIPT 1
+#endif
+#endif
+#if QWT_FORMAT_SVG
 #include <qsvggenerator.h>
 #endif
+#endif
+static QPainterPath qwtCanvasClip(
+#if QWT_PDF_WRITER
+#include <qpdfwriter.h>
+#endif
+static QPainterPath qwtCanvasClip(
     const QWidget* canvas, const QRectF &canvasRect )
+{
 …
+}
+static inline QFont qwtResolvedFont( const QWidget *widget )
+{
+    QFont font = widget->font();
+    font.resolve( QFont::AllPropertiesResolved );
+    return font;
+}
 class QwtPlotRenderer::PrivateData
+{
 …
 };
 /*!
+/*!
    Constructor
    \param parent Parent object
 …
     const QString fmt = format.toLower();
+    if ( fmt == "pdf" )
+    {
+#ifndef QT_NO_PRINTER
+    if ( fmt == QLatin1String( "pdf" ) )
+    {
+#if QWT_FORMAT_PDF
+#if QWT_PDF_WRITER
+        QPdfWriter pdfWriter( fileName );
+        pdfWriter.setPageSizeMM( sizeMM );
+        pdfWriter.setTitle( title );
+        pdfWriter.setPageMargins( QMarginsF() );
+        pdfWriter.setResolution( resolution );
+        QPainter painter( &pdfWriter );
+        render( plot, &painter, documentRect );
+#else
         QPrinter printer;
         printer.setOutputFormat( QPrinter::PdfFormat );
 …
         render( plot, &painter, documentRect );
 #endif
+    }
     else if ( fmt == "ps" )
+    {
+#if QT_VERSION < 0x050000
 #ifndef QT_NO_PRINTER
+#endif
+    }
+    else if ( fmt == QLatin1String( "ps" ) )
+    {
+#if QWT_FORMAT_POSTSCRIPT
         QPrinter printer;
         printer.setOutputFormat( QPrinter::PostScriptFormat );
 …
         render( plot, &painter, documentRect );
 #endif
+#endif
+    }
+    else if ( fmt == "svg" )
+    {
+#ifndef QWT_NO_SVG
+#ifdef QT_SVG_LIB
+#if QT_VERSION >= 0x040500
+    }
+    else if ( fmt == QLatin1String( "svg" ) )
+    {
+#if QWT_FORMAT_SVG
         QSvgGenerator generator;
         generator.setTitle( title );
 …
         render( plot, &painter, documentRect );
 #endif
-#endif
-#endif
+    }
     else
 …
 #endif
+#ifndef QWT_NO_SVG
+#ifdef QT_SVG_LIB
+#if QT_VERSION >= 0x040500
+#if QWT_FORMAT_SVG
 /*!
 …
     render( plot, &p, rect );
+}
+#endif
+#endif
 #endif
 …
             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
 …
                         break;
+                }
-                layoutRect.adjust( left, top, right, bottom );
+            }
+        }
 …
+    {
         layoutOptions |= QwtPlotLayout::IgnoreFrames;
+    }
+    }
     if ( d_data->discardFlags & DiscardLegend )
 …
   \param plot Plot widget
   \param painter Painter
   \param rect Bounding rectangle
+  \param titleRect Bounding rectangle for the title
 */
 void QwtPlotRenderer::renderTitle( const QwtPlot *plot,
     QPainter *painter, const QRectF &rect ) const
+{
     painter->setFont( plot->titleLabel()->font() );
+    QPainter *painter, const QRectF &titleRect ) const
+{
+    painter->setFont( qwtResolvedFont( plot->titleLabel() ) );
     const QColor color = plot->titleLabel()->palette().color(
 …
     painter->setPen( color );
     plot->titleLabel()->text().draw( painter, rect );
+    plot->titleLabel()->text().draw( painter, titleRect );
+}
 …
   \param plot Plot widget
   \param painter Painter
   \param rect Bounding rectangle
+  \param footerRect Bounding rectangle for the footer
 */
 void QwtPlotRenderer::renderFooter( const QwtPlot *plot,
     QPainter *painter, const QRectF &rect ) const
+{
     painter->setFont( plot->footerLabel()->font() );
+    QPainter *painter, const QRectF &footerRect ) const
+{
+    painter->setFont( qwtResolvedFont( plot->footerLabel() ) );
     const QColor color = plot->footerLabel()->palette().color(
 …
     painter->setPen( color );
+    plot->footerLabel()->text().draw( painter, rect );
+}
+    plot->footerLabel()->text().draw( painter, footerRect );
+}
 /*!
 …
   \param plot Plot widget
   \param painter Painter
   \param rect Bounding rectangle
+  \param legendRect Bounding rectangle for the legend
 */
 void QwtPlotRenderer::renderLegend( const QwtPlot *plot,
     QPainter *painter, const QRectF &rect ) const
+    QPainter *painter, const QRectF &legendRect ) const
+{
     if ( plot->legend() )
+    {
         bool fillBackground = !( d_data->discardFlags & DiscardBackground );
         plot->legend()->renderLegend( painter, rect, fillBackground );
+        plot->legend()->renderLegend( painter, legendRect, fillBackground );
+    }
+}
 …
   \param endDist End border distance
   \param baseDist Base distance
   \param rect Bounding rectangle
+  \param scaleRect Bounding rectangle for the scale
 */
 void QwtPlotRenderer::renderScale( const QwtPlot *plot,
     QPainter *painter,
     int axisId, int startDist, int endDist, int baseDist,
     const QRectF &rect ) const
+    const QRectF &scaleRect ) const
+{
     if ( !plot->axisEnabled( axisId ) )
 …
         && scaleWidget->colorBarWidth() > 0 )
+    {
         scaleWidget->drawColorBar( painter, scaleWidget->colorBarRect( rect ) );
+        scaleWidget->drawColorBar( painter, scaleWidget->colorBarRect( scaleRect ) );
         baseDist += scaleWidget->colorBarWidth() + scaleWidget->spacing();
+    }
 …
         case QwtPlot::yLeft:
+        {
             x = rect.right() - 1.0 - baseDist;
             y = rect.y() + startDist;
             w = rect.height() - startDist - endDist;
+            x = scaleRect.right() - 1.0 - baseDist;
+            y = scaleRect.y() + startDist;
+            w = scaleRect.height() - startDist - endDist;
             align = QwtScaleDraw::LeftScale;
             break;
 …
         case QwtPlot::yRight:
+        {
             x = rect.left() + baseDist;
             y = rect.y() + startDist;
             w = rect.height() - startDist - endDist;
+            x = scaleRect.left() + baseDist;
+            y = scaleRect.y() + startDist;
+            w = scaleRect.height() - startDist - endDist;
             align = QwtScaleDraw::RightScale;
             break;
 …
         case QwtPlot::xTop:
+        {
             x = rect.left() + startDist;
             y = rect.bottom() - 1.0 - baseDist;
             w = rect.width() - startDist - endDist;
+            x = scaleRect.left() + startDist;
+            y = scaleRect.bottom() - 1.0 - baseDist;
+            w = scaleRect.width() - startDist - endDist;
             align = QwtScaleDraw::TopScale;
             break;
 …
         case QwtPlot::xBottom:
+        {
             x = rect.left() + startDist;
             y = rect.top() + baseDist;
             w = rect.width() - startDist - endDist;
+            x = scaleRect.left() + startDist;
+            y = scaleRect.top() + baseDist;
+            w = scaleRect.width() - startDist - endDist;
             align = QwtScaleDraw::BottomScale;
             break;
 …
+    }
     scaleWidget->drawTitle( painter, align, rect );
     painter->setFont( scaleWidget->font() );
+    scaleWidget->drawTitle( painter, align, scaleRect );
+    painter->setFont( qwtResolvedFont( scaleWidget ) );
     QwtScaleDraw *sd = const_cast<QwtScaleDraw *>( scaleWidget->scaleDraw() );
 …
   \param plot Plot widget
   \param painter Painter
   \param map Maps mapping between plot and paint device coordinates
+  \param maps Maps mapping between plot and paint device coordinates
   \param canvasRect Canvas rectangle
 */
 void QwtPlotRenderer::renderCanvas( const QwtPlot *plot,
     QPainter *painter, const QRectF &canvasRect,
     const QwtScaleMap *map ) const
+    QPainter *painter, const QRectF &canvasRect,
+    const QwtScaleMap *maps ) const
+{
     const QWidget *canvas = plot->canvas();
 …
         painter->setClipRect( canvasRect );
         plot->drawItems( painter, canvasRect, map );
+        plot->drawItems( painter, canvasRect, maps );
         painter->restore();
 …
             painter->setClipPath( clipPath );
         plot->drawItems( painter, canvasRect, map );
+        plot->drawItems( painter, canvasRect, maps );
         painter->restore();
 …
+        }
         QRectF innerRect = canvasRect.adjusted(
+        QRectF innerRect = canvasRect.adjusted(
             frameWidth, frameWidth, -frameWidth, -frameWidth );
 …
+        }
         plot->drawItems( painter, innerRect, map );
+        plot->drawItems( painter, innerRect, maps );
         painter->restore();
 …
                 canvas->property( "frameShape" ).toInt();
-            const int frameWidth = canvas->property( "frameWidth" ).toInt();
             const QVariant borderRadius = canvas->property( "borderRadius" );
             if ( borderRadius.type() == QVariant::Double
+            if ( borderRadius.type() == QVariant::Double
                 && borderRadius.toDouble() > 0.0 )
+            {
                 const double r = borderRadius.toDouble();
+                const double radius = borderRadius.toDouble();
                 QwtPainter::drawRoundedFrame( painter, canvasRect,
                     r, r, canvas->palette(), frameWidth, frameStyle );
+                    radius, radius, canvas->palette(), frameWidth, frameStyle );
+            }
             else
 …
     double margins[QwtPlot::axisCnt];
     plot->getCanvasMarginsHint( maps, canvasRect,
         margins[QwtPlot::yLeft], margins[QwtPlot::xTop],
+        margins[QwtPlot::yLeft], margins[QwtPlot::xTop],
         margins[QwtPlot::yRight], margins[QwtPlot::xBottom] );
 …
 bool QwtPlotRenderer::exportTo( QwtPlot *plot, const QString &documentName,
      const QSizeF &sizeMM, int resolution )
+{
+{
     if ( plot == NULL )
         return false;
     QString fileName = documentName;
     // What about translation
+    // What about translation
 #ifndef QT_NO_FILEDIALOG
     const QList<QByteArray> imageFormats =
         QImageWriter::supportedImageFormats();
     QStringList filter;
 #ifndef QT_NO_PRINTER
+#if QWT_FORMAT_PDF
     filter += QString( "PDF " ) + tr( "Documents" ) + " (*.pdf)";
 #endif
 #ifndef QWT_NO_SVG
+#if QWT_FORMAT_SVG
     filter += QString( "SVG " ) + tr( "Documents" ) + " (*.svg)";
 #endif
 #ifndef QT_NO_PRINTER
+#if QWT_FORMAT_POSTSCRIPT
     filter += QString( "Postscript " ) + tr( "Documents" ) + " (*.ps)";
 #endif
     if ( imageFormats.size() > 0 )
+    {
 …
             if ( i > 0 )
                 imageFilter += " ";
             imageFilter += "*.";
+            imageFilter += "*.";
             imageFilter += imageFormats[i];
+        }
+        }
         imageFilter += ")";
         filter += imageFilter;
+    }
+    }
     fileName = QFileDialog::getSaveFileName(
         NULL, tr( "Export File Name" ), fileName,
         filter.join( ";;" ), NULL, QFileDialog::DontConfirmOverwrite );
 #endif
+#endif
     if ( fileName.isEmpty() )
         return false;
 …
     return true;
+}
+}

trunk/BNC/qwt/qwt_plot_renderer.h

-              r8127
+              r9383
         DiscardFooter           = 0x10,
         /*!
+        /*!
             Don't render the frame of the canvas
 …
 #endif
     void renderTo( QwtPlot *, QPaintDevice &p ) const;
+    void renderTo( QwtPlot *, QPaintDevice & ) const;
     virtual void render( QwtPlot *,
         QPainter *, const QRectF &rect ) const;
+        QPainter *, const QRectF &plotRect ) const;
     virtual void renderTitle( const QwtPlot *,
         QPainter *, const QRectF & ) const;
+        QPainter *, const QRectF &titleRect ) const;
     virtual void renderFooter( const QwtPlot *,
         QPainter *, const QRectF & ) const;
+        QPainter *, const QRectF &footerRect ) const;
     virtual void renderScale( const QwtPlot *, QPainter *,
         int axisId, int startDist, int endDist,
         int baseDist, const QRectF & ) const;
+        int baseDist, const QRectF &scaleRect ) const;
     virtual void renderCanvas( const QwtPlot *,
 …
         const QwtScaleMap* maps ) const;
     virtual void renderLegend(
         const QwtPlot *, QPainter *, const QRectF & ) const;
+    virtual void renderLegend(
+        const QwtPlot *, QPainter *, const QRectF &legendRect ) const;
     bool exportTo( QwtPlot *, const QString &documentName,

trunk/BNC/qwt/qwt_plot_rescaler.h

r8127	r9383
117	117
118	118	virtual void rescale( const QSize &oldSize, const QSize &newSize ) const;
119		virtual QwtInterval expandScale(
	119	virtual QwtInterval expandScale(
120	120	int axis, const QSize &oldSize, const QSize &newSize ) const;
121	121

trunk/BNC/qwt/qwt_plot_scaleitem.cpp

-              r8127
+              r9383
     if ( d_data->scaleDivFromAxis )
+    {
         const QwtInterval interval =
+        const QwtInterval interval =
             d_data->scaleInterval( canvasRect, xMap, yMap );
 …
     if ( d_data->scaleDivFromAxis && scaleDraw )
+    {
         const QwtScaleDiv &scaleDiv =
+        const QwtScaleDiv &scaleDiv =
             scaleDraw->orientation() == Qt::Horizontal ? xScaleDiv : yScaleDiv;
 …
             const QRectF canvasRect = plt->canvas()->contentsRect();
             const QwtInterval interval = d_data->scaleInterval(
+            const QwtInterval interval = d_data->scaleInterval(
                 canvasRect, plt->canvasMap( xAxis() ), plt->canvasMap( yAxis() ) );

trunk/BNC/qwt/qwt_plot_scaleitem.h

-              r4271
+              r9383
   \par Example
+  The following example shows how to replace the left axis, by a scale item
+  at the x position 0.0.
+  \verbatim
+QwtPlotScaleItem *scaleItem =
+    new QwtPlotScaleItem(QwtScaleDraw::RightScale, 0.0);
+scaleItem->setFont(plot->axisWidget(QwtPlot::yLeft)->font());
+scaleItem->attach(plot);
+    The following example shows how to replace the left axis, by a scale item
+    at the x position 0.0.
+    \code
+      QwtPlotScaleItem *scaleItem = new QwtPlotScaleItem( QwtScaleDraw::RightScale, 0.0 );
+      scaleItem->setFont( plot->axisWidget( QwtPlot::yLeft )->font() );
+      scaleItem->attach(plot);
+plot->enableAxis(QwtPlot::yLeft, false);
+\endverbatim
+      plot->enableAxis( QwtPlot::yLeft, false );
+    \endcode
+  \endpar
 */
 …
     double position() const;
     void setBorderDistance( int numPixels );
+    void setBorderDistance( int );
     int borderDistance() const;
     void setAlignment( QwtScaleDraw::Alignment );
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
     virtual void updateScaleDiv( const QwtScaleDiv &, const QwtScaleDiv & );

trunk/BNC/qwt/qwt_plot_seriesitem.cpp

-              r8127
+              r9383
+{
     d_data = new PrivateData();
+    setItemInterest( QwtPlotItem::ScaleInterest, true );
+}
 …
 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()

trunk/BNC/qwt/qwt_plot_seriesitem.h

-              r8127
+              r9383
+{
 public:
     explicit QwtPlotSeriesItem( const QString &title = QString::null );
+    explicit QwtPlotSeriesItem( const QString &title = QString() );
     explicit QwtPlotSeriesItem( const QwtText &title );
 …
     Qt::Orientation orientation() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF & ) const;
 …
     virtual QRectF boundingRect() const;
     virtual void updateScaleDiv(
+    virtual void updateScaleDiv(
         const QwtScaleDiv &, const QwtScaleDiv & );

trunk/BNC/qwt/qwt_plot_shapeitem.cpp

-              r8127
+              r9383
   \sa setShape(), setPolygon(), shape()
  */
 void QwtPlotShapeItem::setRect( const QRectF &rect )
+void QwtPlotShapeItem::setRect( const QRectF &rect )
+{
     QPainterPath path;
 …
+}
 /*!
+/*!
   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 QwtPlotShapeItem::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+{
     setPen( QPen( color, width, style ) );
+}
 …
   \brief Set the tolerance for the weeding optimization
   After translating the shape into target device coordinate
+  After translating the shape into target device coordinate
   ( usually widget geometries ) the painter path can be simplified
   by a point weeding algorithm ( Douglas-Peucker ).
 …
         return;
     if ( d_data->pen.style() == Qt::NoPen
+    if ( d_data->pen.style() == Qt::NoPen
         && d_data->brush.style() == Qt::NoBrush )
+    {
 …
     const bool doAlign = QwtPainter::roundingAlignment( painter );
     QPainterPath path = qwtTransformPath( xMap, yMap,
+    QPainterPath path = qwtTransformPath( xMap, yMap,
         d_data->shape, doAlign );
 …
   \return A rectangle filled with the color of the brush ( or the pen )
   \param index Index of the legend entry
+  \param index Index of the legend entry
                 ( usually there is only one )
   \param size Icon size

trunk/BNC/qwt/qwt_plot_shapeitem.h

-              r8127
+              r9383
 /*!
   \brief A plot item, which displays any graphical shape,
+  \brief A plot item, which displays any graphical shape,
          that can be defined by a QPainterPath
 …
         LegendShape,
         //! Display a filled rectangle
+        //! Display a filled rectangle
         LegendColor
     };
     explicit QwtPlotShapeItem( const QString &title = QString::null );
+    explicit QwtPlotShapeItem( const QString &title = QString() );
     explicit QwtPlotShapeItem( const QwtText &title );
 …
     virtual QRectF boundingRect() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
     virtual QwtGraphic legendIcon( int index, const QSizeF & ) const;

trunk/BNC/qwt/qwt_plot_spectrocurve.cpp

-              r8127
+              r9383
 /*!
   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.
+           it when its not used anymore.
 */
 void QwtPlotSpectroCurve::setSamples(
 …
+{
     setData( data );
+}
+}
 /*!
 …
                 d_data->colorRange, sample.z() );
             painter->setPen( QPen( QColor::fromRgba( d_data->colorTable[index] ),
+            painter->setPen( QPen( QColor::fromRgba( d_data->colorTable[index] ),
                 d_data->penWidth ) );
+        }

trunk/BNC/qwt/qwt_plot_spectrocurve.h

-              r8127
+              r9383
            mapped to a color.
 */
 class QWT_EXPORT QwtPlotSpectroCurve:
     public QwtPlotSeriesItem, QwtSeriesStore<QwtPoint3D>
+class QWT_EXPORT QwtPlotSpectroCurve:
+    public QwtPlotSeriesItem, public QwtSeriesStore<QwtPoint3D>
+{
 public:
 …
     typedef QFlags<PaintAttribute> PaintAttributes;
     explicit QwtPlotSpectroCurve( const QString &title = QString::null );
+    explicit QwtPlotSpectroCurve( const QString &title = QString() );
     explicit QwtPlotSpectroCurve( const QwtText &title );
 …
         const QRectF &canvasRect, int from, int to ) const;
     void setPenWidth(double width);
+    void setPenWidth( double );
     double penWidth() const;

trunk/BNC/qwt/qwt_plot_spectrogram.cpp

-              r8127
+              r9383
+}
 /*!
+/*!
   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(
+ */
+void QwtPlotSpectrogram::setDefaultContourPen(
     const QColor &color, qreal width, Qt::PenStyle style )
+{
+{
     setDefaultContourPen( QPen( color, width, style ) );
+}
 …
    The geometry of a pixel is used to calculated the resolution and
    alignment of the rendered image.
+   alignment of the rendered image.
    The default implementation returns data()->pixelHint( rect );
 …
    \return Bounding rectangle of a pixel
    \sa QwtPlotRasterItem::pixelHint(), QwtRasterData::pixelHint(),
+   \sa QwtPlotRasterItem::pixelHint(), QwtRasterData::pixelHint(),
        render(), renderImage()
 */
 …
     const QRectF &area, const QSize &imageSize ) const
+{
     if ( imageSize.isEmpty() || d_data->data == NULL
+    if ( imageSize.isEmpty() || d_data->data == NULL
         || d_data->colorMap == NULL )
+    {
 …
 #if DEBUG_RENDER
         QElapsedTimer time;
         time.start();
+    QElapsedTimer time;
+    time.start();
 #endif
 …
    \sa drawContourLines(), QwtRasterData::contourLines()
 */
 QSize QwtPlotSpectrogram::contourRasterSize(
+QSize QwtPlotSpectrogram::contourRasterSize(
     const QRectF &area, const QRect &rect ) const
+{

trunk/BNC/qwt/qwt_plot_spectrogram.h

-              r8127
+              r9383
     typedef QFlags<DisplayMode> DisplayModes;
     explicit QwtPlotSpectrogram( const QString &title = QString::null );
+    explicit QwtPlotSpectrogram( const QString &title = QString() );
     virtual ~QwtPlotSpectrogram();
 …
     virtual QRectF pixelHint( const QRectF & ) const;
     void setDefaultContourPen( const QColor &,
+    void setDefaultContourPen( const QColor &,
         qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setDefaultContourPen( const QPen & );
 …
     virtual int rtti() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
 protected:
 …
         const QRectF &rect, const QSize &raster ) const;
     virtual void drawContourLines( QPainter *p,
+    virtual void drawContourLines( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QwtRasterData::ContourLines& lines ) const;
+        const QwtRasterData::ContourLines& ) const;
     void renderTile( const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRect &imageRect, QImage *image ) const;
+        const QRect &tile, QImage * ) const;
 private:

trunk/BNC/qwt/qwt_plot_svgitem.h

-              r8127
+              r9383
+{
 public:
     explicit QwtPlotSvgItem( const QString& title = QString::null );
+    explicit QwtPlotSvgItem( const QString& title = QString() );
     explicit QwtPlotSvgItem( const QwtText& title );
     virtual ~QwtPlotSvgItem();
 …
     virtual QRectF boundingRect() const;
     virtual void draw( QPainter *p,
+    virtual void draw( QPainter *,
         const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QRectF &rect ) const;
+        const QRectF &canvasRect ) const;
     virtual int rtti() const;
 …
     QSvgRenderer &renderer();
     void render( QPainter *painter,
+    void render( QPainter *,
         const QRectF &viewBox, const QRectF &rect ) const;
     QRectF viewBox( const QRectF &area ) const;
+    QRectF viewBox( const QRectF &rect ) const;
 private:

trunk/BNC/qwt/qwt_plot_textlabel.cpp

-              r8127
+              r9383
 static QRect qwtItemRect( int renderFlags,
     const QRectF &rect, const QSizeF &itemSize )
+    const QRectF &rect, const QSizeF &itemSize )
+{
     int x;
 …
     int y;
     if ( renderFlags & Qt::AlignTop )
+    if ( renderFlags & Qt::AlignTop )
+    {
         y = rect.top();
 …
 class QwtPlotTextLabel::PrivateData
+{
+{
 public:
     PrivateData():
 …
     QPixmap pixmap;
 };
+};
 /*!
 …
 /*!
   Set the text
+  Set the text
   The label will be aligned to the plot canvas according to
 …
             pw = qMax( d_data->text.borderPen().width(), 1 );
         QRect pixmapRect;
+        QRect pixmapRect;
         pixmapRect.setLeft( qFloor( rect.left() ) - pw );
         pixmapRect.setTop( qFloor( rect.top() ) - pw );
         pixmapRect.setRight( qCeil( rect.right() ) + pw );
         pixmapRect.setBottom( qCeil( rect.bottom() ) + pw );
 #define QWT_HIGH_DPI 1
 …
         const QSize scaledSize = pixmapRect.size();
 #endif
         if ( d_data->pixmap.isNull() ||
+        if ( d_data->pixmap.isNull() ||
             ( scaledSize != d_data->pixmap.size() )  )
+        {
 …
             d_data->pixmap.fill( Qt::transparent );
             const QRect r( pw, pw,
+            const QRect r( pw, pw,
                 pixmapRect.width() - 2 * pw, pixmapRect.height() - 2 * pw );
 …
    \sa setMargin(), QwtText::renderFlags(), QwtText::textSize()
  */
 QRectF QwtPlotTextLabel::textRect(
+QRectF QwtPlotTextLabel::textRect(
     const QRectF &rect, const QSizeF &textSize ) const
+{

trunk/BNC/qwt/qwt_plot_textlabel.h

-              r8127
+              r9383
   In opposite to QwtPlotMarker the position of the label is unrelated to
   plot coordinates.
   As drawing a text is an expensive operation the label is cached
   in a pixmap to speed up replots.
   \par Example
+  The following code shows how to add a title.
+    The following code shows how to add a title.
+    \code
+      QwtText title( "Plot Title" );
+      title.setRenderFlags( Qt::AlignHCenter | Qt::AlignTop );
+\verbatim
     QwtText title( "Plot Title" );
     title.setRenderFlags( Qt::AlignHCenter | Qt::AlignTop );
+      QFont font;
+      font.setBold( true );
+      title.setFont( font );
+    QFont font;
+    font.setBold( true );
+    title.setFont( font );
+    QwtPlotTextLabel *titleItem = new QwtPlotTextLabel();
+    titleItem->setText( title );
+    titleItem->attach( this );
+\endverbatim
+      QwtPlotTextLabel *titleItem = new QwtPlotTextLabel();
+      titleItem->setText( title );
+      titleItem->attach( plot );
+    \endcode
+  \endpar
   \sa QwtPlotMarker
 */
+*/
 class QWT_EXPORT QwtPlotTextLabel: public QwtPlotItem

trunk/BNC/qwt/qwt_plot_tradingcurve.cpp

-              r8127
+              r9383
 /*!
   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.
+           it when its not used anymore.
 */
 void QwtPlotTradingCurve::setSamples(
 …
+{
     setData( data );
+}
+}
 /*!
 …
+}
 /*!
+/*!
   Build and assign the symbol 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 QwtPlotTradingCurve::setSymbolPen(
+ */
+void QwtPlotTradingCurve::setSymbolPen(
     const QColor &color, qreal width, Qt::PenStyle style )
+{
+{
     setSymbolPen( QPen( color, width, style ) );
+}
 …
     Direction direction, const QBrush &brush )
+{
+    if ( direction < 0 || direction >= 2 )
+    // silencing -Wtautological-constant-out-of-range-compare
+    const int index = static_cast< int >( direction );
+    if ( index < 0 || index >= 2 )
         return;
     if ( brush != d_data->symbolBrush[ direction ] )
+    {
         d_data->symbolBrush[ direction ] = brush;
+    if ( brush != d_data->symbolBrush[ index ] )
+    {
+        d_data->symbolBrush[ index ] = brush;
         legendChanged();
 …
 QBrush QwtPlotTradingCurve::symbolBrush( Direction direction ) const
+{
+    if ( direction < 0 || direction >= 2 )
+    const int index = static_cast< int >( direction );
+    if ( index < 0 || index >= 2 )
         return QBrush();
     return d_data->symbolBrush[ direction ];
+    return d_data->symbolBrush[ index ];
+}
 …
   \param extent Symbol width in scale coordinates
   \sa symbolExtent(), scaledSymbolWidth(),
+  \sa symbolExtent(), scaledSymbolWidth(),
       setMinSymbolWidth(), setMaxSymbolWidth()
 */
 …
+    {
         d_data->maxSymbolWidth = width;
         legendChanged();
         itemChanged();
 …
+{
     QRectF rect = QwtPlotSeriesItem::boundingRect();
     if ( rect.isValid() && orientation() == Qt::Vertical )
+    if ( orientation() == Qt::Vertical )
         rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
 …
                 case Bar:
+                {
                     drawBar( painter, translatedSample,
+                    drawBar( painter, translatedSample,
                         orient, inverted, symbolWidth );
                     break;
 …
+                {
                     painter->setBrush( d_data->symbolBrush[ brushIndex ] );
                     drawCandleStick( painter, translatedSample,
+                    drawCandleStick( painter, translatedSample,
                         orient, symbolWidth );
                     break;
 …
   \param sample Samples already translated into paint device coordinates
   \param orientation Vertical or horizontal
   \param inverted True, when the opposite scale
+  \param inverted True, when the opposite scale
                   ( Qt::Vertical: x, Qt::Horizontal: y ) is increasing
                   in the opposite direction as QPainter coordinates.
 …
 */
 void QwtPlotTradingCurve::drawBar( QPainter *painter,
     const QwtOHLCSample &sample, Qt::Orientation orientation,
+    const QwtOHLCSample &sample, Qt::Orientation orientation,
     bool inverted, double width ) const
+{
 …
 */
 void QwtPlotTradingCurve::drawCandleStick( QPainter *painter,
     const QwtOHLCSample &sample, Qt::Orientation orientation,
+    const QwtOHLCSample &sample, Qt::Orientation orientation,
     double width ) const
+{
 …
   \return A rectangle filled with the color of the symbol pen
   \param index Index of the legend entry
+  \param index Index of the legend entry
                 ( usually there is only one )
   \param size Icon size
 …
         ( orientation() == Qt::Vertical ) ? &xMap : &yMap;
     const double pos = map->transform( map->s1() + d_data->symbolExtent );
+    const double pos = map->transform( map->s1() + d_data->symbolExtent );
     double width = qAbs( pos - map->p1() );

trunk/BNC/qwt/qwt_plot_tradingcurve.h

-              r8127
+              r9383
   that are used in the domain of technical analysis.
   While the length ( height or width depending on orientation() )
+  While the length ( height or width depending on orientation() )
   of each symbol depends on the corresponding OHLC sample the size
   of the other dimension can be controlled using:
 …
   The extent is a size in scale coordinates, so that the symbol width
   is increasing when the plot is zoomed in. Minimum/Maximum width
   is in widget coordinates independent from the zoom level.
   When setting the minimum and maximum to the same value, the width of
   the symbol is fixed.
+  is in widget coordinates independent from the zoom level.
+  When setting the minimum and maximum to the same value, the width of
+  the symbol is fixed.
 */
 class QWT_EXPORT QwtPlotTradingCurve:
     public QwtPlotSeriesItem, QwtSeriesStore<QwtOHLCSample>
+class QWT_EXPORT QwtPlotTradingCurve:
+    public QwtPlotSeriesItem, public QwtSeriesStore<QwtOHLCSample>
+{
 public:
 …
     typedef QFlags<PaintAttribute> PaintAttributes;
     explicit QwtPlotTradingCurve( const QString &title = QString::null );
+    explicit QwtPlotTradingCurve( const QString &title = QString() );
     explicit QwtPlotTradingCurve( const QwtText &title );
 …
     SymbolStyle symbolStyle() const;
     void setSymbolPen( const QColor &,
+    void setSymbolPen( const QColor &,
         qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setSymbolPen( const QPen & );
 …
     QBrush symbolBrush( Direction ) const;
     void setSymbolExtent( double width );
+    void setSymbolExtent( double );
     double symbolExtent() const;
 …
         const QRectF &canvasRect, int from, int to ) const;
     virtual void drawUserSymbol( QPainter *,
+    virtual void drawUserSymbol( QPainter *,
         SymbolStyle, const QwtOHLCSample &,
+        Qt::Orientation, bool inverted, double symbolWidth ) const;
+    void drawBar( QPainter *painter, const QwtOHLCSample &,
         Qt::Orientation, bool inverted, double width ) const;
+    void drawBar( QPainter *painter, const QwtOHLCSample &,
+        Qt::Orientation, bool inverted, double width ) const;
+    void drawCandleStick( QPainter *, const QwtOHLCSample &,
+    void drawCandleStick( QPainter *, const QwtOHLCSample &,
         Qt::Orientation, double width ) const;

trunk/BNC/qwt/qwt_plot_xml.cpp

-              r8127
+              r9383
   from a specific editor in the Qwt designer plugin.
   \return QString::null
+  \return QString()
   \warning The plot editor has never been implemented.
 */
 …
     return title().text();
 #else
     return QString::null;
+    return QString();
 #endif
+}

trunk/BNC/qwt/qwt_plot_zoneitem.cpp

-              r8127
+              r9383
 class QwtPlotZoneItem::PrivateData
+{
+{
 public:
     PrivateData():
 …
         brush = QBrush( c );
+    }
     Qt::Orientation orientation;
     QPen pen;
     QBrush brush;
     QwtInterval interval;
 };
+};
 /*!
 …
+}
 /*!
+/*!
   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 QwtPlotZoneItem::setPen( const QColor &color, qreal width, Qt::PenStyle style )
+{
+{
     setPen( QPen( color, width, style ) );
+}
 /*!
   \brief Assign a pen
+  \brief Assign a pen
   The pen is used to draw the border lines of the zone
 …
+}
 /*!
   \brief Assign a brush
+/*!
+  \brief Assign a brush
   The brush is used to fill the zone
 …
   \brief Set the orientation of the zone
   A horizontal zone highlights an interval of the y axis,
   a vertical zone of the x axis. It is unbounded in the
+  A horizontal zone highlights an interval of the y axis,
+  a vertical zone of the x axis. It is unbounded in the
   opposite direction.
 …
+    {
         d_data->interval = interval;
         itemChanged();
+    }
+}
+        itemChanged();
+    }
+}
 /*!
 …
+{
     return d_data->interval;
+}
+}
 /*!
 …
+}
 /*!
+/*!
   The bounding rectangle is build from the interval in one direction
   and something invalid for the opposite direction.

trunk/BNC/qwt/qwt_plot_zoneitem.h

-              r8127
+              r9383
   \brief A plot item, which displays a zone
   A horizontal zone highlights an interval of the y axis - a vertical
+  A horizontal zone highlights an interval of the y axis - a vertical
   zone an interval of the x axis - and is unbounded in the opposite direction.
   It is filled with a brush and its border lines are optionally displayed with a pen.
+  It is filled with a brush and its border lines are optionally displayed with a pen.
   \note For displaying an area that is bounded for x and y coordinates
+  \note For displaying an area that is bounded for x and y coordinates
         use QwtPlotShapeItem
 */
 class QWT_EXPORT QwtPlotZoneItem:
+class QWT_EXPORT QwtPlotZoneItem:
     public QwtPlotItem
+{

trunk/BNC/qwt/qwt_plot_zoomer.cpp

r8127	r9383
14	14	#include <qalgorithms.h>
15	15
16		static QwtInterval qwtExpandedZoomInterval( double v1, double v2,
	16	static QwtInterval qwtExpandedZoomInterval( double v1, double v2,
17	17	double minRange, const QwtTransform* transform )
18	18	{

trunk/BNC/qwt/qwt_plot_zoomer.h

-              r8127
+              r9383
   the coordinates of the current mouse position.
   Zooming can be repeated as often as possible, limited only by
+  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
+  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 first point of the zoom rectangle is selected by a mouse press,
     the second point from the position, where the mouse is released.
 …
   - 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
 …
   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
+  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.
 …
 public Q_SLOTS:
     void moveBy( double x, double y );
+    void moveBy( double dx, double dy );
     virtual void moveTo( const QPointF & );
     virtual void zoom( const QRectF & );
     virtual void zoom( int up );
+    virtual void zoom( int offset );
 Q_SIGNALS:

trunk/BNC/qwt/qwt_point_3d.cpp

r4271	r9383
14	14	QDebug operator<<( QDebug debug, const QwtPoint3D &point )
15	15	{
16		debug.nospace() << "QwtPoint3D(" << point.x()
	16	debug.nospace() << "QwtPoint3D(" << point.x()
17	17	<< "," << point.y() << "," << point.z() << ")";
18	18	return debug.space();

trunk/BNC/qwt/qwt_point_data.cpp

-              r8127
+              r9383
    interval is calculated from the "rectangle of interest".
    \param index Index of the requested point
+   \param index Index of the requested point
    \return Calculated x coordinate
 …
         d_interval : d_intervalOfInterest;
     if ( !interval.isValid() )
+    if ( !interval.isValid() )
         return 0.0;

trunk/BNC/qwt/qwt_point_data.h

-              r8127
+              r9383
     virtual size_t size() const;
     virtual QPointF sample( size_t i ) const;
+    virtual QPointF sample( size_t index ) const;
     const QVector<double> &xData() const;
 …
     virtual QRectF boundingRect() const;
     virtual size_t size() const;
     virtual QPointF sample( size_t i ) const;
+    virtual QPointF sample( size_t index ) const;
     const double *xData() const;
 …
     virtual QRectF boundingRect() const;
     virtual QPointF sample( size_t i ) const;
+    virtual QPointF sample( size_t index ) const;
     /*!

trunk/BNC/qwt/qwt_point_mapper.cpp

-              r8127
+              r9383
 #if !defined(QT_NO_QFUTURE)
 #define QWT_USE_THREADS 0
+#define QWT_USE_THREADS 1
 #endif
 …
 static void qwtRenderDots(
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     const QwtDotsCommand command, const QPoint &pos, QImage *image )
+    const QwtDotsCommand command, const QPoint &pos, QImage *image )
+{
     const QRgb rgb = command.rgb;
 …
 struct QwtNoRoundF
+{
+{
     inline double operator()( double value )
+    {
 …
 template<class Polygon, class Point, class Round>
 static inline Polygon qwtToPoints(
+static inline Polygon qwtToPoints(
     const QRectF &boundingRect,
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     const QwtSeriesData<QPointF> *series,
+    const QwtSeriesData<QPointF> *series,
     int from, int to, Round round )
+{
 …
     int from, int to )
+{
     return qwtToPoints<QPolygon, QPoint>(
+    return qwtToPoints<QPolygon, QPoint>(
         boundingRect, xMap, yMap, series, from, to, QwtRoundI() );
+}
 …
     int from, int to, Round round )
+{
     return qwtToPoints<QPolygonF, QPointF>(
+    return qwtToPoints<QPolygonF, QPointF>(
         boundingRect, xMap, yMap, series, from, to, round );
+}
 …
 template<class Polygon, class Point, class Round>
 static inline Polygon qwtToPolylineFiltered(
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     const QwtSeriesData<QPointF> *series,
+static inline Polygon qwtToPolylineFiltered(
+    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
+    const QwtSeriesData<QPointF> *series,
     int from, int to, Round round )
+{
 …
     return qwtToPolylineFiltered<QPolygonF, QPointF>(
         xMap, yMap, series, from, to, round );
+}
+}
 template<class Polygon, class Point>
 …
     return qwtToPointsFiltered<QPolygon, QPoint>(
         boundingRect, xMap, yMap, series, from, to );
+}
+}
 static inline QPolygonF qwtToPointsFilteredF(
 …
   When the WeedOutPoints flag is enabled consecutive points,
   that are mapped to the same position will be one point.
+  that are mapped to the same position will be one point.
   When RoundPoints is set all points are rounded to integers
 …
         if ( d_data->flags & RoundPoints )
+        {
             polyline = qwtToPolylineFilteredF(
+            polyline = qwtToPolylineFilteredF(
                 xMap, yMap, series, from, to, QwtRoundF() );
+        }
         else
+        {
             polyline = qwtToPolylineFilteredF(
+            polyline = qwtToPolylineFilteredF(
                 xMap, yMap, series, from, to, QwtNoRoundF() );
+        }
 …
         if ( d_data->flags & RoundPoints )
+        {
             polyline = qwtToPointsF( qwtInvalidRect,
+            polyline = qwtToPointsF( qwtInvalidRect,
                 xMap, yMap, series, from, to, QwtRoundF() );
+        }
         else
+        {
             polyline = qwtToPointsF( qwtInvalidRect,
+            polyline = qwtToPointsF( qwtInvalidRect,
                 xMap, yMap, series, from, to, QwtNoRoundF() );
+        }
 …
   When the WeedOutPoints flag is enabled consecutive points,
   that are mapped to the same position will be one point.
+  that are mapped to the same position will be one point.
   \param xMap x map
 …
     if ( d_data->flags & WeedOutPoints )
+    {
         polyline = qwtToPolylineFilteredI(
+        polyline = qwtToPolylineFilteredI(
             xMap, yMap, series, from, to );
+    }
     else
+    {
         polyline = qwtToPointsI(
+        polyline = qwtToPointsI(
             qwtInvalidRect, xMap, yMap, series, from, to );
+    }
 …
   - WeedOutPoints & RoundPoints & boundingRect().isValid()
     All points that are mapped to the same position
+    All points that are mapped to the same position
     will be one point. Points outside of the bounding
     rectangle are ignored.
   - WeedOutPoints & RoundPoints & !boundingRect().isValid()
     All consecutive points that are mapped to the same position
+    All consecutive points that are mapped to the same position
     will one point
   - WeedOutPoints & !RoundPoints
     All consecutive points that are mapped to the same position
+  - WeedOutPoints & !RoundPoints
+    All consecutive points that are mapped to the same position
     will one point
 …
+        {
             if ( d_data->boundingRect.isValid() )
+            {
+            {
                 points = qwtToPointsFilteredF( d_data->boundingRect,
                     xMap, yMap, series, from, to );
+            }
             else
+            {
+            {
                 // without a bounding rectangle all we can
                 // do is to filter out duplicates of
                 // consecutive points
                 points = qwtToPolylineFilteredF(
+                points = qwtToPolylineFilteredF(
                     xMap, yMap, series, from, to, QwtRoundF() );
+            }
 …
             // qwtToPointsFilteredF
             points = qwtToPolylineFilteredF(
+            points = qwtToPolylineFilteredF(
                 xMap, yMap, series, from, to, QwtNoRoundF() );
+        }
 …
   - WeedOutPoints & boundingRect().isValid()
     All points that are mapped to the same position
+    All points that are mapped to the same position
     will be one point. Points outside of the bounding
     rectangle are ignored.
   - WeedOutPoints & !boundingRect().isValid()
     All consecutive points that are mapped to the same position
+    All consecutive points that are mapped to the same position
     will one point
 …
             // we can do is to filter out consecutive duplicates
             points = qwtToPolylineFilteredI(
+            points = qwtToPolylineFilteredI(
                 xMap, yMap, series, from, to );
+        }
 …
     else
+    {
         points = qwtToPointsI(
+        points = qwtToPointsI(
             d_data->boundingRect, xMap, yMap, series, from, to );
+    }
 …
 QImage QwtPointMapper::toImage(
     const QwtScaleMap &xMap, const QwtScaleMap &yMap,
     const QwtSeriesData<QPointF> *series, int from, int to,
+    const QwtSeriesData<QPointF> *series, int from, int to,
     const QPen &pen, bool antialiased, uint numThreads ) const
+{
 …
                 command.to = index0 + numPoints - 1;
                 futures += QtConcurrent::run( &qwtRenderDots,
+                futures += QtConcurrent::run( &qwtRenderDots,
                     xMap, yMap, command, pos, &image );
+            }

trunk/BNC/qwt/qwt_point_mapper.h

-              r8127
+              r9383
   QwtPointMapper is a collection of methods and optimizations
   for translating a series of points into paint device coordinates.
   It is used by QwtPlotCurve but might also be useful for
+  for translating a series of points into paint device coordinates.
+  It is used by QwtPlotCurve but might also be useful for
   similar plot items displaying a QwtSeriesData<QPointF>.
  */
 …
+{
 public:
     /*!
+    /*!
       \brief Flags affecting the transformation process
       \sa setFlag(), setFlags()
 …
         RoundPoints = 0x01,
         /*!
+        /*!
           Try to remove points, that are translated to the
           same position.
 …
     };
     /*!
+    /*!
       \brief Flags affecting the transformation process
       \sa setFlag(), setFlags()
 …
     QImage toImage( const QwtScaleMap &xMap, const QwtScaleMap &yMap,
         const QwtSeriesData<QPointF> *series, int from, int to,
+        const QwtSeriesData<QPointF> *series, int from, int to,
         const QPen &, bool antialiased, uint numThreads ) const;

trunk/BNC/qwt/qwt_point_polar.cpp

r8127	r9383
112	112	QDebug operator<<( QDebug debug, const QwtPointPolar &point )
113	113	{
114		debug.nospace() << "QwtPointPolar("
	114	debug.nospace() << "QwtPointPolar("
115	115	<< point.azimuth() << "," << point.radius() << ")";
116	116

trunk/BNC/qwt/qwt_point_polar.h

-              r8127
+              r9383
     QwtPointPolar();
     QwtPointPolar( double azimuth, double radius );
-    QwtPointPolar( const QwtPointPolar & );
     QwtPointPolar( const QPointF & );
 …
     d_azimuth( azimuth ),
     d_radius( radius )
+{
+}
-/*!
-    Constructs a point using the values of the point specified.
-    \param other Other point
-*/
-inline QwtPointPolar::QwtPointPolar( const QwtPointPolar &other ):
-    d_azimuth( other.d_azimuth ),
-    d_radius( other.d_radius )
+{
+}
 …
 inline QPointF qwtFastDegree2Pos( const QPointF &pole,
     double radius, double angle )
+{
+{
     return qwtFastPolar2Pos( pole, radius, angle / 180.0 * M_PI );
+}
+}
 inline QwtPointPolar qwtFastPos2Polar( const QPointF &pos )
 …
+}
 #endif
+#endif

trunk/BNC/qwt/qwt_raster_data.cpp

-              r8127
+              r9383
    \brief Pixel hint
    pixelHint() returns the geometry of a pixel, that can be used
+   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.
    Width and height of the hint need to be the horizontal
    and vertical distances between 2 neighbored points.
    The center of the hint has to be the position of any point
+   representing the data.
+   Width and height of the hint need to be the horizontal
+   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 ).
 …
    Limiting the resolution of the image might significantly improve
    the performance and heavily reduce the amount of memory when rendering
    a QImage from the raster data.
+   a QImage from the raster data.
    The default implementation returns an empty rectangle recommending
 …
                depend on the requested area.
    \return Bounding rectangle of a pixel
+   \return Bounding rectangle of a pixel
 */
 QRectF QwtRasterData::pixelHint( const QRectF &area ) const
+{
     Q_UNUSED( area );
     return QRectF();
+    return QRectF();
+}
 …
     QwtRasterData *that = const_cast<QwtRasterData *>( this );
     that->initRaster( rect, raster );
+#if __GNUC__ >= 9
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-copy"
+#endif
     for ( int y = 0; y < raster.height() - 1; y++ )
 …
+    }
+#if __GNUC__ >= 9
+#pragma GCC diagnostic pop
+#endif
     that->discardRaster();

trunk/BNC/qwt/qwt_round_scale_draw.cpp

r8127	r9383
185	185	\param painter Painter
186	186	\param value Value of the tick
187		\param len Lenght of the tick
	187	\param len Length of the tick
188	188
189	189	\sa drawBackbone(), drawLabel()

trunk/BNC/qwt/qwt_round_scale_draw.h

r8127	r9383
46	46
47	47	protected:
48		virtual void drawTick( QPainter *, double val, double len ) const;
	48	virtual void drawTick( QPainter *, double value, double len ) const;
49	49	virtual void drawBackbone( QPainter * ) const;
50	50	virtual void drawLabel( QPainter *, double val ) const;

trunk/BNC/qwt/qwt_sampling_thread.h

-              r8127
+              r9383
+/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
+ * Qwt Widget Library
+ * Copyright (C) 1997   Josef Wilgen
+ * Copyright (C) 2002   Uwe Rathmann
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the Qwt License, Version 1.0
+ *****************************************************************************/
 #ifndef _QWT_SAMPLING_THREAD_H_
 #define _QWT_SAMPLING_THREAD_H_

trunk/BNC/qwt/qwt_scale_div.cpp

-              r8127
+              r9383
 */
 QwtScaleDiv::QwtScaleDiv( double lowerBound, double upperBound,
         const QList<double> &minorTicks,
+        const QList<double> &minorTicks,
         const QList<double> &mediumTicks,
         const QList<double> &majorTicks ):
 …
+{
     return d_lowerBound;
+}
+}
 /*!
 …
+{
     d_upperBound = upperBound;
+}
+}
 /*!
 …
+}
 /*!
+/*!
    Invert the scale division
    \sa inverted()
 …
+}
 /*!
+/*!
   \return A scale division with inverted boundaries and ticks
   \sa invert()
 …
+}
 /*!
+/*!
    Return a scale division with an interval [lowerBound, upperBound]
    where all ticks outside this interval are removed
 …
    \note lowerBound might be greater than upperBound for inverted scales
 */
 QwtScaleDiv QwtScaleDiv::bounded(
+QwtScaleDiv QwtScaleDiv::bounded(
     double lowerBound, double upperBound ) const
+{

trunk/BNC/qwt/qwt_scale_div.h

-              r8127
+              r9383
     };
     explicit QwtScaleDiv( double lowerBound = 0.0,
+    explicit QwtScaleDiv( double lowerBound = 0.0,
         double upperBound = 0.0 );
 …
         QList<double>[NTickTypes] );
     explicit QwtScaleDiv( double lowerBound, double upperBound,
+    explicit QwtScaleDiv( double lowerBound, double upperBound,
         const QList<double> &minorTicks, const QList<double> &mediumTicks,
         const QList<double> &majorTicks );

trunk/BNC/qwt/qwt_scale_draw.cpp

-              r8127
+              r9383
   \param end End border distance
 */
 void QwtScaleDraw::getBorderDistHint(
+void QwtScaleDraw::getBorderDistHint(
     const QFont &font, int &start, int &end ) const
+{
 …
+    }
     double angle = qwtRadians( labelRotation() );
+    double angle = qwtRadians( labelRotation() );
     if ( vertical )
         angle += M_PI / 2;
 …
    Find the position, where to paint a label
    The position has a distance that depends on the length of the ticks
+   The position has a distance that depends on the length of the ticks
    in direction of the alignment().

trunk/BNC/qwt/qwt_scale_draw.h

-              r8127
+              r9383
         \sa setAlignment(), alignment()
      */
     enum Alignment
+    {
+    enum Alignment
+    {
         //! The scale is below
         BottomScale,
+        BottomScale,
         //! The scale is above
         TopScale,
+        TopScale,
         //! The scale is left
         LeftScale,
+        LeftScale,
         //! The scale is right
         RightScale
+        RightScale
     };
 …
     int maxLabelWidth( const QFont & ) const;
     QPointF labelPosition( double val ) const;
+    QPointF labelPosition( double value ) const;
     QRectF labelRect( const QFont &, double val ) const;
     QSizeF labelSize( const QFont &, double val ) const;
+    QRectF labelRect( const QFont &, double value ) const;
+    QSizeF labelSize( const QFont &, double value ) const;
     QRect boundingLabelRect( const QFont &, double val ) const;
+    QRect boundingLabelRect( const QFont &, double value ) const;
 protected:
     QTransform labelTransformation( const QPointF &, const QSizeF & ) const;
     virtual void drawTick( QPainter *, double val, double len ) const;
+    virtual void drawTick( QPainter *, double value, double len ) const;
     virtual void drawBackbone( QPainter * ) const;
     virtual void drawLabel( QPainter *, double val ) const;
+    virtual void drawLabel( QPainter *, double value ) const;
 private:

trunk/BNC/qwt/qwt_scale_engine.cpp

-              r8127
+              r9383
+}
 static inline QwtInterval qwtPowInterval( double base, const QwtInterval &interval )
+static inline QwtInterval qwtPowInterval( double base, const QwtInterval &interval )
+{
     return QwtInterval( qPow( base, interval.minValue() ),
 …
 static double qwtStepSize( double intervalSize, int maxSteps, uint base )
+{
     const double minStep =
+    const double minStep =
         QwtScaleArithmetic::divideInterval( intervalSize, maxSteps, base );
 …
   \return Calculated step size
  */
 double QwtScaleArithmetic::divideInterval(
     double intervalSize, int numSteps, uint base )
+double QwtScaleArithmetic::divideInterval(
+    double intervalSize, int numSteps, uint base )
+{
     if ( numSteps <= 0 )
 …
 /*!
    Create and return a clone of the transformation
+   Create and return a clone of the transformation
    of the engine. When the engine has no special transformation
    NULL is returned, indicating no transformation.
 …
     double intervalSize, int numSteps ) const
+{
     return QwtScaleArithmetic::divideInterval(
+    return QwtScaleArithmetic::divideInterval(
         intervalSize, numSteps, d_data->base );
+}
 …
 /*!
   \brief Specify a reference point
   \param r new reference value
+  \param reference New reference value
   The reference point is needed if options IncludeReference or
 …
   \sa Attribute
 */
 void QwtScaleEngine::setReference( double r )
+{
     d_data->referenceValue = r;
+void QwtScaleEngine::setReference( double reference )
+{
+    d_data->referenceValue = reference;
+}
 …
  */
 void QwtScaleEngine::setBase( uint base )
+{
+{
     d_data->base = qMax( base, 2U );
+}
 …
         interval = buildInterval( interval.minValue() );
     stepSize = QwtScaleArithmetic::divideInterval(
+    stepSize = QwtScaleArithmetic::divideInterval(
         interval.width(), qMax( maxNumSteps, 1 ), base() );
 …
             maxMajorSteps = 1;
         stepSize = QwtScaleArithmetic::divideInterval(
+        stepSize = QwtScaleArithmetic::divideInterval(
             interval.width(), maxMajorSteps, base() );
+    }
 …
     double x2 = interval.maxValue();
     // when there is no rounding beside some effect, when
+    // when there is no rounding beside some effect, when
     // calculating with doubles, we keep the original value
 …
         interval = buildInterval( interval.minValue() );
     stepSize = divideInterval( qwtLogInterval( logBase, interval ).width(),
+    stepSize = divideInterval( qwtLogInterval( logBase, interval ).width(),
         qMax( maxNumSteps, 1 ) );
     if ( stepSize < 1.0 )
 …
             maxMajorSteps = 1;
         stepSize = divideInterval(
+        stepSize = divideInterval(
             qwtLogInterval( logBase, interval ).width(), maxMajorSteps );
         if ( stepSize < 1.0 )
 …
         if ( minStep == 0.0 )
             return;
         const int numSteps = qRound( stepSize / minStep );
+        const int numSteps = qRound( stepSize / minStep );
         int mediumTickIndex = -1;
 …
         if ( numTicks < 1 )
             return;
+            return;
         int mediumTickIndex = -1;

trunk/BNC/qwt/qwt_scale_engine.h

-              r8127
+              r9383
     static double floorEps( double value, double intervalSize );
     static double divideEps( double interval, double steps );
     static double divideInterval( double interval,
+    static double divideEps( double intervalSize, double numSteps );
+    static double divideInterval( double intervalSize,
         int numSteps, uint base );
 };
 …
   The layout of the scale can be varied with setAttribute().
   Qwt offers implementations for logarithmic and linear scales.
+  Qwt offers implementations for logarithmic and linear scales.
 */
 …
+{
 public:
     /*!
+    /*!
        Layout attributes
        \sa setAttribute(), testAttribute(), reference(),
 …
         /*!
            The endpoints of the scale are supposed to be equal the
            outmost included values plus the specified margins
+           outmost included values plus the specified margins
            (see setMargins()).
            If this attribute is *not* set, the endpoints of the scale will
 …
     Attributes attributes() const;
     void setReference( double reference );
+    void setReference( double );
     double reference() const;
 …
 protected:
     bool contains( const QwtInterval &, double val ) const;
+    bool contains( const QwtInterval &, double value ) const;
     QList<double> strip( const QList<double>&, const QwtInterval & ) const;
     double divideInterval( double interval, int numSteps ) const;
     QwtInterval buildInterval( double v ) const;
+    double divideInterval( double intervalSize, int numSteps ) const;
+    QwtInterval buildInterval( double value ) const;
 private:
 …
     virtual ~QwtLinearScaleEngine();
     virtual void autoScale( int maxSteps,
+    virtual void autoScale( int maxNumSteps,
         double &x1, double &x2, double &stepSize ) const;
     virtual QwtScaleDiv divideScale( double x1, double x2,
         int numMajorSteps, int numMinorSteps,
                                      double stepSize = 0.0 ) const;
+        int maxMajorSteps, int maxMinorSteps,
+        double stepSize = 0.0 ) const;
 …
     void buildTicks(
         const QwtInterval &, double stepSize, int maxMinSteps,
+        const QwtInterval &, double stepSize, int maxMinorSteps,
         QList<double> ticks[QwtScaleDiv::NTickTypes] ) const;
 …
     virtual ~QwtLogScaleEngine();
     virtual void autoScale( int maxSteps,
+    virtual void autoScale( int maxNumSteps,
         double &x1, double &x2, double &stepSize ) const;
     virtual QwtScaleDiv divideScale( double x1, double x2,
         int numMajorSteps, int numMinorSteps,
+        int maxMajorSteps, int maxMinorSteps,
         double stepSize = 0.0 ) const;
 …
     void buildTicks(
         const QwtInterval &, double stepSize, int maxMinSteps,
+        const QwtInterval &, double stepSize, int maxMinorSteps,
         QList<double> ticks[QwtScaleDiv::NTickTypes] ) const;

trunk/BNC/qwt/qwt_scale_map.cpp

-              r8127
+              r9383
   \param s1 first border
   \param s2 second border
   \warning scales might be aligned to
+  \warning scales might be aligned to
            transformation depending boundaries
 */
 …
     const QwtScaleMap &yMap, const QPointF &pos )
+{
     return QPointF(
         xMap.invTransform( pos.x() ),
         yMap.invTransform( pos.y() )
+    return QPointF(
+        xMap.invTransform( pos.x() ),
+        yMap.invTransform( pos.y() )
     );
+}
 …
     const QwtScaleMap &yMap, const QPointF &pos )
+{
     return QPointF(
         xMap.transform( pos.x() ),
+    return QPointF(
+        xMap.transform( pos.x() ),
         yMap.transform( pos.y() )
     );

trunk/BNC/qwt/qwt_scale_map.h

r8127	r9383
25	25
26	26	QwtScaleMap offers transformations from the coordinate system
27		of a scale into the linear coordinate system of a paint device
	27	of a scale into the linear coordinate system of a paint device
28	28	and vice versa.
29	29	*/

trunk/BNC/qwt/qwt_scale_widget.cpp

-              r8127
+              r9383
 #include <qstyle.h>
 #include <qstyleoption.h>
+#include <qapplication.h>
 class QwtScaleWidget::PrivateData
 …
         else
             d_data->layoutFlags &= ~flag;
+        update();
+    }
+}
 …
+    {
         updateGeometry();
+#if 1
+        /*
+            for some reason updateGeometry does not send a LayoutRequest event
+            when the parent is not visible and has no layout
+         */
+        if ( QWidget* w = parentWidget() )
+        {
+            if ( !w->isVisible() && w->layout() == NULL )
+            {
+                if ( w->testAttribute( Qt::WA_WState_Polished ) )
+                    QApplication::postEvent( w, new QEvent( QEvent::LayoutRequest ) );
+            }
+        }
+#endif
         update();
+    }
 …
   is returned.
   \param start Return parameter for the border width at
+  \param start Return parameter for the border width at
                the beginning of the scale
   \param end Return parameter for the border width at the
+  \param end Return parameter for the border width at the
              end of the scale
 …
   the widget borders.
   \param start Return parameter for the border width at
+  \param start Return parameter for the border width at
                the beginning of the scale
   \param end Return parameter for the border width at the
+  \param end Return parameter for the border width at the
              end of the scale

trunk/BNC/qwt/qwt_scale_widget.h

-              r8127
+              r9383
+    {
         /*!
           The title of vertical scales is painted from top to bottom.
+          The title of vertical scales is painted from top to bottom.
           Otherwise it is painted from bottom to top.
          */
 …
     bool testLayoutFlag( LayoutFlag ) const;
     void setBorderDist( int start, int end );
+    void setBorderDist( int dist1, int dist2 );
     int startBorderDist() const;
     int endBorderDist() const;
 …
     int margin() const;
     void setSpacing( int td );
+    void setSpacing( int );
     int spacing() const;
     void setScaleDiv( const QwtScaleDiv &sd );
+    void setScaleDiv( const QwtScaleDiv & );
     void setTransformation( QwtTransform * );
 …
     virtual void resizeEvent( QResizeEvent * );
     void draw( QPainter *p ) const;
+    void draw( QPainter * ) const;
     void scaleChange();
     void layoutScale( bool update = true );
+    void layoutScale( bool update_geometry = true );
 private:

trunk/BNC/qwt/qwt_series_data.cpp

-              r8127
+              r9383
 static inline QRectF qwtBoundingRect( const QwtSetSample &sample )
+{
+    if ( sample.set.empty() )
+        return QRectF( sample.value, 0.0, 0.0, -1.0 );
     double minY = sample.set[0];
     double maxY = sample.set[0];
 …
         if ( sample.set[i] < minY )
             minY = sample.set[i];
         if ( sample.set[i] > maxY )
             maxY = sample.set[i];
+    }
+    double minX = sample.value;
+    double maxX = sample.value;
+    return QRectF( minX, minY, maxX - minX, maxY - minY );
+    return QRectF( sample.value, minY, 0.0, maxY - minY );
+}

trunk/BNC/qwt/qwt_series_data.h

-              r8127
+              r9383
    to implement an individual data access.
    A subclass of QwtSeriesData<QPointF> must implement:
    - size()\n
+   A subclass of QwtSeriesData<QPointF> must implement:
+   - size()\n
      Should return number of data points.
 …
      as QPointF object.
    - boundingRect()\n
+   - 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
+     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>
 …
     //! Destructor
     virtual ~QwtSeriesData();
+#ifndef QWT_PYTHON_WRAPPER
     //! \return Number of samples
 …
     virtual QRectF boundingRect() const = 0;
+#else
+    // Needed for generating the python bindings, but not for using them !
+    virtual size_t size() const { return 0; }
+    virtual T sample( size_t i ) const { return T(); }
+    virtual QRectF boundingRect() const { return d_boundingRect; }
+#endif
     /*!
        Set a the "rect of interest"
 …
        The default implementation does nothing.
        \param rect Rectangle of interest
     */
 …
     The following example shows finds a point of curve from an x
     coordinate
+  \verbatim
+#include <qwt_series_data.h>
+#include <qwt_plot_curve.h>
+struct compareX
+{
+    inline bool operator()( const double x, const QPointF &pos ) const
+    {
+        return ( x < pos.x() );
+    }
+};
+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 )
+    {
+        line.setP1( curve->sample( index - 1 ) );
+        line.setP2( curve->sample( index ) );
+    }
+    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.
+    \code
+      #include <qwt_series_data.h>
+      #include <qwt_plot_curve.h>
+      struct compareX
+      {
+          inline bool operator()( const double x, const QPointF &pos ) const
+          {
+              return ( x < pos.x() );
+          }
+      };
+      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 )
+          {
+              line.setP1( curve->sample( index - 1 ) );
+              line.setP2( curve->sample( index ) );
+          }
+          return line;
+      }
+    \endcode
+  \endpar
+  \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
  */
 template <typename T, typename LessThan>
 inline int qwtUpperSampleIndex( const QwtSeriesData<T> &series,
     double value, LessThan lessThan  )
+    double value, LessThan lessThan  )
+{
     const int indexMax = series.size() - 1;

trunk/BNC/qwt/qwt_series_store.h

-              r8127
+              r9383
     virtual ~QwtAbstractSeriesStore() {}
+#ifndef QWT_PYTHON_WRAPPER
     //! dataChanged() indicates, that the series has been changed.
     virtual void dataChanged() = 0;
 …
     //! \return Number of samples
     virtual size_t dataSize() const = 0;
+#else
+    // Needed for generating the python bindings, but not for using them !
+    virtual void dataChanged() {}
+    virtual void setRectOfInterest( const QRectF & ) {}
+    virtual QRectF dataRect() const { return  QRectF( 0.0, 0.0, -1.0, -1.0 ); }
+    virtual size_t dataSize() const { return 0; }
+#endif
 };

trunk/BNC/qwt/qwt_slider.cpp

-              r8127
+              r9383
 #include <qapplication.h>
 static QSize qwtHandleSize( const QSize &size,
+static QSize qwtHandleSize( const QSize &size,
     Qt::Orientation orientation, bool hasTrough )
+{
 …
+}
 static QwtScaleDraw::Alignment qwtScaleDrawAlignment(
+static QwtScaleDraw::Alignment qwtScaleDrawAlignment(
     Qt::Orientation orientation, QwtSlider::ScalePosition scalePos )
+{
 …
 /*!
   Construct vertical slider in QwtSlider::Trough style
   with a scale to the left.
+  with a scale to the left.
   The scale is initialized to [0.0, 100.0] and the value set to 0.0.
 …
   \param parent Parent widget
   \param orientation Orientation of the slider.
+  \param orientation Orientation of the slider.
 */
 QwtSlider::QwtSlider( Qt::Orientation orientation, QWidget *parent ):
 …
     d_data->orientation = orientation;
     scaleDraw()->setAlignment(
+    scaleDraw()->setAlignment(
         qwtScaleDrawAlignment( orientation, d_data->scalePosition ) );
     scaleDraw()->setLength( 100 );
 …
     d_data->orientation = orientation;
     scaleDraw()->setAlignment(
+    scaleDraw()->setAlignment(
         qwtScaleDrawAlignment( orientation, d_data->scalePosition ) );
 …
     d_data->scalePosition = scalePosition;
     scaleDraw()->setAlignment(
+    scaleDraw()->setAlignment(
         qwtScaleDrawAlignment( d_data->orientation, scalePosition ) );
 …
+}
 /*!
+/*!
   \return Position of the scale
   \sa setScalePosition()
 …
    \param sliderRect Bounding rectangle of the slider
 */
 void QwtSlider::drawSlider(
+void QwtSlider::drawSlider(
     QPainter *painter, const QRect &sliderRect ) const
+{
 …
         const int slotMargin = 4;
         QRect slotRect;
+        QRect slotRect;
         if ( orientation() == Qt::Horizontal )
+        {
 …
   \param pos Position of the handle marker in widget coordinates
 */
 void QwtSlider::drawHandle( QPainter *painter,
+void QwtSlider::drawHandle( QPainter *painter,
     const QRect &handleRect, int pos ) const
+{
     const int bw = d_data->borderWidth;
     qDrawShadePanel( painter,
+    qDrawShadePanel( painter,
         handleRect, palette(), false, bw,
         &palette().brush( QPalette::Button ) );
 …
   \param pos Mouse position
   \retval True, when handleRect() contains pos
+  \retval True, when handleRect() contains pos
   \sa scrolledTo()
 */
 …
     if ( handleRect().contains( pos ) )
+    {
         const double v = ( orientation() == Qt::Horizontal )
+        const double v = ( orientation() == Qt::Horizontal )
             ? pos.x() : pos.y();
 …
 double QwtSlider::scrolledTo( const QPoint &pos ) const
+{
     int p = ( orientation() == Qt::Horizontal )
+    int p = ( orientation() == Qt::Horizontal )
         ? pos.x() : pos.y();
 …
    \param event Mouse event
 */
+*/
 void QwtSlider::timerEvent( QTimerEvent *event )
+{
 …
         killTimer( d_data->repeatTimerId );
         d_data->repeatTimerId = startTimer( updateInterval() );
         d_data->timerTick = true;
+    }
+    }
+}
 …
 void QwtSlider::changeEvent( QEvent *event )
+{
     if ( event->type() == QEvent::StyleChange ||
+    if ( event->type() == QEvent::StyleChange ||
         event->type() == QEvent::FontChange )
+    {
 …
     /*
        The marker line of the handle needs to be aligned to
        the scale. But the marker is in the center
+       the scale. But the marker is in the center
        and we need space enough to display the rest of the handle.
 …
+    {
         d_data->hasGroove = on;
         if ( testAttribute( Qt::WA_WState_Polished ) )
             layoutSlider( true );
 …
+{
     return d_data->hasGroove;
+}
+}
 /*!
 …
         bw = d_data->borderWidth;
     int sliderLength = 0;
+    int sliderLength = 0;
     int scaleExtent = 0;

trunk/BNC/qwt/qwt_slider.h

r8127	r9383
84	84	QSize handleSize() const;
85	85
86		void setBorderWidth( int bw );
	86	void setBorderWidth( int );
87	87	int borderWidth() const;
88	88

trunk/BNC/qwt/qwt_symbol.cpp

-              r8127
+              r9383
+}
 static QwtGraphic qwtPathGraphic( const QPainterPath &path,
+static QwtGraphic qwtPathGraphic( const QPainterPath &path,
     const QPen &pen, const QBrush& brush )
+{
 …
+}
 static inline QRectF qwtScaledBoundingRect(
+static inline QRectF qwtScaledBoundingRect(
     const QwtGraphic &graphic, const QSizeF size )
+{
 …
     if ( scaledSize.isEmpty() )
         scaledSize = graphic.defaultSize();
     const QSizeF sz = graphic.controlPointRect().size();
 …
     if ( sz.width() > 0.0 )
         sx = scaledSize.width() / sz.width();
     double sy = 1.0;
     if ( sz.height() > 0.0 )
 …
     if ( pm.size() != size )
         pm = pm.scaled( size );
     QPointF pinPoint( 0.5 * size.width(), 0.5 * size.height() );
     if ( symbol.isPinPointEnabled() )
 …
         const QPointF pos = transform.map( points[i] ) - pinPoint;
         QwtPainter::drawPixmap( painter,
+        QwtPainter::drawPixmap( painter,
             QRect( pos.toPoint(), pm.size() ), pm );
+    }
 …
 #ifndef QWT_NO_SVG
 static inline void qwtDrawSvgSymbols( QPainter *painter,
     const QPointF *points, int numPoints,
+static inline void qwtDrawSvgSymbols( QPainter *painter,
+    const QPointF *points, int numPoints,
     QSvgRenderer *renderer, const QwtSymbol &symbol )
+{
 …
         const double y = points[i].y() - dy;
         renderer->render( painter,
+        renderer->render( painter,
             QRectF( x, y, sz.width(), sz.height() ) );
+    }
 …
 #endif
 static inline void qwtDrawGraphicSymbols( QPainter *painter,
+static inline void qwtDrawGraphicSymbols( QPainter *painter,
     const QPointF *points, int numPoints, const QwtGraphic &graphic,
     const QwtSymbol &symbol )
 …
 */
 QwtSymbol::QwtSymbol( const QPainterPath &path,
+QwtSymbol::QwtSymbol( const QPainterPath &path,
     const QBrush &brush, const QPen &pen )
+{
 …
   \brief Set a painter path as symbol
   The symbol is represented by a painter path, where the
+  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.
 …
   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
+  \par Example
+    The following code defines a symbol drawing an arrow:
+    \code
+      #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 );
+    \endcode
+  \endpar
   \param path Painter path
 …
   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
+  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
 …
+                    {
                         if ( !d_data->size.isEmpty() &&
                             d_data->size != d_data->pixmap.pixmap.size() )
+                            d_data->size != d_data->pixmap.pixmap.size() )
+                        {
                             useCache = true;
+                        }
                         break;
+                    }
+                    }
                     default:
                         useCache = true;
 …
         const QRect br = boundingRect();
-        const QRect rect( 0, 0, br.width(), br.height() );
         if ( d_data->cache.pixmap.isNull() )
+        {
 …
   \param painter Painter
   \param rect Target rectangle for the symbol
+  \param rect Target rectangle for the symbol
 */
 void QwtSymbol::drawSymbol( QPainter *painter, const QRectF &rect ) const
 …
     if ( d_data->style == QwtSymbol::Graphic )
+    {
         d_data->graphic.graphic.render(
+        d_data->graphic.graphic.render(
             painter, rect, Qt::KeepAspectRatio );
+    }
 …
         if ( d_data->path.graphic.isNull() )
+        {
             d_data->path.graphic = qwtPathGraphic(
+            d_data->path.graphic = qwtPathGraphic(
                 d_data->path.path, d_data->pen, d_data->brush );
+        }
         d_data->path.graphic.render(
+        d_data->path.graphic.render(
             painter, rect, Qt::KeepAspectRatio );
         return;
 …
+            }
             d_data->svg.renderer->render(
+            d_data->svg.renderer->render(
                 painter, scaledRect );
+        }
 …
         // scale the symbol size to fit into rect.
         const double ratio = qMin( rect.width() / br.width(),
+        const double ratio = qMin( rect.width() / br.width(),
             rect.height() / br.height() );
 …
         const QPointF pos;
         renderSymbols( painter, &pos, 1 );
         d_data->isPinPointEnabled = isPinPointEnabled;
 …
             if ( d_data->path.graphic.isNull() )
+            {
                 d_data->path.graphic = qwtPathGraphic( d_data->path.path,
+                d_data->path.graphic = qwtPathGraphic( d_data->path.path,
                     d_data->pen, d_data->brush );
+            }
             qwtDrawGraphicSymbols( painter, points, numPoints,
+            qwtDrawGraphicSymbols( painter, points, numPoints,
                 d_data->path.graphic, *this );
             break;
 …
         case QwtSymbol::Graphic:
+        {
             qwtDrawGraphicSymbols( painter, points, numPoints,
+            qwtDrawGraphicSymbols( painter, points, numPoints,
                 d_data->graphic.graphic, *this );
             break;
 …
+        {
 #ifndef QWT_NO_SVG
             qwtDrawSvgSymbols( painter, points, numPoints,
+            qwtDrawSvgSymbols( painter, points, numPoints,
                 d_data->svg.renderer, *this );
 #endif
 …
+            }
             rect = qwtScaledBoundingRect(
+            rect = qwtScaledBoundingRect(
                 d_data->path.graphic, d_data->size );
             pinPointTranslation = true;
 …
             else
                 rect.setSize( d_data->size );
             pinPointTranslation = true;
 …
         case QwtSymbol::Graphic:
+        {
             rect = qwtScaledBoundingRect(
+            rect = qwtScaledBoundingRect(
                 d_data->graphic.graphic, d_data->size );
             pinPointTranslation = true;

trunk/BNC/qwt/qwt_symbol.h

-              r8127
+              r9383
         /*!
           The symbol is represented by a painter path, where the
+          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.
 …
       F.e. the raster paint engine is a pure software renderer
       where in cache mode a draw operation usually ends in
+      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.
 …
       \sa setCachePolicy(), cachePolicy()
       \note The policy has no effect, when the symbol is painted
+      \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
 …
         Cache,
         /*!
+        /*!
            Use a cache when one of the following conditions is true:
            - The symbol is rendered with the software
+           - The symbol is rendered with the software
              renderer ( QPaintEngine::Raster )
          */
 …
     void setSize( const QSize & );
     void setSize( int width, int height = -1 );
     const QSize& size() const;
+    const QSize &size() const;
     void setPinPoint( const QPointF &pos, bool enable = true );
 …
     virtual void setColor( const QColor & );
     void setBrush( const QBrush& b );
     const QBrush& brush() const;
+    void setBrush( const QBrush & );
+    const QBrush &brush() const;
     void setPen( const QColor &, qreal width = 0.0, Qt::PenStyle = Qt::SolidLine );
     void setPen( const QPen & );
     const QPen& pen() const;
+    const QPen &pen() const;
     void setStyle( Style );

trunk/BNC/qwt/qwt_system_clock.cpp

r8127	r9383
33	33	delete d_data;
34	34	}
35
	35
36	36	bool QwtSystemClock::isNull() const
37	37	{
38	38	return d_data->timer.isValid();
39	39	}
40
	40
41	41	void QwtSystemClock::start()
42	42	{
…	…
55	55	return nsecs / 1e6;
56	56	}
57
	57
58	58	#else // !USE_ELAPSED_TIMER
59	59
…	…
357	357
358	358	/*!
359		Set the start time to the current time
	359	Set the start time to the current time
360	360	\return Time, that is elapsed since the previous start time.
361	361	*/

trunk/BNC/qwt/qwt_system_clock.h

-              r8127
+              r9383
   Precision and time intervals are multiples of milliseconds (ms).
+  ( QwtSystemClock is obsolete since Qt 4.8 as QElapsedTimer offers the same
+    precision )
   \note The implementation uses high-resolution performance counter on Windows,
         mach_absolute_time() on the Mac or POSIX timers on other systems.
+        mach_absolute_time() on the Mac or POSIX timers on other systems.
         If none is available it falls back on QTimer.
 */

trunk/BNC/qwt/qwt_text.cpp

-              r8127
+              r9383
 QwtTextEngineDict::~QwtTextEngineDict()
+{
     for ( EngineMap::const_iterator it = d_map.begin();
         it != d_map.end(); ++it )
+    for ( EngineMap::const_iterator it = d_map.constBegin();
+        it != d_map.constEnd(); ++it )
+    {
         const QwtTextEngine *textEngine = engine( it );
 …
         return;
+    EngineMap::const_iterator it = d_map.find( format );
+    if ( it != d_map.end() )
+    {
+        const QwtTextEngine *e = this->engine( it );
+        if ( e )
+            delete e;
+    EngineMap::const_iterator it = d_map.constFind( format );
+    if ( it != d_map.constEnd() )
+    {
+        delete this->engine( it );
         d_map.remove( format );
+    }

trunk/BNC/qwt/qwt_text.h

-              r8127
+              r9383
           Use a MathML (http://en.wikipedia.org/wiki/MathML) render engine
           to display the text. The Qwt MathML extension offers such an engine
           based on the MathML renderer of the Qt solutions package.
+          based on the MathML renderer of the former Qt solutions package.
           To enable MathML support the following code needs to be added to the
           application:
+\verbatim QwtText::setTextEngine(QwtText::MathMLText, new QwtMathMLTextEngine()); \endverbatim
+          \code
+            QwtText::setTextEngine( QwtText::MathMLText, new QwtMathMLTextEngine() );
+          \endcode
          */
         MathMLText,
 …
     typedef QFlags<LayoutAttribute> LayoutAttributes;
     QwtText( const QString & = QString::null,
+    QwtText( const QString & = QString(),
              TextFormat textFormat = AutoText );
     QwtText( const QwtText & );
 …
     QFont usedFont( const QFont & ) const;
     void setRenderFlags( int flags );
+    void setRenderFlags( int );
     int renderFlags() const;
 …
     void draw( QPainter *painter, const QRectF &rect ) const;
     static const QwtTextEngine *textEngine(
+    static const QwtTextEngine *textEngine(
         const QString &text, QwtText::TextFormat = AutoText );

trunk/BNC/qwt/qwt_text_engine.cpp

-              r8127
+              r9383
         QMap<QString, int>::const_iterator it =
+            d_ascentCache.find( fontKey );
+        if ( it == d_ascentCache.end() )
+        {
+            int ascent = findAscent( font );
+            it = d_ascentCache.insert( fontKey, ascent );
+        }
+        return ( *it );
+            d_ascentCache.constFind( fontKey );
+        if ( it != d_ascentCache.constEnd() )
+            return *it;
+        const int ascent = findAscent( font );
+        d_ascentCache.insert( fontKey, ascent );
+        return ascent;
+    }
 …
         for ( row = 0; row < img.height(); row++ )
+        {
             const QRgb *line = reinterpret_cast<const QRgb *>(
+            const QRgb *line = reinterpret_cast<const QRgb *>(
                 img.scanLine( row ) );

trunk/BNC/qwt/qwt_text_engine.h

-              r8127
+              r9383
   QwtPlainTextEngine and QwtRichTextEngine are part of the Qwt library.
   The implementation of QwtMathMLTextEngine uses code from the
+  The implementation of QwtMathMLTextEngine uses code from the
   Qt solution package. Because of license implications it is built into
   a separate library.
   \sa QwtText::setTextEngine()
 */

trunk/BNC/qwt/qwt_text_label.cpp

r8127	r9383
90	90	\sa QwtText
91	91	*/
92		void QwtTextLabel::setText( const QString &text,
	92	void QwtTextLabel::setText( const QString &text,
93	93	QwtText::TextFormat textFormat )
94	94	{

trunk/BNC/qwt/qwt_text_label.h

r8127	r9383
64	64
65	65	protected:
66		virtual void paintEvent( QPaintEvent *e );
	66	virtual void paintEvent( QPaintEvent * );
67	67	virtual void drawContents( QPainter * );
68	68

trunk/BNC/qwt/qwt_thermo.cpp

-              r8127
+              r9383
 #include <qmath.h>
 static inline void qwtDrawLine( QPainter *painter, int pos,
+static inline void qwtDrawLine( QPainter *painter, int pos,
     const QColor &color, const QRect &pipeRect, const QRect &liquidRect,
     Qt::Orientation orientation )
 …
             if ( v > lowerLimit && v < upperLimit )
                 values += v;
+        }
+    }
+        }
+    }
     values += upperLimit;
     return values;
+}
 …
     const QBrush brush = palette().brush( QPalette::Base );
     qDrawShadePanel( &painter,
+    qDrawShadePanel( &painter,
         tRect.adjusted( -bw, -bw, bw, bw ),
         palette(), true, bw,
+        palette(), true, bw,
         d_data->autoFillPipe ? &brush : NULL );
 …
+}
 /*!
+/*!
   Resize event handler
   \param event Resize event
 …
+}
 /*!
+/*!
   Qt change event handler
   \param event Event
 …
         if ( d_data->scalePosition == QwtThermo::LeadingScale )
             pipeRect.setLeft( bw );
         else
+        else
             pipeRect.setLeft( cr.left() + cr.width() - bw - d_data->pipeWidth );
 …
    \param pipeRect Bounding rectangle of the pipe without borders
 */
 void QwtThermo::drawLiquid(
+void QwtThermo::drawLiquid(
     QPainter *painter, const QRect &pipeRect ) const
+{
 …
                 const double v = scaleMap.invTransform( pos );
                 qwtDrawLine( painter, pos,
+                qwtDrawLine( painter, pos,
                     d_data->colorMap->color( interval, v ),
                     pipeRect, liquidRect, d_data->orientation );
 …
 /*!
   \brief Change the brush of the liquid.
   Changes the QPalette::ButtonText brush of the palette.
   \param brush New brush.
+  \param brush New brush.
   \sa fillBrush(), QWidget::setPalette()
 */
 …
 /*!
   \return Liquid ( QPalette::ButtonText ) brush.
+  \return Liquid ( QPalette::ButtonText ) brush.
   \sa setFillBrush(), QWidget::palette()
 */
 …
   Changes the QPalette::Highlight brush of the palette.
   \param brush New brush.
+  \param brush New brush.
   \sa alarmBrush(), QWidget::setPalette()
 …
+}
 /*!
+/*!
   \return True, when the alarm threshold is enabled.
 …
 QRect QwtThermo::fillRect( const QRect &pipeRect ) const
+{
     double origin;
+    double origin;
     if ( d_data->originMode == OriginMinimum )
+    {
 …
     if ( to < from )
         qSwap( from, to );
     QRect fillRect = pipeRect;
     if ( d_data->orientation == Qt::Horizontal )
 …
     const bool inverted = ( upperBound() < lowerBound() );
     bool increasing;
     if ( d_data->originMode == OriginCustom )
 …
     const int alarmPos = qRound( map.transform( d_data->alarmLevel ) );
     const int valuePos = qRound( map.transform( d_data->value ) );
     if ( d_data->orientation == Qt::Horizontal )
+    {
 …
     return alarmRect;
+}
+}

trunk/BNC/qwt/qwt_thermo.h

-              r8127
+              r9383
   The fill colors might be calculated from an optional color map
   If no color map has been assigned QwtThermo uses the
+  If no color map has been assigned QwtThermo uses the
   following colors/brushes from the widget palette:
 …
     Q_PROPERTY( Qt::Orientation orientation
         READ orientation WRITE setOrientation )
     Q_PROPERTY( ScalePosition scalePosition
+    Q_PROPERTY( ScalePosition scalePosition
         READ scalePosition WRITE setScalePosition )
     Q_PROPERTY( OriginMode originMode READ originMode WRITE setOriginMode )
 …
     int spacing() const;
     void setBorderWidth( int w );
+    void setBorderWidth( int );
     int borderWidth() const;
 …
     double origin() const;
     void setFillBrush( const QBrush &b );
+    void setFillBrush( const QBrush & );
     QBrush fillBrush() const;
     void setAlarmBrush( const QBrush &b );
+    void setAlarmBrush( const QBrush & );
     QBrush alarmBrush() const;
     void setAlarmLevel( double v );
+    void setAlarmLevel( double );
     double alarmLevel() const;
     void setAlarmEnabled( bool tf );
+    void setAlarmEnabled( bool );
     bool alarmEnabled() const;
 …
     const QwtColorMap *colorMap() const;
     void setPipeWidth( int w );
+    void setPipeWidth( int );
     int pipeWidth() const;
 …
 public Q_SLOTS:
     virtual void setValue( double val );
+    virtual void setValue( double );
 protected:

trunk/BNC/qwt/qwt_transform.cpp

-              r8127
+              r9383
 //! Smallest allowed value for logarithmic scales: 1.0e-150
 const double QwtLogTransform::LogMin = 1.0e-150;
 //! Largest allowed value for logarithmic scales: 1.0e150
 const double QwtLogTransform::LogMax = 1.0e150;
 …
+}
 /*!
+/*!
   \param value Value to be bounded
   \return value unmodified
 …
+}
 /*!
+/*!
   \param value Value to be transformed
   \return value unmodified
 …
+}
 /*!
+/*!
   \param value Value to be transformed
   \return value unmodified
 …
+}
 /*!
+/*!
   \param value Value to be transformed
   \return log( value )
 …
+}
 /*!
+/*!
   \param value Value to be transformed
   \return exp( value )
 …
+}
 /*!
+/*!
   \param value Value to be bounded
   \return qBound( LogMin, value, LogMax )
 …
+}
 /*!
+/*!
   \param value Value to be transformed
   \return Exponentiation preserving the sign
 …
     else
         return qPow( value, 1.0 / d_exponent );
+}
 /*!
+/*!
   \param value Value to be transformed
   \return Inverse exponentiation preserving the sign

trunk/BNC/qwt/qwt_transform.h

-              r8127
+              r9383
    QwtNullTransform returns the values unmodified.
  */
 class QWT_EXPORT QwtNullTransform: public QwtTransform
 …
    \note In the calculations of QwtScaleMap the base of the log function
          has no effect on the mapping. So QwtLogTransform can be used
+         has no effect on the mapping. So QwtLogTransform can be used
          for log2(), log10() or any other logarithmic scale.
  */
 class QWT_EXPORT QwtLogTransform: public QwtTransform
+{
+{
 public:
     QwtLogTransform();
     virtual ~QwtLogTransform();
     virtual double transform( double value ) const;
     virtual double invTransform( double value ) const;
 …
    \brief A transformation using pow()
    QwtPowerTransform preserves the sign of a value.
+   QwtPowerTransform preserves the sign of a value.
    F.e. a transformation with a factor of 2
    transforms a value of -3 to -9 and v.v. Thus QwtPowerTransform

trunk/BNC/qwt/qwt_wheel.cpp

-              r8127
+              r9383
         wrapping( false )
+    {
     };
+    }
     Qt::Orientation orientation;
 …
   \brief En/Disable tracking
   If tracking is enabled (the default), the wheel emits the valueChanged()
   signal while the wheel is moving. If tracking is disabled, the wheel
+  If tracking is enabled (the default), the wheel emits the valueChanged()
+  signal while the wheel is moving. If tracking is disabled, the wheel
   emits the valueChanged() signal only when the wheel movement is terminated.
 …
    \brief Mouse press event handler
    Start movement of the wheel.
+   Start movement of the wheel.
    \param event Mouse event
 …
         d_data->speed = ( mouseValue - d_data->mouseValue ) / ms;
+    }
     d_data->mouseValue = mouseValue;
+    d_data->mouseValue = mouseValue;
     double value = boundedValue( mouseValue - d_data->mouseOffset );
     if ( d_data->stepAlignment )
         value = alignedValue( value );
     if ( value != d_data->value )
+    {
 …
    \param event Mouse event
 */
+*/
 void QwtWheel::mouseReleaseEvent( QMouseEvent *event )
 …
     if ( startFlying )
+    {
         d_data->flyingValue =
+        d_data->flyingValue =
             boundedValue( d_data->mouseValue - d_data->mouseOffset );
 …
   The flying wheel effect is implemented using a timer
   \param event Timer event
 …
   \brief Handle wheel events
   In/Decrement the value
+  In/Decrement the value
   \param event Wheel event
 …
     double increment = 0.0;
     if ( ( event->modifiers() & Qt::ControlModifier) ||
+    if ( ( event->modifiers() & Qt::ControlModifier) ||
         ( event->modifiers() & Qt::ShiftModifier ) )
+    {
 …
   - Qt::Key_Up\n
     In case of a horizontal or not inverted vertical wheel the value
+    In case of a horizontal or not inverted vertical wheel the value
     will be incremented by the step size. For an inverted vertical wheel
     the value will be decremented by the step size.
   - Qt::Key_Down\n
     In case of a horizontal or not inverted vertical wheel the value
+    In case of a horizontal or not inverted vertical wheel the value
     will be decremented by the step size. For an inverted vertical wheel
     the value will be incremented by the step size.
 …
     if ( event->isAccepted() )
         stopFlying();
     if ( increment != 0.0 )
+    {
 …
 /*!
    \return Wheel border width
+   \return Wheel border width
    \sa setWheelBorderWidth()
 */
 …
 /*!
   \brief Set the border width
+  \brief Set the border width
   The border defaults to 2.
 …
 /*!
    \return Border width
+   \return Border width
    \sa setBorderWidth()
 */
 …
+}
 /*!
+/*!
   Determine the value corresponding to a specified point
 …
+}
 /*!
+/*!
    \brief Qt Paint Event
    \param event Paint event
 …
     style()->drawPrimitive(QStyle::PE_Widget, &opt, &painter, this);
     qDrawShadePanel( &painter,
+    qDrawShadePanel( &painter,
         contentsRect(), palette(), true, d_data->borderWidth );
 …
    \param rect Geometry for the wheel
 */
 void QwtWheel::drawWheelBackground(
+void QwtWheel::drawWheelBackground(
     QPainter *painter, const QRectF &rect )
+{
 …
     //  draw shaded background
     QLinearGradient gradient( rect.topLeft(),
+    QLinearGradient gradient( rect.topLeft(),
         ( d_data->orientation == Qt::Horizontal ) ? rect.topRight() : rect.bottomLeft() );
     gradient.setColorAt( 0.0, pal.color( QPalette::Button ) );
 …
     // draw internal border
     const QPen lightPen( palette().color( QPalette::Light ),
+    const QPen lightPen( palette().color( QPalette::Light ),
         d_data->wheelBorderWidth, Qt::SolidLine, Qt::FlatCap );
     const QPen darkPen( pal.color( QPalette::Dark ),
+    const QPen darkPen( pal.color( QPalette::Dark ),
         d_data->wheelBorderWidth, Qt::SolidLine, Qt::FlatCap );
 …
+    {
         painter->setPen( lightPen );
         painter->drawLine( QPointF( rect.left(), rect.top() + bw2 ),
+        painter->drawLine( QPointF( rect.left(), rect.top() + bw2 ),
             QPointF( rect.right(), rect.top() + bw2 ) );
         painter->setPen( darkPen );
         painter->drawLine( QPointF( rect.left(), rect.bottom() - bw2 ),
+        painter->drawLine( QPointF( rect.left(), rect.bottom() - bw2 ),
             QPointF( rect.right(), rect.bottom() - bw2 ) );
+    }
 …
+    {
         painter->setPen( lightPen );
         painter->drawLine( QPointF( rect.left() + bw2, rect.top() ),
+        painter->drawLine( QPointF( rect.left() + bw2, rect.top() ),
             QPointF( rect.left() + bw2, rect.bottom() ) );
         painter->setPen( darkPen );
         painter->drawLine( QPointF( rect.right() - bw2, rect.top() ),
+        painter->drawLine( QPointF( rect.right() - bw2, rect.top() ),
             QPointF( rect.right() - bw2, rect.bottom() ) );
+    }
 …
+    }
     const QPen lightPen( palette().color( QPalette::Light ),
+    const QPen lightPen( palette().color( QPalette::Light ),
 , Qt::SolidLine, Qt::FlatCap );
     const QPen darkPen( palette().color( QPalette::Dark ),
+    const QPen darkPen( palette().color( QPalette::Dark ),
 , Qt::SolidLine, Qt::FlatCap );
 …
             double tickPos;
             if ( d_data->inverted )
+            if ( d_data->inverted )
                 tickPos = rect.left() + off;
             else
 …
+            {
                 painter->setPen( darkPen );
                 painter->drawLine( QPointF( tickPos - 1 , l1 ),
+                painter->drawLine( QPointF( tickPos - 1 , l1 ),
                     QPointF( tickPos - 1,  l2 ) );
                 painter->setPen( lightPen );
                 painter->drawLine( QPointF( tickPos, l1 ),
+                painter->drawLine( QPointF( tickPos, l1 ),
                     QPointF( tickPos, l2 ) );
+            }
 …
+            {
                 painter->setPen( darkPen );
                 painter->drawLine( QPointF( l1, tickPos - 1 ),
+                painter->drawLine( QPointF( l1, tickPos - 1 ),
                     QPointF( l2, tickPos - 1 ) );
                 painter->setPen( lightPen );
                 painter->drawLine( QPointF( l1, tickPos ),
+                painter->drawLine( QPointF( l1, tickPos ),
                     QPointF( l2, tickPos ) );
+            }
 …
 /*!
   \brief Set the page step count
+  \brief Set the page step count
   pageStepCount is a multiplicator for the single step size
   that typically corresponds to the user pressing PageUp or PageDown.
   A value of 0 disables page stepping.
+  A value of 0 disables page stepping.
   The default value is 1.
 …
+}
 /*!
+/*!
   \return Page step count
   \sa setPageStepCount(), singleStep()
 …
   The direction of an inverted horizontal wheel will be from right to left
   an inverted vertical wheel will increase from bottom to top.
   \param on En/Disable inverted appearance
   \sa isInverted()
  */
 void QwtWheel::setInverted( bool on )
 …
   \brief En/Disable wrapping
   If wrapping is true stepping up from maximum() value will take
   you to the minimum() value and vice versa.
+  If wrapping is true stepping up from maximum() value will take
+  you to the minimum() value and vice versa.
   \param on En/Disable wrapping
 …
+{
     const double range = d_data->maximum - d_data->minimum;
     if ( d_data->wrapping && range >= 0.0 )
+    {
 …
+        {
             value += ::ceil( ( d_data->minimum - value ) / range ) * range;
+        }
+        }
         else if ( value > d_data->maximum )
+        {
 …
+            }
+        }
+    }
+    }
     return value;

trunk/BNC/qwt/qwt_wheel.h

-              r8127
+              r9383
     int borderWidth() const;
     void setInverted( bool tf );
+    void setInverted( bool );
     bool isInverted() const;
     void setWrapping( bool tf );
+    void setWrapping( bool );
     bool wrapping() const;
 …
     bool stepAlignment() const;
     void setRange( double vmin, double vmax );
+    void setRange( double min, double max );
     void setMinimum( double min );
+    void setMinimum( double );
     double minimum() const;
     void setMaximum( double max );
+    void setMaximum( double );
     double maximum() const;
 …
     int updateInterval() const;
     void setTracking( bool enable );
+    void setTracking( bool );
     bool isTracking() const;
 …
       When tracking is enabled this signal will be emitted every
       time the value changes.
+      time the value changes.
       \param value new value

trunk/BNC/qwt/qwt_widget_overlay.cpp

-              r8127
+              r9383
 #include <qpainter.h>
 #include <qpaintengine.h>
+#include <qpainterpath.h>
 #include <qimage.h>
 #include <qevent.h>
 …
+}
 static QRegion qwtAlphaMask(
     const QImage& image, const QVector<QRect> rects )
+static QRegion qwtAlphaMask(
+    const QImage& image, const QVector<QRect> &rects )
+{
     const int w = image.width();
 …
         y2 = qMin( y2, h - 1 );
         for ( int y = y1; y <= y2; ++y )
+        for ( int y = y1; y <= y2; ++y )
+        {
             bool inRect = false;
             int rx0 = -1;
             const uint *line =
+            const uint *line =
                 reinterpret_cast<const uint *> ( image.scanLine( y ) ) + x1;
             for ( int x = x1; x <= x2; x++ )
+            for ( int x = x1; x <= x2; x++ )
+            {
                 const bool on = ( ( *line++ >> 24 ) != 0 );
                 if ( on != inRect )
+                if ( on != inRect )
+                {
                     if ( inRect  )
+                    if ( inRect  )
+                    {
                         rect.setCoords( rx0, y, x - 1, y );
                         region += rect;
+                    }
                     else
+                    }
+                    else
+                    {
                         rx0 = x;
 …
                     inRect = on;
+                }
+                }
+            }
             if ( inRect )
+            if ( inRect )
+            {
                 rect.setCoords( rx0, y, x2, y );
 …
         d_data->rgbaBuffer = ( uchar* )::calloc( width() * height(), 4 );
         QImage image( d_data->rgbaBuffer,
+        QImage image( d_data->rgbaBuffer,
             width(), height(), qwtMaskImageFormat() );
 …
 void QwtWidgetOverlay::paintEvent( QPaintEvent* event )
+{
     const QRegion clipRegion = event->region();
+    const QRegion &clipRegion = event->region();
     QPainter painter( this );
 …
     if ( d_data->rgbaBuffer && useRgbaBuffer )
+    {
         const QImage image( d_data->rgbaBuffer,
+        const QImage image( d_data->rgbaBuffer,
             width(), height(), qwtMaskImageFormat() );

trunk/BNC/qwt/qwt_widget_overlay.h

-              r8127
+              r9383
    heavy repaint operation of the widget below.
    F.e. in combination with the plot canvas an overlay
    avoid replots as the content of the canvas can be restored from
+   F.e. in combination with the plot canvas an overlay
+   avoid replots as the content of the canvas can be restored from
    its backing store.
 …
    - maskHint()
    Internally QwtPlotPicker uses overlays for displaying
+   Internally QwtPlotPicker uses overlays for displaying
    the rubber band and the tracker text.
 …
        the masked regions of the overlay only. Otherwise
        Qt triggers full repaints. On less powerful hardware
        ( f.e embedded systems ) - or when using the raster paint
+       ( f.e embedded systems ) - or when using the raster paint
        engine on a remote desktop - bit blitting is a noticeable
        operation, that needs to be avoided.
        If and how to mask depends on how expensive the calculation
+       If and how to mask depends on how expensive the calculation
        of the mask is and how many pixels can be excluded by the mask.
 …
            \brief Use maskHint() as mask
            For many situations a fast approximation is good enough
+           For many situations a fast approximation is good enough
            and it is not necessary to build a more detailed mask
            ( f.e the bounding rectangle of a text ).
 …
            and the mask needs to be calculated by drawing the overlay
            and testing the result.
            When a valid maskHint() is available
            only pixels inside this approximation are checked.

trunk/BNC/qwt/src.pri

-              r8127
+              r9383
         qwt_series_data.cpp \
         qwt_point_data.cpp \
+        qwt_scale_widget.cpp
+        qwt_scale_widget.cpp
+    contains(QWT_CONFIG, QwtOpenGL) {
+        HEADERS += \
+            qwt_plot_glcanvas.h
+        SOURCES += \
+            qwt_plot_glcanvas.cpp
+    }
+    contains(QWT_CONFIG, QwtSvg) {
+        HEADERS += \
+            qwt_plot_svgitem.h
+        SOURCES += \
+            qwt_plot_svgitem.cpp
+    }
+}
 …
 contains(QWT_CONFIG, QwtSvg) {
+    QT += svg
+    HEADERS += qwt_plot_svgitem.h
+    SOURCES += qwt_plot_svgitem.cpp
+    greaterThan(QT_MAJOR_VERSION, 4) {
+        qtHaveModule(svg) {
+            QT += svg
+        }
+        else {
+            warning("QwtSvg is enabled in qwtconfig.pri, but Qt has not been built with svg support")
+        }
+    }
+    else {
+        QT += svg
+    }
+}
 else {
 …
     QT += opengl
-    HEADERS += qwt_plot_glcanvas.h
-    SOURCES += qwt_plot_glcanvas.cpp
+}
 else {

trunk/BNC/qwtpolar/qwt_polar_canvas.cpp

-              r8127
+              r9383
                     QWidget *bgWidget = qwtBackgroundWidget( plot() );
                                         QwtPainter::fillPixmap( bgWidget, bs,
                                                 mapTo( bgWidget, rect().topLeft() ) );
+                    QwtPainter::fillPixmap( bgWidget, bs,
+                        mapTo( bgWidget, rect().topLeft() ) );
                     p.begin( &bs );

Context Navigation

Changeset 9383 in ntrip for trunk/BNC

Legend: