qwt_plot_grid.cpp

/******************************************************************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/
 
#include "qwt_plot_grid.h"
#include "qwt_painter.h"
#include "qwt_text.h"
#include "qwt_scale_map.h"
#include "qwt_scale_div.h"
 
#include <qpainter.h>
#include <qpen.h>
 
static inline bool qwtFuzzyGreaterOrEqual( double d1, double d2 )
{
    return ( d1 >= d2 ) || qFuzzyCompare( d1, d2 );
}
 
class QwtPlotGrid::PrivateData
{
  public:
    PrivateData()
        : xEnabled( true )
        , yEnabled( true )
        , xMinEnabled( false )
        , yMinEnabled( false )
    {
    }
 
    bool xEnabled;
    bool yEnabled;
    bool xMinEnabled;
    bool yMinEnabled;
 
    QwtScaleDiv xScaleDiv;
    QwtScaleDiv yScaleDiv;
 
    QPen majorPen;
    QPen minorPen;
};
 
QwtPlotGrid::QwtPlotGrid()
    : QwtPlotItem( QwtText( "Grid" ) )
{
    m_data = new PrivateData;
 
    setItemInterest( QwtPlotItem::ScaleInterest, true );
    setZ( 10.0 );
}
 
QwtPlotGrid::~QwtPlotGrid()
{
    delete m_data;
}
 
int QwtPlotGrid::rtti() const
{
    return QwtPlotItem::Rtti_PlotGrid;
}
 
void QwtPlotGrid::enableX( bool on )
{
    if ( m_data->xEnabled != on )
    {
        m_data->xEnabled = on;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::enableY( bool on )
{
    if ( m_data->yEnabled != on )
    {
        m_data->yEnabled = on;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::enableXMin( bool on )
{
    if ( m_data->xMinEnabled != on )
    {
        m_data->xMinEnabled = on;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::enableYMin( bool on )
{
    if ( m_data->yMinEnabled != on )
    {
        m_data->yMinEnabled = on;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::setXDiv( const QwtScaleDiv& scaleDiv )
{
    if ( m_data->xScaleDiv != scaleDiv )
    {
        m_data->xScaleDiv = scaleDiv;
        itemChanged();
    }
}
 
void QwtPlotGrid::setYDiv( const QwtScaleDiv& scaleDiv )
{
    if ( m_data->yScaleDiv != scaleDiv )
    {
        m_data->yScaleDiv = scaleDiv;
        itemChanged();
    }
}
 
void QwtPlotGrid::setPen( const QColor& color, qreal width, Qt::PenStyle style )
{
    setPen( QPen( color, width, style ) );
}
 
void QwtPlotGrid::setPen( const QPen& pen )
{
    if ( m_data->majorPen != pen || m_data->minorPen != pen )
    {
        m_data->majorPen = pen;
        m_data->minorPen = pen;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::setMajorPen( const QColor& color, qreal width, Qt::PenStyle style )
{
    setMajorPen( QPen( color, width, style ) );
}
 
void QwtPlotGrid::setMajorPen( const QPen& pen )
{
    if ( m_data->majorPen != pen )
    {
        m_data->majorPen = pen;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::setMinorPen( const QColor& color, qreal width, Qt::PenStyle style )
{
    setMinorPen( QPen( color, width, style ) );
}
 
void QwtPlotGrid::setMinorPen( const QPen& pen )
{
    if ( m_data->minorPen != pen )
    {
        m_data->minorPen = pen;
 
        legendChanged();
        itemChanged();
    }
}
 
void QwtPlotGrid::draw( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    //  draw minor grid lines
    QPen minorPen = m_data->minorPen;
    minorPen.setCapStyle( Qt::FlatCap );
 
    painter->setPen( minorPen );
 
    if ( m_data->xEnabled && m_data->xMinEnabled )
    {
        drawLines( painter, canvasRect, Qt::Vertical, xMap,
            m_data->xScaleDiv.ticks( QwtScaleDiv::MinorTick ) );
        drawLines( painter, canvasRect, Qt::Vertical, xMap,
            m_data->xScaleDiv.ticks( QwtScaleDiv::MediumTick ) );
    }
 
    if ( m_data->yEnabled && m_data->yMinEnabled )
    {
        drawLines( painter, canvasRect, Qt::Horizontal, yMap,
            m_data->yScaleDiv.ticks( QwtScaleDiv::MinorTick ) );
        drawLines( painter, canvasRect, Qt::Horizontal, yMap,
            m_data->yScaleDiv.ticks( QwtScaleDiv::MediumTick ) );
    }
 
    //  draw major grid lines
    QPen majorPen = m_data->majorPen;
    majorPen.setCapStyle( Qt::FlatCap );
 
    painter->setPen( majorPen );
 
    if ( m_data->xEnabled )
    {
        drawLines( painter, canvasRect, Qt::Vertical, xMap,
            m_data->xScaleDiv.ticks( QwtScaleDiv::MajorTick ) );
    }
 
    if ( m_data->yEnabled )
    {
        drawLines( painter, canvasRect, Qt::Horizontal, yMap,
            m_data->yScaleDiv.ticks( QwtScaleDiv::MajorTick ) );
    }
}
 
void QwtPlotGrid::drawLines( QPainter* painter, const QRectF& canvasRect,
    Qt::Orientation orientation, const QwtScaleMap& scaleMap,
    const QList< double >& values ) const
{
    const double x1 = canvasRect.left();
    const double x2 = canvasRect.right() - 1.0;
    const double y1 = canvasRect.top();
    const double y2 = canvasRect.bottom() - 1.0;
 
    const bool doAlign = QwtPainter::roundingAlignment( painter );
 
    for ( int i = 0; i < values.count(); i++ )
    {
        double value = scaleMap.transform( values[i] );
        if ( doAlign )
            value = qRound( value );
 
        if ( orientation == Qt::Horizontal )
        {
            if ( qwtFuzzyGreaterOrEqual( value, y1 ) &&
                qwtFuzzyGreaterOrEqual( y2, value ) )
            {
                QwtPainter::drawLine( painter, x1, value, x2, value );
            }
        }
        else
        {
            if ( qwtFuzzyGreaterOrEqual( value, x1 ) &&
                qwtFuzzyGreaterOrEqual( x2, value ) )
            {
                QwtPainter::drawLine( painter, value, y1, value, y2 );
            }
        }
    }
}
 
const QPen& QwtPlotGrid::majorPen() const
{
    return m_data->majorPen;
}
 
const QPen& QwtPlotGrid::minorPen() const
{
    return m_data->minorPen;
}
 
bool QwtPlotGrid::xEnabled() const
{
    return m_data->xEnabled;
}
 
bool QwtPlotGrid::xMinEnabled() const
{
    return m_data->xMinEnabled;
}
 
bool QwtPlotGrid::yEnabled() const
{
    return m_data->yEnabled;
}
 
bool QwtPlotGrid::yMinEnabled() const
{
    return m_data->yMinEnabled;
}
 
 
const QwtScaleDiv& QwtPlotGrid::xScaleDiv() const
{
    return m_data->xScaleDiv;
}
 
const QwtScaleDiv& QwtPlotGrid::yScaleDiv() const
{
    return m_data->yScaleDiv;
}
 
void QwtPlotGrid::updateScaleDiv( const QwtScaleDiv& xScaleDiv,
    const QwtScaleDiv& yScaleDiv )
{
    setXDiv( xScaleDiv );
    setYDiv( yScaleDiv );
}