source: ntrip/trunk/BNC/qwt/qwt_magnifier.cpp @ 4271

Last change on this file since 4271 was 4271, checked in by mervart, 7 years ago
File size: 11.0 KB
Line 
1/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
2 * Qwt Widget Library
3 * Copyright (C) 1997   Josef Wilgen
4 * Copyright (C) 2002   Uwe Rathmann
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the Qwt License, Version 1.0
8 *****************************************************************************/
9
10#include "qwt_magnifier.h"
11#include "qwt_math.h"
12#include <qevent.h>
13#include <qwidget.h>
14
15class QwtMagnifier::PrivateData
16{
17public:
18    PrivateData():
19        isEnabled( false ),
20        wheelFactor( 0.9 ),
21        wheelButtonState( Qt::NoButton ),
22        mouseFactor( 0.95 ),
23        mouseButton( Qt::RightButton ),
24        mouseButtonState( Qt::NoButton ),
25        keyFactor( 0.9 ),
26        zoomInKey( Qt::Key_Plus ),
27        zoomOutKey( Qt::Key_Minus ),
28        zoomInKeyModifiers( Qt::NoModifier ),
29        zoomOutKeyModifiers( Qt::NoModifier ),
30        mousePressed( false )
31    {
32    }
33
34    bool isEnabled;
35
36    double wheelFactor;
37    int wheelButtonState;
38
39    double mouseFactor;
40    int mouseButton;
41    int mouseButtonState;
42
43    double keyFactor;
44    int zoomInKey;
45    int zoomOutKey;
46    int zoomInKeyModifiers;
47    int zoomOutKeyModifiers;
48
49    bool mousePressed;
50    bool hasMouseTracking;
51    QPoint mousePos;
52};
53
54/*!
55   Constructor
56   \param parent Widget to be magnified
57*/
58QwtMagnifier::QwtMagnifier( QWidget *parent ):
59    QObject( parent )
60{
61    d_data = new PrivateData();
62    setEnabled( true );
63}
64
65//! Destructor
66QwtMagnifier::~QwtMagnifier()
67{
68    delete d_data;
69}
70
71/*!
72  \brief En/disable the magnifier
73
74  When enabled is true an event filter is installed for
75  the observed widget, otherwise the event filter is removed.
76
77  \param on true or false
78  \sa isEnabled(), eventFilter()
79*/
80void QwtMagnifier::setEnabled( bool on )
81{
82    if ( d_data->isEnabled != on )
83    {
84        d_data->isEnabled = on;
85
86        QObject *o = parent();
87        if ( o )
88        {
89            if ( d_data->isEnabled )
90                o->installEventFilter( this );
91            else
92                o->removeEventFilter( this );
93        }
94    }
95}
96
97/*!
98  \return true when enabled, false otherwise
99  \sa setEnabled(), eventFilter()
100*/
101bool QwtMagnifier::isEnabled() const
102{
103    return d_data->isEnabled;
104}
105
106/*!
107   \brief Change the wheel factor
108
109   The wheel factor defines the ratio between the current range
110   on the parent widget and the zoomed range for each step of the wheel.
111   The default value is 0.9.
112
113   \param factor Wheel factor
114   \sa wheelFactor(), setWheelButtonState(),
115       setMouseFactor(), setKeyFactor()
116*/
117void QwtMagnifier::setWheelFactor( double factor )
118{
119    d_data->wheelFactor = factor;
120}
121
122/*!
123   \return Wheel factor
124   \sa setWheelFactor()
125*/
126double QwtMagnifier::wheelFactor() const
127{
128    return d_data->wheelFactor;
129}
130
131/*!
132   Assign a mandatory button state for zooming in/out using the wheel.
133   The default button state is Qt::NoButton.
134
135   \param buttonState Button state
136   \sa wheelButtonState()
137*/
138void QwtMagnifier::setWheelButtonState( int buttonState )
139{
140    d_data->wheelButtonState = buttonState;
141}
142
143/*!
144   \return Wheel button state
145   \sa setWheelButtonState()
146*/
147int QwtMagnifier::wheelButtonState() const
148{
149    return d_data->wheelButtonState;
150}
151
152/*!
153   \brief Change the mouse factor
154
155   The mouse factor defines the ratio between the current range
156   on the parent widget and the zoomed range for each vertical mouse movement.
157   The default value is 0.95.
158
159   \param factor Wheel factor
160   \sa mouseFactor(), setMouseButton(), setWheelFactor(), setKeyFactor()
161*/
162void QwtMagnifier::setMouseFactor( double factor )
163{
164    d_data->mouseFactor = factor;
165}
166
167/*!
168   \return Mouse factor
169   \sa setMouseFactor()
170*/
171double QwtMagnifier::mouseFactor() const
172{
173    return d_data->mouseFactor;
174}
175
176/*!
177   Assign the mouse button, that is used for zooming in/out.
178   The default value is Qt::RightButton.
179
180   \param button Button
181   \param buttonState Button state
182   \sa getMouseButton()
183*/
184void QwtMagnifier::setMouseButton( int button, int buttonState )
185{
186    d_data->mouseButton = button;
187    d_data->mouseButtonState = buttonState;
188}
189
190//! \sa setMouseButton()
191void QwtMagnifier::getMouseButton(
192    int &button, int &buttonState ) const
193{
194    button = d_data->mouseButton;
195    buttonState = d_data->mouseButtonState;
196}
197
198/*!
199   \brief Change the key factor
200
201   The key factor defines the ratio between the current range
202   on the parent widget and the zoomed range for each key press of
203   the zoom in/out keys. The default value is 0.9.
204
205   \param factor Key factor
206   \sa keyFactor(), setZoomInKey(), setZoomOutKey(),
207       setWheelFactor, setMouseFactor()
208*/
209void QwtMagnifier::setKeyFactor( double factor )
210{
211    d_data->keyFactor = factor;
212}
213
214/*!
215   \return Key factor
216   \sa setKeyFactor()
217*/
218double QwtMagnifier::keyFactor() const
219{
220    return d_data->keyFactor;
221}
222
223/*!
224   Assign the key, that is used for zooming in.
225   The default combination is Qt::Key_Plus + Qt::NoModifier.
226
227   \param key
228   \param modifiers
229   \sa getZoomInKey(), setZoomOutKey()
230*/
231void QwtMagnifier::setZoomInKey( int key, int modifiers )
232{
233    d_data->zoomInKey = key;
234    d_data->zoomInKeyModifiers = modifiers;
235}
236
237//! \sa setZoomInKey()
238void QwtMagnifier::getZoomInKey( int &key, int &modifiers ) const
239{
240    key = d_data->zoomInKey;
241    modifiers = d_data->zoomInKeyModifiers;
242}
243
244/*!
245   Assign the key, that is used for zooming out.
246   The default combination is Qt::Key_Minus + Qt::NoModifier.
247
248   \param key
249   \param modifiers
250   \sa getZoomOutKey(), setZoomOutKey()
251*/
252void QwtMagnifier::setZoomOutKey( int key, int modifiers )
253{
254    d_data->zoomOutKey = key;
255    d_data->zoomOutKeyModifiers = modifiers;
256}
257
258//! \sa setZoomOutKey()
259void QwtMagnifier::getZoomOutKey( int &key, int &modifiers ) const
260{
261    key = d_data->zoomOutKey;
262    modifiers = d_data->zoomOutKeyModifiers;
263}
264
265/*!
266  \brief Event filter
267
268  When isEnabled() the mouse events of the observed widget are filtered.
269
270  \param object Object to be filtered
271  \param event Event
272
273  \sa widgetMousePressEvent(), widgetMouseReleaseEvent(),
274      widgetMouseMoveEvent(), widgetWheelEvent(), widgetKeyPressEvent()
275      widgetKeyReleaseEvent()
276*/
277bool QwtMagnifier::eventFilter( QObject *object, QEvent *event )
278{
279    if ( object && object == parent() )
280    {
281        switch ( event->type() )
282        {
283            case QEvent::MouseButtonPress:
284            {
285                widgetMousePressEvent( ( QMouseEvent * )event );
286                break;
287            }
288            case QEvent::MouseMove:
289            {
290                widgetMouseMoveEvent( ( QMouseEvent * )event );
291                break;
292            }
293            case QEvent::MouseButtonRelease:
294            {
295                widgetMouseReleaseEvent( ( QMouseEvent * )event );
296                break;
297            }
298            case QEvent::Wheel:
299            {
300                widgetWheelEvent( ( QWheelEvent * )event );
301                break;
302            }
303            case QEvent::KeyPress:
304            {
305                widgetKeyPressEvent( ( QKeyEvent * )event );
306                break;
307            }
308            case QEvent::KeyRelease:
309            {
310                widgetKeyReleaseEvent( ( QKeyEvent * )event );
311                break;
312            }
313            default:;
314        }
315    }
316    return QObject::eventFilter( object, event );
317}
318
319/*!
320  Handle a mouse press event for the observed widget.
321
322  \param mouseEvent Mouse event
323  \sa eventFilter(), widgetMouseReleaseEvent(), widgetMouseMoveEvent()
324*/
325void QwtMagnifier::widgetMousePressEvent( QMouseEvent *mouseEvent )
326{
327    if ( ( mouseEvent->button() != d_data->mouseButton) 
328        || parentWidget() == NULL )
329    {
330        return;
331    }
332
333    if ( ( mouseEvent->modifiers() & Qt::KeyboardModifierMask ) !=
334        ( int )( d_data->mouseButtonState & Qt::KeyboardModifierMask ) )
335    {
336        return;
337    }
338
339    d_data->hasMouseTracking = parentWidget()->hasMouseTracking();
340    parentWidget()->setMouseTracking( true );
341    d_data->mousePos = mouseEvent->pos();
342    d_data->mousePressed = true;
343}
344
345/*!
346  Handle a mouse release event for the observed widget.
347
348  \param mouseEvent Mouse event
349
350  \sa eventFilter(), widgetMousePressEvent(), widgetMouseMoveEvent(),
351*/
352void QwtMagnifier::widgetMouseReleaseEvent( QMouseEvent *mouseEvent )
353{
354    Q_UNUSED( mouseEvent );
355
356    if ( d_data->mousePressed && parentWidget() )
357    {
358        d_data->mousePressed = false;
359        parentWidget()->setMouseTracking( d_data->hasMouseTracking );
360    }
361}
362
363/*!
364  Handle a mouse move event for the observed widget.
365
366  \param mouseEvent Mouse event
367  \sa eventFilter(), widgetMousePressEvent(), widgetMouseReleaseEvent(),
368*/
369void QwtMagnifier::widgetMouseMoveEvent( QMouseEvent *mouseEvent )
370{
371    if ( !d_data->mousePressed )
372        return;
373
374    const int dy = mouseEvent->pos().y() - d_data->mousePos.y();
375    if ( dy != 0 )
376    {
377        double f = d_data->mouseFactor;
378        if ( dy < 0 )
379            f = 1 / f;
380
381        rescale( f );
382    }
383
384    d_data->mousePos = mouseEvent->pos();
385}
386
387/*!
388  Handle a wheel event for the observed widget.
389
390  \param wheelEvent Wheel event
391  \sa eventFilter()
392*/
393void QwtMagnifier::widgetWheelEvent( QWheelEvent *wheelEvent )
394{
395    if ( ( wheelEvent->modifiers() & Qt::KeyboardModifierMask ) !=
396        ( int )( d_data->wheelButtonState & Qt::KeyboardModifierMask ) )
397    {
398        return;
399    }
400
401    if ( d_data->wheelFactor != 0.0 )
402    {
403        /*
404            A positive delta indicates that the wheel was
405            rotated forwards away from the user; a negative
406            value indicates that the wheel was rotated
407            backwards toward the user.
408            Most mouse types work in steps of 15 degrees,
409            in which case the delta value is a multiple
410            of 120 (== 15 * 8).
411         */
412        double f = qPow( d_data->wheelFactor, 
413            qAbs( wheelEvent->delta() / 120 ) );
414
415        if ( wheelEvent->delta() > 0 )
416            f = 1 / f;
417
418        rescale( f );
419    }
420}
421
422/*!
423  Handle a key press event for the observed widget.
424
425  \param keyEvent Key event
426  \sa eventFilter(), widgetKeyReleaseEvent()
427*/
428void QwtMagnifier::widgetKeyPressEvent( QKeyEvent *keyEvent )
429{
430    const int key = keyEvent->key();
431    const int state = keyEvent->modifiers();
432
433    if ( key == d_data->zoomInKey &&
434        state == d_data->zoomInKeyModifiers )
435    {
436        rescale( d_data->keyFactor );
437    }
438    else if ( key == d_data->zoomOutKey &&
439        state == d_data->zoomOutKeyModifiers )
440    {
441        rescale( 1.0 / d_data->keyFactor );
442    }
443}
444
445/*!
446  Handle a key release event for the observed widget.
447
448  \param keyEvent Key event
449  \sa eventFilter(), widgetKeyReleaseEvent()
450*/
451void QwtMagnifier::widgetKeyReleaseEvent( QKeyEvent *keyEvent )
452{
453    Q_UNUSED( keyEvent );
454}
455
456//! \return Parent widget, where the rescaling happens
457QWidget *QwtMagnifier::parentWidget()
458{
459    if ( parent()->inherits( "QWidget" ) )
460        return ( QWidget * )parent();
461
462    return NULL;
463}
464
465//! \return Parent widget, where the rescaling happens
466const QWidget *QwtMagnifier::parentWidget() const
467{
468    if ( parent()->inherits( "QWidget" ) )
469        return ( const QWidget * )parent();
470
471    return NULL;
472}
473
Note: See TracBrowser for help on using the repository browser.