qwt_picker.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 <qapplication.h>
#include <qevent.h>
#include <qpainter.h>
#include <qframe.h>
#include <qcursor.h>
#include <qbitmap.h>
#include "qwt_math.h"
#include "qwt_painter.h"
#include "qwt_picker_machine.h"
#include "qwt_picker.h"
#if QT_VERSION < 0x040000
#include <qguardedptr.h>
#else
#include <qpointer.h>
#include <qpaintengine.h>
#endif

class QwtPicker::PickerWidget: public QWidget
{
public:
    enum Type
    {
        RubberBand,
        Text
    };

    PickerWidget(QwtPicker *, QWidget *, Type);
    virtual void updateMask();

    /*
       For a tracker text with a background we can use the background 
       rect as mask. Also for "regular" Qt widgets >= 4.3.0 we
       don't need to mask the text anymore.
     */
    bool d_hasTextMask;

protected:
    virtual void paintEvent(QPaintEvent *);

    QwtPicker *d_picker;
    Type d_type;
};

class QwtPicker::PrivateData
{
public:
    bool enabled;

    QwtPickerMachine *stateMachine;

    int selectionFlags;
    QwtPicker::ResizeMode resizeMode;

    QwtPicker::RubberBand rubberBand;
    QPen rubberBandPen;

    QwtPicker::DisplayMode trackerMode;
    QPen trackerPen;
    QFont trackerFont;

    QwtPolygon selection;
    bool isActive;
    QPoint trackerPosition;

    bool mouseTracking; // used to save previous value

    /*
      On X11 the widget below the picker widgets gets paint events
      with a region that is the bounding rect of the mask, if it is complex.
      In case of (f.e) a CrossRubberBand and a text this creates complete
      repaints of the widget. So we better use two different widgets.
     */
     
#if QT_VERSION < 0x040000
    QGuardedPtr<PickerWidget> rubberBandWidget;
    QGuardedPtr<PickerWidget> trackerWidget;
#else
    QPointer<PickerWidget> rubberBandWidget;
    QPointer<PickerWidget> trackerWidget;
#endif
};

QwtPicker::PickerWidget::PickerWidget(
        QwtPicker *picker, QWidget *parent, Type type):
    QWidget(parent),
    d_hasTextMask(false),
    d_picker(picker),
    d_type(type)
{
#if QT_VERSION >= 0x040000
    setAttribute(Qt::WA_TransparentForMouseEvents);
    setAttribute(Qt::WA_NoSystemBackground);
    setFocusPolicy(Qt::NoFocus);
#else
    setBackgroundMode(Qt::NoBackground);
    setFocusPolicy(QWidget::NoFocus);
    setMouseTracking(true);
#endif
    hide();
}

void QwtPicker::PickerWidget::updateMask()
{
    QRegion mask;

    if ( d_type == RubberBand )
    {
        QBitmap bm(width(), height());
        bm.fill(Qt::color0);

        QPainter painter(&bm);
        QPen pen = d_picker->rubberBandPen();
        pen.setColor(Qt::color1);
        painter.setPen(pen);

        d_picker->drawRubberBand(&painter);

        mask = QRegion(bm);
    }
    if ( d_type == Text )
    {
        d_hasTextMask = true;
#if QT_VERSION >= 0x040300
        if ( !parentWidget()->testAttribute(Qt::WA_PaintOnScreen) )
        {
#if 0
            if ( parentWidget()->paintEngine()->type() != QPaintEngine::OpenGL )
#endif
            {
                // With Qt >= 4.3 drawing of the tracker can be implemented in an
                // easier way, using the textRect as mask. 

                d_hasTextMask = false;
            }
        }
#endif
        
        if ( d_hasTextMask )
        {
            const QwtText label = d_picker->trackerText(
                d_picker->trackerPosition());
            if ( label.testPaintAttribute(QwtText::PaintBackground)
                && label.backgroundBrush().style() != Qt::NoBrush )
            {
#if QT_VERSION >= 0x040300
                if ( label.backgroundBrush().color().alpha() > 0 )
#endif
                // We don't need a text mask, when we have a background
                d_hasTextMask = false;
            }
        }

        if ( d_hasTextMask )
        {
            QBitmap bm(width(), height());
            bm.fill(Qt::color0);

            QPainter painter(&bm);
            painter.setFont(font());

            QPen pen = d_picker->trackerPen();
            pen.setColor(Qt::color1);
            painter.setPen(pen);

            d_picker->drawTracker(&painter);

            mask = QRegion(bm);
        }
        else
        {
            mask = d_picker->trackerRect(font());
        }
    }

#if QT_VERSION < 0x040000
    QWidget *w = parentWidget();
    const bool doUpdate = w->isUpdatesEnabled();
    const Qt::BackgroundMode bgMode = w->backgroundMode();
    w->setUpdatesEnabled(false);
    if ( bgMode != Qt::NoBackground )
        w->setBackgroundMode(Qt::NoBackground);
#endif

    setMask(mask);

#if QT_VERSION < 0x040000
    if ( bgMode != Qt::NoBackground )
        w->setBackgroundMode(bgMode);

    w->setUpdatesEnabled(doUpdate);
#endif

    setShown(!mask.isEmpty());
}

void QwtPicker::PickerWidget::paintEvent(QPaintEvent *e)
{
    QPainter painter(this);
    painter.setClipRegion(e->region());

    if ( d_type == RubberBand )
    {
        painter.setPen(d_picker->rubberBandPen());
        d_picker->drawRubberBand(&painter);
    }

    if ( d_type == Text )
    {
        /*
           If we have a text mask we simply fill the region of
           the mask. This gives better results for antialiased fonts.
         */
        bool doDrawTracker = !d_hasTextMask;
#if QT_VERSION < 0x040000
        if ( !doDrawTracker && QPainter::redirect(this) )
        {
            // setMask + painter redirection doesn't work
            doDrawTracker = true;
        }
#endif
        if ( doDrawTracker )
        {
            painter.setPen(d_picker->trackerPen());
            d_picker->drawTracker(&painter);
        }
        else
            painter.fillRect(e->rect(), QBrush(d_picker->trackerPen().color()));
    }
}

QwtPicker::QwtPicker(QWidget *parent):
    QObject(parent)
{
    init(parent, NoSelection, NoRubberBand, AlwaysOff);
}

QwtPicker::QwtPicker(int selectionFlags, RubberBand rubberBand,
        DisplayMode trackerMode, QWidget *parent):
    QObject(parent)
{
    init(parent, selectionFlags, rubberBand, trackerMode);
}

QwtPicker::~QwtPicker()
{
    setMouseTracking(false);
    delete d_data->stateMachine;
    delete d_data->rubberBandWidget;
    delete d_data->trackerWidget;
    delete d_data;
}

void QwtPicker::init(QWidget *parent, int selectionFlags, 
    RubberBand rubberBand, DisplayMode trackerMode)
{
    d_data = new PrivateData;

    d_data->rubberBandWidget = NULL;
    d_data->trackerWidget = NULL;

    d_data->rubberBand = rubberBand;
    d_data->enabled = false;
    d_data->resizeMode = Stretch;
    d_data->trackerMode = AlwaysOff;
    d_data->isActive = false;
    d_data->trackerPosition = QPoint(-1, -1);
    d_data->mouseTracking = false;

    d_data->stateMachine = NULL;
    setSelectionFlags(selectionFlags);

    if ( parent )
    {
#if QT_VERSION >= 0x040000
        if ( parent->focusPolicy() == Qt::NoFocus )
            parent->setFocusPolicy(Qt::WheelFocus);
#else
        if ( parent->focusPolicy() == QWidget::NoFocus )
            parent->setFocusPolicy(QWidget::WheelFocus);
#endif

        d_data->trackerFont = parent->font();
        d_data->mouseTracking = parent->hasMouseTracking();
        setEnabled(true);
    }
    setTrackerMode(trackerMode);
}

void QwtPicker::setStateMachine(QwtPickerMachine *stateMachine)
{
    if ( d_data->stateMachine != stateMachine )
    {
        reset();

        delete d_data->stateMachine;
        d_data->stateMachine = stateMachine;

        if ( d_data->stateMachine )
            d_data->stateMachine->reset();
    }
}

QwtPickerMachine *QwtPicker::stateMachine(int flags) const
{
    if ( flags & PointSelection )
    {
        if ( flags & ClickSelection )
            return new QwtPickerClickPointMachine;
        else
            return new QwtPickerDragPointMachine;
    }
    if ( flags & RectSelection )
    {
        if ( flags & ClickSelection )
            return new QwtPickerClickRectMachine;
        else
            return new QwtPickerDragRectMachine;
    }
    if ( flags & PolygonSelection )
    {
        return new QwtPickerPolygonMachine();
    }
    return NULL;
}

QWidget *QwtPicker::parentWidget()
{
    QObject *obj = parent();
    if ( obj && obj->isWidgetType() )
        return (QWidget *)obj;

    return NULL;
}

const QWidget *QwtPicker::parentWidget() const
{
    QObject *obj = parent();
    if ( obj && obj->isWidgetType() )
        return (QWidget *)obj;

    return NULL;
}

void QwtPicker::setSelectionFlags(int flags)
{
    d_data->selectionFlags = flags;
    setStateMachine(stateMachine(flags));
}

int QwtPicker::selectionFlags() const
{
    return d_data->selectionFlags;
}

void QwtPicker::setRubberBand(RubberBand rubberBand)
{
    d_data->rubberBand = rubberBand;
}

QwtPicker::RubberBand QwtPicker::rubberBand() const
{
    return d_data->rubberBand;
}

void QwtPicker::setTrackerMode(DisplayMode mode)
{   
    if ( d_data->trackerMode != mode )
    {
        d_data->trackerMode = mode;
        setMouseTracking(d_data->trackerMode == AlwaysOn);
    }
}   

QwtPicker::DisplayMode QwtPicker::trackerMode() const
{   
    return d_data->trackerMode;
}   

void QwtPicker::setResizeMode(ResizeMode mode)
{
    d_data->resizeMode = mode;
}   

QwtPicker::ResizeMode QwtPicker::resizeMode() const
{   
    return d_data->resizeMode;
}

void QwtPicker::setEnabled(bool enabled)
{
    if ( d_data->enabled != enabled )
    {
        d_data->enabled = enabled;

        QWidget *w = parentWidget();
        if ( w )
        {
            if ( enabled )
                w->installEventFilter(this);
            else
                w->removeEventFilter(this);
        }

        updateDisplay();
    }
}

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

void QwtPicker::setTrackerFont(const QFont &font)
{
    if ( font != d_data->trackerFont )
    {
        d_data->trackerFont = font;
        updateDisplay();
    }
}

QFont QwtPicker::trackerFont() const
{
    return d_data->trackerFont;
}

void QwtPicker::setTrackerPen(const QPen &pen)
{
    if ( pen != d_data->trackerPen )
    {
        d_data->trackerPen = pen;
        updateDisplay();
    }
}

QPen QwtPicker::trackerPen() const
{
    return d_data->trackerPen;
}

void QwtPicker::setRubberBandPen(const QPen &pen)
{
    if ( pen != d_data->rubberBandPen )
    {
        d_data->rubberBandPen = pen;
        updateDisplay();
    }
}

QPen QwtPicker::rubberBandPen() const
{
    return d_data->rubberBandPen;
}

QwtText QwtPicker::trackerText(const QPoint &pos) const
{
    QString label;

    switch(rubberBand())
    {
        case HLineRubberBand:
            label.sprintf("%d", pos.y());
            break;
        case VLineRubberBand:
            label.sprintf("%d", pos.x());
            break;
        default:
            label.sprintf("%d, %d", pos.x(), pos.y());
    }
    return label;
}

void QwtPicker::drawRubberBand(QPainter *painter) const
{
    if ( !isActive() || rubberBand() == NoRubberBand || 
        rubberBandPen().style() == Qt::NoPen )
    {
        return;
    }

    const QRect &pRect = pickRect();
    const QwtPolygon &pa = d_data->selection;

    if ( selectionFlags() & PointSelection )
    {
        if ( pa.count() < 1 )
            return;

        const QPoint pos = pa[0];

        switch(rubberBand())
        {
            case VLineRubberBand:
                QwtPainter::drawLine(painter, pos.x(),
                    pRect.top(), pos.x(), pRect.bottom());
                break;

            case HLineRubberBand:
                QwtPainter::drawLine(painter, pRect.left(), 
                    pos.y(), pRect.right(), pos.y());
                break;

            case CrossRubberBand:
                QwtPainter::drawLine(painter, pos.x(),
                    pRect.top(), pos.x(), pRect.bottom());
                QwtPainter::drawLine(painter, pRect.left(), 
                    pos.y(), pRect.right(), pos.y());
                break;
            default:
                break;
        }
    }

    else if ( selectionFlags() & RectSelection )
    {
        if ( pa.count() < 2 )
            return;

        QPoint p1 = pa[0];
        QPoint p2 = pa[int(pa.count() - 1)];

        if ( selectionFlags() & CenterToCorner )
        {
            p1.setX(p1.x() - (p2.x() - p1.x()));
            p1.setY(p1.y() - (p2.y() - p1.y()));
        }
        else if ( selectionFlags() & CenterToRadius )
        {
            const int radius = qwtMax(qwtAbs(p2.x() - p1.x()), 
                qwtAbs(p2.y() - p1.y()));
            p2.setX(p1.x() + radius);
            p2.setY(p1.y() + radius);
            p1.setX(p1.x() - radius);
            p1.setY(p1.y() - radius);
        }

#if QT_VERSION < 0x040000
        const QRect rect = QRect(p1, p2).normalize();
#else
        const QRect rect = QRect(p1, p2).normalized();
#endif
        switch(rubberBand())
        {
            case EllipseRubberBand:
                QwtPainter::drawEllipse(painter, rect);
                break;
            case RectRubberBand:
                QwtPainter::drawRect(painter, rect);
                break;
            default:
                break;
        }
    }
    else if ( selectionFlags() & PolygonSelection )
    {
        if ( rubberBand() == PolygonRubberBand )
            painter->drawPolyline(pa);
    }
}

void QwtPicker::drawTracker(QPainter *painter) const
{
    const QRect textRect = trackerRect(painter->font());
    if ( !textRect.isEmpty() )
    {
        QwtText label = trackerText(d_data->trackerPosition);
        if ( !label.isEmpty() )
        {
            painter->save();

#if defined(Q_WS_MAC)
            // Antialiased fonts are broken on the Mac.
#if QT_VERSION >= 0x040000 
            painter->setRenderHint(QPainter::TextAntialiasing, false);
#else
            QFont fnt = label.usedFont(painter->font());
            fnt.setStyleStrategy(QFont::NoAntialias);
            label.setFont(fnt);
#endif
#endif
            label.draw(painter, textRect);

            painter->restore();
        }
    }
}

QPoint QwtPicker::trackerPosition() const 
{
    return d_data->trackerPosition;
}

QRect QwtPicker::trackerRect(const QFont &font) const
{
    if ( trackerMode() == AlwaysOff || 
        (trackerMode() == ActiveOnly && !isActive() ) )
    {
        return QRect();
    }

    if ( d_data->trackerPosition.x() < 0 || d_data->trackerPosition.y() < 0 )
        return QRect();

    QwtText text = trackerText(d_data->trackerPosition);
    if ( text.isEmpty() )
        return QRect();

    QRect textRect(QPoint(0, 0), text.textSize(font));

    const QPoint &pos = d_data->trackerPosition;

    int alignment = 0;
    if ( isActive() && d_data->selection.count() > 1 
        && rubberBand() != NoRubberBand )
    {
        const QPoint last = 
            d_data->selection[int(d_data->selection.count()) - 2];

        alignment |= (pos.x() >= last.x()) ? Qt::AlignRight : Qt::AlignLeft;
        alignment |= (pos.y() > last.y()) ? Qt::AlignBottom : Qt::AlignTop;
    }
    else
        alignment = Qt::AlignTop | Qt::AlignRight;

    const int margin = 5;

    int x = pos.x();
    if ( alignment & Qt::AlignLeft )
        x -= textRect.width() + margin;
    else if ( alignment & Qt::AlignRight )
        x += margin;

    int y = pos.y();
    if ( alignment & Qt::AlignBottom )
        y += margin;
    else if ( alignment & Qt::AlignTop )
        y -= textRect.height() + margin;
    
    textRect.moveTopLeft(QPoint(x, y));

    int right = qwtMin(textRect.right(), pickRect().right() - margin);
    int bottom = qwtMin(textRect.bottom(), pickRect().bottom() - margin);
    textRect.moveBottomRight(QPoint(right, bottom));

    int left = qwtMax(textRect.left(), pickRect().left() + margin);
    int top = qwtMax(textRect.top(), pickRect().top() + margin);
    textRect.moveTopLeft(QPoint(left, top));

    return textRect;
}

bool QwtPicker::eventFilter(QObject *o, QEvent *e)
{
    if ( o && o == parentWidget() )
    {
        switch(e->type())
        {
            case QEvent::Resize:
            {
                const QResizeEvent *re = (QResizeEvent *)e;
                if ( d_data->resizeMode == Stretch )
                    stretchSelection(re->oldSize(), re->size());

                if ( d_data->rubberBandWidget )
                    d_data->rubberBandWidget->resize(re->size());
             
                if ( d_data->trackerWidget )
                    d_data->trackerWidget->resize(re->size());
                break;
            }
            case QEvent::Leave:
                widgetLeaveEvent(e);
                break;
            case QEvent::MouseButtonPress:
                widgetMousePressEvent((QMouseEvent *)e);
                break;
            case QEvent::MouseButtonRelease:
                widgetMouseReleaseEvent((QMouseEvent *)e);
                break;
            case QEvent::MouseButtonDblClick:
                widgetMouseDoubleClickEvent((QMouseEvent *)e);
                break;
            case QEvent::MouseMove:
                widgetMouseMoveEvent((QMouseEvent *)e);
                break;
            case QEvent::KeyPress:
                widgetKeyPressEvent((QKeyEvent *)e);
                break;
            case QEvent::KeyRelease:
                widgetKeyReleaseEvent((QKeyEvent *)e);
                break;
            case QEvent::Wheel:
                widgetWheelEvent((QWheelEvent *)e);
                break;
            default:
                break;
        }
    }
    return false;
}

void QwtPicker::widgetMousePressEvent(QMouseEvent *e)
{
    transition(e);
}

void QwtPicker::widgetMouseMoveEvent(QMouseEvent *e)
{
    if ( pickRect().contains(e->pos()) )
        d_data->trackerPosition = e->pos();
    else
        d_data->trackerPosition = QPoint(-1, -1);

    if ( !isActive() )
        updateDisplay();

    transition(e);
}

void QwtPicker::widgetLeaveEvent(QEvent *)   
{
    d_data->trackerPosition = QPoint(-1, -1);
    if ( !isActive() )
        updateDisplay();
}

void QwtPicker::widgetMouseReleaseEvent(QMouseEvent *e)
{
    transition(e);
}

void QwtPicker::widgetMouseDoubleClickEvent(QMouseEvent *me)
{
    transition(me);
}
    

void QwtPicker::widgetWheelEvent(QWheelEvent *e)
{
    if ( pickRect().contains(e->pos()) )
        d_data->trackerPosition = e->pos();
    else
        d_data->trackerPosition = QPoint(-1, -1);

    updateDisplay();

    transition(e);
}

void QwtPicker::widgetKeyPressEvent(QKeyEvent *ke)
{
    int dx = 0;
    int dy = 0;

    int offset = 1;
    if ( ke->isAutoRepeat() )
        offset = 5;

    if ( keyMatch(KeyLeft, ke) )
        dx = -offset;
    else if ( keyMatch(KeyRight, ke) )
        dx = offset;
    else if ( keyMatch(KeyUp, ke) )
        dy = -offset;
    else if ( keyMatch(KeyDown, ke) )
        dy = offset;
    else if ( keyMatch(KeyAbort, ke) )
    {
        reset();
    }
    else
        transition(ke);

    if ( dx != 0 || dy != 0 )
    {
        const QRect rect = pickRect();
        const QPoint pos = parentWidget()->mapFromGlobal(QCursor::pos());

        int x = pos.x() + dx;
        x = qwtMax(rect.left(), x);
        x = qwtMin(rect.right(), x);

        int y = pos.y() + dy;
        y = qwtMax(rect.top(), y);
        y = qwtMin(rect.bottom(), y);

        QCursor::setPos(parentWidget()->mapToGlobal(QPoint(x, y)));
    }
}
 
void QwtPicker::widgetKeyReleaseEvent(QKeyEvent *ke)
{
    transition(ke);
}

void QwtPicker::transition(const QEvent *e)
{
    if ( !d_data->stateMachine )
        return;

    QwtPickerMachine::CommandList commandList =
        d_data->stateMachine->transition(*this, e);

    QPoint pos;
    switch(e->type())
    {
        case QEvent::MouseButtonDblClick:
        case QEvent::MouseButtonPress:
        case QEvent::MouseButtonRelease:
        case QEvent::MouseMove:
        {
            const QMouseEvent *me = (QMouseEvent *)e;
            pos = me->pos();
            break;
        }
        default:
            pos = parentWidget()->mapFromGlobal(QCursor::pos());
    }

    for ( uint i = 0; i < (uint)commandList.count(); i++ )
    {
        switch(commandList[i])
        {
            case QwtPickerMachine::Begin:
            {
                begin();
                break;
            }
            case QwtPickerMachine::Append:
            {
                append(pos);
                break;
            }
            case QwtPickerMachine::Move:
            {
                move(pos);
                break;
            }
            case QwtPickerMachine::End:
            {
                end();
                break;
            }
        }
    }
}

void QwtPicker::begin()
{
    if ( d_data->isActive )
        return;

    d_data->selection.resize(0);
    d_data->isActive = true;

    if ( trackerMode() != AlwaysOff )
    {
        if ( d_data->trackerPosition.x() < 0 || d_data->trackerPosition.y() < 0 ) 
        {
            QWidget *w = parentWidget();
            if ( w )
                d_data->trackerPosition = w->mapFromGlobal(QCursor::pos());
        }
    }

    updateDisplay();
    setMouseTracking(true);
}

bool QwtPicker::end(bool ok)
{
    if ( d_data->isActive )
    {
        setMouseTracking(false);

        d_data->isActive = false;

        if ( trackerMode() == ActiveOnly )
            d_data->trackerPosition = QPoint(-1, -1);

        if ( ok )
            ok = accept(d_data->selection);

        if ( ok )
            emit selected(d_data->selection);
        else
            d_data->selection.resize(0);

        updateDisplay();
    }
    else
        ok = false;

    return ok;
}

void QwtPicker::reset()
{
    if ( d_data->stateMachine )
        d_data->stateMachine->reset();

    if (isActive())
        end(false);
}

void QwtPicker::append(const QPoint &pos)
{
    if ( d_data->isActive )
    {
        const int idx = d_data->selection.count();
        d_data->selection.resize(idx + 1);
        d_data->selection[idx] = pos;

        updateDisplay();

        emit appended(pos);
    }
}

void QwtPicker::move(const QPoint &pos)
{
    if ( d_data->isActive )
    {
        const int idx = d_data->selection.count() - 1;
        if ( idx >= 0 )
        {
            if ( d_data->selection[idx] != pos )
            {
                d_data->selection[idx] = pos;

                updateDisplay();

                emit moved(pos);
            }
        }
    }
}

bool QwtPicker::accept(QwtPolygon &) const
{
    return true;
}

bool QwtPicker::isActive() const 
{
    return d_data->isActive;
}

const QwtPolygon &QwtPicker::selection() const
{
    return d_data->selection;
}

void QwtPicker::stretchSelection(const QSize &oldSize, const QSize &newSize)
{
    if ( oldSize.isEmpty() )
    {
        // avoid division by zero. But scaling for small sizes also 
        // doesn't make much sense, because of rounding losses. TODO ...
        return;
    }

    const double xRatio =
        double(newSize.width()) / double(oldSize.width());
    const double yRatio =
        double(newSize.height()) / double(oldSize.height());

    for ( int i = 0; i < int(d_data->selection.count()); i++ )
    {
        QPoint &p = d_data->selection[i];
        p.setX(qRound(p.x() * xRatio));
        p.setY(qRound(p.y() * yRatio));

        emit changed(d_data->selection);
    }
}

void QwtPicker::setMouseTracking(bool enable)
{
    QWidget *widget = parentWidget();
    if ( !widget )
        return;

    if ( enable )
    {
        d_data->mouseTracking = widget->hasMouseTracking();
        widget->setMouseTracking(true);
    }
    else
    {
        widget->setMouseTracking(d_data->mouseTracking);
    }
}

QRect QwtPicker::pickRect() const
{
    QRect rect;

    const QWidget *widget = parentWidget();
    if ( !widget )
        return rect;

    if ( widget->inherits("QFrame") )
        rect = ((QFrame *)widget)->contentsRect();
    else
        rect = widget->rect();

    return rect;
}

void QwtPicker::updateDisplay()
{
    QWidget *w = parentWidget();

    bool showRubberband = false;
    bool showTracker = false;
    if ( w && w->isVisible() && d_data->enabled )
    {
        if ( rubberBand() != NoRubberBand && isActive() &&
            rubberBandPen().style() != Qt::NoPen )
        {
            showRubberband = true;
        }

        if ( trackerMode() == AlwaysOn ||
            (trackerMode() == ActiveOnly && isActive() ) )
        {
            if ( trackerPen() != Qt::NoPen )
                showTracker = true;
        }
    }

#if QT_VERSION < 0x040000
    QGuardedPtr<PickerWidget> &rw = d_data->rubberBandWidget;
#else
    QPointer<PickerWidget> &rw = d_data->rubberBandWidget;
#endif
    if ( showRubberband )
    {
        if ( rw.isNull() )
        {
            rw = new PickerWidget( this, w, PickerWidget::RubberBand);
            rw->resize(w->size());
        }
        rw->updateMask();
        rw->update(); // Needed, when the mask doesn't change
    }
    else
        delete rw;

#if QT_VERSION < 0x040000
    QGuardedPtr<PickerWidget> &tw = d_data->trackerWidget;
#else
    QPointer<PickerWidget> &tw = d_data->trackerWidget;
#endif
    if ( showTracker )
    {
        if ( tw.isNull() )
        {
            tw = new PickerWidget( this, w, PickerWidget::Text);
            tw->resize(w->size());
        }
        tw->updateMask();
        tw->update(); // Needed, when the mask doesn't change
    }
    else
        delete tw;
}

const QWidget *QwtPicker::rubberBandWidget() const
{
    return d_data->rubberBandWidget;
}

const QWidget *QwtPicker::trackerWidget() const
{
    return d_data->trackerWidget;
}