qwt_magnifier.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_magnifier.h"
#include "qwt_math.h"

#include <qevent.h>
#include <qwidget.h>

class QwtMagnifier::PrivateData
{
public:
    PrivateData():
        isEnabled( false ),
        wheelFactor( 0.9 ),
        wheelModifiers( Qt::NoModifier ),
        mouseFactor( 0.95 ),
        mouseButton( Qt::RightButton ),
        mouseButtonModifiers( Qt::NoModifier ),
        keyFactor( 0.9 ),
        zoomInKey( Qt::Key_Plus ),
        zoomInKeyModifiers( Qt::NoModifier ),
        zoomOutKey( Qt::Key_Minus ),
        zoomOutKeyModifiers( Qt::NoModifier ),
        mousePressed( false ),
        hasMouseTracking( false )
    {
    }

    bool isEnabled;

    double wheelFactor;
    Qt::KeyboardModifiers wheelModifiers;

    double mouseFactor;

    Qt::MouseButton mouseButton;
    Qt::KeyboardModifiers mouseButtonModifiers;

    double keyFactor;

    int zoomInKey;
    Qt::KeyboardModifiers zoomInKeyModifiers;

    int zoomOutKey;
    Qt::KeyboardModifiers  zoomOutKeyModifiers;

    bool mousePressed;
    bool hasMouseTracking;
    QPoint mousePos;
};

QwtMagnifier::QwtMagnifier( QWidget *parent ):
    QObject( parent )
{
    d_data = new PrivateData();

    if ( parent )
    {
        if ( parent->focusPolicy() == Qt::NoFocus )
            parent->setFocusPolicy( Qt::WheelFocus );
    }

    setEnabled( true );
}

QwtMagnifier::~QwtMagnifier()
{
    delete d_data;
}

void QwtMagnifier::setEnabled( bool on )
{
    if ( d_data->isEnabled != on )
    {
        d_data->isEnabled = on;

        QObject *o = parent();
        if ( o )
        {
            if ( d_data->isEnabled )
                o->installEventFilter( this );
            else
                o->removeEventFilter( this );
        }
    }
}

bool QwtMagnifier::isEnabled() const
{
    return d_data->isEnabled;
}

void QwtMagnifier::setWheelFactor( double factor )
{
    d_data->wheelFactor = factor;
}

double QwtMagnifier::wheelFactor() const
{
    return d_data->wheelFactor;
}

void QwtMagnifier::setWheelModifiers( Qt::KeyboardModifiers modifiers )
{
    d_data->wheelModifiers = modifiers;
}

Qt::KeyboardModifiers QwtMagnifier::wheelModifiers() const
{
    return d_data->wheelModifiers;
}

void QwtMagnifier::setMouseFactor( double factor )
{
    d_data->mouseFactor = factor;
}

double QwtMagnifier::mouseFactor() const
{
    return d_data->mouseFactor;
}

void QwtMagnifier::setMouseButton(
    Qt::MouseButton button, Qt::KeyboardModifiers modifiers )
{
    d_data->mouseButton = button;
    d_data->mouseButtonModifiers = modifiers;
}

void QwtMagnifier::getMouseButton(
    Qt::MouseButton &button, Qt::KeyboardModifiers &modifiers ) const
{
    button = d_data->mouseButton;
    modifiers = d_data->mouseButtonModifiers;
}

void QwtMagnifier::setKeyFactor( double factor )
{
    d_data->keyFactor = factor;
}

double QwtMagnifier::keyFactor() const
{
    return d_data->keyFactor;
}

void QwtMagnifier::setZoomInKey( int key,
    Qt::KeyboardModifiers modifiers )
{
    d_data->zoomInKey = key;
    d_data->zoomInKeyModifiers = modifiers;
}

void QwtMagnifier::getZoomInKey( int &key,
    Qt::KeyboardModifiers &modifiers ) const
{
    key = d_data->zoomInKey;
    modifiers = d_data->zoomInKeyModifiers;
}

void QwtMagnifier::setZoomOutKey( int key,
    Qt::KeyboardModifiers modifiers )
{
    d_data->zoomOutKey = key;
    d_data->zoomOutKeyModifiers = modifiers;
}

void QwtMagnifier::getZoomOutKey( int &key,
    Qt::KeyboardModifiers &modifiers ) const
{
    key = d_data->zoomOutKey;
    modifiers = d_data->zoomOutKeyModifiers;
}

bool QwtMagnifier::eventFilter( QObject *object, QEvent *event )
{
    if ( object && object == parent() )
    {
        switch ( event->type() )
        {
            case QEvent::MouseButtonPress:
            {
                widgetMousePressEvent( static_cast<QMouseEvent *>( event ) );
                break;
            }
            case QEvent::MouseMove:
            {
                widgetMouseMoveEvent( static_cast<QMouseEvent *>( event ) );
                break;
            }
            case QEvent::MouseButtonRelease:
            {
                widgetMouseReleaseEvent( static_cast<QMouseEvent *>( event ) );
                break;
            }
            case QEvent::Wheel:
            {
                widgetWheelEvent( static_cast<QWheelEvent *>( event ) );
                break;
            }
            case QEvent::KeyPress:
            {
                widgetKeyPressEvent( static_cast<QKeyEvent *>( event ) );
                break;
            }
            case QEvent::KeyRelease:
            {
                widgetKeyReleaseEvent( static_cast<QKeyEvent *>( event ) );
                break;
            }
            default:;
        }
    }
    return QObject::eventFilter( object, event );
}

void QwtMagnifier::widgetMousePressEvent( QMouseEvent *mouseEvent )
{
    if ( parentWidget() == NULL )
        return;

    if ( ( mouseEvent->button() != d_data->mouseButton ) ||
        ( mouseEvent->modifiers() != d_data->mouseButtonModifiers ) )
    {
        return;
    }

    d_data->hasMouseTracking = parentWidget()->hasMouseTracking();

    parentWidget()->setMouseTracking( true );
    d_data->mousePos = mouseEvent->pos();
    d_data->mousePressed = true;
}

void QwtMagnifier::widgetMouseReleaseEvent( QMouseEvent *mouseEvent )
{
    Q_UNUSED( mouseEvent );

    if ( d_data->mousePressed && parentWidget() )
    {
        d_data->mousePressed = false;
        parentWidget()->setMouseTracking( d_data->hasMouseTracking );
    }
}

void QwtMagnifier::widgetMouseMoveEvent( QMouseEvent *mouseEvent )
{
    if ( !d_data->mousePressed )
        return;

    const int dy = mouseEvent->pos().y() - d_data->mousePos.y();
    if ( dy != 0 )
    {
        double f = d_data->mouseFactor;
        if ( dy < 0 )
            f = 1 / f;

        rescale( f );
    }

    d_data->mousePos = mouseEvent->pos();
}

void QwtMagnifier::widgetWheelEvent( QWheelEvent *wheelEvent )
{
    if ( wheelEvent->modifiers() != d_data->wheelModifiers )
    {
        return;
    }

    if ( d_data->wheelFactor != 0.0 )
    {
#if QT_VERSION < 0x050000
        const int wheelDelta = wheelEvent->delta();
#else
        const QPoint delta = wheelEvent->angleDelta();
        const int wheelDelta = ( qAbs( delta.x() ) > qAbs( delta.y() ) )
            ? delta.x() : delta.y();
#endif

        /*
            A positive delta indicates that the wheel was
            rotated forwards away from the user; a negative
            value indicates that the wheel was rotated
            backwards toward the user.
            Most mouse types work in steps of 15 degrees,
            in which case the delta value is a multiple
            of 120 (== 15 * 8).
         */
        double f = std::pow( d_data->wheelFactor,
            qAbs( wheelDelta / 120.0 ) );

        if ( wheelDelta > 0 )
            f = 1 / f;

        rescale( f );
    }
}

void QwtMagnifier::widgetKeyPressEvent( QKeyEvent *keyEvent )
{
    if ( keyEvent->key() == d_data->zoomInKey &&
        keyEvent->modifiers() == d_data->zoomInKeyModifiers )
    {
        rescale( d_data->keyFactor );
    }
    else if ( keyEvent->key() == d_data->zoomOutKey &&
        keyEvent->modifiers() == d_data->zoomOutKeyModifiers )
    {
        rescale( 1.0 / d_data->keyFactor );
    }
}

void QwtMagnifier::widgetKeyReleaseEvent( QKeyEvent *keyEvent )
{
    Q_UNUSED( keyEvent );
}

QWidget *QwtMagnifier::parentWidget()
{
    return qobject_cast<QWidget *>( parent() );
}

const QWidget *QwtMagnifier::parentWidget() const
{
    return qobject_cast<const QWidget *>( parent() );
}

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