qwt_interval_symbol.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_interval_symbol.h"
#include "qwt_painter.h"
#include "qwt_math.h"
 
#include <qpainter.h>
#include <qmath.h>
 
class QwtIntervalSymbol::PrivateData
{
  public:
    PrivateData()
        : style( QwtIntervalSymbol::NoSymbol )
        , width( 6 )
    {
    }
 
    bool operator==( const PrivateData& other ) const
    {
        return ( style == other.style )
               && ( width == other.width )
               && ( brush == other.brush )
               && ( pen == other.pen );
    }
 
    QwtIntervalSymbol::Style style;
    int width;
 
    QPen pen;
    QBrush brush;
};
 
QwtIntervalSymbol::QwtIntervalSymbol( Style style )
{
    m_data = new PrivateData();
    m_data->style = style;
}
 
QwtIntervalSymbol::QwtIntervalSymbol( const QwtIntervalSymbol& other )
{
    m_data = new PrivateData();
    *m_data = *other.m_data;
}
 
QwtIntervalSymbol::~QwtIntervalSymbol()
{
    delete m_data;
}
 
QwtIntervalSymbol& QwtIntervalSymbol::operator=(
    const QwtIntervalSymbol& other )
{
    *m_data = *other.m_data;
    return *this;
}
 
bool QwtIntervalSymbol::operator==(
    const QwtIntervalSymbol& other ) const
{
    return *m_data == *other.m_data;
}
 
bool QwtIntervalSymbol::operator!=(
    const QwtIntervalSymbol& other ) const
{
    return !( *m_data == *other.m_data );
}
 
void QwtIntervalSymbol::setStyle( Style style )
{
    m_data->style = style;
}
 
QwtIntervalSymbol::Style QwtIntervalSymbol::style() const
{
    return m_data->style;
}
 
void QwtIntervalSymbol::setWidth( int width )
{
    m_data->width = width;
}
 
int QwtIntervalSymbol::width() const
{
    return m_data->width;
}
 
void QwtIntervalSymbol::setBrush( const QBrush& brush )
{
    m_data->brush = brush;
}
 
const QBrush& QwtIntervalSymbol::brush() const
{
    return m_data->brush;
}
 
void QwtIntervalSymbol::setPen( const QColor& color,
    qreal width, Qt::PenStyle style )
{
    setPen( QPen( color, width, style ) );
}
 
void QwtIntervalSymbol::setPen( const QPen& pen )
{
    m_data->pen = pen;
}
 
const QPen& QwtIntervalSymbol::pen() const
{
    return m_data->pen;
}
 
void QwtIntervalSymbol::draw( QPainter* painter, Qt::Orientation orientation,
    const QPointF& from, const QPointF& to ) const
{
    const qreal pw = QwtPainter::effectivePenWidth( painter->pen() );
 
    QPointF p1 = from;
    QPointF p2 = to;
    if ( QwtPainter::roundingAlignment( painter ) )
    {
        p1 = p1.toPoint();
        p2 = p2.toPoint();
    }
 
    switch ( m_data->style )
    {
        case QwtIntervalSymbol::Bar:
        {
            QwtPainter::drawLine( painter, p1, p2 );
            if ( m_data->width > pw )
            {
                if ( ( orientation == Qt::Horizontal )
                    && ( p1.y() == p2.y() ) )
                {
                    const double sw = m_data->width;
 
                    const double y = p1.y() - sw / 2;
                    QwtPainter::drawLine( painter,
                        p1.x(), y, p1.x(), y + sw );
                    QwtPainter::drawLine( painter,
                        p2.x(), y, p2.x(), y + sw );
                }
                else if ( ( orientation == Qt::Vertical )
                    && ( p1.x() == p2.x() ) )
                {
                    const double sw = m_data->width;
 
                    const double x = p1.x() - sw / 2;
                    QwtPainter::drawLine( painter,
                        x, p1.y(), x + sw, p1.y() );
                    QwtPainter::drawLine( painter,
                        x, p2.y(), x + sw, p2.y() );
                }
                else
                {
                    const double sw = m_data->width;
 
                    const double dx = p2.x() - p1.x();
                    const double dy = p2.y() - p1.y();
                    const double angle = std::atan2( dy, dx ) + M_PI_2;
                    double dw2 = sw / 2.0;
 
                    const double cx = qFastCos( angle ) * dw2;
                    const double sy = qFastSin( angle ) * dw2;
 
                    QwtPainter::drawLine( painter,
                        p1.x() - cx, p1.y() - sy,
                        p1.x() + cx, p1.y() + sy );
                    QwtPainter::drawLine( painter,
                        p2.x() - cx, p2.y() - sy,
                        p2.x() + cx, p2.y() + sy );
                }
            }
            break;
        }
        case QwtIntervalSymbol::Box:
        {
            if ( m_data->width <= pw )
            {
                QwtPainter::drawLine( painter, p1, p2 );
            }
            else
            {
                if ( ( orientation == Qt::Horizontal )
                    && ( p1.y() == p2.y() ) )
                {
                    const double sw = m_data->width;
 
                    const double y = p1.y() - m_data->width / 2;
                    QwtPainter::drawRect( painter,
                        p1.x(), y, p2.x() - p1.x(),  sw );
                }
                else if ( ( orientation == Qt::Vertical )
                    && ( p1.x() == p2.x() ) )
                {
                    const double sw = m_data->width;
 
                    const double x = p1.x() - m_data->width / 2;
                    QwtPainter::drawRect( painter,
                        x, p1.y(), sw, p2.y() - p1.y() );
                }
                else
                {
                    const double sw = m_data->width;
 
                    const double dx = p2.x() - p1.x();
                    const double dy = p2.y() - p1.y();
                    const double angle = std::atan2( dy, dx ) + M_PI_2;
                    double dw2 = sw / 2.0;
 
                    const double cx = qFastCos( angle ) * dw2;
                    const double sy = qFastSin( angle ) * dw2;
 
                    QPolygonF polygon;
                    polygon += QPointF( p1.x() - cx, p1.y() - sy );
                    polygon += QPointF( p1.x() + cx, p1.y() + sy );
                    polygon += QPointF( p2.x() + cx, p2.y() + sy );
                    polygon += QPointF( p2.x() - cx, p2.y() - sy );
 
                    QwtPainter::drawPolygon( painter, polygon );
                }
            }
            break;
        }
        default:;
    }
}