QwtPolar: headers diff between 0.1.0 and 1.0.0 versions

	qwt_polar.h	qwt_polar.h

	skipping to change at line 16	skipping to change at line 16
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_H	#ifndef QWT_POLAR_H
	#define QWT_POLAR_H 1	#define QWT_POLAR_H 1

	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	namespace QwtPolar	namespace QwtPolar
	{	{

	/*!	//! Unit of an angle
	An enum, that identifies the type of a coordinate	enum AngleUnit
		{
		//! 0.0 -> 2_M_PI
		Radians,


	- Azimuth\n	//! 0.0 -> 360.0
	- Radius\n	Degrees,
	*/
		//! 0.0 - 400.0
		Gradians,

		//! 0.0 - 1.0
		Turns
		};

		//! An enum, that identifies the type of a coordinate
	enum Coordinate	enum Coordinate
	{	{

		//! Azimuth
	Azimuth,	Azimuth,


		//! Radius
	Radius	Radius
	};	};

	/*!	/*!
	Indices used to identify an axis.	Indices used to identify an axis.


	- AxisAzimuth\n
	- AxisLeft\n
	- AxisRight\n
	- AxisTop\n
	- AxisBottom\n
	- AxesCount\n

	\sa Scale	\sa Scale
	*/	*/
	enum Axis	enum Axis
	{	{

		//! Azimuth axis
	AxisAzimuth,	AxisAzimuth,


		//! Left axis
	AxisLeft,	AxisLeft,


		//! Right axis
	AxisRight,	AxisRight,


		//! Top axis
	AxisTop,	AxisTop,


		//! Bottom axis
	AxisBottom,	AxisBottom,


		//! Number of available axis
	AxesCount	AxesCount
	};	};

	/*!	/*!
	Indices used to identify a scale.	Indices used to identify a scale.


	- ScaleAzimuth\n
	- ScaleRadius\n

	\sa Axis	\sa Axis
	*/	*/
	enum Scale	enum Scale
	{	{

		//! Azimuth scale
	ScaleAzimuth = Azimuth,	ScaleAzimuth = Azimuth,


		//! Radial scale
	ScaleRadius = Radius,	ScaleRadius = Radius,


		//! Number of scales
	ScaleCount	ScaleCount
	};	};

		}
	};

	#endif	#endif

End of changes. 16 change blocks.
	19 lines changed or deleted	33 lines changed or added

	qwt_polar_canvas.h	qwt_polar_canvas.h

	skipping to change at line 12	skipping to change at line 12
	* QwtPolar Widget Library	* QwtPolar Widget Library
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_CANVAS_H	#ifndef QWT_POLAR_CANVAS_H
	#define QWT_POLAR_CANVAS_H 1	#define QWT_POLAR_CANVAS_H 1


	#include <qframe.h>
	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	#include "qwt_double_rect.h"	#include <qwt_point_polar.h>
		#include <qframe.h>

	class QPainter;	class QPainter;
	class QwtPolarPlot;	class QwtPolarPlot;

	/*!	/*!
	\brief Canvas of a QwtPolarPlot.	\brief Canvas of a QwtPolarPlot.

	The canvas is the widget, where all polar items are painted to.	The canvas is the widget, where all polar items are painted to.

	\note In opposite to QwtPlot all axes are painted on the canvas.	\note In opposite to QwtPlot all axes are painted on the canvas.
	\sa QwtPolarPlot	\sa QwtPolarPlot
	*/	*/
	class QWT_POLAR_EXPORT QwtPolarCanvas: public QFrame	class QWT_POLAR_EXPORT QwtPolarCanvas: public QFrame
	{	{
	Q_OBJECT	Q_OBJECT

	public:	public:
	/*!	/*!
	\brief Paint attributes	\brief Paint attributes


	- PaintCached\n	The default setting enables BackingStore
	Paint double buffered and reuse the content of the pixmap buffer
	for some spontaneous repaints that happen when a plot gets unhidden
	,
	deiconified or changes the focus.


	The default setting enables PaintCached	\sa setPaintAttribute(), testPaintAttribute(), backingStore()
	\sa setPaintAttribute(), testPaintAttribute(), paintCache()
	*/	*/

	enum PaintAttribute	enum PaintAttribute
	{	{

	PaintCached = 1	/*!
		Paint double buffered and reuse the content of the pixmap buffer
		for some spontaneous repaints that happen when a plot gets unhidd
		en,
		deiconified or changes the focus.
		*/
		BackingStore = 0x01
	};	};


	explicit QwtPolarCanvas(QwtPolarPlot *);	//! Paint attributes
		typedef QFlags<PaintAttribute> PaintAttributes;

		explicit QwtPolarCanvas( QwtPolarPlot * );
	virtual ~QwtPolarCanvas();	virtual ~QwtPolarCanvas();

	QwtPolarPlot *plot();	QwtPolarPlot *plot();
	const QwtPolarPlot *plot() const;	const QwtPolarPlot *plot() const;


	void setPaintAttribute(PaintAttribute, bool on = true);	void setPaintAttribute( PaintAttribute, bool on = true );
	bool testPaintAttribute(PaintAttribute) const;	bool testPaintAttribute( PaintAttribute ) const;


	QPixmap *paintCache();	const QPixmap *backingStore() const;
	const QPixmap *paintCache() const;	void invalidateBackingStore();
	void invalidatePaintCache();


	protected:	QwtPointPolar invTransform( const QPoint & ) const;
	virtual void paintEvent(QPaintEvent *);	QPoint transform( const QwtPointPolar & ) const;
	virtual void resizeEvent(QResizeEvent *);


	virtual void drawContents(QPainter *);	protected:
		virtual void paintEvent( QPaintEvent * );
	void drawCanvas(QPainter *, const QwtDoubleRect &);	virtual void resizeEvent( QResizeEvent * );


		private:
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};


		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarCanvas::PaintAttributes )

	#endif	#endif

End of changes. 12 change blocks.
	22 lines changed or deleted	27 lines changed or added

	qwt_polar_curve.h	qwt_polar_curve.h

	skipping to change at line 13	skipping to change at line 13
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_CURVE_H	#ifndef QWT_POLAR_CURVE_H
	#define QWT_POLAR_CURVE_H	#define QWT_POLAR_CURVE_H

	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	#include "qwt_data.h"
	#include "qwt_polar_point.h"
	#include "qwt_polar_item.h"	#include "qwt_polar_item.h"

		#include <qwt_point_polar.h>
		#include <qwt_series_data.h>

	class QPainter;	class QPainter;
	class QwtSymbol;	class QwtSymbol;
	class QwtCurveFitter;	class QwtCurveFitter;

	/*!	/*!
	\brief An item, that represents a series of points	\brief An item, that represents a series of points

	A curve is the representation of a series of points in polar coordinates.	A curve is the representation of a series of points in polar coordinates.
	The points are connected to the curve using the abstract QwtData interfac e.	The points are connected to the curve using the abstract QwtData interfac e.

	\sa QwtPolarPlot, QwtSymbol, QwtScaleMap	\sa QwtPolarPlot, QwtSymbol, QwtScaleMap
	*/	*/

	class QWT_POLAR_EXPORT QwtPolarCurve: public QwtPolarItem	class QWT_POLAR_EXPORT QwtPolarCurve: public QwtPolarItem
	{	{
	public:	public:
	/*!	/*!
	Curve styles.	Curve styles.

		\sa setStyle(), style()
	- NoCurve\n
	Don't draw a curve. Note: This doesn't affect the symbols.
	- Lines\n
	Connect the points with straight lines. The lines might
	be interpolated depending on the 'Fitted' attribute. Curve
	fitting can be configured using setCurveFitter().

	\sa setStyle()
	*/	*/
	enum CurveStyle	enum CurveStyle
	{	{

		//! Don't draw a curve. Note: This doesn't affect the symbols.
	NoCurve,	NoCurve,


		/*!
		Connect the points with straight lines. The lines might
		be interpolated depending on the 'Fitted' attribute. Curve
		fitting can be configured using setCurveFitter().
		*/
	Lines,	Lines,


		//! Values > 100 are reserved for user specific curve styles
	UserCurve = 100	UserCurve = 100
	};	};


		/*!
		\brief Attributes how to represent the curve on the legend

		If none of the flags is activated QwtPlotCurve tries to find
		a color representing the curve and paints a rectangle with it.
		In the default setting all attributes are off.

		\sa setLegendAttribute(), testLegendAttribute(),
		drawLegendIdentifier()
		*/

		enum LegendAttribute
		{
		/*!
		If the curveStyle() is not NoCurve a line is painted with the
		curvePen().
		*/
		LegendShowLine = 0x01,

		//! If the curve has a valid symbol it is painted.
		LegendShowSymbol = 0x02
		};

		//! Legend attributes
		typedef QFlags<LegendAttribute> LegendAttributes;

	explicit QwtPolarCurve();	explicit QwtPolarCurve();

	explicit QwtPolarCurve(const QwtText &title);	explicit QwtPolarCurve( const QwtText &title );
	explicit QwtPolarCurve(const QString &title);	explicit QwtPolarCurve( const QString &title );

	virtual ~QwtPolarCurve();	virtual ~QwtPolarCurve();

	virtual int rtti() const;	virtual int rtti() const;


	void setData(const QwtData &data);	void setLegendAttribute( LegendAttribute, bool on = true );
	QwtData &data();	bool testLegendAttribute( LegendAttribute ) const;
	const QwtData &data() const;

	int dataSize() const;
	double radius(int i) const;
	double azimuth(int i) const;
	QwtPolarPoint sample(int i) const;


	void setPen(const QPen &);	void setData( QwtSeriesData<QwtPointPolar> *data );
		const QwtSeriesData<QwtPointPolar> *data() const;

		size_t dataSize() const;
		QwtPointPolar sample( int i ) const;

		void setPen( const QPen & );
	const QPen &pen() const;	const QPen &pen() const;


	void setStyle(CurveStyle style);	void setStyle( CurveStyle style );
	CurveStyle style() const;	CurveStyle style() const;


	void setSymbol(const QwtSymbol &s);	void setSymbol( const QwtSymbol * );
	const QwtSymbol& symbol() const;	const QwtSymbol *symbol() const;


	void setCurveFitter(QwtCurveFitter *);	void setCurveFitter( QwtCurveFitter * );
	QwtCurveFitter *curveFitter() const;	QwtCurveFitter *curveFitter() const;


	virtual void draw(QPainter *p,	virtual void draw( QPainter *p,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtDoubleRect &canvasRect) const;	const QRectF &canvasRect ) const;


	virtual void draw(QPainter *p,	virtual void draw( QPainter *p,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole,	const QPointF &pole, int from, int to ) const;
	int from, int to) const;


	virtual void updateLegend(QwtLegend *) const;	virtual void updateLegend( QwtLegend * ) const;
	virtual QwtDoubleInterval boundingInterval(int scaleId) const;	virtual QwtInterval boundingInterval( int scaleId ) const;

		virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const;

	protected:	protected:

	void init();	void init();


	virtual void drawCurve(QPainter *, int style,	virtual void drawCurve( QPainter *, int style,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole,	const QPointF &pole, int from, int to ) const;
	int from, int to) const;


	virtual void drawSymbols(QPainter *, const QwtSymbol &,	virtual void drawSymbols( QPainter *, const QwtSymbol &,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole,	const QPointF &pole, int from, int to ) const;
	int from, int to) const;


	void drawLines(QPainter *,	void drawLines( QPainter *,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole,	const QPointF &pole, int from, int to ) const;
	int from, int to) const;

	private:	private:

	QwtData *d_points;	QwtSeriesData<QwtPointPolar> *d_series;

	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};

	//! \return the the curve data	//! \return the the curve data

	inline QwtData &QwtPolarCurve::data()	inline const QwtSeriesData<QwtPointPolar> *QwtPolarCurve::data() const
	{	{

	return *d_points;	return d_series;
	}

	//! \return the the curve data
	inline const QwtData &QwtPolarCurve::data() const
	{
	return *d_points;
	}

	/*!
	\param i index
	\return azimuth at position i
	*/
	inline double QwtPolarCurve::azimuth(int i) const
	{
	return d_points->x(i);
	}

	/*!
	\param i index
	\return radius at position i
	*/
	inline double QwtPolarCurve::radius(int i) const
	{
	return d_points->y(i);
	}	}

	/*!	/*!
	\param i index	\param i index
	\return point at position i	\return point at position i
	*/	*/

	inline QwtPolarPoint QwtPolarCurve::sample(int i) const	inline QwtPointPolar QwtPolarCurve::sample( int i ) const
	{	{

	return QwtPolarPoint(azimuth(i), radius(i));	return d_series->sample( i );
	}	}


		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarCurve::LegendAttributes )

	#endif	#endif

End of changes. 30 change blocks.
	72 lines changed or deleted	75 lines changed or added

	qwt_polar_fitter.h	qwt_polar_fitter.h

	skipping to change at line 13	skipping to change at line 13
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_FITTER_H	#ifndef QWT_POLAR_FITTER_H
	#define QWT_POLAR_FITTER_H	#define QWT_POLAR_FITTER_H

	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	#include "qwt_curve_fitter.h"	#include <qwt_curve_fitter.h>

	/*!	/*!
	\brief A simple curve fitter for polar points	\brief A simple curve fitter for polar points

	QwtPolarFitter adds equidistant points between 2 curve points,	QwtPolarFitter adds equidistant points between 2 curve points,
	so that the connection gets rounded according to the nature of	so that the connection gets rounded according to the nature of
	a polar plot.	a polar plot.

	\sa QwtPolarCurve::setCurveFitter()	\sa QwtPolarCurve::setCurveFitter()
	*/	*/
	class QWT_POLAR_EXPORT QwtPolarFitter: public QwtCurveFitter	class QWT_POLAR_EXPORT QwtPolarFitter: public QwtCurveFitter
	{	{
	public:	public:

	QwtPolarFitter(int stepCount = 5);	QwtPolarFitter( int stepCount = 5 );
	virtual ~QwtPolarFitter();	virtual ~QwtPolarFitter();


	void setStepCount(int size);	void setStepCount( int size );
	int stepCount() const;	int stepCount() const;


	#if QT_VERSION < 0x040000	virtual QPolygonF fitCurve( const QPolygonF & ) const;
	virtual QwtArray<QwtDoublePoint> fitCurve(
	const QwtArray<QwtDoublePoint> &) const;
	#else
	virtual QPolygonF fitCurve(const QPolygonF &) const;
	#endif

	private:	private:
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};

	#endif	#endif

End of changes. 4 change blocks.
	9 lines changed or deleted	4 lines changed or added

	qwt_polar_global.h	qwt_polar_global.h

	skipping to change at line 13	skipping to change at line 13
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_GLOBAL_H	#ifndef QWT_POLAR_GLOBAL_H
	#define QWT_POLAR_GLOBAL_H	#define QWT_POLAR_GLOBAL_H

	#include <qglobal.h>	#include <qglobal.h>

	#if QT_VERSION < 0x040000
	#include <qmodules.h>
	#endif

	// QWT_POLAR_VERSION is (major << 16) + (minor << 8) + patch.	// QWT_POLAR_VERSION is (major << 16) + (minor << 8) + patch.


	#define QWT_POLAR_VERSION 0x000100	#define QWT_POLAR_VERSION 0x010000
	#define QWT_POLAR_VERSION_STR "0.1.0"	#define QWT_POLAR_VERSION_STR "1.0.0"


	#if defined(Q_WS_WIN)	#if defined(Q_WS_WIN) \|\| defined(Q_WS_S60)

	#if defined(_MSC_VER) /* MSVC Compiler */	#if defined(_MSC_VER) /* MSVC Compiler */
	/* template-class specialization 'identifier' is already instantiated */	/* template-class specialization 'identifier' is already instantiated */
	#pragma warning(disable: 4660)	#pragma warning(disable: 4660)
	#endif // _MSC_VER	#endif // _MSC_VER

	#ifdef QWT_POLAR_DLL	#ifdef QWT_POLAR_DLL

	#if defined(QWT_POLAR_MAKEDLL) // create a Qwt DLL library	#if defined(QWT_POLAR_MAKEDLL) // create a Qwt DLL library
	#define QWT_POLAR_EXPORT __declspec(dllexport)	#define QWT_POLAR_EXPORT __declspec(dllexport)

End of changes. 3 change blocks.
	6 lines changed or deleted	3 lines changed or added

	qwt_polar_grid.h	qwt_polar_grid.h

	skipping to change at line 16	skipping to change at line 16
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_GRID_H	#ifndef QWT_POLAR_GRID_H
	#define QWT_POLAR_GRID_H	#define QWT_POLAR_GRID_H

	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"
	#include "qwt_polar.h"	#include "qwt_polar.h"
	#include "qwt_polar_item.h"	#include "qwt_polar_item.h"
	#include "qwt_polar_plot.h"	#include "qwt_polar_plot.h"

	#include "qwt_scale_div.h"

	class QPainter;	class QPainter;
	class QPen;	class QPen;
	class QwtScaleMap;	class QwtScaleMap;
	class QwtScaleDiv;	class QwtScaleDiv;
	class QwtRoundScaleDraw;	class QwtRoundScaleDraw;
	class QwtScaleDraw;	class QwtScaleDraw;

	/*!	/*!
	\brief An item which draws scales and grid lines on a polar plot.	\brief An item which draws scales and grid lines on a polar plot.

	skipping to change at line 49	skipping to change at line 48
	\sa QwtPolarPlot, QwtPolar::Axis	\sa QwtPolarPlot, QwtPolar::Axis
	*/	*/

	class QWT_POLAR_EXPORT QwtPolarGrid: public QwtPolarItem	class QWT_POLAR_EXPORT QwtPolarGrid: public QwtPolarItem
	{	{
	public:	public:
	/*!	/*!
	Mysterious flags trying to avoid conflicts, when painting the	Mysterious flags trying to avoid conflicts, when painting the
	scales and grid lines.	scales and grid lines.


	- SmartOriginLabel\n	The default setting enables all flags.
	Try to avoid situations, where the label of the origin is
	painted over another axis.	\sa setDisplayFlag(), testDisplayFlag()
	- HideMaxRadiusLabel\n	*/
		enum DisplayFlag
		{
		/*!
		Try to avoid situations, where the label of the origin is
		painted over another axis.
		*/
		SmartOriginLabel = 1,

		/*!
	Often the outermost tick of the radial scale is close to the	Often the outermost tick of the radial scale is close to the
	canvas border. With HideMaxRadiusLabel enabled it is not painted.	canvas border. With HideMaxRadiusLabel enabled it is not painted.

	- ClipAxisBackground\n	*/
		HideMaxRadiusLabel = 2,

		/*!
	The tick labels of the radial scales might be hard to read, when	The tick labels of the radial scales might be hard to read, when
	they are painted on top of the radial grid lines ( or on top	they are painted on top of the radial grid lines ( or on top
	of a curve/spectrogram ). When ClipAxisBackground the bounding rect	of a curve/spectrogram ). When ClipAxisBackground the bounding rect
	of each label is added to the clip region.	of each label is added to the clip region.

	- SmartScaleDraw\n	*/
		ClipAxisBackground = 4,

		/*!
	Don't paint the backbone of the radial axes, when they are very clo se	Don't paint the backbone of the radial axes, when they are very clo se
	to a line of the azimuth grid.	to a line of the azimuth grid.

	- ClipGridLines\n	*/
		SmartScaleDraw = 8,

		/*!
	All grid lines are clipped against the plot area before being paint ed.	All grid lines are clipped against the plot area before being paint ed.
	When the plot is zoomed in this will have an significant impact	When the plot is zoomed in this will have an significant impact
	on the performance of the painting cde.	on the performance of the painting cde.

		*/
	The default setting enables all flags.
	*/
	enum DisplayFlag
	{
	SmartOriginLabel = 1,
	HideMaxRadiusLabel = 2,
	ClipAxisBackground = 4,
	SmartScaleDraw = 8,
	ClipGridLines = 16	ClipGridLines = 16
	};	};


		//! Display flags
		typedef QFlags<DisplayFlag> DisplayFlags;

	/*!	/*!
	\brief Grid attributes	\brief Grid attributes

		\sa setGridAttributes(), testGridAttributes()
	- AutoScaling\n
	When AutoScaling is enabled, the radial axes will be adjusted
	to the interval, that is currently visible on the canvas plot.
	*/	*/
	enum GridAttribute	enum GridAttribute
	{	{

	AutoScaling = 1	/*!
		When AutoScaling is enabled, the radial axes will be adjusted
		to the interval, that is currently visible on the canvas plot.
		*/
		AutoScaling = 0x01
	};	};


		//! Grid attributes
		typedef QFlags<GridAttribute> GridAttributes;

	explicit QwtPolarGrid();	explicit QwtPolarGrid();
	virtual ~QwtPolarGrid();	virtual ~QwtPolarGrid();

	virtual int rtti() const;	virtual int rtti() const;


	void setDisplayFlag(DisplayFlag, bool on = true);	void setDisplayFlag( DisplayFlag, bool on = true );
	bool testDisplayFlag(DisplayFlag) const;	bool testDisplayFlag( DisplayFlag ) const;


	void setGridAttribute(GridAttribute, bool on = true);	void setGridAttribute( GridAttribute, bool on = true );
	bool testGridAttribute(GridAttribute) const;	bool testGridAttribute( GridAttribute ) const;


	void showGrid(int scaleId, bool show = true);	void showGrid( int scaleId, bool show = true );
	bool isGridVisible(int scaleId) const;	bool isGridVisible( int scaleId ) const;


	void showMinorGrid(int scaleId, bool show = true);	void showMinorGrid( int scaleId, bool show = true );
	bool isMinorGridVisible(int scaleId) const;	bool isMinorGridVisible( int scaleId ) const;


	void showAxis(int axisId, bool show = true);	void showAxis( int axisId, bool show = true );
	bool isAxisVisible(int axisId) const;	bool isAxisVisible( int axisId ) const;


	void setPen(const QPen &p);	void setPen( const QPen &p );
	void setFont(const QFont &);	void setFont( const QFont & );


	void setMajorGridPen(const QPen &p);	void setMajorGridPen( const QPen &p );
	void setMajorGridPen(int scaleId, const QPen &p);	void setMajorGridPen( int scaleId, const QPen &p );
	QPen majorGridPen(int scaleId) const;	QPen majorGridPen( int scaleId ) const;


	void setMinorGridPen(const QPen &p);	void setMinorGridPen( const QPen &p );
	void setMinorGridPen(int scaleId, const QPen &p);	void setMinorGridPen( int scaleId, const QPen &p );
	QPen minorGridPen(int scaleId) const;	QPen minorGridPen( int scaleId ) const;


	void setAxisPen(int axisId, const QPen &p);	void setAxisPen( int axisId, const QPen &p );
	QPen axisPen(int axisId) const;	QPen axisPen( int axisId ) const;


	void setAxisFont(int axisId, const QFont &p);	void setAxisFont( int axisId, const QFont &p );
	QFont axisFont(int axisId) const;	QFont axisFont( int axisId ) const;


	virtual void draw(QPainter *p,	void setScaleDraw( int axisId, QwtScaleDraw * );
		const QwtScaleDraw *scaleDraw( int axisId ) const;
		QwtScaleDraw *scaleDraw( int axisId );

		void setAzimuthScaleDraw( QwtRoundScaleDraw * );
		const QwtRoundScaleDraw *azimuthScaleDraw() const;
		QwtRoundScaleDraw *azimuthScaleDraw();

		virtual void draw( QPainter *p,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtDoubleRect &rect) const;	const QRectF &rect ) const;


	virtual void updateScaleDiv(const QwtScaleDiv &azimuthMap,	virtual void updateScaleDiv( const QwtScaleDiv &azimuthMap,
	const QwtScaleDiv &radialMap, const QwtDoubleInterval &);	const QwtScaleDiv &radialMap, const QwtInterval & );

	virtual int marginHint() const;	virtual int marginHint() const;

	protected:	protected:

	void drawRays(QPainter *, const QwtDoubleRect &,	void drawRays( QPainter *, const QRectF &,
	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtScaleMap &azimuthMap, const QwtValueList &) const;	const QwtScaleMap &azimuthMap, const QList<double> & ) const;
	void drawCircles(QPainter *, const QwtDoubleRect &,	void drawCircles( QPainter *, const QRectF &,
	const QwtDoublePoint &pole, const QwtScaleMap &radialMap,	const QPointF &pole, const QwtScaleMap &radialMap,
	const QwtValueList &) const;	const QList<double> & ) const;


	void drawAxis(QPainter *, int axisId) const;	void drawAxis( QPainter *, int axisId ) const;

	private:	private:
	void updateScaleDraws(	void updateScaleDraws(
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, const double radius) const;	const QPointF &pole, const double radius ) const;

	private:	private:
	class GridData;	class GridData;
	class AxisData;	class AxisData;
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};


		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarGrid::DisplayFlags )
		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarGrid::GridAttributes )

	#endif	#endif

End of changes. 27 change blocks.
	57 lines changed or deleted	84 lines changed or added

	qwt_polar_item.h	qwt_polar_item.h

	skipping to change at line 13	skipping to change at line 13
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_ITEM_H	#ifndef QWT_POLAR_ITEM_H
	#define QWT_POLAR_ITEM_H	#define QWT_POLAR_ITEM_H

	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	#include "qwt_text.h"	#include <qwt_text.h>
	#include "qwt_legend_itemmanager.h"	#include <qwt_legend_itemmanager.h>
	#include "qwt_double_interval.h"	#include <qwt_interval.h>
	#include "qwt_double_rect.h"

	class QString;	class QString;
	class QRect;	class QRect;

		class QPointF;
	class QPainter;	class QPainter;
	class QwtPolarPlot;	class QwtPolarPlot;
	class QwtScaleMap;	class QwtScaleMap;
	class QwtScaleDiv;	class QwtScaleDiv;

	/*!	/*!
	\brief Base class for items on a polar plot	\brief Base class for items on a polar plot

	A QwtPolarItem is "something that can be painted on the canvas".	A QwtPolarItem is "something that can be painted on the canvas".
	It is connected to the QwtPolar framework by a couple of virtual	It is connected to the QwtPolar framework by a couple of virtual

	skipping to change at line 47	skipping to change at line 47
	{	{
	public:	public:
	/*!	/*!
	\brief Runtime type information	\brief Runtime type information

	RttiValues is used to cast plot items, without	RttiValues is used to cast plot items, without
	having to enable runtime type information of the compiler.	having to enable runtime type information of the compiler.
	*/	*/
	enum RttiValues	enum RttiValues
	{	{

		//! Unspecific value, that can be used, when it doesn't matter
	Rtti_PolarItem = 0,	Rtti_PolarItem = 0,


		//! For QwtPolarGrid
	Rtti_PolarGrid,	Rtti_PolarGrid,

	Rtti_PolarScale,
		//! For QwtPolarMarker
	Rtti_PolarMarker,	Rtti_PolarMarker,


		//! For QwtPolarCurve
	Rtti_PolarCurve,	Rtti_PolarCurve,


		//! For QwtPolarSpectrogram
	Rtti_PolarSpectrogram,	Rtti_PolarSpectrogram,


		/*!
		Values >= Rtti_PolarUserItem are reserved for plot items
		not implemented in the QwtPolar library.
		*/
	Rtti_PolarUserItem = 1000	Rtti_PolarUserItem = 1000
	};	};

	/*!	/*!
	\brief Plot Item Attributes	\brief Plot Item Attributes


	- Legend\n
	The item is represented on the legend.
	- AutoScale \n
	The boundingRect() of the item is included in the
	autoscaling calculation.

	\sa setItemAttribute(), testItemAttribute()	\sa setItemAttribute(), testItemAttribute()
	*/	*/
	enum ItemAttribute	enum ItemAttribute
	{	{

	Legend = 1,	//! The item is represented on the legend.
	AutoScale = 2	Legend = 0x01,

		/*!
		The boundingRect() of the item is included in the
		autoscaling calculation.
		*/
		AutoScale = 0x02
	};	};


	#if QT_VERSION >= 0x040000	//! Item attributes
	//! Render hints	typedef QFlags<ItemAttribute> ItemAttributes;

		/*!
		\brief Render hints
		\sa setRenderHint(), testRenderHint()
		*/
	enum RenderHint	enum RenderHint
	{	{

	RenderAntialiased = 1	//! Enable antialiasing
		RenderAntialiased = 0x01
	};	};

	#endif


	explicit QwtPolarItem(const QwtText &title = QwtText());	//! Item attributes
		typedef QFlags<RenderHint> RenderHints;

		explicit QwtPolarItem( const QwtText &title = QwtText() );
	virtual ~QwtPolarItem();	virtual ~QwtPolarItem();


	void attach(QwtPolarPlot *plot);	void attach( QwtPolarPlot *plot );

	/*!	/*!
	\brief This method detaches a QwtPolarItem from any QwtPolarPlot it	\brief This method detaches a QwtPolarItem from any QwtPolarPlot it
	has been associated with.	has been associated with.

	detach() is equivalent to calling attach( NULL )	detach() is equivalent to calling attach( NULL )
	\sa attach( QwtPolarPlot* plot )	\sa attach( QwtPolarPlot* plot )
	*/	*/

	void detach() { attach(NULL); }	void detach() { attach( NULL ); }

	QwtPolarPlot *plot() const;	QwtPolarPlot *plot() const;


	void setTitle(const QString &title);	void setTitle( const QString &title );
	void setTitle(const QwtText &title);	void setTitle( const QwtText &title );
	const QwtText &title() const;	const QwtText &title() const;

	virtual int rtti() const;	virtual int rtti() const;


	void setItemAttribute(ItemAttribute, bool on = true);	void setItemAttribute( ItemAttribute, bool on = true );
	bool testItemAttribute(ItemAttribute) const;	bool testItemAttribute( ItemAttribute ) const;


	#if QT_VERSION >= 0x040000	void setRenderHint( RenderHint, bool on = true );
	void setRenderHint(RenderHint, bool on = true);	bool testRenderHint( RenderHint ) const;
	bool testRenderHint(RenderHint) const;
	#endif

	double z() const;	double z() const;

	void setZ(double z);	void setZ( double z );

	void show();	void show();
	void hide();	void hide();

	virtual void setVisible(bool);	virtual void setVisible( bool );
	bool isVisible () const;	bool isVisible () const;

	virtual void itemChanged();	virtual void itemChanged();

	/*!	/*!
	\brief Draw the item	\brief Draw the item

	\param painter Painter	\param painter Painter
	\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI	\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
	\param radialMap Maps radius values into painter coordinates.	\param radialMap Maps radius values into painter coordinates.
	\param pole Position of the pole in painter coordinates	\param pole Position of the pole in painter coordinates
	\param radius Radius of the complete plot area in painter coordinates	\param radius Radius of the complete plot area in painter coordinates
	\param canvasRect Contents rect of the canvas in painter coordinates	\param canvasRect Contents rect of the canvas in painter coordinates
	*/	*/

	virtual void draw(QPainter *painter,	virtual void draw( QPainter *painter,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtDoubleRect &canvasRect) const = 0;	const QRectF &canvasRect ) const = 0;


	virtual QwtDoubleInterval boundingInterval(int scaleId) const;	virtual QwtInterval boundingInterval( int scaleId ) const;

	virtual QWidget *legendItem() const;	virtual QWidget *legendItem() const;


	virtual void updateLegend(QwtLegend *) const;	virtual void updateLegend( QwtLegend * ) const;
	virtual void updateScaleDiv(const QwtScaleDiv &,	virtual void updateScaleDiv( const QwtScaleDiv &,
	const QwtScaleDiv &, const QwtDoubleInterval &);	const QwtScaleDiv &, const QwtInterval & );

	virtual int marginHint() const;	virtual int marginHint() const;

	private:	private:
	// Disabled copy constructor and operator=	// Disabled copy constructor and operator=
	QwtPolarItem( const QwtPolarItem & );	QwtPolarItem( const QwtPolarItem & );
	QwtPolarItem &operator=( const QwtPolarItem & );	QwtPolarItem &operator=( const QwtPolarItem & );

	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};


		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarItem::ItemAttributes )
		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarItem::RenderHints )

	#endif	#endif

End of changes. 26 change blocks.
	38 lines changed or deleted	57 lines changed or added

	qwt_polar_itemdict.h	qwt_polar_itemdict.h

	skipping to change at line 16	skipping to change at line 16
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_ITEMDICT_H	#ifndef QWT_POLAR_ITEMDICT_H
	#define QWT_POLAR_ITEMDICT_H	#define QWT_POLAR_ITEMDICT_H

	/! \file !/	/! \file !/

	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"
	#include "qwt_polar_item.h"	#include "qwt_polar_item.h"


	#if QT_VERSION < 0x040000
	#include <qvaluelist.h>
	typedef QValueListConstIterator<QwtPolarItem *> QwtPolarItemIterator;
	/// \var typedef QValueList< QwtPolarItem *> QwtPolarItemList
	/// \brief See QT 3.x assistant documentation for QValueList
	typedef QValueList<QwtPolarItem *> QwtPolarItemList;
	#else
	#include <qlist.h>	#include <qlist.h>


	typedef QList<QwtPolarItem *>::ConstIterator QwtPolarItemIterator;	typedef QList<QwtPolarItem *>::ConstIterator QwtPolarItemIterator;
	/// \var typedef QList< QwtPolarItem *> QwtPolarItemList	/// \var typedef QList< QwtPolarItem *> QwtPolarItemList
	/// \brief See QT 4.x assistant documentation for QList	/// \brief See QT 4.x assistant documentation for QList
	typedef QList<QwtPolarItem *> QwtPolarItemList;	typedef QList<QwtPolarItem *> QwtPolarItemList;

	#endif

	/*!	/*!
	\brief A dictionary for polar plot items	\brief A dictionary for polar plot items

	QwtPolarItemDict organizes polar plot items in increasing z-order.	QwtPolarItemDict organizes polar plot items in increasing z-order.
	If autoDelete() is enabled, all attached items will be deleted	If autoDelete() is enabled, all attached items will be deleted
	in the destructor of the dictionary.	in the destructor of the dictionary.

	\sa QwtPolarItem::attach(), QwtPolarItem::detach(), QwtPolarItem::z()	\sa QwtPolarItem::attach(), QwtPolarItem::detach(), QwtPolarItem::z()
	*/	*/
	class QWT_POLAR_EXPORT QwtPolarItemDict	class QWT_POLAR_EXPORT QwtPolarItemDict
	{	{
	public:	public:
	explicit QwtPolarItemDict();	explicit QwtPolarItemDict();
	~QwtPolarItemDict();	~QwtPolarItemDict();


	void setAutoDelete(bool);	void setAutoDelete( bool );
	bool autoDelete() const;	bool autoDelete() const;

	const QwtPolarItemList& itemList() const;	const QwtPolarItemList& itemList() const;


	void detachItems(int rtti = QwtPolarItem::Rtti_PolarItem,	void detachItems( int rtti = QwtPolarItem::Rtti_PolarItem,
	bool autoDelete = true);	bool autoDelete = true );

	private:	private:
	friend class QwtPolarItem;	friend class QwtPolarItem;


	void attachItem(QwtPolarItem *, bool);	void attachItem( QwtPolarItem *, bool );

	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};

	#endif	#endif

End of changes. 6 change blocks.
	13 lines changed or deleted	5 lines changed or added

	qwt_polar_layout.h	qwt_polar_layout.h

	skipping to change at line 12	skipping to change at line 12
	* QwtPolar Widget Library	* QwtPolar Widget Library
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_LAYOUT_H	#ifndef QWT_POLAR_LAYOUT_H
	#define QWT_POLAR_LAYOUT_H	#define QWT_POLAR_LAYOUT_H


	#include "qwt_global.h"	#include "qwt_polar_global.h"
	#include "qwt_polar_plot.h"	#include "qwt_polar_plot.h"

	/*!	/*!
	\brief Layout class for QwtPolarPlot.	\brief Layout class for QwtPolarPlot.

	Organizes the geometry for the different QwtPolarPlot components.	Organizes the geometry for the different QwtPolarPlot components.
	It is used by the QwtPolar widget to organize its internal widgets	It is used by the QwtPolar widget to organize its internal widgets

	or by QwtPolarPlot::renderTo() to render its content to a QPaintDevice li ke	or by QwtPolarRnderer to render its content to a QPaintDevice like
	a QPrinter, QPixmap/QImage or QSvgRenderer.	a QPrinter, QPixmap/QImage or QSvgRenderer.
	*/	*/

	class QWT_POLAR_EXPORT QwtPolarLayout	class QWT_POLAR_EXPORT QwtPolarLayout
	{	{
	public:	public:

	/*!
	Options to configure the plot layout engine


	- IgnoreScrollbars\n	//! \brief Options to configure the plot layout engine
	Ignore the dimension of the scrollbars. There are no	enum Option
	scrollbars, when the plot is rendered to a paint device
	(QwtPolarPlot::renderTo() ).
	- IgnoreFrames\n
	Ignore all frames. QwtPolarPlot::renderTo() doesn't paint them.
	- IgnoreTitle\n
	Ignore the title.
	- IgnoreLegend\n
	Ignore the legend.
	*/

	enum Options
	{	{

	IgnoreScrollbars = 1,	//! Ignore the dimension of the scrollbars.
	IgnoreFrames = 2,	IgnoreScrollbars = 0x01,
	IgnoreTitle = 4,
	IgnoreLegend = 8	//! Ignore all frames.
		IgnoreFrames = 0x02,

		//! Ignore the title.
		IgnoreTitle = 0x04,

		//! Ignore the legend.
		IgnoreLegend = 0x08
	};	};


		//! Options to configure the plot layout engine
		typedef QFlags<Option> Options;

	explicit QwtPolarLayout();	explicit QwtPolarLayout();
	virtual ~QwtPolarLayout();	virtual ~QwtPolarLayout();


	void setLegendPosition(QwtPolarPlot::LegendPosition pos, double ratio);	void setLegendPosition( QwtPolarPlot::LegendPosition pos, double ratio
	void setLegendPosition(QwtPolarPlot::LegendPosition pos);	);
		void setLegendPosition( QwtPolarPlot::LegendPosition pos );
	QwtPolarPlot::LegendPosition legendPosition() const;	QwtPolarPlot::LegendPosition legendPosition() const;


	void setLegendRatio(double ratio);	void setLegendRatio( double ratio );
	double legendRatio() const;	double legendRatio() const;


	virtual QSize minimumSizeHint(const QwtPolarPlot *) const;	virtual void activate( const QwtPolarPlot *,
		const QRectF &rect, Options options = 0 );
	virtual void activate(const QwtPolarPlot *,
	const QRect &rect, int options = 0);

	virtual void invalidate();	virtual void invalidate();


	const QRect &titleRect() const;	const QRectF &titleRect() const;
	const QRect &legendRect() const;	const QRectF &legendRect() const;
	const QRect &canvasRect() const;	const QRectF &canvasRect() const;

	class LayoutData;	class LayoutData;

	protected:	protected:

	QRect layoutLegend(int options, const QRect &) const;	QRectF layoutLegend( Options options, QRectF & ) const;

	private:	private:
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};


		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarLayout::Options )

	#endif	#endif

End of changes. 12 change blocks.
	32 lines changed or deleted	30 lines changed or added

	qwt_polar_magnifier.h	qwt_polar_magnifier.h

	skipping to change at line 35	skipping to change at line 35
	an individual navigation of the plot canvas.	an individual navigation of the plot canvas.

	\sa QwtPolarPanner, QwtPolarPlot, QwtPolarCanvas	\sa QwtPolarPanner, QwtPolarPlot, QwtPolarCanvas
	*/	*/

	class QWT_POLAR_EXPORT QwtPolarMagnifier: public QwtMagnifier	class QWT_POLAR_EXPORT QwtPolarMagnifier: public QwtMagnifier
	{	{
	Q_OBJECT	Q_OBJECT

	public:	public:

	explicit QwtPolarMagnifier(QwtPolarCanvas *);	explicit QwtPolarMagnifier( QwtPolarCanvas * );
	virtual ~QwtPolarMagnifier();	virtual ~QwtPolarMagnifier();


	void setUnzoomKey(int key, int modifiers);	void setUnzoomKey( int key, int modifiers );
	void getUnzoomKey(int &key, int &modifiers) const;	void getUnzoomKey( int &key, int &modifiers ) const;

	QwtPolarPlot *plot();	QwtPolarPlot *plot();
	const QwtPolarPlot *plot() const;	const QwtPolarPlot *plot() const;

	QwtPolarCanvas *canvas();	QwtPolarCanvas *canvas();
	const QwtPolarCanvas *canvas() const;	const QwtPolarCanvas *canvas() const;

	protected:	protected:

	virtual void rescale(double factor);	virtual void rescale( double factor );
	void unzoom();	void unzoom();


	virtual void widgetKeyPressEvent(QKeyEvent *);	virtual void widgetKeyPressEvent( QKeyEvent * );

	private:	private:
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};

	#endif	#endif

End of changes. 4 change blocks.
	5 lines changed or deleted	5 lines changed or added

	qwt_polar_marker.h	qwt_polar_marker.h

	skipping to change at line 12	skipping to change at line 12
	* QwtPolar Widget Library	* QwtPolar Widget Library
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_MARKER_H	#ifndef QWT_POLAR_MARKER_H
	#define QWT_POLAR_MARKER_H	#define QWT_POLAR_MARKER_H


	#include <qstring.h>
	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	#include "qwt_polar_point.h"
	#include "qwt_polar_item.h"	#include "qwt_polar_item.h"

		#include <qwt_point_polar.h>
		#include <qstring.h>

	class QRect;	class QRect;
	class QwtText;	class QwtText;
	class QwtSymbol;	class QwtSymbol;

	/*!	/*!
	\brief A class for drawing markers	\brief A class for drawing markers

	A marker can be a a symbol, a label or a combination of them, which can	A marker can be a a symbol, a label or a combination of them, which can
	be drawn around a center point inside a bounding rectangle.	be drawn around a center point inside a bounding rectangle.

	skipping to change at line 46	skipping to change at line 46
	*/	*/

	class QWT_POLAR_EXPORT QwtPolarMarker: public QwtPolarItem	class QWT_POLAR_EXPORT QwtPolarMarker: public QwtPolarItem
	{	{
	public:	public:
	explicit QwtPolarMarker();	explicit QwtPolarMarker();
	virtual ~QwtPolarMarker();	virtual ~QwtPolarMarker();

	virtual int rtti() const;	virtual int rtti() const;


	void setPosition(const QwtPolarPoint &);	void setPosition( const QwtPointPolar & );
	QwtPolarPoint position() const;	QwtPointPolar position() const;


	void setSymbol(const QwtSymbol &s);	void setSymbol( const QwtSymbol *s );
	const QwtSymbol &symbol() const;	const QwtSymbol *symbol() const;


	void setLabel(const QwtText&);	void setLabel( const QwtText& );
	QwtText label() const;	QwtText label() const;


	#if QT_VERSION < 0x040000	void setLabelAlignment( Qt::Alignment );
	void setLabelAlignment(int align);
	int labelAlignment() const;
	#else
	void setLabelAlignment(Qt::Alignment);
	Qt::Alignment labelAlignment() const;	Qt::Alignment labelAlignment() const;

	#endif


	virtual void draw(QPainter *painter,	virtual void draw( QPainter *painter,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtDoubleRect &canvasRect) const;	const QRectF &canvasRect ) const;


	virtual QwtDoubleInterval boundingInterval(int scaleId) const;	virtual QwtInterval boundingInterval( int scaleId ) const;

	private:	private:
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};

	#endif	#endif

End of changes. 11 change blocks.
	17 lines changed or deleted	12 lines changed or added

	qwt_polar_panner.h	qwt_polar_panner.h

	skipping to change at line 36	skipping to change at line 36
	of navigating on a QwtPolarPlot widget can be implemented easily.	of navigating on a QwtPolarPlot widget can be implemented easily.

	\sa QwtPolarMagnifier	\sa QwtPolarMagnifier
	*/	*/

	class QWT_POLAR_EXPORT QwtPolarPanner: public QwtPanner	class QWT_POLAR_EXPORT QwtPolarPanner: public QwtPanner
	{	{
	Q_OBJECT	Q_OBJECT

	public:	public:

	explicit QwtPolarPanner(QwtPolarCanvas *);	explicit QwtPolarPanner( QwtPolarCanvas * );
	virtual ~QwtPolarPanner();	virtual ~QwtPolarPanner();

	QwtPolarPlot *plot();	QwtPolarPlot *plot();
	const QwtPolarPlot *plot() const;	const QwtPolarPlot *plot() const;

	QwtPolarCanvas *canvas();	QwtPolarCanvas *canvas();
	const QwtPolarCanvas *canvas() const;	const QwtPolarCanvas *canvas() const;


	protected slots:	protected Q_SLOTS:
	virtual void movePlot(int dx, int dy);	virtual void movePlot( int dx, int dy );

	protected:	protected:

	virtual void widgetMousePressEvent(QMouseEvent *);	virtual void widgetMousePressEvent( QMouseEvent * );
	};	};

	#endif	#endif

End of changes. 3 change blocks.
	4 lines changed or deleted	4 lines changed or added

	qwt_polar_plot.h	qwt_polar_plot.h

	skipping to change at line 12	skipping to change at line 12
	* QwtPolar Widget Library	* QwtPolar Widget Library
	* Copyright (C) 2008 Uwe Rathmann	* Copyright (C) 2008 Uwe Rathmann
	*	*
	* This library is free software; you can redistribute it and/or	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the Qwt License, Version 1.0	* modify it under the terms of the Qwt License, Version 1.0
	************************************************************************ */	************************************************************************ */

	#ifndef QWT_POLAR_PLOT_H	#ifndef QWT_POLAR_PLOT_H
	#define QWT_POLAR_PLOT_H 1	#define QWT_POLAR_PLOT_H 1


	#include <qframe.h>
	#include "qwt_polar_global.h"	#include "qwt_polar_global.h"

	#include "qwt_double_interval.h"
	#include "qwt_scale_map.h"
	#include "qwt_polar.h"	#include "qwt_polar.h"

	#include "qwt_polar_point.h"
	#include "qwt_polar_itemdict.h"	#include "qwt_polar_itemdict.h"

		#include <qwt_interval.h>
		#include <qwt_scale_map.h>
		#include <qwt_point_polar.h>
		#include <qframe.h>

	class QwtRoundScaleDraw;	class QwtRoundScaleDraw;
	class QwtScaleEngine;	class QwtScaleEngine;
	class QwtScaleDiv;	class QwtScaleDiv;
	class QwtTextLabel;	class QwtTextLabel;
	class QwtPolarCanvas;	class QwtPolarCanvas;
	class QwtPolarLayout;	class QwtPolarLayout;

	/*!	/*!
	\brief A plotting widget, displaying a polar coordinate system	\brief A plotting widget, displaying a polar coordinate system

	skipping to change at line 49	skipping to change at line 49
	for the radial scale.	for the radial scale.

	In opposite to QwtPlot the scales might be different from the	In opposite to QwtPlot the scales might be different from the
	view, that is displayed on the canvas. The view can be changed by	view, that is displayed on the canvas. The view can be changed by
	zooming - f.e. by using QwtPolarPanner or QwtPolarMaginfier.	zooming - f.e. by using QwtPolarPanner or QwtPolarMaginfier.
	*/	*/
	class QWT_POLAR_EXPORT QwtPolarPlot: public QFrame, public QwtPolarItemDict	class QWT_POLAR_EXPORT QwtPolarPlot: public QFrame, public QwtPolarItemDict
	{	{
	Q_OBJECT	Q_OBJECT


	Q_PROPERTY(QBrush plotBackground READ plotBackground WRITE setPlotBackg	Q_PROPERTY( QBrush plotBackground READ plotBackground WRITE setPlotBack
	round)	ground )
	Q_PROPERTY(double azimuthOrigin READ azimuthOrigin WRITE setAzimuthOrig	Q_PROPERTY( double azimuthOrigin READ azimuthOrigin WRITE setAzimuthOri
	in)	gin )

	public:	public:
	/*!	/*!
	Position of the legend, relative to the canvas.	Position of the legend, relative to the canvas.


	- LeftLegend\n
	The legend will be left from the canvas.
	- RightLegend\n
	The legend will be right from the canvas.
	- BottomLegend\n
	The legend will be below the canvas.
	- TopLegend\n
	The legend will be between canvas and title.
	- ExternalLegend\n
	External means that only the content of the legend
	will be handled by QwtPlot, but not its geometry.
	This might be interesting if an application wants to
	have a legend in an external window ( or on the canvas ).

	\note In case of ExternalLegend, the legend is not
	painted by renderTo().

	\sa insertLegend()	\sa insertLegend()
	*/	*/
	enum LegendPosition	enum LegendPosition
	{	{

		//! The legend will be left from the canvas.
	LeftLegend,	LeftLegend,


		//! The legend will be right from the canvas.
	RightLegend,	RightLegend,


		//! The legend will be below the canvas.
	BottomLegend,	BottomLegend,


		//! The legend will be between canvas and title.
	TopLegend,	TopLegend,


		/*!
		External means that only the content of the legend
		will be handled by QwtPlot, but not its geometry.
		This might be interesting if an application wants to
		have a legend in an external window ( or on the canvas ).

		\note The legend is not painted by QwtPolarRenderer
		*/
	ExternalLegend	ExternalLegend
	};	};


	explicit QwtPolarPlot( QWidget *parent = NULL);	explicit QwtPolarPlot( QWidget *parent = NULL );
	QwtPolarPlot(const QwtText &title, QWidget *parent = NULL);	QwtPolarPlot( const QwtText &title, QWidget *parent = NULL );

	virtual ~QwtPolarPlot();	virtual ~QwtPolarPlot();


	void setTitle(const QString &);	void setTitle( const QString & );
	void setTitle(const QwtText &);	void setTitle( const QwtText & );

	QwtText title() const;	QwtText title() const;

	QwtTextLabel *titleLabel();	QwtTextLabel *titleLabel();
	const QwtTextLabel *titleLabel() const;	const QwtTextLabel *titleLabel() const;


	void setAutoReplot(bool tf = true);	void setAutoReplot( bool tf = true );
	bool autoReplot() const;	bool autoReplot() const;


	void setAutoScale(int scaleId);	void setAutoScale( int scaleId );
	bool hasAutoScale(int scaleId) const;	bool hasAutoScale( int scaleId ) const;


	void setScaleMaxMinor(int scaleId, int maxMinor);	void setScaleMaxMinor( int scaleId, int maxMinor );
	int scaleMaxMinor(int scaleId) const;	int scaleMaxMinor( int scaleId ) const;


	int scaleMaxMajor(int scaleId) const;	int scaleMaxMajor( int scaleId ) const;
	void setScaleMaxMajor(int scaleId, int maxMajor);	void setScaleMaxMajor( int scaleId, int maxMajor );


	QwtScaleEngine *scaleEngine(int scaleId);	QwtScaleEngine *scaleEngine( int scaleId );
	const QwtScaleEngine *scaleEngine(int scaleId) const;	const QwtScaleEngine *scaleEngine( int scaleId ) const;
	void setScaleEngine(int scaleId, QwtScaleEngine *);	void setScaleEngine( int scaleId, QwtScaleEngine * );


	void setScale(int scaleId, double min, double max, double step = 0);	void setScale( int scaleId, double min, double max, double step = 0 );


	void setScaleDiv(int scaleId, const QwtScaleDiv &);	void setScaleDiv( int scaleId, const QwtScaleDiv & );
	const QwtScaleDiv *scaleDiv(int scaleId) const;	const QwtScaleDiv *scaleDiv( int scaleId ) const;
	QwtScaleDiv *scaleDiv(int scaleId);	QwtScaleDiv *scaleDiv( int scaleId );


	QwtScaleMap scaleMap(int scaleId, double radius) const;	QwtScaleMap scaleMap( int scaleId, double radius ) const;
	QwtScaleMap scaleMap(int scaleId) const;	QwtScaleMap scaleMap( int scaleId ) const;


	void updateScale(int scaleId);	void updateScale( int scaleId );

	double azimuthOrigin() const;	double azimuthOrigin() const;


	void zoom(const QwtPolarPoint&, double factor);	void zoom( const QwtPointPolar&, double factor );
	void unzoom();	void unzoom();


	QwtPolarPoint zoomPos() const;	QwtPointPolar zoomPos() const;
	double zoomFactor() const;	double zoomFactor() const;


	virtual void polish();

	// Canvas	// Canvas

	QwtPolarCanvas *canvas();	QwtPolarCanvas *canvas();
	const QwtPolarCanvas *canvas() const;	const QwtPolarCanvas *canvas() const;


	void setPlotBackground (const QBrush &c);	void setPlotBackground ( const QBrush &c );
	const QBrush& plotBackground() const;	const QBrush& plotBackground() const;


	virtual void drawCanvas(QPainter *, const QwtDoubleRect &) const;	virtual void drawCanvas( QPainter *, const QRectF & ) const;

	// Legend	// Legend


	void insertLegend(QwtLegend *, LegendPosition = QwtPolarPlot::RightLege	void insertLegend( QwtLegend *,
	nd,	LegendPosition = RightLegend, double ratio = -1.0 );
	double ratio = -1.0);

	QwtLegend *legend();	QwtLegend *legend();
	const QwtLegend *legend() const;	const QwtLegend *legend() const;

	// Layout	// Layout
	QwtPolarLayout *plotLayout();	QwtPolarLayout *plotLayout();
	const QwtPolarLayout *plotLayout() const;	const QwtPolarLayout *plotLayout() const;


	QwtDoubleInterval visibleInterval() const;	QwtInterval visibleInterval() const;
	QwtDoubleRect plotRect() const;	QRectF plotRect() const;
	QwtDoubleRect plotRect(const QRect &) const;	QRectF plotRect( const QRectF & ) const;

	int plotMarginHint() const;	int plotMarginHint() const;


	void renderTo(QPaintDevice &) const;	Q_SIGNALS:
	virtual void renderTo(QPainter *, const QRect &) const;

	signals:
	/*!	/*!
	A signal which is emitted when the user has clicked on	A signal which is emitted when the user has clicked on
	a legend item, which is in QwtLegend::ClickableItem mode.	a legend item, which is in QwtLegend::ClickableItem mode.

	\param plotItem Corresponding plot item of the	\param plotItem Corresponding plot item of the
	selected legend item	selected legend item

	\note clicks are disabled as default	\note clicks are disabled as default
	\sa QwtLegend::setItemMode, QwtLegend::itemMode	\sa QwtLegend::setItemMode, QwtLegend::itemMode
	*/	*/

	void legendClicked(QwtPolarItem *plotItem);	void legendClicked( QwtPolarItem *plotItem );

	/*!	/*!
	A signal which is emitted when the user has clicked on	A signal which is emitted when the user has clicked on
	a legend item, which is in QwtLegend::CheckableItem mode	a legend item, which is in QwtLegend::CheckableItem mode

	\param plotItem Corresponding plot item of the	\param plotItem Corresponding plot item of the
	selected legend item	selected legend item
	\param on True when the legen item is checked	\param on True when the legen item is checked

	\note clicks are disabled as default	\note clicks are disabled as default
	\sa QwtLegend::setItemMode, QwtLegend::itemMode	\sa QwtLegend::setItemMode, QwtLegend::itemMode
	*/	*/

	void legendChecked(QwtPolarItem *plotItem, bool on);	void legendChecked( QwtPolarItem *plotItem, bool on );

	/*!	/*!
	A signal that is emitted, whenever the layout of the plot	A signal that is emitted, whenever the layout of the plot
	has been recalculated.	has been recalculated.
	*/	*/
	void layoutChanged();	void layoutChanged();


	public slots:	public Q_SLOTS:
	virtual void replot();	virtual void replot();
	void autoRefresh();	void autoRefresh();

	void setAzimuthOrigin(double);	void setAzimuthOrigin( double );


	protected slots:	protected Q_SLOTS:
	virtual void legendItemClicked();	virtual void legendItemClicked();

	virtual void legendItemChecked(bool);	virtual void legendItemChecked( bool );

	protected:	protected:

	virtual bool event(QEvent *);	virtual bool event( QEvent * );
	virtual void resizeEvent(QResizeEvent *);	virtual void resizeEvent( QResizeEvent * );

	virtual void updateLayout();	virtual void updateLayout();


	virtual void drawItems(QPainter *painter,	virtual void drawItems( QPainter *painter,
	const QwtScaleMap &radialMap, const QwtScaleMap &azimuthMap,	const QwtScaleMap &radialMap, const QwtScaleMap &azimuthMap,

	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtDoubleRect &canvasRect) const;	const QRectF &canvasRect ) const;

	virtual void renderTitle(QPainter *, const QRect &) const;
	virtual void renderLegend(QPainter *, const QRect &) const;
	virtual void renderLegendItem(QPainter *,
	const QWidget *, const QRect &) const;

	private:	private:

	void initPlot(const QwtText &);	void initPlot( const QwtText & );

	class ScaleData;	class ScaleData;
	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};

	#endif	#endif

End of changes. 40 change blocks.
	80 lines changed or deleted	66 lines changed or added

	qwt_polar_spectrogram.h	qwt_polar_spectrogram.h

	skipping to change at line 31	skipping to change at line 31

	A spectrogram displays threedimenional data, where the 3rd dimension	A spectrogram displays threedimenional data, where the 3rd dimension
	( the intensity ) is displayed using colors. The colors are calculated	( the intensity ) is displayed using colors. The colors are calculated
	from the values using a color map.	from the values using a color map.

	\sa QwtRasterData, QwtColorMap	\sa QwtRasterData, QwtColorMap
	*/	*/
	class QWT_POLAR_EXPORT QwtPolarSpectrogram: public QwtPolarItem	class QWT_POLAR_EXPORT QwtPolarSpectrogram: public QwtPolarItem
	{	{
	public:	public:

		/*!
		Attributes to modify the drawing algorithm.
		The default setting disables ApproximatedAtan

		\sa setPaintAttribute(), testPaintAttribute()
		*/
		enum PaintAttribute
		{
		/*!
		Use qwtFastAtan2 instead of atan2 for translating
		widget into polar coordinates.
		*/

		ApproximatedAtan = 0x01
		};

		//! Paint attributes
		typedef QFlags<PaintAttribute> PaintAttributes;

	explicit QwtPolarSpectrogram();	explicit QwtPolarSpectrogram();
	virtual ~QwtPolarSpectrogram();	virtual ~QwtPolarSpectrogram();


	void setData(const QwtRasterData &data);	void setData( QwtRasterData *data );
	const QwtRasterData &data() const;	const QwtRasterData *data() const;

		void setColorMap( QwtColorMap * );
		const QwtColorMap *colorMap() const;

		void setPaintAttribute( PaintAttribute, bool on = true );
		bool testPaintAttribute( PaintAttribute ) const;


	void setColorMap(const QwtColorMap &);	void setRenderThreadCount( uint numThreads );
	const QwtColorMap &colorMap() const;	uint renderThreadCount() const;

	virtual int rtti() const;	virtual int rtti() const;


	virtual void draw(QPainter *painter,	virtual void draw( QPainter *painter,
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, double radius,	const QPointF &pole, double radius,
	const QwtDoubleRect &canvasRect) const;	const QRectF &canvasRect ) const;


	virtual QwtDoubleInterval boundingInterval(int scaleId) const;	virtual QwtInterval boundingInterval( int scaleId ) const;

	protected:	protected:
	virtual QImage renderImage(	virtual QImage renderImage(
	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,	const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,

	const QwtDoublePoint &pole, const QRect &rect) const;	const QPointF &pole, const QRect &rect ) const;

		virtual void renderTile(
		const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
		const QPointF &pole, const QPoint &imagePos,
		const QRect &tile, QImage *image ) const;

	private:	private:

		class TileInfo;
		void renderTile( const QwtScaleMap &, const QwtScaleMap &,
		const QPointF &pole, TileInfo * ) const;

	class PrivateData;	class PrivateData;
	PrivateData *d_data;	PrivateData *d_data;
	};	};


		Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarSpectrogram::PaintAttributes )

	#endif	#endif

End of changes. 9 change blocks.
	9 lines changed or deleted	45 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/