qwt_plot_tradingcurve.cpp

Go to the documentation of this file.

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

#include "qwt_plot_tradingcurve.h"
#include "qwt_scale_map.h"
#include "qwt_clipper.h"
#include "qwt_painter.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 d_data;
}

void QwtPlotTradingCurve::init()
{
    setItemAttribute( QwtPlotItem::Legend, true );
    setItemAttribute( QwtPlotItem::AutoScale, true );

    d_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 )
        d_data->paintAttributes |= attribute;
    else
        d_data->paintAttributes &= ~attribute;
}

bool QwtPlotTradingCurve::testPaintAttribute(
    PaintAttribute attribute ) const
{
    return ( d_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 != d_data->symbolStyle )
    {
        d_data->symbolStyle = style;

        legendChanged();
        itemChanged();
    }
}

QwtPlotTradingCurve::SymbolStyle QwtPlotTradingCurve::symbolStyle() const
{
    return d_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 != d_data->symbolPen )
    {
        d_data->symbolPen = pen;

        legendChanged();
        itemChanged();
    }
}

QPen QwtPlotTradingCurve::symbolPen() const
{
    return d_data->symbolPen;
}

void QwtPlotTradingCurve::setSymbolBrush(
    Direction direction, const QBrush &brush )
{
    if ( brush != d_data->symbolBrush[ direction ] )
    {
        d_data->symbolBrush[ direction ] = brush;

        legendChanged();
        itemChanged();
    }
}

QBrush QwtPlotTradingCurve::symbolBrush( Direction direction ) const
{
    return d_data->symbolBrush[ direction ];
}

void QwtPlotTradingCurve::setSymbolExtent( double extent )
{
    extent = qMax( 0.0, extent );
    if ( extent != d_data->symbolExtent )
    {
        d_data->symbolExtent = extent;

        legendChanged();
        itemChanged();
    }
}

double QwtPlotTradingCurve::symbolExtent() const
{
    return d_data->symbolExtent;
}

void QwtPlotTradingCurve::setMinSymbolWidth( double width )
{
    width = qMax( width, 0.0 );
    if ( width != d_data->minSymbolWidth )
    {
        d_data->minSymbolWidth = width;

        legendChanged();
        itemChanged();
    }
}

double QwtPlotTradingCurve::minSymbolWidth() const
{
    return d_data->minSymbolWidth;
}

void QwtPlotTradingCurve::setMaxSymbolWidth( double width )
{
    if ( width != d_data->maxSymbolWidth )
    {
        d_data->maxSymbolWidth = width;
    
        legendChanged();
        itemChanged();
    }
}

double QwtPlotTradingCurve::maxSymbolWidth() const
{
    return d_data->maxSymbolWidth;
}

QRectF QwtPlotTradingCurve::boundingRect() const
{
    QRectF rect = QwtPlotSeriesItem::boundingRect();
    if ( rect.isValid() && 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 ( d_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 = d_data->paintAttributes & ClipSymbols;
    const bool doAlign = QwtPainter::roundingAlignment( painter );

    double symbolWidth = scaledSymbolWidth( xMap, yMap, canvasRect );
    if ( doAlign )
        symbolWidth = qFloor( 0.5 * symbolWidth ) * 2.0;

    QPen pen = d_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( d_data->symbolStyle )
            {
                case Bar:
                {
                    drawBar( painter, translatedSample, 
                        orient, inverted, symbolWidth );
                    break;
                }
                case CandleStick:
                {
                    painter->setBrush( d_data->symbolBrush[ brushIndex ] );
                    drawCandleStick( painter, translatedSample, 
                        orient, symbolWidth );
                    break;
                }
                default:
                {
                    if ( d_data->symbolStyle >= UserSymbol )
                    {
                        painter->setBrush( d_data->symbolBrush[ brushIndex ] );
                        drawUserSymbol( painter, d_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 = qMin( sample.low, sample.high );
    const double v2 = qMin( sample.open, sample.close );
    const double v3 = qMax( sample.low, sample.high );
    const double v4 = qMax( 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( d_data->symbolPen.color(), size );
}

double QwtPlotTradingCurve::scaledSymbolWidth(
    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
    const QRectF &canvasRect ) const
{
    Q_UNUSED( canvasRect );

    if ( d_data->maxSymbolWidth > 0.0 &&
        d_data->minSymbolWidth >= d_data->maxSymbolWidth )
    {
        return d_data->minSymbolWidth;
    }

    const QwtScaleMap *map =
        ( orientation() == Qt::Vertical ) ? &xMap : &yMap;

    const double pos = map->transform( map->s1() + d_data->symbolExtent ); 

    double width = qAbs( pos - map->p1() );

    width = qMax( width,  d_data->minSymbolWidth );
    if ( d_data->maxSymbolWidth > 0.0 )
        width = qMin( width, d_data->maxSymbolWidth );

    return width;
}