Index: /trunk/BNC/qwtpolar/qwt_polar.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar.h (revision 4272) @@ -0,0 +1,84 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_H +#define QWT_POLAR_H 1 + +#include "qwt_polar_global.h" + +namespace QwtPolar +{ + //! Unit of an angle + enum AngleUnit + { + //! 0.0 -> 2_M_PI + Radians, + + //! 0.0 -> 360.0 + Degrees, + + //! 0.0 - 400.0 + Gradians, + + //! 0.0 - 1.0 + Turns + }; + + //! An enum, that identifies the type of a coordinate + enum Coordinate + { + //! Azimuth + Azimuth, + + //! Radius + Radius + }; + + /*! + Indices used to identify an axis. + \sa Scale + */ + enum Axis + { + //! Azimuth axis + AxisAzimuth, + + //! Left axis + AxisLeft, + + //! Right axis + AxisRight, + + //! Top axis + AxisTop, + + //! Bottom axis + AxisBottom, + + //! Number of available axis + AxesCount + }; + + /*! + Indices used to identify a scale. + \sa Axis + */ + enum Scale + { + //! Azimuth scale + ScaleAzimuth = Azimuth, + + //! Radial scale + ScaleRadius = Radius, + + //! Number of scales + ScaleCount + }; +} + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_canvas.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_canvas.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_canvas.cpp (revision 4272) @@ -0,0 +1,316 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_canvas.h" +#include "qwt_polar_plot.h" +#include +#include +#include +#include +#include +#ifdef Q_WS_X11 +#include +#endif + +static inline void qwtDrawStyledBackground( + QWidget *widget, QPainter *painter ) +{ + QStyleOption opt; + opt.initFrom( widget ); + widget->style()->drawPrimitive( QStyle::PE_Widget, &opt, painter, widget ); +} + +static QWidget *qwtBackgroundWidget( QWidget *w ) +{ + if ( w->parentWidget() == NULL ) + return w; + + if ( w->autoFillBackground() ) + { + const QBrush brush = w->palette().brush( w->backgroundRole() ); + if ( brush.color().alpha() > 0 ) + return w; + } + + if ( w->testAttribute( Qt::WA_StyledBackground ) ) + { + QImage image( 1, 1, QImage::Format_ARGB32 ); + image.fill( Qt::transparent ); + + QPainter painter( &image ); + painter.translate( -w->rect().center() ); + qwtDrawStyledBackground( w, &painter ); + painter.end(); + + if ( qAlpha( image.pixel( 0, 0 ) ) != 0 ) + return w; + } + + return qwtBackgroundWidget( w->parentWidget() ); +} + +class QwtPolarCanvas::PrivateData +{ +public: + PrivateData(): + paintAttributes( 0 ), + backingStore( NULL ) + { + } + + ~PrivateData() + { + delete backingStore; + } + + QwtPolarCanvas::PaintAttributes paintAttributes; + QPixmap *backingStore; +}; + +//! Constructor +QwtPolarCanvas::QwtPolarCanvas( QwtPolarPlot *plot ): + QFrame( plot ) +{ + d_data = new PrivateData; + +#ifndef QT_NO_CURSOR + setCursor( Qt::CrossCursor ); +#endif + setFocusPolicy( Qt::WheelFocus ); + + setPaintAttribute( BackingStore, true ); +} + +//! Destructor +QwtPolarCanvas::~QwtPolarCanvas() +{ + delete d_data; +} + +//! \return Parent plot widget +QwtPolarPlot *QwtPolarCanvas::plot() +{ + return qobject_cast( parent() ); +} + +//! \return Parent plot widget +const QwtPolarPlot *QwtPolarCanvas::plot() const +{ + return qobject_cast( parent() ); +} + +/*! + \brief Changing the paint attributes + + \param attribute Paint attribute + \param on On/Off + + The default setting enables BackingStore + + \sa testPaintAttribute(), paintCache() +*/ +void QwtPolarCanvas::setPaintAttribute( PaintAttribute attribute, bool on ) +{ + if ( bool( d_data->paintAttributes & attribute ) == on ) + return; + + if ( on ) + d_data->paintAttributes |= attribute; + else + d_data->paintAttributes &= ~attribute; + + switch( attribute ) + { + case BackingStore: + { + if ( on ) + { + if ( d_data->backingStore == NULL ) + d_data->backingStore = new QPixmap(); + + if ( isVisible() ) + { + const QRect cr = contentsRect(); + *d_data->backingStore = QPixmap::grabWidget( this, cr ); + } + } + else + { + delete d_data->backingStore; + d_data->backingStore = NULL; + } + break; + } + } +} + +/*! + Test wether a paint attribute is enabled + + \param attribute Paint attribute + \return true if the attribute is enabled + \sa setPaintAttribute() +*/ +bool QwtPolarCanvas::testPaintAttribute( PaintAttribute attribute ) const +{ + return ( d_data->paintAttributes & attribute ) != 0; +} + +//! \return Backing store, might be null +const QPixmap *QwtPolarCanvas::backingStore() const +{ + return d_data->backingStore; +} + +//! Invalidate the internal backing store +void QwtPolarCanvas::invalidateBackingStore() +{ + if ( d_data->backingStore ) + *d_data->backingStore = QPixmap(); +} + +/*! + Paint event + \param event Paint event +*/ +void QwtPolarCanvas::paintEvent( QPaintEvent *event ) +{ + QPainter painter( this ); + painter.setClipRegion( event->region() ); + + if ( ( d_data->paintAttributes & BackingStore ) + && d_data->backingStore != NULL ) + { + QPixmap &bs = *d_data->backingStore; + if ( bs.size() != size() ) + { + bs = QPixmap( size() ); +#ifdef Q_WS_X11 + if ( bs.x11Info().screen() != x11Info().screen() ) + bs.x11SetScreen( x11Info().screen() ); +#endif + + QPainter p; + + if ( testAttribute( Qt::WA_StyledBackground ) ) + { + p.begin( &bs ); + qwtDrawStyledBackground( this, &p ); + } + else + { + if ( autoFillBackground() ) + { + p.begin( &bs ); + p.fillRect( rect(), palette().brush( backgroundRole() ) ); + } + else + { + QWidget *bgWidget = qwtBackgroundWidget( plot() ); + bs.fill( bgWidget, mapTo( bgWidget, rect().topLeft() ) ); + p.begin( &bs ); + } + } + + plot()->drawCanvas( &p, contentsRect() ); + + if ( frameWidth() > 0 ) + drawFrame( &p ); + } + + painter.drawPixmap( 0, 0, *d_data->backingStore ); + } + else + { + qwtDrawStyledBackground( this, &painter ); + + plot()->drawCanvas( &painter, contentsRect() ); + + if ( frameWidth() > 0 ) + drawFrame( &painter ); + } +} + +/*! + Resize event + \param event Resize event +*/ +void QwtPolarCanvas::resizeEvent( QResizeEvent *event ) +{ + QFrame::resizeEvent( event ); + + for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ ) + plot()->updateScale( scaleId ); +} + +/*! + Translate a point from widget into plot coordinates + + \param pos Point in widget coordinates of the plot canvas + \return Point in plot coordinates + + \sa transform() +*/ +QwtPointPolar QwtPolarCanvas::invTransform( const QPoint &pos ) const +{ + const QwtPolarPlot *pl = plot(); + + const QwtScaleMap azimuthMap = pl->scaleMap( QwtPolar::Azimuth ); + const QwtScaleMap radialMap = pl->scaleMap( QwtPolar::Radius ); + + const QPointF center = pl->plotRect().center(); + + double dx = pos.x() - center.x(); + double dy = -( pos.y() - center.y() ); + + const QwtPointPolar polarPos = QwtPointPolar( QPoint( dx, dy ) ).normalized(); + + double azimuth = azimuthMap.invTransform( polarPos.azimuth() ); + + // normalize the azimuth + double min = azimuthMap.s1(); + double max = azimuthMap.s2(); + if ( max < min ) + qSwap( min, max ); + + if ( azimuth < min ) + { + azimuth += max - min; + } + else if ( azimuth > max ) + { + azimuth -= max - min; + } + + const double radius = radialMap.invTransform( polarPos.radius() ); + + return QwtPointPolar( azimuth, radius ); +} + +/*! + Translate a point from plot into widget coordinates + + \param polarPos Point in plot coordinates + \return Point in widget coordinates + \sa transform() +*/ +QPoint QwtPolarCanvas::transform( const QwtPointPolar &polarPos ) const +{ + const QwtPolarPlot *pl = plot(); + + const QwtScaleMap azimuthMap = pl->scaleMap( QwtPolar::Azimuth ); + const QwtScaleMap radialMap = pl->scaleMap( QwtPolar::Radius ); + + const double radius = radialMap.transform( polarPos.radius() ); + const double azimuth = azimuthMap.transform( polarPos.azimuth() ); + + const QPointF pos = qwtPolar2Pos( + pl->plotRect().center(), radius, azimuth ); + + return pos.toPoint(); +} Index: /trunk/BNC/qwtpolar/qwt_polar_canvas.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_canvas.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_canvas.h (revision 4272) @@ -0,0 +1,79 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_CANVAS_H +#define QWT_POLAR_CANVAS_H 1 + +#include "qwt_polar_global.h" +#include +#include + +class QPainter; +class QwtPolarPlot; + +/*! + \brief Canvas of a QwtPolarPlot. + + The canvas is the widget, where all polar items are painted to. + + \note In opposite to QwtPlot all axes are painted on the canvas. + \sa QwtPolarPlot +*/ +class QWT_POLAR_EXPORT QwtPolarCanvas: public QFrame +{ + Q_OBJECT + +public: + /*! + \brief Paint attributes + + The default setting enables BackingStore + + \sa setPaintAttribute(), testPaintAttribute(), backingStore() + */ + + enum PaintAttribute + { + /*! + 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. + */ + BackingStore = 0x01 + }; + + //! Paint attributes + typedef QFlags PaintAttributes; + + explicit QwtPolarCanvas( QwtPolarPlot * ); + virtual ~QwtPolarCanvas(); + + QwtPolarPlot *plot(); + const QwtPolarPlot *plot() const; + + void setPaintAttribute( PaintAttribute, bool on = true ); + bool testPaintAttribute( PaintAttribute ) const; + + const QPixmap *backingStore() const; + void invalidateBackingStore(); + + QwtPointPolar invTransform( const QPoint & ) const; + QPoint transform( const QwtPointPolar & ) const; + +protected: + virtual void paintEvent( QPaintEvent * ); + virtual void resizeEvent( QResizeEvent * ); + +private: + class PrivateData; + PrivateData *d_data; +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarCanvas::PaintAttributes ) + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_curve.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_curve.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_curve.cpp (revision 4272) @@ -0,0 +1,635 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_curve.h" +#include "qwt_polar.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static inline bool qwtInsidePole( const QwtScaleMap &map, double radius ) +{ + return map.isInverting() ? ( radius > map.s1() ) : ( radius < map.s1() ); +} + +static int qwtVerifyRange( int size, int &i1, int &i2 ) +{ + if ( size < 1 ) + return 0; + + i1 = qBound( 0, i1, size - 1 ); + i2 = qBound( 0, i2, size - 1 ); + + if ( i1 > i2 ) + qSwap( i1, i2 ); + + return ( i2 - i1 + 1 ); +} + +class QwtPolarCurve::PrivateData +{ +public: + PrivateData(): + style( QwtPolarCurve::Lines ), + curveFitter( NULL ), + legendAttributes( 0 ) + { + symbol = new QwtSymbol(); + pen = QPen( Qt::black ); + } + + ~PrivateData() + { + delete symbol; + delete curveFitter; + } + + QwtPolarCurve::CurveStyle style; + const QwtSymbol *symbol; + QPen pen; + QwtCurveFitter *curveFitter; + + QwtPolarCurve::LegendAttributes legendAttributes; +}; + +//! Constructor +QwtPolarCurve::QwtPolarCurve(): + QwtPolarItem( QwtText() ) +{ + init(); +} + +/*! + Constructor + \param title title of the curve +*/ +QwtPolarCurve::QwtPolarCurve( const QwtText &title ): + QwtPolarItem( title ) +{ + init(); +} + +/*! + Constructor + \param title title of the curve +*/ +QwtPolarCurve::QwtPolarCurve( const QString &title ): + QwtPolarItem( QwtText( title ) ) +{ + init(); +} + +//! Destructor +QwtPolarCurve::~QwtPolarCurve() +{ + delete d_series; + delete d_data; +} + +//! Initialize data members +void QwtPolarCurve::init() +{ + d_data = new PrivateData; + d_series = NULL; + + setItemAttribute( QwtPolarItem::AutoScale ); + setItemAttribute( QwtPolarItem::Legend ); + setZ( 20.0 ); + + setRenderHint( RenderAntialiased, true ); +} + +//! \return QwtPolarCurve::Rtti_PolarCurve +int QwtPolarCurve::rtti() const +{ + return QwtPolarItem::Rtti_PolarCurve; +} + +/*! + Specify an attribute how to draw the legend identifier + + \param attribute Attribute + \param on On/Off + /sa LegendAttribute, testLegendAttribute() +*/ +void QwtPolarCurve::setLegendAttribute( LegendAttribute attribute, bool on ) +{ + if ( on ) + d_data->legendAttributes |= attribute; + else + d_data->legendAttributes &= ~attribute; +} + +/*! + \brief Test if a lefend attribute is enables + + \param attribute Legend attribute + + \return True if attribute is enabled + \sa LegendAttribute, setLegendAttribute() +*/ +bool QwtPolarCurve::testLegendAttribute( LegendAttribute attribute ) const +{ + return ( d_data->legendAttributes & attribute ); +} + +/*! + Set the curve's drawing style + + \param style Curve style + \sa CurveStyle, style() +*/ +void QwtPolarCurve::setStyle( CurveStyle style ) +{ + if ( style != d_data->style ) + { + d_data->style = style; + itemChanged(); + } +} + +/*! + \return Current style + \sa CurveStyle, setStyle() +*/ +QwtPolarCurve::CurveStyle QwtPolarCurve::style() const +{ + return d_data->style; +} + +/*! + \brief Assign a symbol + \param symbol Symbol + \sa symbol() +*/ +void QwtPolarCurve::setSymbol( const QwtSymbol *symbol ) +{ + if ( symbol != d_data->symbol ) + { + delete d_data->symbol; + d_data->symbol = symbol; + itemChanged(); + } +} + +/*! + \return The current symbol + \sa setSymbol() +*/ +const QwtSymbol *QwtPolarCurve::symbol() const +{ + return d_data->symbol; +} + +/*! + \brief Assign a pen + \param pen New pen + \sa pen() +*/ +void QwtPolarCurve::setPen( const QPen &pen ) +{ + if ( pen != d_data->pen ) + { + d_data->pen = pen; + itemChanged(); + } +} + +/*! + \return Pen used to draw the lines + \sa setPen() +*/ +const QPen& QwtPolarCurve::pen() const +{ + return d_data->pen; +} + +/*! + Initialize data with a pointer to QwtSeriesData. + + The x-values of the data object represent the azimuth, + the y-value respresent the radius. + + \param data Data +*/ +void QwtPolarCurve::setData( QwtSeriesData *data ) +{ + if ( d_series != data ) + { + delete d_series; + d_series = data; + itemChanged(); + } +} + +/*! + \brief Insert a curve fitter + + \param curveFitter Curve fitter + + A curve fitter interpolates the curve points. F.e QwtPolarFitter + adds equidistant points so that the connection gets rounded instead + of having straight lines. If curveFitter is NULL fitting is disabled. + + \sa curveFitter() +*/ +void QwtPolarCurve::setCurveFitter( QwtCurveFitter *curveFitter ) +{ + if ( curveFitter != d_data->curveFitter ) + { + delete d_data->curveFitter; + d_data->curveFitter = curveFitter; + + itemChanged(); + } +} + +/*! + \return The curve fitter + \sa setCurveFitter() +*/ +QwtCurveFitter *QwtPolarCurve::curveFitter() const +{ + return d_data->curveFitter; +} + +/*! + Draw the curve + + \param painter Painter + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param radius Radius of the complete plot area in painter coordinates + \param canvasRect Contents rect of the canvas in painter coordinates +*/ +void QwtPolarCurve::draw( QPainter *painter, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, double radius, + const QRectF &canvasRect ) const +{ + Q_UNUSED( radius ); + Q_UNUSED( canvasRect ); + + draw( painter, azimuthMap, radialMap, pole, 0, -1 ); +} + +/*! + \brief Draw an interval of the curve + \param painter Painter + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param from index of the first point to be painted + \param to index of the last point to be painted. If to < 0 the + curve will be painted to its last point. + + \sa drawCurve(), drawSymbols(), +*/ +void QwtPolarCurve::draw( QPainter *painter, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const +{ + if ( !painter || dataSize() <= 0 ) + return; + + if ( to < 0 ) + to = dataSize() - 1; + + if ( qwtVerifyRange( dataSize(), from, to ) > 0 ) + { + painter->save(); + painter->setPen( d_data->pen ); + + drawCurve( painter, d_data->style, + azimuthMap, radialMap, pole, from, to ); + + painter->restore(); + + if ( d_data->symbol->style() != QwtSymbol::NoSymbol ) + { + painter->save(); + drawSymbols( painter, *d_data->symbol, + azimuthMap, radialMap, pole, from, to ); + painter->restore(); + } + } +} + +/*! + Draw the line part (without symbols) of a curve interval. + + \param painter Painter + \param style Curve style, see QwtPolarCurve::CurveStyle + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param from index of the first point to be painted + \param to index of the last point to be painted. + \sa draw(), drawLines() +*/ +void QwtPolarCurve::drawCurve( QPainter *painter, int style, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const +{ + switch ( style ) + { + case Lines: + drawLines( painter, azimuthMap, radialMap, pole, from, to ); + break; + case NoCurve: + default: + break; + } +} + +/*! + Draw lines + + \param painter Painter + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param from index of the first point to be painted + \param to index of the last point to be painted. + \sa draw(), drawLines(), setCurveFitter() +*/ +void QwtPolarCurve::drawLines( QPainter *painter, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const +{ + int size = to - from + 1; + if ( size <= 0 ) + return; + + QPolygonF polyline; + if ( d_data->curveFitter ) + { + QPolygonF points( size ); + for ( int j = from; j <= to; j++ ) + { + const QwtPointPolar point = sample( j ); + points[j - from] = QPointF( point.azimuth(), point.radius() ); + } + + points = d_data->curveFitter->fitCurve( points ); + + polyline.resize( points.size() ); + + QPointF *polylineData = polyline.data(); + QPointF *pointsData = points.data(); + + for ( int i = 0; i < points.size(); i++ ) + { + const QwtPointPolar point( pointsData[i].x(), pointsData[i].y() ); + + double r = radialMap.transform( point.radius() ); + const double a = azimuthMap.transform( point.azimuth() ); + + polylineData[i] = qwtPolar2Pos( pole, r, a ); + } + } + else + { + polyline.resize( size ); + QPointF *polylineData = polyline.data(); + + for ( int i = from; i <= to; i++ ) + { + QwtPointPolar point = sample( i ); + if ( !qwtInsidePole( radialMap, point.radius() ) ) + { + double r = radialMap.transform( point.radius() ); + const double a = azimuthMap.transform( point.azimuth() ); + polylineData[i - from] = qwtPolar2Pos( pole, r, a ); + } + else + { + polylineData[i - from] = pole; + } + } + } + + QRectF clipRect; + if ( painter->hasClipping() ) + clipRect = painter->clipRegion().boundingRect(); + else + { + clipRect = painter->window(); + if ( !clipRect.isEmpty() ) + clipRect = painter->transform().inverted().mapRect( clipRect ); + } + + if ( !clipRect.isEmpty() ) + { + double off = qCeil( qMax( 1.0, painter->pen().widthF() ) ); + clipRect = clipRect.toRect().adjusted( -off, -off, off, off ); + polyline = QwtClipper::clipPolygonF( clipRect, polyline ); + } + + QwtPainter::drawPolyline( painter, polyline ); + painter->drawPolyline( polyline ); +} + +/*! + Draw symbols + + \param painter Painter + \param symbol Curve symbol + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param from index of the first point to be painted + \param to index of the last point to be painted. + + \sa setSymbol(), draw(), drawCurve() +*/ +void QwtPolarCurve::drawSymbols( QPainter *painter, const QwtSymbol &symbol, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const +{ + painter->setBrush( symbol.brush() ); + painter->setPen( symbol.pen() ); + + const int chunkSize = 500; + + for ( int i = from; i <= to; i += chunkSize ) + { + const int n = qMin( chunkSize, to - i + 1 ); + + QPolygonF points; + for ( int j = 0; j < n; j++ ) + { + const QwtPointPolar point = sample( i + j ); + + if ( !qwtInsidePole( radialMap, point.radius() ) ) + { + const double r = radialMap.transform( point.radius() ); + const double a = azimuthMap.transform( point.azimuth() ); + + points += qwtPolar2Pos( pole, r, a ); + } + else + { + points += pole; + } + } + + if ( points.size() > 0 ) + symbol.drawSymbols( painter, points ); + } +} + +/*! + \return Number of points + \sa setData() +*/ +size_t QwtPolarCurve::dataSize() const +{ + return d_series->size(); +} + +//! Update the widget that represents the curve on the legend +void QwtPolarCurve::updateLegend( QwtLegend *legend ) const +{ + if ( legend && testItemAttribute( QwtPolarCurve::Legend ) + && ( d_data->legendAttributes & QwtPolarCurve::LegendShowSymbol ) + && d_data->symbol + && d_data->symbol->style() != QwtSymbol::NoSymbol ) + { + QWidget *lgdItem = legend->find( this ); + if ( lgdItem == NULL ) + { + lgdItem = legendItem(); + if ( lgdItem ) + legend->insert( this, lgdItem ); + } + + QwtLegendItem *l = qobject_cast( lgdItem ); + if ( l ) + { + QSize sz = d_data->symbol->boundingSize(); + sz += QSize( 2, 2 ); // margin + + if ( d_data->legendAttributes & QwtPolarCurve::LegendShowLine ) + { + // Avoid, that the line is completely covered by the symbol + + int w = qCeil( 1.5 * sz.width() ); + if ( w % 2 ) + w++; + + sz.setWidth( qMax( 8, w ) ); + } + + l->setIdentifierSize( sz ); + } + } + + QwtPolarItem::updateLegend( legend ); +} + +/*! + \brief Draw the identifier representing the curve on the legend + + \param painter Qt Painter + \param rect Bounding rectangle for the identifier + + \sa setLegendAttribute +*/ +void QwtPolarCurve::drawLegendIdentifier( + QPainter *painter, const QRectF &rect ) const +{ + if ( rect.isEmpty() ) + return; + + const double dim = qMin( rect.width(), rect.height() ); + + QSizeF size( dim, dim ); + + QRectF r( 0, 0, size.width(), size.height() ); + r.moveCenter( rect.center() ); + + if ( d_data->legendAttributes == 0 ) + { + QBrush brush; + if ( style() != QwtPolarCurve::NoCurve ) + brush = QBrush( pen().color() ); + else if ( d_data->symbol && + ( d_data->symbol->style() != QwtSymbol::NoSymbol ) ) + { + brush = QBrush( d_data->symbol->pen().color() ); + } + if ( brush.style() != Qt::NoBrush ) + painter->fillRect( r, brush ); + } + if ( d_data->legendAttributes & QwtPolarCurve::LegendShowLine ) + { + if ( pen() != Qt::NoPen ) + { + painter->setPen( pen() ); + QwtPainter::drawLine( painter, rect.left(), rect.center().y(), + rect.right() - 1.0, rect.center().y() ); + } + } + if ( d_data->legendAttributes & QwtPolarCurve::LegendShowSymbol ) + { + if ( d_data->symbol && + ( d_data->symbol->style() != QwtSymbol::NoSymbol ) ) + { + QSize symbolSize = d_data->symbol->boundingSize(); + symbolSize -= QSize( 2, 2 ); + + // scale the symbol size down if it doesn't fit into rect. + + double xRatio = 1.0; + if ( rect.width() < symbolSize.width() ) + xRatio = rect.width() / symbolSize.width(); + double yRatio = 1.0; + if ( rect.height() < symbolSize.height() ) + yRatio = rect.height() / symbolSize.height(); + + const double ratio = qMin( xRatio, yRatio ); + + painter->save(); + painter->scale( ratio, ratio ); + + d_data->symbol->drawSymbol( painter, rect.center() / ratio ); + + painter->restore(); + } + } +} + +/*! + Interval, that is necessary to display the item + This interval can be useful for operations like clipping or autoscaling + + \param scaleId Scale index + \return bounding interval + + \sa QwtData::boundingRect() +*/ +QwtInterval QwtPolarCurve::boundingInterval( int scaleId ) const +{ + const QRectF boundingRect = d_series->boundingRect(); + + if ( scaleId == QwtPolar::ScaleAzimuth ) + return QwtInterval( boundingRect.left(), boundingRect.right() ); + + if ( scaleId == QwtPolar::ScaleRadius ) + return QwtInterval( boundingRect.top(), boundingRect.bottom() ); + + return QwtInterval(); +} Index: /trunk/BNC/qwtpolar/qwt_polar_curve.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_curve.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_curve.h (revision 4272) @@ -0,0 +1,163 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_CURVE_H +#define QWT_POLAR_CURVE_H + +#include "qwt_polar_global.h" +#include "qwt_polar_item.h" +#include +#include + +class QPainter; +class QwtSymbol; +class QwtCurveFitter; + +/*! + \brief An item, that represents a series of points + + A curve is the representation of a series of points in polar coordinates. + The points are connected to the curve using the abstract QwtData interface. + + \sa QwtPolarPlot, QwtSymbol, QwtScaleMap +*/ + +class QWT_POLAR_EXPORT QwtPolarCurve: public QwtPolarItem +{ +public: + /*! + Curve styles. + \sa setStyle(), style() + */ + enum CurveStyle + { + //! Don't draw a curve. Note: This doesn't affect the symbols. + 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, + + //! Values > 100 are reserved for user specific curve styles + 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 LegendAttributes; + + + explicit QwtPolarCurve(); + explicit QwtPolarCurve( const QwtText &title ); + explicit QwtPolarCurve( const QString &title ); + + virtual ~QwtPolarCurve(); + + virtual int rtti() const; + + void setLegendAttribute( LegendAttribute, bool on = true ); + bool testLegendAttribute( LegendAttribute ) const; + + void setData( QwtSeriesData *data ); + const QwtSeriesData *data() const; + + size_t dataSize() const; + QwtPointPolar sample( int i ) const; + + void setPen( const QPen & ); + const QPen &pen() const; + + void setStyle( CurveStyle style ); + CurveStyle style() const; + + void setSymbol( const QwtSymbol * ); + const QwtSymbol *symbol() const; + + void setCurveFitter( QwtCurveFitter * ); + QwtCurveFitter *curveFitter() const; + + virtual void draw( QPainter *p, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, double radius, + const QRectF &canvasRect ) const; + + virtual void draw( QPainter *p, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const; + + virtual void updateLegend( QwtLegend * ) const; + virtual QwtInterval boundingInterval( int scaleId ) const; + + virtual void drawLegendIdentifier( QPainter *, const QRectF & ) const; + +protected: + + void init(); + + virtual void drawCurve( QPainter *, int style, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const; + + virtual void drawSymbols( QPainter *, const QwtSymbol &, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const; + + void drawLines( QPainter *, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, int from, int to ) const; + +private: + QwtSeriesData *d_series; + + class PrivateData; + PrivateData *d_data; +}; + +//! \return the the curve data +inline const QwtSeriesData *QwtPolarCurve::data() const +{ + return d_series; +} + +/*! + \param i index + \return point at position i +*/ +inline QwtPointPolar QwtPolarCurve::sample( int i ) const +{ + return d_series->sample( i ); +} + +Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarCurve::LegendAttributes ) + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_fitter.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_fitter.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_fitter.cpp (revision 4272) @@ -0,0 +1,100 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_fitter.h" + +class QwtPolarFitter::PrivateData +{ +public: + PrivateData(): + stepCount( 5 ) + { + } + + int stepCount; +}; + +/*! + Constructor + + \param stepCount Number of points, that will be inserted between 2 points + \sa setStepCount() +*/ +QwtPolarFitter::QwtPolarFitter( int stepCount ) +{ + d_data = new PrivateData; + d_data->stepCount = stepCount; +} + +//! Destructor +QwtPolarFitter::~QwtPolarFitter() +{ + delete d_data; +} + +/*! + Assign the number of points, that will be inserted between 2 points + The default value is 5. + + \param stepCount Number of steps + + \sa stepCount() +*/ +void QwtPolarFitter::setStepCount( int stepCount ) +{ + d_data->stepCount = qMax( stepCount, 0 ); +} + +/*! + \return Number of points, that will be inserted between 2 points + \sa setStepCount() +*/ +int QwtPolarFitter::stepCount() const +{ + return d_data->stepCount; +} + +/*! + Insert stepCount() number of additional points between 2 elements + of points. + + \param points Array of points + \return Array of points including the additional points +*/ +QPolygonF QwtPolarFitter::fitCurve( const QPolygonF &points ) const +{ + if ( d_data->stepCount <= 0 || points.size() <= 1 ) + return points; + + QPolygonF fittedPoints; + + int numPoints = points.size() + ( points.size() - 1 ) * d_data->stepCount; + + fittedPoints.resize( numPoints ); + + int index = 0; + fittedPoints[index++] = points[0]; + for ( int i = 1; i < points.size(); i++ ) + { + const QPointF &p1 = points[i-1]; + const QPointF &p2 = points[i]; + + const double dx = ( p2.x() - p1.x() ) / d_data->stepCount; + const double dy = ( p2.y() - p1.y() ) / d_data->stepCount; + for ( int j = 1; j <= d_data->stepCount; j++ ) + { + const double x = p1.x() + j * dx; + const double y = p1.y() + j * dy; + + fittedPoints[index++] = QPointF( x, y ); + } + } + fittedPoints.resize( index ); + + return fittedPoints; +} Index: /trunk/BNC/qwtpolar/qwt_polar_fitter.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_fitter.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_fitter.h (revision 4272) @@ -0,0 +1,40 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_FITTER_H +#define QWT_POLAR_FITTER_H + +#include "qwt_polar_global.h" +#include + +/*! + \brief A simple curve fitter for polar points + + QwtPolarFitter adds equidistant points between 2 curve points, + so that the connection gets rounded according to the nature of + a polar plot. + + \sa QwtPolarCurve::setCurveFitter() +*/ +class QWT_POLAR_EXPORT QwtPolarFitter: public QwtCurveFitter +{ +public: + QwtPolarFitter( int stepCount = 5 ); + virtual ~QwtPolarFitter(); + + void setStepCount( int size ); + int stepCount() const; + + virtual QPolygonF fitCurve( const QPolygonF & ) const; + +private: + class PrivateData; + PrivateData *d_data; +}; + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_global.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_global.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_global.h (revision 4272) @@ -0,0 +1,43 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_GLOBAL_H +#define QWT_POLAR_GLOBAL_H + +#include + +// QWT_POLAR_VERSION is (major << 16) + (minor << 8) + patch. + +#define QWT_POLAR_VERSION 0x010000 +#define QWT_POLAR_VERSION_STR "1.0.0" + +#if defined(Q_WS_WIN) || defined(Q_WS_S60) + +#if defined(_MSC_VER) /* MSVC Compiler */ +/* template-class specialization 'identifier' is already instantiated */ +#pragma warning(disable: 4660) +#endif // _MSC_VER + +#ifdef QWT_POLAR_DLL + +#if defined(QWT_POLAR_MAKEDLL) // create a Qwt DLL library +#define QWT_POLAR_EXPORT __declspec(dllexport) +#define QWT_POLAR_TEMPLATEDLL +#else // use a Qwt DLL library +#define QWT_POLAR_EXPORT __declspec(dllimport) +#endif + +#endif // QWT_POLAR_MAKEDLL + +#endif // Q_WS_WIN + +#ifndef QWT_POLAR_EXPORT +#define QWT_POLAR_EXPORT +#endif + +#endif // QWT_POLAR_GLOBAL_H Index: /trunk/BNC/qwtpolar/qwt_polar_grid.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_grid.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_grid.cpp (revision 4272) @@ -0,0 +1,1129 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_grid.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static inline bool isClose( double value1, double value2 ) +{ + return qAbs( value1 - value2 ) < DBL_EPSILON; +} + +class QwtPolarGrid::AxisData +{ +public: + AxisData(): + isVisible( false ), + scaleDraw( NULL ) + { + } + ~AxisData() + { + delete scaleDraw; + } + + bool isVisible; + mutable QwtAbstractScaleDraw *scaleDraw; + QPen pen; + QFont font; +}; + +class QwtPolarGrid::GridData +{ +public: + GridData(): + isVisible( true ), + isMinorVisible( false ) + { + } + + bool isVisible; + bool isMinorVisible; + QwtScaleDiv scaleDiv; + + QPen majorPen; + QPen minorPen; +}; + +class QwtPolarGrid::PrivateData +{ +public: + GridData gridData[QwtPolar::ScaleCount]; + AxisData axisData[QwtPolar::AxesCount]; + QwtPolarGrid::DisplayFlags displayFlags; + QwtPolarGrid::GridAttributes attributes; +}; + +/*! + \brief Constructor + + Enables major and disables minor grid lines. + The azimuth and right radial axis are visible. all other axes + are hidden. Autoscaling is enabled. +*/ +QwtPolarGrid::QwtPolarGrid(): + QwtPolarItem( QwtText( "Grid" ) ) +{ + d_data = new PrivateData; + + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + AxisData &axis = d_data->axisData[axisId]; + switch( axisId ) + { + case QwtPolar::AxisAzimuth: + { + axis.scaleDraw = new QwtRoundScaleDraw; + axis.scaleDraw->setTickLength( QwtScaleDiv::MinorTick, 2 ); + axis.scaleDraw->setTickLength( QwtScaleDiv::MediumTick, 2 ); + axis.scaleDraw->setTickLength( QwtScaleDiv::MajorTick, 4 ); + axis.isVisible = true; + break; + } + case QwtPolar::AxisLeft: + { + QwtScaleDraw *scaleDraw = new QwtScaleDraw; + scaleDraw->setAlignment( QwtScaleDraw::BottomScale ); + + axis.scaleDraw = scaleDraw; + axis.isVisible = false; + break; + } + case QwtPolar::AxisRight: + { + QwtScaleDraw *scaleDraw = new QwtScaleDraw; + scaleDraw->setAlignment( QwtScaleDraw::BottomScale ); + + axis.scaleDraw = scaleDraw; + axis.isVisible = true; + break; + } + case QwtPolar::AxisTop: + { + QwtScaleDraw *scaleDraw = new QwtScaleDraw; + scaleDraw->setAlignment( QwtScaleDraw::LeftScale ); + + axis.scaleDraw = scaleDraw; + axis.isVisible = false; + break; + } + case QwtPolar::AxisBottom: + { + QwtScaleDraw *scaleDraw = new QwtScaleDraw; + scaleDraw->setAlignment( QwtScaleDraw::LeftScale ); + + axis.scaleDraw = scaleDraw; + axis.isVisible = true; + break; + } + default:; + } + } + + d_data->attributes = AutoScaling; + + d_data->displayFlags = 0; + d_data->displayFlags |= SmartOriginLabel; + d_data->displayFlags |= HideMaxRadiusLabel; + d_data->displayFlags |= ClipAxisBackground; + d_data->displayFlags |= SmartScaleDraw; + d_data->displayFlags |= ClipGridLines; + + setZ( 10.0 ); + setRenderHint( RenderAntialiased, true ); +} + +//! Destructor +QwtPolarGrid::~QwtPolarGrid() +{ + delete d_data; +} + +//! \return QwtPlotItem::Rtti_PolarGrid +int QwtPolarGrid::rtti() const +{ + return QwtPolarItem::Rtti_PolarGrid; +} + +/*! + Change the display flags + + \param flag See DisplayFlag + \param on true/false +*/ +void QwtPolarGrid::setDisplayFlag( DisplayFlag flag, bool on ) +{ + if ( ( ( d_data->displayFlags & flag ) != 0 ) != on ) + { + if ( on ) + d_data->displayFlags |= flag; + else + d_data->displayFlags &= ~flag; + + itemChanged(); + } +} + +/*! + \return true, if flag is enabled + \param flag See DisplayFlag +*/ +bool QwtPolarGrid::testDisplayFlag( DisplayFlag flag ) const +{ + return ( d_data->displayFlags & flag ); +} + +/*! + \brief Specify an attribute for the grid + + \param attribute Grid attribute + \param on On/Off + + /sa GridAttribute, testGridAttribute(), updateScaleDiv(), + QwtPolarPlot::zoom(), QwtPolarPlot::scaleDiv() +*/ +void QwtPolarGrid::setGridAttribute( GridAttribute attribute, bool on ) +{ + if ( bool( d_data->attributes & attribute ) == on ) + return; + + if ( on ) + d_data->attributes |= attribute; + else + d_data->attributes &= ~attribute; + + itemChanged(); +} + +/*! + \return true, if attribute is enabled + \sa GridAttribute, setGridAttribute() +*/ +bool QwtPolarGrid::testGridAttribute( GridAttribute attribute ) const +{ + return d_data->attributes & attribute; +} + +/*! + Assign a pen for painting an axis + + \param axisId Axis id (QwtPolar::Axis) + \param pen Pen + + \sa axisPen() +*/ +void QwtPolarGrid::setAxisPen( int axisId, const QPen &pen ) +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return; + + AxisData &axisData = d_data->axisData[axisId]; + if ( axisData.pen != pen ) + { + axisData.pen = pen; + itemChanged(); + } +} + +/*! + Show/Hide grid lines for a scale + + \param scaleId Scale id ( QwtPolar::Scale ) + \param show true/false +*/ +void QwtPolarGrid::showGrid( int scaleId, bool show ) +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return; + + GridData &grid = d_data->gridData[scaleId]; + if ( grid.isVisible != show ) + { + grid.isVisible = show; + itemChanged(); + } +} + +/*! + \return true if grid lines are enabled + \param scaleId Scale id ( QwtPolar::Scale ) + \sa QwtPolar::Scale, showGrid() +*/ +bool QwtPolarGrid::isGridVisible( int scaleId ) const +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return false; + + return d_data->gridData[scaleId].isVisible; +} + +/*! + Show/Hide minor grid lines for a scale + + To display minor grid lines. showGrid() needs to be enabled too. + + \param scaleId Scale id ( QwtPolar::Scale ) + \param show true/false + + \sa showGrid +*/ +void QwtPolarGrid::showMinorGrid( int scaleId, bool show ) +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return; + + GridData &grid = d_data->gridData[scaleId]; + if ( grid.isMinorVisible != show ) + { + grid.isMinorVisible = show; + itemChanged(); + } +} + +/*! + \return true if minor grid lines are enabled + \param scaleId Scale id ( QwtPolar::Scale ) + \sa showMinorGrid() +*/ +bool QwtPolarGrid::isMinorGridVisible( int scaleId ) const +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return false; + + return d_data->gridData[scaleId].isMinorVisible; +} + +/*! + Show/Hide an axis + + \param axisId Axis id (QwtPolar::Axis) + \param show true/false + + \sa isAxisVisible() +*/ +void QwtPolarGrid::showAxis( int axisId, bool show ) +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return; + + AxisData &axisData = d_data->axisData[axisId]; + if ( axisData.isVisible != show ) + { + axisData.isVisible = show; + itemChanged(); + } +} + +/*! + \return true if the axis is visible + \param axisId Axis id (QwtPolar::Axis) + + \sa showAxis() +*/ +bool QwtPolarGrid::isAxisVisible( int axisId ) const +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return false; + + return d_data->axisData[axisId].isVisible; +} + +/*! + Assign a pen for all axes and grid lines + + \param pen Pen + \sa setMajorGridPen(), setMinorGridPen(), setAxisPen() +*/ +void QwtPolarGrid::setPen( const QPen &pen ) +{ + bool isChanged = false; + + for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ ) + { + GridData &grid = d_data->gridData[scaleId]; + if ( grid.majorPen != pen || grid.minorPen != pen ) + { + grid.majorPen = pen; + grid.minorPen = pen; + isChanged = true; + } + } + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + AxisData &axis = d_data->axisData[axisId]; + if ( axis.pen != pen ) + { + axis.pen = pen; + isChanged = true; + } + } + if ( isChanged ) + itemChanged(); +} + +/*! + Assign a font for all scale tick labels + + \param font Font + \sa setAxisFont() +*/ +void QwtPolarGrid::setFont( const QFont &font ) +{ + bool isChanged = false; + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + AxisData &axis = d_data->axisData[axisId]; + if ( axis.font != font ) + { + axis.font = font; + isChanged = true; + } + } + if ( isChanged ) + itemChanged(); +} + +/*! + Assign a pen for the major grid lines + + \param pen Pen + \sa setPen(), setMinorGridPen(), majorGridPen +*/ +void QwtPolarGrid::setMajorGridPen( const QPen &pen ) +{ + bool isChanged = false; + + for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ ) + { + GridData &grid = d_data->gridData[scaleId]; + if ( grid.majorPen != pen ) + { + grid.majorPen = pen; + isChanged = true; + } + } + if ( isChanged ) + itemChanged(); +} + +/*! + Assign a pen for the major grid lines of a specific scale + + \param scaleId Scale id ( QwtPolar::Scale ) + \param pen Pen + \sa setPen(), setMinorGridPen(), majorGridPen +*/ +void QwtPolarGrid::setMajorGridPen( int scaleId, const QPen &pen ) +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return; + + GridData &grid = d_data->gridData[scaleId]; + if ( grid.majorPen != pen ) + { + grid.majorPen = pen; + itemChanged(); + } +} + +/*! + \return Pen for painting the major grid lines of a specific scale + \param scaleId Scale id ( QwtPolar::Scale ) + \sa setMajorGridPen(), minorGridPen() +*/ +QPen QwtPolarGrid::majorGridPen( int scaleId ) const +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return QPen(); + + const GridData &grid = d_data->gridData[scaleId]; + return grid.majorPen; +} + +/*! + Assign a pen for the minor grid lines + + \param pen Pen + \sa setPen(), setMajorGridPen(), minorGridPen() +*/ +void QwtPolarGrid::setMinorGridPen( const QPen &pen ) +{ + bool isChanged = false; + + for ( int scaleId = 0; scaleId < QwtPolar::ScaleCount; scaleId++ ) + { + GridData &grid = d_data->gridData[scaleId]; + if ( grid.minorPen != pen ) + { + grid.minorPen = pen; + isChanged = true; + } + } + if ( isChanged ) + itemChanged(); +} + +/*! + Assign a pen for the minor grid lines of a specific scale + + \param scaleId Scale id ( QwtPolar::Scale ) + \param pen Pen + \sa setPen(), setMajorGridPen(), minorGridPen +*/ +void QwtPolarGrid::setMinorGridPen( int scaleId, const QPen &pen ) +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return; + + GridData &grid = d_data->gridData[scaleId]; + if ( grid.minorPen != pen ) + { + grid.minorPen = pen; + itemChanged(); + } +} + +/*! + \return Pen for painting the minor grid lines of a specific scale + \param scaleId Scale id ( QwtPolar::Scale ) +*/ +QPen QwtPolarGrid::minorGridPen( int scaleId ) const +{ + if ( scaleId < 0 || scaleId >= QwtPolar::ScaleCount ) + return QPen(); + + const GridData &grid = d_data->gridData[scaleId]; + return grid.minorPen; +} + +/*! + \return Pen for painting a specific axis + + \param axisId Axis id (QwtPolar::Axis) + \sa setAxisPen() +*/ +QPen QwtPolarGrid::axisPen( int axisId ) const +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return QPen(); + + return d_data->axisData[axisId].pen; +} + +/*! + Assign a font for the tick labels of a specific axis + + \param axisId Axis id (QwtPolar::Axis) + \param font new Font +*/ +void QwtPolarGrid::setAxisFont( int axisId, const QFont &font ) +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return; + + AxisData &axisData = d_data->axisData[axisId]; + if ( axisData.font != font ) + { + axisData.font = font; + itemChanged(); + } +} + +/*! + \return Font for the tick labels of a specific axis + \param axisId Axis id (QwtPolar::Axis) +*/ +QFont QwtPolarGrid::axisFont( int axisId ) const +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return QFont(); + + return d_data->axisData[axisId].font; +} + +/*! + Draw the grid and axes + + \param painter Painter + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param radius Radius of the complete plot area in painter coordinates + \param canvasRect Contents rect of the canvas in painter coordinates +*/ +void QwtPolarGrid::draw( QPainter *painter, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, double radius, + const QRectF &canvasRect ) const +{ + updateScaleDraws( azimuthMap, radialMap, pole, radius ); + + painter->save(); + + if ( testDisplayFlag( ClipAxisBackground ) ) + { + QRegion clipRegion( canvasRect.toRect() ); + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + const AxisData &axis = d_data->axisData[axisId]; + if ( axisId != QwtPolar::AxisAzimuth && axis.isVisible ) + { + QwtScaleDraw *scaleDraw = static_cast( axis.scaleDraw ); + if ( scaleDraw->hasComponent( QwtScaleDraw::Labels ) ) + { + const QList &ticks = + scaleDraw->scaleDiv().ticks( QwtScaleDiv::MajorTick ); + for ( int i = 0; i < int( ticks.size() ); i++ ) + { + if ( !scaleDraw->scaleDiv().contains( ticks[i] ) ) + continue; + + QRect labelRect = + scaleDraw->boundingLabelRect( axis.font, ticks[i] ); + + const int margin = 2; + labelRect.adjust( -margin, -margin, margin, margin ); + + if ( labelRect.isValid() ) + clipRegion -= QRegion( labelRect ); + } + } + } + } + painter->setClipRegion( clipRegion ); + } + + // draw radial grid + + const GridData &radialGrid = d_data->gridData[QwtPolar::Radius]; + if ( radialGrid.isVisible && radialGrid.isMinorVisible ) + { + painter->setPen( radialGrid.minorPen ); + + drawCircles( painter, canvasRect, pole, radialMap, + radialGrid.scaleDiv.ticks( QwtScaleDiv::MinorTick ) ); + drawCircles( painter, canvasRect, pole, radialMap, + radialGrid.scaleDiv.ticks( QwtScaleDiv::MediumTick ) ); + } + if ( radialGrid.isVisible ) + { + painter->setPen( radialGrid.majorPen ); + + drawCircles( painter, canvasRect, pole, radialMap, + radialGrid.scaleDiv.ticks( QwtScaleDiv::MajorTick ) ); + } + + // draw azimuth grid + + const GridData &azimuthGrid = + d_data->gridData[QwtPolar::Azimuth]; + + if ( azimuthGrid.isVisible && azimuthGrid.isMinorVisible ) + { + painter->setPen( azimuthGrid.minorPen ); + + drawRays( painter, canvasRect, pole, radius, azimuthMap, + azimuthGrid.scaleDiv.ticks( QwtScaleDiv::MinorTick ) ); + drawRays( painter, canvasRect, pole, radius, azimuthMap, + azimuthGrid.scaleDiv.ticks( QwtScaleDiv::MediumTick ) ); + } + if ( azimuthGrid.isVisible ) + { + painter->setPen( azimuthGrid.majorPen ); + + drawRays( painter, canvasRect, pole, radius, azimuthMap, + azimuthGrid.scaleDiv.ticks( QwtScaleDiv::MajorTick ) ); + } + painter->restore(); + + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + const AxisData &axis = d_data->axisData[axisId]; + if ( axis.isVisible ) + { + painter->save(); + drawAxis( painter, axisId ); + painter->restore(); + } + } +} + +/*! + Draw lines from the pole + + \param painter Painter + \param canvasRect Contents rect of the canvas in painter coordinates + \param pole Position of the pole in painter coordinates + \param radius Length of the lines in painter coordinates + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param values Azimuth values, indicating the direction of the lines +*/ +void QwtPolarGrid::drawRays( + QPainter *painter, const QRectF &canvasRect, + const QPointF &pole, double radius, + const QwtScaleMap &azimuthMap, const QList &values ) const +{ + for ( int i = 0; i < int( values.size() ); i++ ) + { + double azimuth = azimuthMap.transform( values[i] ); + azimuth = ::fmod( azimuth, 2 * M_PI ); + + bool skipLine = false; + if ( testDisplayFlag( SmartScaleDraw ) ) + { + const QwtAbstractScaleDraw::ScaleComponent bone = + QwtAbstractScaleDraw::Backbone; + if ( isClose( azimuth, 0.0 ) ) + { + const AxisData &axis = d_data->axisData[QwtPolar::AxisRight]; + if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) ) + skipLine = true; + } + else if ( isClose( azimuth, M_PI / 2 ) ) + { + const AxisData &axis = d_data->axisData[QwtPolar::AxisTop]; + if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) ) + skipLine = true; + } + else if ( isClose( azimuth, M_PI ) ) + { + const AxisData &axis = d_data->axisData[QwtPolar::AxisLeft]; + if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) ) + skipLine = true; + } + else if ( isClose( azimuth, 3 * M_PI / 2.0 ) ) + { + const AxisData &axis = d_data->axisData[QwtPolar::AxisBottom]; + if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) ) + skipLine = true; + } + } + if ( !skipLine ) + { + const QPointF pos = qwtPolar2Pos( pole, radius, azimuth ); + + /* + Qt4 is horrible slow, when painting primitives, + with coordinates far outside the visible area. + */ + + QPolygonF polygon( 2 ); + polygon[0] = pole.toPoint(); + polygon[1] = pos.toPoint(); + + if ( testDisplayFlag( ClipGridLines ) ) + polygon = QwtClipper::clipPolygonF( canvasRect, polygon ); + + QwtPainter::drawPolyline( painter, polygon ); + } + } +} + +/*! + Draw circles + + \param painter Painter + \param canvasRect Contents rect of the canvas in painter coordinates + \param pole Position of the pole in painter coordinates + \param radialMap Maps radius values into painter coordinates. + \param values Radial values, indicating the distances from the pole +*/ +void QwtPolarGrid::drawCircles( + QPainter *painter, const QRectF &canvasRect, + const QPointF &pole, const QwtScaleMap &radialMap, + const QList &values ) const +{ + for ( int i = 0; i < int( values.size() ); i++ ) + { + const double val = values[i]; + + const GridData &gridData = + d_data->gridData[QwtPolar::Radius]; + + bool skipLine = false; + if ( testDisplayFlag( SmartScaleDraw ) ) + { + const AxisData &axis = d_data->axisData[QwtPolar::AxisAzimuth]; + if ( axis.isVisible && + axis.scaleDraw->hasComponent( QwtAbstractScaleDraw::Backbone ) ) + { + if ( isClose( val, gridData.scaleDiv.upperBound() ) ) + skipLine = true; + } + } + + if ( isClose( val, gridData.scaleDiv.lowerBound() ) ) + skipLine = true; + + if ( !skipLine ) + { + const double radius = radialMap.transform( val ); + + QRectF outerRect( 0, 0, 2 * radius, 2 * radius ); + outerRect.moveCenter( pole ); + + if ( testDisplayFlag( ClipGridLines ) ) + { + /* + Qt4 is horrible slow, when painting primitives, + with coordinates far outside the visible area. + We need to clip. + */ + + const QVector angles = + QwtClipper::clipCircle( canvasRect, pole, radius ); + for ( int i = 0; i < angles.size(); i++ ) + { + const QwtInterval intv = angles[i]; + if ( intv.minValue() == 0 && intv.maxValue() == 2 * M_PI ) + QwtPainter::drawEllipse( painter, outerRect ); + else + { + const double from = intv.minValue() / M_PI * 180; + const double to = intv.maxValue() / M_PI * 180; + double span = to - from; + if ( span < 0.0 ) + span += 360.0; + + painter->drawArc( outerRect, + qRound( from * 16 ), qRound( span * 16 ) ); + } + } + } + else + { + QwtPainter::drawEllipse( painter, outerRect ); + } + } + } +} + +/*! + Paint an axis + + \param painter Painter + \param axisId Axis id (QwtPolar::Axis) +*/ +void QwtPolarGrid::drawAxis( QPainter *painter, int axisId ) const +{ + if ( axisId < 0 || axisId >= QwtPolar::AxesCount ) + return; + + AxisData &axis = d_data->axisData[axisId]; + + painter->setPen( axis.pen ); + painter->setFont( axis.font ); + + QPalette pal; + pal.setColor( QPalette::Foreground, axis.pen.color() ); + pal.setColor( QPalette::Text, axis.pen.color() ); + + axis.scaleDraw->draw( painter, pal ); +} + +/*! + Update the axis scale draw geometries + + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param radius Radius of the complete plot area in painter coordinates + + \sa updateScaleDiv() +*/ +void QwtPolarGrid::updateScaleDraws( + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, double radius ) const +{ + const QPoint p = pole.toPoint(); + + const QwtInterval interval = + d_data->gridData[QwtPolar::ScaleRadius].scaleDiv.interval(); + + const int min = radialMap.transform( interval.minValue() ); + const int max = radialMap.transform( interval.maxValue() ); + const int l = max - min; + + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + AxisData &axis = d_data->axisData[axisId]; + + if ( axisId == QwtPolar::AxisAzimuth ) + { + QwtRoundScaleDraw *scaleDraw = + static_cast( axis.scaleDraw ); + + scaleDraw->setRadius( qRound( radius ) ); + scaleDraw->moveCenter( p ); + + double from = ::fmod( 90.0 - azimuthMap.p1() * 180.0 / M_PI, 360.0 ); + if ( from < 0.0 ) + from += 360.0; + + scaleDraw->setAngleRange( from, from - 360.0 ); + scaleDraw->setTransformation( azimuthMap.transformation()->copy() ); + } + else + { + QwtScaleDraw *scaleDraw = + static_cast( axis.scaleDraw ); + + switch( axisId ) + { + case QwtPolar::AxisLeft: + { + scaleDraw->move( p.x() - min, p.y() ); + scaleDraw->setLength( -l ); + break; + } + case QwtPolar::AxisRight: + { + scaleDraw->move( p.x() + min, p.y() ); + scaleDraw->setLength( l ); + break; + } + case QwtPolar::AxisTop: + { + scaleDraw->move( p.x(), p.y() - max ); + scaleDraw->setLength( l ); + break; + } + case QwtPolar::AxisBottom: + { + scaleDraw->move( p.x(), p.y() + max ); + scaleDraw->setLength( -l ); + break; + } + } + scaleDraw->setTransformation( radialMap.transformation()->copy() ); + } + } +} + +/*! + \brief Update the item to changes of the axes scale division + + If AutoScaling is enabled the radial scale is calculated + from the interval, otherwise the scales are adopted to + the plot scales. + + \param azimuthScaleDiv Scale division of the azimuth-scale + \param radialScaleDiv Scale division of the radius-axis + \param interval The interval of the radius-axis, that is + visible on the canvas + + \sa QwtPolarPlot::setGridAttributes() +*/ + +void QwtPolarGrid::updateScaleDiv( const QwtScaleDiv &azimuthScaleDiv, + const QwtScaleDiv &radialScaleDiv, const QwtInterval &interval ) +{ + GridData &radialGrid = d_data->gridData[QwtPolar::Radius]; + + const QwtPolarPlot *plt = plot(); + if ( plt && testGridAttribute( AutoScaling ) ) + { + const QwtScaleEngine *se = plt->scaleEngine( QwtPolar::Radius ); + radialGrid.scaleDiv = se->divideScale( + interval.minValue(), interval.maxValue(), + plt->scaleMaxMajor( QwtPolar::Radius ), + plt->scaleMaxMinor( QwtPolar::Radius ), 0 ); + } + else + { + if ( radialGrid.scaleDiv != radialScaleDiv ) + radialGrid.scaleDiv = radialScaleDiv; + } + + GridData &azimuthGrid = d_data->gridData[QwtPolar::Azimuth]; + if ( azimuthGrid.scaleDiv != azimuthScaleDiv ) + { + azimuthGrid.scaleDiv = azimuthScaleDiv; + } + + bool hasOrigin = false; + for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ ) + { + AxisData &axis = d_data->axisData[axisId]; + if ( axis.isVisible && axis.scaleDraw ) + { + if ( axisId == QwtPolar::AxisAzimuth ) + { + axis.scaleDraw->setScaleDiv( azimuthGrid.scaleDiv ); + if ( testDisplayFlag( SmartScaleDraw ) ) + { + axis.scaleDraw->enableComponent( + QwtAbstractScaleDraw::Ticks, !azimuthGrid.isVisible ); + } + } + else + { + QwtScaleDiv sd = radialGrid.scaleDiv; + + QList &ticks = + const_cast &>( sd.ticks( QwtScaleDiv::MajorTick ) ); + + if ( testDisplayFlag( SmartOriginLabel ) ) + { + bool skipOrigin = hasOrigin; + if ( !skipOrigin ) + { + if ( axisId == QwtPolar::AxisLeft + || axisId == QwtPolar::AxisRight ) + { + if ( d_data->axisData[QwtPolar::AxisBottom].isVisible ) + skipOrigin = true; + } + else + { + if ( d_data->axisData[QwtPolar::AxisLeft].isVisible ) + skipOrigin = true; + } + } + if ( ticks.size() > 0 && ticks.first() == sd.lowerBound() ) + { + if ( skipOrigin ) + ticks.removeFirst(); + else + hasOrigin = true; + } + } + + if ( testDisplayFlag( HideMaxRadiusLabel ) ) + { + if ( ticks.size() > 0 && ticks.last() == sd.upperBound() ) + ticks.removeLast(); + } + + axis.scaleDraw->setScaleDiv( sd ); + + if ( testDisplayFlag( SmartScaleDraw ) ) + { + axis.scaleDraw->enableComponent( + QwtAbstractScaleDraw::Ticks, !radialGrid.isVisible ); + } + + } + } + } +} + +/*! + \return Number of pixels, that are necessary to paint the azimuth scale + \sa QwtRoundScaleDraw::extent() +*/ +int QwtPolarGrid::marginHint() const +{ + const AxisData &axis = d_data->axisData[QwtPolar::AxisAzimuth]; + if ( axis.isVisible ) + { + const int extent = axis.scaleDraw->extent( axis.font ); + return extent; + } + + return 0; +} + +/*! + Returns the scale draw of a specified axis + + \param axisId axis index ( QwtPolar::AxisLeft <= axisId <= QwtPolar::AxisBottom) + \return specified scaleDraw for axis, or NULL if axis is invalid. + \sa azimuthScaleDraw() +*/ +const QwtScaleDraw *QwtPolarGrid::scaleDraw( int axisId ) const +{ + if ( axisId >= QwtPolar::AxisLeft || axisId <= QwtPolar::AxisBottom ) + return static_cast( d_data->axisData[axisId].scaleDraw ); + + return NULL; +} + +/*! + Returns the scale draw of a specified axis + + \param axisId axis index ( QwtPolar::AxisLeft <= axisId <= QwtPolar::AxisBottom) + \return specified scaleDraw for axis, or NULL if axis is invalid. + \sa setScaleDraw(), azimuthScaleDraw() +*/ +QwtScaleDraw *QwtPolarGrid::scaleDraw( int axisId ) +{ + if ( axisId >= QwtPolar::AxisLeft || axisId <= QwtPolar::AxisBottom ) + return static_cast( d_data->axisData[axisId].scaleDraw ); + + return NULL; +} + +/*! + \brief Set a scale draw + + \param axisId axis index ( QwtPolar::AxisLeft <= axisId <= QwtPolar::AxisBottom) + \param scaleDraw object responsible for drawing scales. + + \sa scaleDraw(), setAzimuthScaleDraw() +*/ +void QwtPolarGrid::setScaleDraw( int axisId, QwtScaleDraw *scaleDraw ) +{ + if ( axisId < QwtPolar::AxisLeft || axisId > QwtPolar::AxisBottom ) + return; + + AxisData &axisData = d_data->axisData[axisId]; + if ( axisData.scaleDraw != scaleDraw ) + { + delete axisData.scaleDraw; + axisData.scaleDraw = scaleDraw; + itemChanged(); + } +} + +/*! + \return Scale draw for the azimuth scale + \sa setAzimuthScaleDraw(), scaleDraw() +*/ +const QwtRoundScaleDraw *QwtPolarGrid::azimuthScaleDraw() const +{ + return static_cast( + d_data->axisData[QwtPolar::AxisAzimuth].scaleDraw ); +} + +/*! + \return Scale draw for the azimuth scale + \sa setAzimuthScaleDraw(), scaleDraw() +*/ +QwtRoundScaleDraw *QwtPolarGrid::azimuthScaleDraw() +{ + return static_cast( + d_data->axisData[QwtPolar::AxisAzimuth].scaleDraw ); +} + +/*! + \brief Set a scale draw for the azimuth scale + + \param scaleDraw object responsible for drawing scales. + \sa azimuthScaleDraw(), setScaleDraw() +*/ +void QwtPolarGrid::setAzimuthScaleDraw( QwtRoundScaleDraw *scaleDraw ) +{ + AxisData &axisData = d_data->axisData[QwtPolar::AxisAzimuth]; + if ( axisData.scaleDraw != scaleDraw ) + { + delete axisData.scaleDraw; + axisData.scaleDraw = scaleDraw; + itemChanged(); + } +} Index: /trunk/BNC/qwtpolar/qwt_polar_grid.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_grid.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_grid.h (revision 4272) @@ -0,0 +1,187 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_GRID_H +#define QWT_POLAR_GRID_H + +#include "qwt_polar_global.h" +#include "qwt_polar.h" +#include "qwt_polar_item.h" +#include "qwt_polar_plot.h" + +class QPainter; +class QPen; +class QwtScaleMap; +class QwtScaleDiv; +class QwtRoundScaleDraw; +class QwtScaleDraw; + +/*! + \brief An item which draws scales and grid lines on a polar plot. + + The QwtPolarGrid class can be used to draw a coordinate grid. + A coordinate grid consists of major and minor gridlines. + The locations of the gridlines are determined by the azimuth and radial + scale divisions. + + QwtPolarGrid is also responsible for drawing the axis representing the + scales. It is possible to display 4 radial and one azimuth axis. + + Whenever the scale divisions of the plot widget changes the grid + is synchronized by updateScaleDiv(). + + \sa QwtPolarPlot, QwtPolar::Axis +*/ + +class QWT_POLAR_EXPORT QwtPolarGrid: public QwtPolarItem +{ +public: + /*! + Mysterious flags trying to avoid conflicts, when painting the + scales and grid lines. + + The default setting enables all flags. + + \sa setDisplayFlag(), testDisplayFlag() + */ + 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 + canvas border. With HideMaxRadiusLabel enabled it is not painted. + */ + HideMaxRadiusLabel = 2, + + /*! + 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 + of a curve/spectrogram ). When ClipAxisBackground the bounding rect + of each label is added to the clip region. + */ + ClipAxisBackground = 4, + + /*! + Don't paint the backbone of the radial axes, when they are very close + to a line of the azimuth grid. + */ + SmartScaleDraw = 8, + + /*! + All grid lines are clipped against the plot area before being painted. + When the plot is zoomed in this will have an significant impact + on the performance of the painting cde. + */ + ClipGridLines = 16 + }; + + //! Display flags + typedef QFlags DisplayFlags; + + /*! + \brief Grid attributes + \sa setGridAttributes(), testGridAttributes() + */ + enum GridAttribute + { + /*! + 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 GridAttributes; + + explicit QwtPolarGrid(); + virtual ~QwtPolarGrid(); + + virtual int rtti() const; + + void setDisplayFlag( DisplayFlag, bool on = true ); + bool testDisplayFlag( DisplayFlag ) const; + + void setGridAttribute( GridAttribute, bool on = true ); + bool testGridAttribute( GridAttribute ) const; + + void showGrid( int scaleId, bool show = true ); + bool isGridVisible( int scaleId ) const; + + void showMinorGrid( int scaleId, bool show = true ); + bool isMinorGridVisible( int scaleId ) const; + + void showAxis( int axisId, bool show = true ); + bool isAxisVisible( int axisId ) const; + + void setPen( const QPen &p ); + void setFont( const QFont & ); + + void setMajorGridPen( const QPen &p ); + void setMajorGridPen( int scaleId, const QPen &p ); + QPen majorGridPen( int scaleId ) const; + + void setMinorGridPen( const QPen &p ); + void setMinorGridPen( int scaleId, const QPen &p ); + QPen minorGridPen( int scaleId ) const; + + void setAxisPen( int axisId, const QPen &p ); + QPen axisPen( int axisId ) const; + + void setAxisFont( int axisId, const QFont &p ); + QFont axisFont( int axisId ) const; + + 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 QPointF &pole, double radius, + const QRectF &rect ) const; + + virtual void updateScaleDiv( const QwtScaleDiv &azimuthMap, + const QwtScaleDiv &radialMap, const QwtInterval & ); + + virtual int marginHint() const; + +protected: + void drawRays( QPainter *, const QRectF &, + const QPointF &pole, double radius, + const QwtScaleMap &azimuthMap, const QList & ) const; + void drawCircles( QPainter *, const QRectF &, + const QPointF &pole, const QwtScaleMap &radialMap, + const QList & ) const; + + void drawAxis( QPainter *, int axisId ) const; + +private: + void updateScaleDraws( + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, const double radius ) const; + +private: + class GridData; + class AxisData; + class PrivateData; + PrivateData *d_data; +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarGrid::DisplayFlags ) +Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarGrid::GridAttributes ) + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_item.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_item.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_item.cpp (revision 4272) @@ -0,0 +1,453 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_plot.h" +#include "qwt_polar_item.h" +#include +#include +#include +#include + +class QwtPolarItem::PrivateData +{ +public: + PrivateData(): + plot( NULL ), + isVisible( true ), + attributes( 0 ), + renderHints( 0 ), + z( 0.0 ) + { + } + + mutable QwtPolarPlot *plot; + + bool isVisible; + QwtPolarItem::ItemAttributes attributes; + QwtPolarItem::RenderHints renderHints; + double z; + + QwtText title; +}; + +/*! + Constructor + + \param title Item title, f.e used on a legend + + \sa setTitle() +*/ +QwtPolarItem::QwtPolarItem( const QwtText &title ) +{ + d_data = new PrivateData; + d_data->title = title; +} + +//! Destroy the QwtPolarItem +QwtPolarItem::~QwtPolarItem() +{ + attach( NULL ); + delete d_data; +} + +/*! + \brief Attach the item to a plot. + + This method will attach a QwtPolarItem to the QwtPolarPlot argument. + It will first detach the QwtPolarItem from any plot from a previous + call to attach (if necessary). + If a NULL argument is passed, it will detach from any QwtPolarPlot it + was attached to. + + \param plot Plot widget + + \sa QwtPolarItem::detach() +*/ +void QwtPolarItem::attach( QwtPolarPlot *plot ) +{ + if ( plot == d_data->plot ) + return; + + // remove the item from the previous plot + + if ( d_data->plot ) + { + if ( d_data->plot->legend() ) + d_data->plot->legend()->remove( this ); + + d_data->plot->attachItem( this, false ); + + if ( d_data->plot->autoReplot() ) + d_data->plot->update(); + } + + d_data->plot = plot; + + if ( d_data->plot ) + { + // insert the item into the current plot + + d_data->plot->attachItem( this, true ); + itemChanged(); + } +} + +/*! + Return rtti for the specific class represented. QwtPolarItem is simply + a virtual interface class, and base classes will implement this method + with specific rtti values so a user can differentiate them. + + The rtti value is useful for environments, where the + runtime type information is disabled and it is not possible + to do a dynamic_cast<...>. + + \return rtti value + \sa RttiValues +*/ +int QwtPolarItem::rtti() const +{ + return Rtti_PolarItem; +} + +//! \return Attached plot +QwtPolarPlot *QwtPolarItem::plot() const +{ + return d_data->plot; +} + +/*! + Plot items are painted in increasing z-order. + + \return Z value + \sa setZ(), QwtPolarItemDict::itemList() +*/ +double QwtPolarItem::z() const +{ + return d_data->z; +} + +/*! + \brief Set the z value + + Plot items are painted in increasing z-order. + + \param z Z-value + \sa z(), QwtPolarItemDict::itemList() +*/ +void QwtPolarItem::setZ( double z ) +{ + if ( d_data->z != z ) + { + if ( d_data->plot ) + d_data->plot->attachItem( this, false ); + + d_data->z = z; + + if ( d_data->plot ) + d_data->plot->attachItem( this, true ); + + itemChanged(); + } +} + +/*! + Set a new title + + \param title Title + \sa title() +*/ +void QwtPolarItem::setTitle( const QString &title ) +{ + setTitle( QwtText( title ) ); +} + +/*! + Set a new title + + \param title Title + \sa title() +*/ +void QwtPolarItem::setTitle( const QwtText &title ) +{ + if ( d_data->title != title ) + { + d_data->title = title; + itemChanged(); + } +} + +/*! + \return Title of the item + \sa setTitle() +*/ +const QwtText &QwtPolarItem::title() const +{ + return d_data->title; +} + +/*! + Toggle an item attribute + + \param attribute Attribute type + \param on true/false + + \sa testItemAttribute(), ItemAttribute +*/ +void QwtPolarItem::setItemAttribute( ItemAttribute attribute, bool on ) +{ + if ( bool( d_data->attributes & attribute ) != on ) + { + if ( on ) + d_data->attributes |= attribute; + else + d_data->attributes &= ~attribute; + + itemChanged(); + } +} + +/*! + Test an item attribute + + \param attribute Attribute type + \return true/false + \sa setItemAttribute(), ItemAttribute +*/ +bool QwtPolarItem::testItemAttribute( ItemAttribute attribute ) const +{ + return d_data->attributes & attribute; +} + +/*! + Toggle an render hint + + \param hint Render hint + \param on true/false + + \sa testRenderHint(), RenderHint +*/ +void QwtPolarItem::setRenderHint( RenderHint hint, bool on ) +{ + if ( ( ( d_data->renderHints & hint ) != 0 ) != on ) + { + if ( on ) + d_data->renderHints |= hint; + else + d_data->renderHints &= ~hint; + + itemChanged(); + } +} + +/*! + Test a render hint + + \param hint Render hint + \return true/false + \sa setRenderHint(), RenderHint +*/ +bool QwtPolarItem::testRenderHint( RenderHint hint ) const +{ + return ( d_data->renderHints & hint ); +} + +//! Show the item +void QwtPolarItem::show() +{ + setVisible( true ); +} + +//! Hide the item +void QwtPolarItem::hide() +{ + setVisible( false ); +} + +/*! + Show/Hide the item + + \param on Show if true, otherwise hide + \sa isVisible(), show(), hide() +*/ +void QwtPolarItem::setVisible( bool on ) +{ + if ( on != d_data->isVisible ) + { + d_data->isVisible = on; + itemChanged(); + } +} + +/*! + \return true if visible + \sa setVisible(), show(), hide() +*/ +bool QwtPolarItem::isVisible() const +{ + return d_data->isVisible; +} + +/*! + Update the legend and call QwtPolarPlot::autoRefresh for the + parent plot. + + \sa updateLegend() +*/ +void QwtPolarItem::itemChanged() +{ + if ( d_data->plot ) + { + if ( d_data->plot->legend() ) + updateLegend( d_data->plot->legend() ); + + d_data->plot->autoRefresh(); + } +} + +/*! + Interval, that is necessary to display the item + + This interval can be useful for operations like clipping or autoscaling + For items ( like the grid ), where a bounding interval makes no + sense an invalid interval is returned. + + \param scaleId Scale id ( QwtPolar::Scale ) + \return Bounding interval of the plot item for a specific scale +*/ +QwtInterval QwtPolarItem::boundingInterval( int scaleId ) const +{ + Q_UNUSED( scaleId ); + + return QwtInterval(); // invalid +} + +/*! + \brief Update the item to changes of the axes scale division + + Update the item, when the axes of plot have changed. + The default implementation does nothing, but items that depend + on the scale division (like QwtPolarGrid()) have to reimplement + updateScaleDiv() + + \param azimuthScaleDiv Scale division of the azimuth-scale + \param radialScaleDiv Scale division of the radius-axis + \param interval The interval of the radius-axis, that is + visible on the canvas + + \sa QwtPolarPlot::updateAxes() +*/ +void QwtPolarItem::updateScaleDiv( const QwtScaleDiv &azimuthScaleDiv, + const QwtScaleDiv &radialScaleDiv, const QwtInterval &interval ) +{ + Q_UNUSED( azimuthScaleDiv ); + Q_UNUSED( radialScaleDiv ); + Q_UNUSED( interval ); +} + +/*! + \brief Update the widget that represents the item on the legend + + updateLegend() is called from itemChanged() to adopt the widget + representing the item on the legend to its new configuration. + + The default implementation is made for QwtPolarCurve and updates a + QwtLegendItem(), but an item could be represented by any type of widget, + by overloading legendItem() and updateLegend(). + + \sa legendItem(), itemChanged(), QwtLegend() +*/ +void QwtPolarItem::updateLegend( QwtLegend *legend ) const +{ + if ( legend == NULL ) + return; + + QWidget *lgdItem = legend->find( this ); + if ( testItemAttribute( QwtPolarItem::Legend ) ) + { + if ( lgdItem == NULL ) + { + lgdItem = legendItem(); + if ( lgdItem ) + legend->insert( this, lgdItem ); + } + + QwtLegendItem* label = qobject_cast( lgdItem ); + if ( label ) + { + // paint the identifier + const QSize sz = label->identifierSize(); + + QPixmap identifier( sz.width(), sz.height() ); + identifier.fill( Qt::transparent ); + + QPainter painter( &identifier ); + painter.setRenderHint( QPainter::Antialiasing, + testRenderHint( QwtPolarItem::RenderAntialiased ) ); + + drawLegendIdentifier( &painter, + QRect( 0, 0, sz.width(), sz.height() ) ); + + painter.end(); + + const bool doUpdate = label->updatesEnabled(); + if ( doUpdate ) + label->setUpdatesEnabled( false ); + + label->setText( title() ); + label->setIdentifier( identifier ); + label->setItemMode( legend->itemMode() ); + + if ( doUpdate ) + label->setUpdatesEnabled( true ); + + label->update(); + } + } + else + { + if ( lgdItem ) + { + lgdItem->hide(); + lgdItem->deleteLater(); + } + } +} +/*! + \brief Allocate the widget that represents the item on the legend + + The default implementation is made for QwtPolarCurve and returns a + QwtLegendItem(), but an item could be represented by any type of widget, + by overloading legendItem() and updateLegend(). + + \return QwtLegendItem() + \sa updateLegend() QwtLegend() +*/ +QWidget *QwtPolarItem::legendItem() const +{ + QwtLegendItem *item = new QwtLegendItem; + if ( d_data->plot ) + { + QObject::connect( item, SIGNAL( clicked() ), + d_data->plot, SLOT( legendItemClicked() ) ); + QObject::connect( item, SIGNAL( checked( bool ) ), + d_data->plot, SLOT( legendItemChecked( bool ) ) ); + } + return item; +} + +/*! + Some items like to display something (f.e. the azimuth axis) outside + of the area of the interval of the radial scale. + The default implementation returns 0 pixels + + \return Hint for the margin +*/ +int QwtPolarItem::marginHint() const +{ + return 0; +} Index: /trunk/BNC/qwtpolar/qwt_polar_item.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_item.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_item.h (revision 4272) @@ -0,0 +1,176 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_ITEM_H +#define QWT_POLAR_ITEM_H + +#include "qwt_polar_global.h" +#include +#include +#include + +class QString; +class QRect; +class QPointF; +class QPainter; +class QwtPolarPlot; +class QwtScaleMap; +class QwtScaleDiv; + +/*! + \brief Base class for items on a polar plot + + A QwtPolarItem is "something that can be painted on the canvas". + It is connected to the QwtPolar framework by a couple of virtual + methods, that are individually implemented in derived item classes. + + QwtPolar offers an implementation of the most common types of items, + but deriving from QwtPolarItem makes it easy to implement additional + types of items. +*/ +class QWT_POLAR_EXPORT QwtPolarItem: public QwtLegendItemManager +{ +public: + /*! + \brief Runtime type information + + RttiValues is used to cast plot items, without + having to enable runtime type information of the compiler. + */ + enum RttiValues + { + //! Unspecific value, that can be used, when it doesn't matter + Rtti_PolarItem = 0, + + //! For QwtPolarGrid + Rtti_PolarGrid, + + //! For QwtPolarMarker + Rtti_PolarMarker, + + //! For QwtPolarCurve + Rtti_PolarCurve, + + //! For QwtPolarSpectrogram + Rtti_PolarSpectrogram, + + /*! + Values >= Rtti_PolarUserItem are reserved for plot items + not implemented in the QwtPolar library. + */ + Rtti_PolarUserItem = 1000 + }; + + /*! + \brief Plot Item Attributes + \sa setItemAttribute(), testItemAttribute() + */ + enum ItemAttribute + { + //! The item is represented on the legend. + Legend = 0x01, + + /*! + The boundingRect() of the item is included in the + autoscaling calculation. + */ + AutoScale = 0x02 + }; + + //! Item attributes + typedef QFlags ItemAttributes; + + /*! + \brief Render hints + \sa setRenderHint(), testRenderHint() + */ + enum RenderHint + { + //! Enable antialiasing + RenderAntialiased = 0x01 + }; + + //! Item attributes + typedef QFlags RenderHints; + + explicit QwtPolarItem( const QwtText &title = QwtText() ); + virtual ~QwtPolarItem(); + + void attach( QwtPolarPlot *plot ); + + /*! + \brief This method detaches a QwtPolarItem from any QwtPolarPlot it + has been associated with. + + detach() is equivalent to calling attach( NULL ) + \sa attach( QwtPolarPlot* plot ) + */ + void detach() { attach( NULL ); } + + QwtPolarPlot *plot() const; + + void setTitle( const QString &title ); + void setTitle( const QwtText &title ); + const QwtText &title() const; + + virtual int rtti() const; + + void setItemAttribute( ItemAttribute, bool on = true ); + bool testItemAttribute( ItemAttribute ) const; + + void setRenderHint( RenderHint, bool on = true ); + bool testRenderHint( RenderHint ) const; + + double z() const; + void setZ( double z ); + + void show(); + void hide(); + virtual void setVisible( bool ); + bool isVisible () const; + + virtual void itemChanged(); + + /*! + \brief Draw the item + + \param painter Painter + \param azimuthMap Maps azimuth values to values related to 0.0, M_2PI + \param radialMap Maps radius values into painter coordinates. + \param pole Position of the pole in painter coordinates + \param radius Radius of the complete plot area in painter coordinates + \param canvasRect Contents rect of the canvas in painter coordinates + */ + virtual void draw( QPainter *painter, + const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, + const QPointF &pole, double radius, + const QRectF &canvasRect ) const = 0; + + virtual QwtInterval boundingInterval( int scaleId ) const; + + virtual QWidget *legendItem() const; + + virtual void updateLegend( QwtLegend * ) const; + virtual void updateScaleDiv( const QwtScaleDiv &, + const QwtScaleDiv &, const QwtInterval & ); + + virtual int marginHint() const; + +private: + // Disabled copy constructor and operator= + QwtPolarItem( const QwtPolarItem & ); + QwtPolarItem &operator=( const QwtPolarItem & ); + + class PrivateData; + PrivateData *d_data; +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarItem::ItemAttributes ) +Q_DECLARE_OPERATORS_FOR_FLAGS( QwtPolarItem::RenderHints ) + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_itemdict.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_itemdict.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_itemdict.cpp (revision 4272) @@ -0,0 +1,169 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_itemdict.h" + +class QwtPolarItemDict::PrivateData +{ +public: + class ItemList: public QList + { + public: + void insertItem( QwtPolarItem *item ) + { + if ( item == NULL ) + return; + + // Unfortunately there is no inSort operation + // for lists in Qt4. The implementation below + // is slow, but there shouldn't be many plot items. + + QList::Iterator it; + for ( it = begin(); it != end(); ++it ) + { + if ( *it == item ) + return; + + if ( ( *it )->z() > item->z() ) + { + insert( it, item ); + return; + } + } + append( item ); + } + + void removeItem( QwtPolarItem *item ) + { + if ( item == NULL ) + return; + + int i = 0; + + QList::Iterator it; + for ( it = begin(); it != end(); ++it ) + { + if ( item == *it ) + { + removeAt( i ); + return; + } + i++; + } + } + }; + + ItemList itemList; + bool autoDelete; +}; + +/*! + Constructor + + Auto deletion is enabled. + \sa setAutoDelete, attachItem +*/ +QwtPolarItemDict::QwtPolarItemDict() +{ + d_data = new QwtPolarItemDict::PrivateData; + d_data->autoDelete = true; +} + +/*! + Destructor + + If autoDelete is on, all attached items will be deleted + \sa setAutoDelete, autoDelete, attachItem +*/ +QwtPolarItemDict::~QwtPolarItemDict() +{ + detachItems( QwtPolarItem::Rtti_PolarItem, d_data->autoDelete ); + delete d_data; +} + +/*! + En/Disable Auto deletion + + If Auto deletion is on all attached plot items will be deleted + in the destructor of QwtPolarItemDict. The default value is on. + + \sa autoDelete, attachItem +*/ +void QwtPolarItemDict::setAutoDelete( bool autoDelete ) +{ + d_data->autoDelete = autoDelete; +} + +/*! + \return true if auto deletion is enabled + \sa setAutoDelete, attachItem +*/ +bool QwtPolarItemDict::autoDelete() const +{ + return d_data->autoDelete; +} + +/*! + Attach/Detach a plot item + + Attached items will be deleted in the destructor, + if auto deletion is enabled (default). Manually detached + items are not deleted. + + \param item Plot item to attach/detach + \ on If true attach, else detach the item + + \sa setAutoDelete, ~QwtPolarItemDict +*/ +void QwtPolarItemDict::attachItem( QwtPolarItem *item, bool on ) +{ + if ( on ) + d_data->itemList.insertItem( item ); + else + d_data->itemList.removeItem( item ); +} + +/*! + Detach items from the dictionary + + \param rtti In case of QwtPolarItem::Rtti_PlotItem detach all items + otherwise only those items of the type rtti. + \param autoDelete If true, delete all detached items +*/ +void QwtPolarItemDict::detachItems( int rtti, bool autoDelete ) +{ + PrivateData::ItemList list = d_data->itemList; + QwtPolarItemIterator it = list.begin(); + while ( it != list.end() ) + { + QwtPolarItem *item = *it; + + ++it; // increment before removing item from the list + + if ( rtti == QwtPolarItem::Rtti_PolarItem || item->rtti() == rtti ) + { + item->attach( NULL ); + if ( autoDelete ) + delete item; + } + } +} + +/*! + \brief A QwtPolarItemList of all attached plot items. + + \return List of all attached plot items. + \note Use caution when iterating these lists, as removing/detaching + an item will invalidate the iterator. + Instead you can place pointers to objects to be + removed in a removal list, and traverse that list later. +*/ +const QwtPolarItemList &QwtPolarItemDict::itemList() const +{ + return d_data->itemList; +} Index: /trunk/BNC/qwtpolar/qwt_polar_itemdict.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_itemdict.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_itemdict.h (revision 4272) @@ -0,0 +1,55 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_ITEMDICT_H +#define QWT_POLAR_ITEMDICT_H + +/*! \file !*/ + +#include "qwt_polar_global.h" +#include "qwt_polar_item.h" +#include + +typedef QList::ConstIterator QwtPolarItemIterator; +/// \var typedef QList< QwtPolarItem *> QwtPolarItemList +/// \brief See QT 4.x assistant documentation for QList +typedef QList QwtPolarItemList; + +/*! + \brief A dictionary for polar plot items + + QwtPolarItemDict organizes polar plot items in increasing z-order. + If autoDelete() is enabled, all attached items will be deleted + in the destructor of the dictionary. + + \sa QwtPolarItem::attach(), QwtPolarItem::detach(), QwtPolarItem::z() +*/ +class QWT_POLAR_EXPORT QwtPolarItemDict +{ +public: + explicit QwtPolarItemDict(); + ~QwtPolarItemDict(); + + void setAutoDelete( bool ); + bool autoDelete() const; + + const QwtPolarItemList& itemList() const; + + void detachItems( int rtti = QwtPolarItem::Rtti_PolarItem, + bool autoDelete = true ); + +private: + friend class QwtPolarItem; + + void attachItem( QwtPolarItem *, bool ); + + class PrivateData; + PrivateData *d_data; +}; + +#endif Index: /trunk/BNC/qwtpolar/qwt_polar_layout.cpp =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_layout.cpp (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_layout.cpp (revision 4272) @@ -0,0 +1,444 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 Uwe Rathmann + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the Qwt License, Version 1.0 + *****************************************************************************/ + +#include "qwt_polar_layout.h" +#include "qwt_polar_plot.h" +#include "qwt_polar_canvas.h" +#include +#include +#include +#include + +class QwtPolarLayout::LayoutData +{ +public: + void init( const QwtPolarPlot *, const QRectF &rect ); + + struct t_legendData + { + int frameWidth; + int vScrollBarWidth; + int hScrollBarHeight; + QSizeF hint; + } legend; + + struct t_titleData + { + QwtText text; + int frameWidth; + } title; + + struct t_canvasData + { + int frameWidth; + } canvas; +}; + +void QwtPolarLayout::LayoutData::init( + const QwtPolarPlot *plot, const QRectF &rect ) +{ + // legend + + if ( plot->plotLayout()->legendPosition() != QwtPolarPlot::ExternalLegend + && plot->legend() ) + { + legend.frameWidth = plot->legend()->frameWidth(); + legend.vScrollBarWidth = + plot->legend()->verticalScrollBar()->sizeHint().width(); + legend.hScrollBarHeight = + plot->legend()->horizontalScrollBar()->sizeHint().height(); + + const QSizeF hint = plot->legend()->sizeHint(); + + double w = qMin( hint.width(), rect.width() ); + double h = plot->legend()->heightForWidth( w ); + if ( h == 0.0 ) + h = hint.height(); + + if ( h > rect.height() ) + w += legend.vScrollBarWidth; + + legend.hint = QSizeF( w, h ); + } + + // title + + title.frameWidth = 0; + title.text = QwtText(); + + if ( plot->titleLabel() ) + { + const QwtTextLabel *label = plot->titleLabel(); + title.text = label->text(); + if ( !( title.text.testPaintAttribute( QwtText::PaintUsingTextFont ) ) ) + title.text.setFont( label->font() ); + + title.frameWidth = plot->titleLabel()->frameWidth(); + } + + // canvas + + canvas.frameWidth = plot->canvas()->frameWidth(); +} + +class QwtPolarLayout::PrivateData +{ +public: + PrivateData(): + margin( 0 ), + spacing( 0 ) + { + } + + QRectF titleRect; + QRectF legendRect; + QRectF canvasRect; + + QwtPolarLayout::LayoutData layoutData; + + QwtPolarPlot::LegendPosition legendPos; + double legendRatio; + + unsigned int margin; + unsigned int spacing; +}; + +/*! + \brief Constructor + */ + +QwtPolarLayout::QwtPolarLayout() +{ + d_data = new PrivateData; + + setLegendPosition( QwtPolarPlot::BottomLegend ); + invalidate(); +} + +//! Destructor +QwtPolarLayout::~QwtPolarLayout() +{ + delete d_data; +} + +/*! + \brief Specify the position of the legend + \param pos The legend's position. + \param ratio Ratio between legend and the bounding rect + of title, canvas and axes. The legend will be shrinked + if it would need more space than the given ratio. + The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0 + it will be reset to the default ratio. + The default vertical/horizontal ratio is 0.33/0.5. + + \sa QwtPolarPlot::setLegendPosition() +*/ + +void QwtPolarLayout::setLegendPosition( + QwtPolarPlot::LegendPosition pos, double ratio ) +{ + if ( ratio > 1.0 ) + ratio = 1.0; + + switch( pos ) + { + case QwtPolarPlot::TopLegend: + case QwtPolarPlot::BottomLegend: + { + if ( ratio <= 0.0 ) + ratio = 0.33; + d_data->legendRatio = ratio; + d_data->legendPos = pos; + break; + } + case QwtPolarPlot::LeftLegend: + case QwtPolarPlot::RightLegend: + { + if ( ratio <= 0.0 ) + ratio = 0.5; + d_data->legendRatio = ratio; + d_data->legendPos = pos; + break; + } + case QwtPolarPlot::ExternalLegend: + { + d_data->legendRatio = ratio; // meaningless + d_data->legendPos = pos; + break; + } + default: + break; + } +} + +/*! + \brief Specify the position of the legend + \param pos The legend's position. Valid values are + \c QwtPolarPlot::LeftLegend, \c QwtPolarPlot::RightLegend, + \c QwtPolarPlot::TopLegend, \c QwtPolarPlot::BottomLegend. + + \sa QwtPolarPlot::setLegendPosition() +*/ +void QwtPolarLayout::setLegendPosition( QwtPolarPlot::LegendPosition pos ) +{ + setLegendPosition( pos, 0.0 ); +} + +/*! + \return Position of the legend + \sa setLegendPosition(), QwtPolarPlot::setLegendPosition(), + QwtPolarPlot::legendPosition() +*/ +QwtPolarPlot::LegendPosition QwtPolarLayout::legendPosition() const +{ + return d_data->legendPos; +} + +/*! + Specify the relative size of the legend in the plot + \param ratio Ratio between legend and the bounding rect + of title, canvas and axes. The legend will be shrinked + if it would need more space than the given ratio. + The ratio is limited to ]0.0 .. 1.0]. In case of <= 0.0 + it will be reset to the default ratio. + The default vertical/horizontal ratio is 0.33/0.5. +*/ +void QwtPolarLayout::setLegendRatio( double ratio ) +{ + setLegendPosition( legendPosition(), ratio ); +} + +/*! + \return The relative size of the legend in the plot. + \sa setLegendPosition() +*/ +double QwtPolarLayout::legendRatio() const +{ + return d_data->legendRatio; +} + +/*! + \return Geometry for the title + \sa activate(), invalidate() +*/ + +const QRectF &QwtPolarLayout::titleRect() const +{ + return d_data->titleRect; +} + +/*! + \return Geometry for the legend + \sa activate(), invalidate() +*/ + +const QRectF &QwtPolarLayout::legendRect() const +{ + return d_data->legendRect; +} + +/*! + \return Geometry for the canvas + \sa activate(), invalidate() +*/ +const QRectF &QwtPolarLayout::canvasRect() const +{ + return d_data->canvasRect; +} + +/*! + Invalidate the geometry of all components. + \sa activate() +*/ +void QwtPolarLayout::invalidate() +{ + d_data->titleRect = d_data->legendRect = d_data->canvasRect = QRect(); +} + +/*! + Find the geometry for the legend + \param options Options how to layout the legend + \param rect Rectangle where to place the legend + \return Geometry for the legend +*/ + +QRectF QwtPolarLayout::layoutLegend( Options options, QRectF &rect ) const +{ + const QSizeF hint( d_data->layoutData.legend.hint ); + + int dim; + if ( d_data->legendPos == QwtPolarPlot::LeftLegend + || d_data->legendPos == QwtPolarPlot::RightLegend ) + { + // We don't allow vertical legends to take more than + // half of the available space. + + dim = qMin( hint.width(), rect.width() * d_data->legendRatio ); + + if ( !( options & IgnoreScrollbars ) ) + { + if ( hint.height() > rect.height() ) + { + // The legend will need additional + // space for the vertical scrollbar. + + dim += d_data->layoutData.legend.vScrollBarWidth; + } + } + } + else + { + dim = qMin( hint.height(), rect.height() * d_data->legendRatio ); + dim = qMax( dim, d_data->layoutData.legend.hScrollBarHeight ); + } + + QRectF legendRect = rect; + switch( d_data->legendPos ) + { + case QwtPolarPlot::LeftLegend: + { + legendRect.setWidth( dim ); + rect.setLeft( legendRect.right() ); + break; + } + case QwtPolarPlot::RightLegend: + { + legendRect.setX( rect.right() - dim + 1 ); + legendRect.setWidth( dim ); + rect.setRight( legendRect.left() ); + break; + } + case QwtPolarPlot::TopLegend: + { + legendRect.setHeight( dim ); + rect.setTop( legendRect.bottom() ); + break; + } + case QwtPolarPlot::BottomLegend: + { + legendRect.setY( rect.bottom() - dim + 1 ); + legendRect.setHeight( dim ); + rect.setBottom( legendRect.top() ); + break; + } + case QwtPolarPlot::ExternalLegend: + break; + } + + return legendRect; +} + +/*! + \brief Recalculate the geometry of all components. + + \param plot Plot to be layout + \param boundingRect Rect where to place the components + \param options Options + + \sa invalidate(), titleRect(), legendRect(), canvasRect() +*/ +void QwtPolarLayout::activate( const QwtPolarPlot *plot, + const QRectF &boundingRect, Options options ) +{ + invalidate(); + + QRectF rect( boundingRect ); // undistributed rest of the plot rect + rect.adjust( d_data->margin, d_data->margin, + -d_data->margin, -d_data->margin ); + + // We extract all layout relevant data from the widgets + // and save them to d_data->layoutData. + + d_data->layoutData.init( plot, rect ); + if ( !( options & IgnoreLegend ) + && d_data->legendPos != QwtPolarPlot::ExternalLegend + && plot->legend() && !plot->legend()->isEmpty() ) + { + d_data->legendRect = layoutLegend( options, rect ); + if ( d_data->layoutData.legend.frameWidth && + !( options & IgnoreFrames ) ) + { + // In case of a frame we have to insert a spacing. + // Otherwise the leading of the font separates + // legend and scale/canvas + + switch( d_data->legendPos ) + { + case QwtPolarPlot::LeftLegend: + rect.setLeft( rect.left() + d_data->spacing ); + break; + + case QwtPolarPlot::RightLegend: + rect.setRight( rect.right() - d_data->spacing ); + break; + + case QwtPolarPlot::TopLegend: + rect.setTop( rect.top() + d_data->spacing ); + break; + + case QwtPolarPlot::BottomLegend: + rect.setBottom( rect.bottom() - d_data->spacing ); + break; + + case QwtPolarPlot::ExternalLegend: + break; // suppress compiler warning + } + } + } + + if ( !( options & IgnoreTitle ) && + !d_data->layoutData.title.text.isEmpty() ) + { + int h = d_data->layoutData.title.text.heightForWidth( rect.width() ); + if ( !( options & IgnoreFrames ) ) + h += 2 * d_data->layoutData.title.frameWidth; + + d_data->titleRect = QRectF( rect.x(), rect.y(), rect.width(), h ); + + // subtract title + rect.setTop( rect.top() + h + d_data->spacing ); + } + + if ( plot->zoomPos().radius() > 0.0 || plot->zoomFactor() < 1.0 ) + { + // In zoomed state we have no idea about the geometry that + // is best for the plot. So we use the complete rectangle + // accepting, that there might a lot of space wasted + // around the plot. + + d_data->canvasRect = rect; + } + else + { + // In full state we know, that we want + // to display something circular. + + const int dim = qMin( rect.width(), rect.height() ); + + d_data->canvasRect.setX( rect.center().x() - dim / 2 ); + d_data->canvasRect.setY( rect.y() ); + d_data->canvasRect.setSize( QSize( dim, dim ) ); + } + + if ( !d_data->legendRect.isEmpty() ) + { + if ( d_data->legendPos == QwtPolarPlot::LeftLegend + || d_data->legendPos == QwtPolarPlot::RightLegend ) + { + // We prefer to align the legend to the canvas - not to + // the complete plot - if possible. + + if ( d_data->layoutData.legend.hint.height() + < d_data->canvasRect.height() ) + { + d_data->legendRect.setY( d_data->canvasRect.y() ); + d_data->legendRect.setHeight( d_data->canvasRect.height() ); + } + } + } +} Index: /trunk/BNC/qwtpolar/qwt_polar_layout.h =================================================================== --- /trunk/BNC/qwtpolar/qwt_polar_layout.h (revision 4272) +++ /trunk/BNC/qwtpolar/qwt_polar_layout.h (revision 4272) @@ -0,0 +1,78 @@ +/* -*- mode: C++ ; c-file-style: "stroustrup" -*- ***************************** + * QwtPolar Widget Library + * Copyright (C) 2008 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_POLAR_LAYOUT_H +#define QWT_POLAR_LAYOUT_H + +#include "qwt_polar_global.h" +#include "qwt_polar_plot.h" + +/*! + \brief Layout class for QwtPolarPlot. + + Organizes the geometry for the different QwtPolarPlot components. + It is used by the QwtPolar widget to organize its internal widgets + or by QwtPolarRnderer to render its content to a QPaintDevice like + a QPrinter, QPixmap/QImage or QSvgRenderer. +*/ + +class QWT_POLAR_EXPORT QwtPolarLayout +{ +public: + + //! \brief Options to configure the plot layout engine + enum Option + { + //! Ignore the dimension of the scrollbars. + IgnoreScrollbars = 0x01, + + //! Ignore all frames. + IgnoreFrames = 0x02, + + //! Ignore the title. + IgnoreTitle = 0x04, + + //! Ignore the legend. + IgnoreLegend = 0x08 + }; + + //! Options to configure the plot layout engine + typedef QFlags