qwt_plot_tradingcurve.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_tradingcurve.h"
#include "qwt_scale_map.h"
#include "qwt_painter.h"
#include "qwt_text.h"
#include "qwt_graphic.h"
#include "qwt_math.h"
 
#include <qpainter.h>
 
static inline bool qwtIsSampleInside( const QwtOHLCSample& sample,
    double tMin, double tMax, double vMin, double vMax )
{
    const double t = sample.time;
    const QwtInterval interval = sample.boundingInterval();
 
    const bool isOffScreen = ( t < tMin ) || ( t > tMax )
        || ( interval.maxValue() < vMin ) || ( interval.minValue() > vMax );
 
    return !isOffScreen;
}
 
class QwtPlotTradingCurve::PrivateData
{
  public:
    PrivateData()
        : symbolStyle( QwtPlotTradingCurve::CandleStick )
        , symbolExtent( 0.6 )
        , minSymbolWidth( 2.0 )
        , maxSymbolWidth( -1.0 )
        , paintAttributes( QwtPlotTradingCurve::ClipSymbols )
    {
        symbolBrush[0] = QBrush( Qt::white );
        symbolBrush[1] = QBrush( Qt::black );
    }
 
    QwtPlotTradingCurve::SymbolStyle symbolStyle;
    double symbolExtent;
    double minSymbolWidth;
    double maxSymbolWidth;
 
    QPen symbolPen;
    QBrush symbolBrush[2]; // Increasing/Decreasing
 
    QwtPlotTradingCurve::PaintAttributes paintAttributes;
};
 
QwtPlotTradingCurve::QwtPlotTradingCurve( const QwtText& title )
    : QwtPlotSeriesItem( title )
{
    init();
}
 
QwtPlotTradingCurve::QwtPlotTradingCurve( const QString& title )
    : QwtPlotSeriesItem( QwtText( title ) )
{
    init();
}
 
QwtPlotTradingCurve::~QwtPlotTradingCurve()
{
    delete m_data;
}
 
void QwtPlotTradingCurve::init()
{
    setItemAttribute( QwtPlotItem::Legend, true );
    setItemAttribute( QwtPlotItem::AutoScale, true );
 
    m_data = new PrivateData;
    setData( new QwtTradingChartData() );
 
    setZ( 19.0 );
}
 
int QwtPlotTradingCurve::rtti() const
{
    return QwtPlotTradingCurve::Rtti_PlotTradingCurve;
}
 
void QwtPlotTradingCurve::setPaintAttribute(
    PaintAttribute attribute, bool on )
{
    if ( on )
        m_data->paintAttributes |= attribute;
    else
        m_data->paintAttributes &= ~attribute;
}
 
bool QwtPlotTradingCurve::testPaintAttribute(
    PaintAttribute attribute ) const
{
    return ( m_data->paintAttributes & attribute );
}
 
void QwtPlotTradingCurve::setSamples(
    const QVector< QwtOHLCSample >& samples )
{
    setData( new QwtTradingChartData( samples ) );
}
 
void QwtPlotTradingCurve::setSamples(
    QwtSeriesData< QwtOHLCSample >* data )
{
    setData( data );
}
 
void QwtPlotTradingCurve::setSymbolStyle( SymbolStyle style )
{
    if ( style != m_data->symbolStyle )
    {
        m_data->symbolStyle = style;
 
        legendChanged();
        itemChanged();
    }
}
 
QwtPlotTradingCurve::SymbolStyle QwtPlotTradingCurve::symbolStyle() const
{
    return m_data->symbolStyle;
}
 
void QwtPlotTradingCurve::setSymbolPen(
    const QColor& color, qreal width, Qt::PenStyle style )
{
    setSymbolPen( QPen( color, width, style ) );
}
 
void QwtPlotTradingCurve::setSymbolPen( const QPen& pen )
{
    if ( pen != m_data->symbolPen )
    {
        m_data->symbolPen = pen;
 
        legendChanged();
        itemChanged();
    }
}
 
QPen QwtPlotTradingCurve::symbolPen() const
{
    return m_data->symbolPen;
}
 
void QwtPlotTradingCurve::setSymbolBrush(
    Direction direction, const QBrush& brush )
{
    // silencing -Wtautological-constant-out-of-range-compare
    const int index = static_cast< int >( direction );
    if ( index < 0 || index >= 2 )
        return;
 
    if ( brush != m_data->symbolBrush[ index ] )
    {
        m_data->symbolBrush[ index ] = brush;
 
        legendChanged();
        itemChanged();
    }
}
 
QBrush QwtPlotTradingCurve::symbolBrush( Direction direction ) const
{
    const int index = static_cast< int >( direction );
    if ( index < 0 || index >= 2 )
        return QBrush();
 
    return m_data->symbolBrush[ index ];
}
 
void QwtPlotTradingCurve::setSymbolExtent( double extent )
{
    extent = qwtMaxF( 0.0, extent );
    if ( extent != m_data->symbolExtent )
    {
        m_data->symbolExtent = extent;
 
        legendChanged();
        itemChanged();
    }
}
 
double QwtPlotTradingCurve::symbolExtent() const
{
    return m_data->symbolExtent;
}
 
void QwtPlotTradingCurve::setMinSymbolWidth( double width )
{
    width = qwtMaxF( width, 0.0 );
    if ( width != m_data->minSymbolWidth )
    {
        m_data->minSymbolWidth = width;
 
        legendChanged();
        itemChanged();
    }
}
 
double QwtPlotTradingCurve::minSymbolWidth() const
{
    return m_data->minSymbolWidth;
}
 
void QwtPlotTradingCurve::setMaxSymbolWidth( double width )
{
    if ( width != m_data->maxSymbolWidth )
    {
        m_data->maxSymbolWidth = width;
 
        legendChanged();
        itemChanged();
    }
}
 
double QwtPlotTradingCurve::maxSymbolWidth() const
{
    return m_data->maxSymbolWidth;
}
 
QRectF QwtPlotTradingCurve::boundingRect() const
{
    QRectF rect = QwtPlotSeriesItem::boundingRect();
    if ( orientation() == Qt::Vertical )
        rect.setRect( rect.y(), rect.x(), rect.height(), rect.width() );
 
    return rect;
}
 
void QwtPlotTradingCurve::drawSeries( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, int from, int to ) const
{
    if ( to < 0 )
        to = dataSize() - 1;
 
    if ( from < 0 )
        from = 0;
 
    if ( from > to )
        return;
 
    painter->save();
 
    if ( m_data->symbolStyle != QwtPlotTradingCurve::NoSymbol )
        drawSymbols( painter, xMap, yMap, canvasRect, from, to );
 
    painter->restore();
}
 
void QwtPlotTradingCurve::drawSymbols( QPainter* painter,
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect, int from, int to ) const
{
    const QRectF tr = QwtScaleMap::invTransform( xMap, yMap, canvasRect );
 
    const QwtScaleMap* timeMap, * valueMap;
    double tMin, tMax, vMin, vMax;
 
    const Qt::Orientation orient = orientation();
    if ( orient == Qt::Vertical )
    {
        timeMap = &xMap;
        valueMap = &yMap;
 
        tMin = tr.left();
        tMax = tr.right();
        vMin = tr.top();
        vMax = tr.bottom();
    }
    else
    {
        timeMap = &yMap;
        valueMap = &xMap;
 
        vMin = tr.left();
        vMax = tr.right();
        tMin = tr.top();
        tMax = tr.bottom();
    }
 
    const bool inverted = timeMap->isInverting();
    const bool doClip = m_data->paintAttributes & ClipSymbols;
    const bool doAlign = QwtPainter::roundingAlignment( painter );
 
    double symbolWidth = scaledSymbolWidth( xMap, yMap, canvasRect );
    if ( doAlign )
        symbolWidth = std::floor( 0.5 * symbolWidth ) * 2.0;
 
    QPen pen = m_data->symbolPen;
    pen.setCapStyle( Qt::FlatCap );
 
    painter->setPen( pen );
 
    for ( int i = from; i <= to; i++ )
    {
        const QwtOHLCSample s = sample( i );
 
        if ( !doClip || qwtIsSampleInside( s, tMin, tMax, vMin, vMax ) )
        {
            QwtOHLCSample translatedSample;
 
            translatedSample.time = timeMap->transform( s.time );
            translatedSample.open = valueMap->transform( s.open );
            translatedSample.high = valueMap->transform( s.high );
            translatedSample.low = valueMap->transform( s.low );
            translatedSample.close = valueMap->transform( s.close );
 
            const int brushIndex = ( s.open < s.close )
                ? QwtPlotTradingCurve::Increasing
                : QwtPlotTradingCurve::Decreasing;
 
            if ( doAlign )
            {
                translatedSample.time = qRound( translatedSample.time );
                translatedSample.open = qRound( translatedSample.open );
                translatedSample.high = qRound( translatedSample.high );
                translatedSample.low = qRound( translatedSample.low );
                translatedSample.close = qRound( translatedSample.close );
            }
 
            switch( m_data->symbolStyle )
            {
                case Bar:
                {
                    drawBar( painter, translatedSample,
                        orient, inverted, symbolWidth );
                    break;
                }
                case CandleStick:
                {
                    painter->setBrush( m_data->symbolBrush[ brushIndex ] );
                    drawCandleStick( painter, translatedSample,
                        orient, symbolWidth );
                    break;
                }
                default:
                {
                    if ( m_data->symbolStyle >= UserSymbol )
                    {
                        painter->setBrush( m_data->symbolBrush[ brushIndex ] );
                        drawUserSymbol( painter, m_data->symbolStyle,
                            translatedSample, orient, inverted, symbolWidth );
                    }
                }
            }
        }
    }
}
 
void QwtPlotTradingCurve::drawUserSymbol( QPainter* painter,
    SymbolStyle symbolStyle, const QwtOHLCSample& sample,
    Qt::Orientation orientation, bool inverted, double symbolWidth ) const
{
    Q_UNUSED( painter )
    Q_UNUSED( symbolStyle )
    Q_UNUSED( orientation )
    Q_UNUSED( inverted )
    Q_UNUSED( symbolWidth )
    Q_UNUSED( sample )
}
 
void QwtPlotTradingCurve::drawBar( QPainter* painter,
    const QwtOHLCSample& sample, Qt::Orientation orientation,
    bool inverted, double width ) const
{
    double w2 = 0.5 * width;
    if ( inverted )
        w2 *= -1;
 
    if ( orientation == Qt::Vertical )
    {
        QwtPainter::drawLine( painter,
            sample.time, sample.low, sample.time, sample.high );
 
        QwtPainter::drawLine( painter,
            sample.time - w2, sample.open, sample.time, sample.open );
        QwtPainter::drawLine( painter,
            sample.time + w2, sample.close, sample.time, sample.close );
    }
    else
    {
        QwtPainter::drawLine( painter, sample.low, sample.time,
            sample.high, sample.time );
        QwtPainter::drawLine( painter,
            sample.open, sample.time - w2, sample.open, sample.time );
        QwtPainter::drawLine( painter,
            sample.close, sample.time + w2, sample.close, sample.time );
    }
}
 
void QwtPlotTradingCurve::drawCandleStick( QPainter* painter,
    const QwtOHLCSample& sample, Qt::Orientation orientation,
    double width ) const
{
    const double t = sample.time;
    const double v1 = qwtMinF( sample.low, sample.high );
    const double v2 = qwtMinF( sample.open, sample.close );
    const double v3 = qwtMaxF( sample.low, sample.high );
    const double v4 = qwtMaxF( sample.open, sample.close );
 
    if ( orientation == Qt::Vertical )
    {
        QwtPainter::drawLine( painter, t, v1, t, v2 );
        QwtPainter::drawLine( painter, t, v3, t, v4 );
 
        QRectF rect( t - 0.5 * width, sample.open,
            width, sample.close - sample.open );
 
        QwtPainter::drawRect( painter, rect );
    }
    else
    {
        QwtPainter::drawLine( painter, v1, t, v2, t );
        QwtPainter::drawLine( painter, v3, t, v4, t );
 
        const QRectF rect( sample.open, t - 0.5 * width,
            sample.close - sample.open, width );
 
        QwtPainter::drawRect( painter, rect );
    }
}
 
QwtGraphic QwtPlotTradingCurve::legendIcon( int index,
    const QSizeF& size ) const
{
    Q_UNUSED( index );
    return defaultIcon( m_data->symbolPen.color(), size );
}
 
double QwtPlotTradingCurve::scaledSymbolWidth(
    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
    const QRectF& canvasRect ) const
{
    Q_UNUSED( canvasRect );
 
    if ( m_data->maxSymbolWidth > 0.0 &&
        m_data->minSymbolWidth >= m_data->maxSymbolWidth )
    {
        return m_data->minSymbolWidth;
    }
 
    const QwtScaleMap* map =
        ( orientation() == Qt::Vertical ) ? &xMap : &yMap;
 
    const double pos = map->transform( map->s1() + m_data->symbolExtent );
 
    double width = qAbs( pos - map->p1() );
 
    width = qwtMaxF( width,  m_data->minSymbolWidth );
    if ( m_data->maxSymbolWidth > 0.0 )
        width = qwtMinF( width, m_data->maxSymbolWidth );
 
    return width;
}