qwt_scale_widget.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_scale_widget.h"
#include "qwt_painter.h"
#include "qwt_color_map.h"
#include "qwt_scale_map.h"
#include "qwt_math.h"
#include "qwt_scale_div.h"
#include "qwt_text.h"
#include "qwt_interval.h"
#include "qwt_scale_engine.h"
 
#include <qpainter.h>
#include <qevent.h>
#include <qstyle.h>
#include <qstyleoption.h>
#include <qapplication.h>
#include <qmargins.h>
 
class QwtScaleWidget::PrivateData
{
  public:
    PrivateData()
        : scaleDraw( NULL )
    {
        colorBar.colorMap = NULL;
    }
 
    ~PrivateData()
    {
        delete scaleDraw;
        delete colorBar.colorMap;
    }
 
    QwtScaleDraw* scaleDraw;
 
    int borderDist[2];
    int minBorderDist[2];
    int scaleLength;
    int margin;
 
    int titleOffset;
    int spacing;
    QwtText title;
 
    QwtScaleWidget::LayoutFlags layoutFlags;
 
    struct t_colorBar
    {
        bool isEnabled;
        int width;
        QwtInterval interval;
        QwtColorMap* colorMap;
    } colorBar;
};
 
QwtScaleWidget::QwtScaleWidget( QWidget* parent )
    : QWidget( parent )
{
    initScale( QwtScaleDraw::LeftScale );
}
 
QwtScaleWidget::QwtScaleWidget( QwtScaleDraw::Alignment align, QWidget* parent )
    : QWidget( parent )
{
    initScale( align );
}
 
QwtScaleWidget::~QwtScaleWidget()
{
    delete m_data;
}
 
void QwtScaleWidget::initScale( QwtScaleDraw::Alignment align )
{
    m_data = new PrivateData;
 
    if ( align == QwtScaleDraw::RightScale )
        m_data->layoutFlags |= TitleInverted;
 
    m_data->borderDist[0] = 0;
    m_data->borderDist[1] = 0;
    m_data->minBorderDist[0] = 0;
    m_data->minBorderDist[1] = 0;
    m_data->margin = 4;
    m_data->titleOffset = 0;
    m_data->spacing = 2;
 
    m_data->scaleDraw = new QwtScaleDraw;
    m_data->scaleDraw->setAlignment( align );
    m_data->scaleDraw->setLength( 10 );
 
    m_data->scaleDraw->setScaleDiv(
        QwtLinearScaleEngine().divideScale( 0.0, 100.0, 10, 5 ) );
 
    m_data->colorBar.colorMap = new QwtLinearColorMap();
    m_data->colorBar.isEnabled = false;
    m_data->colorBar.width = 10;
 
    const int flags = Qt::AlignHCenter
        | Qt::TextExpandTabs | Qt::TextWordWrap;
    m_data->title.setRenderFlags( flags );
    m_data->title.setFont( font() );
 
    QSizePolicy policy( QSizePolicy::MinimumExpanding,
        QSizePolicy::Fixed );
    if ( m_data->scaleDraw->orientation() == Qt::Vertical )
        policy.transpose();
 
    setSizePolicy( policy );
 
    setAttribute( Qt::WA_WState_OwnSizePolicy, false );
}
 
void QwtScaleWidget::setLayoutFlag( LayoutFlag flag, bool on )
{
    if ( ( ( m_data->layoutFlags & flag ) != 0 ) != on )
    {
        if ( on )
            m_data->layoutFlags |= flag;
        else
            m_data->layoutFlags &= ~flag;
 
        update();
    }
}
 
bool QwtScaleWidget::testLayoutFlag( LayoutFlag flag ) const
{
    return ( m_data->layoutFlags & flag );
}
 
void QwtScaleWidget::setTitle( const QString& title )
{
    if ( m_data->title.text() != title )
    {
        m_data->title.setText( title );
        layoutScale();
    }
}
 
void QwtScaleWidget::setTitle( const QwtText& title )
{
    QwtText t = title;
    const int flags = title.renderFlags() & ~( Qt::AlignTop | Qt::AlignBottom );
    t.setRenderFlags( flags );
 
    if ( t != m_data->title )
    {
        m_data->title = t;
        layoutScale();
    }
}
 
void QwtScaleWidget::setAlignment( QwtScaleDraw::Alignment alignment )
{
    if ( m_data->scaleDraw == NULL )
        return;
 
    m_data->scaleDraw->setAlignment( alignment );
 
    if ( !testAttribute( Qt::WA_WState_OwnSizePolicy ) )
    {
        QSizePolicy policy( QSizePolicy::MinimumExpanding, QSizePolicy::Fixed );
        if ( m_data->scaleDraw->orientation() == Qt::Vertical )
            policy.transpose();
 
        setSizePolicy( policy );
 
        setAttribute( Qt::WA_WState_OwnSizePolicy, false );
    }
 
    layoutScale();
}
 
 
QwtScaleDraw::Alignment QwtScaleWidget::alignment() const
{
    if ( !scaleDraw() )
        return QwtScaleDraw::LeftScale;
 
    return scaleDraw()->alignment();
}
 
void QwtScaleWidget::setBorderDist( int dist1, int dist2 )
{
    if ( dist1 != m_data->borderDist[0] || dist2 != m_data->borderDist[1] )
    {
        m_data->borderDist[0] = dist1;
        m_data->borderDist[1] = dist2;
        layoutScale();
    }
}
 
void QwtScaleWidget::setMargin( int margin )
{
    margin = qMax( 0, margin );
    if ( margin != m_data->margin )
    {
        m_data->margin = margin;
        layoutScale();
    }
}
 
void QwtScaleWidget::setSpacing( int spacing )
{
    spacing = qMax( 0, spacing );
    if ( spacing != m_data->spacing )
    {
        m_data->spacing = spacing;
        layoutScale();
    }
}
 
void QwtScaleWidget::setLabelAlignment( Qt::Alignment alignment )
{
    m_data->scaleDraw->setLabelAlignment( alignment );
    layoutScale();
}
 
void QwtScaleWidget::setLabelRotation( double rotation )
{
    m_data->scaleDraw->setLabelRotation( rotation );
    layoutScale();
}
 
void QwtScaleWidget::setScaleDraw( QwtScaleDraw* scaleDraw )
{
    if ( ( scaleDraw == NULL ) || ( scaleDraw == m_data->scaleDraw ) )
        return;
 
    const QwtScaleDraw* sd = m_data->scaleDraw;
    if ( sd )
    {
        scaleDraw->setAlignment( sd->alignment() );
        scaleDraw->setScaleDiv( sd->scaleDiv() );
 
        QwtTransform* transform = NULL;
        if ( sd->scaleMap().transformation() )
            transform = sd->scaleMap().transformation()->copy();
 
        scaleDraw->setTransformation( transform );
    }
 
    delete m_data->scaleDraw;
    m_data->scaleDraw = scaleDraw;
 
    layoutScale();
}
 
const QwtScaleDraw* QwtScaleWidget::scaleDraw() const
{
    return m_data->scaleDraw;
}
 
QwtScaleDraw* QwtScaleWidget::scaleDraw()
{
    return m_data->scaleDraw;
}
 
QwtText QwtScaleWidget::title() const
{
    return m_data->title;
}
 
int QwtScaleWidget::startBorderDist() const
{
    return m_data->borderDist[0];
}
 
int QwtScaleWidget::endBorderDist() const
{
    return m_data->borderDist[1];
}
 
int QwtScaleWidget::margin() const
{
    return m_data->margin;
}
 
int QwtScaleWidget::spacing() const
{
    return m_data->spacing;
}
 
void QwtScaleWidget::paintEvent( QPaintEvent* event )
{
    QPainter painter( this );
    painter.setClipRegion( event->region() );
 
    QStyleOption opt;
    opt.initFrom(this);
    style()->drawPrimitive(QStyle::PE_Widget, &opt, &painter, this);
 
    draw( &painter );
}
 
void QwtScaleWidget::draw( QPainter* painter ) const
{
    m_data->scaleDraw->draw( painter, palette() );
 
    if ( m_data->colorBar.isEnabled && m_data->colorBar.width > 0 &&
        m_data->colorBar.interval.isValid() )
    {
        drawColorBar( painter, colorBarRect( contentsRect() ) );
    }
 
    QRect r = contentsRect();
    if ( m_data->scaleDraw->orientation() == Qt::Horizontal )
    {
        r.setLeft( r.left() + m_data->borderDist[0] );
        r.setWidth( r.width() - m_data->borderDist[1] );
    }
    else
    {
        r.setTop( r.top() + m_data->borderDist[0] );
        r.setHeight( r.height() - m_data->borderDist[1] );
    }
 
    if ( !m_data->title.isEmpty() )
        drawTitle( painter, m_data->scaleDraw->alignment(), r );
}
 
QRectF QwtScaleWidget::colorBarRect( const QRectF& rect ) const
{
    QRectF cr = rect;
 
    if ( m_data->scaleDraw->orientation() == Qt::Horizontal )
    {
        cr.setLeft( cr.left() + m_data->borderDist[0] );
        cr.setWidth( cr.width() - m_data->borderDist[1] + 1 );
    }
    else
    {
        cr.setTop( cr.top() + m_data->borderDist[0] );
        cr.setHeight( cr.height() - m_data->borderDist[1] + 1 );
    }
 
    switch ( m_data->scaleDraw->alignment() )
    {
        case QwtScaleDraw::LeftScale:
        {
            cr.setLeft( cr.right() - m_data->margin
                - m_data->colorBar.width );
            cr.setWidth( m_data->colorBar.width );
            break;
        }
 
        case QwtScaleDraw::RightScale:
        {
            cr.setLeft( cr.left() + m_data->margin );
            cr.setWidth( m_data->colorBar.width );
            break;
        }
 
        case QwtScaleDraw::BottomScale:
        {
            cr.setTop( cr.top() + m_data->margin );
            cr.setHeight( m_data->colorBar.width );
            break;
        }
 
        case QwtScaleDraw::TopScale:
        {
            cr.setTop( cr.bottom() - m_data->margin
                - m_data->colorBar.width );
            cr.setHeight( m_data->colorBar.width );
            break;
        }
    }
 
    return cr;
}
 
void QwtScaleWidget::changeEvent( QEvent* event )
{
    if ( event->type() == QEvent::LocaleChange )
    {
        m_data->scaleDraw->invalidateCache();
    }
 
    QWidget::changeEvent( event );
}
 
void QwtScaleWidget::resizeEvent( QResizeEvent* event )
{
    Q_UNUSED( event );
    layoutScale( false );
}
 
void QwtScaleWidget::layoutScale( bool update_geometry )
{
    int bd0, bd1;
    getBorderDistHint( bd0, bd1 );
    if ( m_data->borderDist[0] > bd0 )
        bd0 = m_data->borderDist[0];
    if ( m_data->borderDist[1] > bd1 )
        bd1 = m_data->borderDist[1];
 
    int colorBarWidth = 0;
    if ( m_data->colorBar.isEnabled && m_data->colorBar.interval.isValid() )
        colorBarWidth = m_data->colorBar.width + m_data->spacing;
 
    const QRectF r = contentsRect();
    double x, y, length;
 
    if ( m_data->scaleDraw->orientation() == Qt::Vertical )
    {
        y = r.top() + bd0;
        length = r.height() - ( bd0 + bd1 );
 
        if ( m_data->scaleDraw->alignment() == QwtScaleDraw::LeftScale )
            x = r.right() - 1.0 - m_data->margin - colorBarWidth;
        else
            x = r.left() + m_data->margin + colorBarWidth;
    }
    else
    {
        x = r.left() + bd0;
        length = r.width() - ( bd0 + bd1 );
 
        if ( m_data->scaleDraw->alignment() == QwtScaleDraw::BottomScale )
            y = r.top() + m_data->margin + colorBarWidth;
        else
            y = r.bottom() - 1.0 - m_data->margin - colorBarWidth;
    }
 
    m_data->scaleDraw->move( x, y );
    m_data->scaleDraw->setLength( length );
 
    const int extent = qwtCeil( m_data->scaleDraw->extent( font() ) );
 
    m_data->titleOffset =
        m_data->margin + m_data->spacing + colorBarWidth + extent;
 
    if ( update_geometry )
    {
        updateGeometry();
 
#if 1
        /*
            for some reason updateGeometry does not send a LayoutRequest event
            when the parent is not visible and has no layout
         */
 
        if ( QWidget* w = parentWidget() )
        {
            if ( !w->isVisible() && w->layout() == NULL )
            {
                if ( w->testAttribute( Qt::WA_WState_Polished ) )
                    QApplication::postEvent( w, new QEvent( QEvent::LayoutRequest ) );
            }
        }
#endif
 
        update();
    }
}
 
void QwtScaleWidget::drawColorBar( QPainter* painter, const QRectF& rect ) const
{
    if ( !m_data->colorBar.interval.isValid() )
        return;
 
    const QwtScaleDraw* sd = m_data->scaleDraw;
 
    QwtPainter::drawColorBar( painter, *m_data->colorBar.colorMap,
        m_data->colorBar.interval.normalized(), sd->scaleMap(),
        sd->orientation(), rect );
}
 
void QwtScaleWidget::drawTitle( QPainter* painter,
    QwtScaleDraw::Alignment align, const QRectF& rect ) const
{
    QRectF r = rect;
    double angle;
    int flags = m_data->title.renderFlags() &
        ~( Qt::AlignTop | Qt::AlignBottom | Qt::AlignVCenter );
 
    switch ( align )
    {
        case QwtScaleDraw::LeftScale:
            angle = -90.0;
            flags |= Qt::AlignTop;
            r.setRect( r.left(), r.bottom(),
                r.height(), r.width() - m_data->titleOffset );
            break;
 
        case QwtScaleDraw::RightScale:
            angle = -90.0;
            flags |= Qt::AlignTop;
            r.setRect( r.left() + m_data->titleOffset, r.bottom(),
                r.height(), r.width() - m_data->titleOffset );
            break;
 
        case QwtScaleDraw::BottomScale:
            angle = 0.0;
            flags |= Qt::AlignBottom;
            r.setTop( r.top() + m_data->titleOffset );
            break;
 
        case QwtScaleDraw::TopScale:
        default:
            angle = 0.0;
            flags |= Qt::AlignTop;
            r.setBottom( r.bottom() - m_data->titleOffset );
            break;
    }
 
    if ( m_data->layoutFlags & TitleInverted )
    {
        if ( align == QwtScaleDraw::LeftScale
            || align == QwtScaleDraw::RightScale )
        {
            angle = -angle;
            r.setRect( r.x() + r.height(), r.y() - r.width(),
                r.width(), r.height() );
        }
    }
 
    painter->save();
    painter->setFont( font() );
    painter->setPen( palette().color( QPalette::Text ) );
 
    painter->translate( r.x(), r.y() );
    if ( angle != 0.0 )
        painter->rotate( angle );
 
    QwtText title = m_data->title;
    title.setRenderFlags( flags );
    title.draw( painter, QRectF( 0.0, 0.0, r.width(), r.height() ) );
 
    painter->restore();
}
 
void QwtScaleWidget::scaleChange()
{
    layoutScale();
}
 
QSize QwtScaleWidget::sizeHint() const
{
    return minimumSizeHint();
}
 
QSize QwtScaleWidget::minimumSizeHint() const
{
    const Qt::Orientation o = m_data->scaleDraw->orientation();
 
    // Border Distance cannot be less than the scale borderDistHint
    // Note, the borderDistHint is already included in minHeight/minWidth
    int length = 0;
    int mbd1, mbd2;
    getBorderDistHint( mbd1, mbd2 );
    length += qMax( 0, m_data->borderDist[0] - mbd1 );
    length += qMax( 0, m_data->borderDist[1] - mbd2 );
    length += m_data->scaleDraw->minLength( font() );
 
    int dim = dimForLength( length, font() );
    if ( length < dim )
    {
        // compensate for long titles
        length = dim;
        dim = dimForLength( length, font() );
    }
 
    QSize size( length + 2, dim );
    if ( o == Qt::Vertical )
        size.transpose();
 
    const QMargins m = contentsMargins();
    return size + QSize( m.left() + m.right(), m.top() + m.bottom() );
}
 
int QwtScaleWidget::titleHeightForWidth( int width ) const
{
    return qwtCeil( m_data->title.heightForWidth( width, font() ) );
}
 
int QwtScaleWidget::dimForLength( int length, const QFont& scaleFont ) const
{
    const int extent = qwtCeil( m_data->scaleDraw->extent( scaleFont ) );
 
    int dim = m_data->margin + extent + 1;
 
    if ( !m_data->title.isEmpty() )
        dim += titleHeightForWidth( length ) + m_data->spacing;
 
    if ( m_data->colorBar.isEnabled && m_data->colorBar.interval.isValid() )
        dim += m_data->colorBar.width + m_data->spacing;
 
    return dim;
}
 
void QwtScaleWidget::getBorderDistHint( int& start, int& end ) const
{
    m_data->scaleDraw->getBorderDistHint( font(), start, end );
 
    if ( start < m_data->minBorderDist[0] )
        start = m_data->minBorderDist[0];
 
    if ( end < m_data->minBorderDist[1] )
        end = m_data->minBorderDist[1];
}
 
void QwtScaleWidget::setMinBorderDist( int start, int end )
{
    m_data->minBorderDist[0] = start;
    m_data->minBorderDist[1] = end;
}
 
void QwtScaleWidget::getMinBorderDist( int& start, int& end ) const
{
    start = m_data->minBorderDist[0];
    end = m_data->minBorderDist[1];
}
 
void QwtScaleWidget::setScaleDiv( const QwtScaleDiv& scaleDiv )
{
    QwtScaleDraw* sd = m_data->scaleDraw;
    if ( sd->scaleDiv() != scaleDiv )
    {
        sd->setScaleDiv( scaleDiv );
        layoutScale();
 
        Q_EMIT scaleDivChanged();
    }
}
 
void QwtScaleWidget::setTransformation( QwtTransform* transformation )
{
    m_data->scaleDraw->setTransformation( transformation );
    layoutScale();
}
 
void QwtScaleWidget::setColorBarEnabled( bool on )
{
    if ( on != m_data->colorBar.isEnabled )
    {
        m_data->colorBar.isEnabled = on;
        layoutScale();
    }
}
 
bool QwtScaleWidget::isColorBarEnabled() const
{
    return m_data->colorBar.isEnabled;
}
 
void QwtScaleWidget::setColorBarWidth( int width )
{
    if ( width != m_data->colorBar.width )
    {
        m_data->colorBar.width = width;
        if ( isColorBarEnabled() )
            layoutScale();
    }
}
 
int QwtScaleWidget::colorBarWidth() const
{
    return m_data->colorBar.width;
}
 
QwtInterval QwtScaleWidget::colorBarInterval() const
{
    return m_data->colorBar.interval;
}
 
void QwtScaleWidget::setColorMap(
    const QwtInterval& interval, QwtColorMap* colorMap )
{
    m_data->colorBar.interval = interval;
 
    if ( colorMap != m_data->colorBar.colorMap )
    {
        delete m_data->colorBar.colorMap;
        m_data->colorBar.colorMap = colorMap;
    }
 
    if ( isColorBarEnabled() )
        layoutScale();
}
 
const QwtColorMap* QwtScaleWidget::colorMap() const
{
    return m_data->colorBar.colorMap;
}
 
#include "moc_qwt_scale_widget.cpp"