qwt_scale_widget.cpp

Go to the documentation of this file.

/******************************************************************************
 * 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 )
        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;
}

#if QWT_MOC_INCLUDE
#include "moc_qwt_scale_widget.cpp"
#endif