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

Last change on this file since 8127 was 8127, checked in by stoecker, 2 years ago

update qwt and qwtpolar, many QT5 fixes (unfinished)

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