← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/qwt/oneiric-proposed

« back to all changes in this revision

Viewing changes to src/qwt_magnifier.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fathi Boudra
  • Date: 2011-06-10 11:22:47 UTC
  • mfrom: (1.1.6 upstream) (2.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20110610112247-0i1019vvmzaq6p86
Tags: 6.0.0-1
http://bugs.debian.org/624107
http://bugs.debian.org/604379
http://bugs.debian.org/626868
http://bugs.debian.org/626567
* New upstream release (Closes: #624107):
  - drop Qt3 support. (Closes: #604379, #626868)
* Register documentation with doc-base. (Closes: #626567)
* Drop patches:
  - 01_makefiles.diff
  - 02_add_missing_warnings.diff
  - 03_qwt_branch_pull_r544.diff
* Add qwt_install_paths.patch to fix the hardcoded installation paths.
* Update debian/control:
  - drop libqt3-mt-dev build dependency.
  - bump Standards-Version to 3.9.2 (no changes).
  - drop Qt3 related packages.
  - due to bump soname (and as we dropper Qt3 support):
    - libqwt5-qt4-dev -> libqwt-dev
    - libqwt5-qt4 -> libqwt6
    - libqwt5-doc -> libqwt-doc
* Update debian/copyright file.
* Update debian/rules: drop Qt3 packages support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/qwt_magnifier.cpp
 
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
 
 
15
class QwtMagnifier::PrivateData
 
16
{
 
17
public:
 
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
*/
 
58
QwtMagnifier::QwtMagnifier( QWidget *parent ):
 
59
    QObject( parent )
 
60
{
 
61
    d_data = new PrivateData();
 
62
    setEnabled( true );
 
63
}
 
64
 
 
65
//! Destructor
 
66
QwtMagnifier::~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
*/
 
80
void 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
*/
 
101
bool 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
*/
 
117
void QwtMagnifier::setWheelFactor( double factor )
 
118
{
 
119
    d_data->wheelFactor = factor;
 
120
}
 
121
 
 
122
/*!
 
123
   \return Wheel factor
 
124
   \sa setWheelFactor()
 
125
*/
 
126
double 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
*/
 
138
void QwtMagnifier::setWheelButtonState( int buttonState )
 
139
{
 
140
    d_data->wheelButtonState = buttonState;
 
141
}
 
142
 
 
143
/*!
 
144
   \return Wheel button state
 
145
   \sa setWheelButtonState()
 
146
*/
 
147
int 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
*/
 
162
void QwtMagnifier::setMouseFactor( double factor )
 
163
{
 
164
    d_data->mouseFactor = factor;
 
165
}
 
166
 
 
167
/*!
 
168
   \return Mouse factor
 
169
   \sa setMouseFactor()
 
170
*/
 
171
double 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
*/
 
184
void QwtMagnifier::setMouseButton( int button, int buttonState )
 
185
{
 
186
    d_data->mouseButton = button;
 
187
    d_data->mouseButtonState = buttonState;
 
188
}
 
189
 
 
190
//! \sa setMouseButton()
 
191
void 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
*/
 
209
void QwtMagnifier::setKeyFactor( double factor )
 
210
{
 
211
    d_data->keyFactor = factor;
 
212
}
 
213
 
 
214
/*!
 
215
   \return Key factor
 
216
   \sa setKeyFactor()
 
217
*/
 
218
double 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
*/
 
231
void QwtMagnifier::setZoomInKey( int key, int modifiers )
 
232
{
 
233
    d_data->zoomInKey = key;
 
234
    d_data->zoomInKeyModifiers = modifiers;
 
235
}
 
236
 
 
237
//! \sa setZoomInKey()
 
238
void 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
*/
 
252
void QwtMagnifier::setZoomOutKey( int key, int modifiers )
 
253
{
 
254
    d_data->zoomOutKey = key;
 
255
    d_data->zoomOutKeyModifiers = modifiers;
 
256
}
 
257
 
 
258
//! \sa setZoomOutKey()
 
259
void 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
  \sa widgetMousePressEvent(), widgetMouseReleaseEvent(),
 
271
      widgetMouseMoveEvent(), widgetWheelEvent(), widgetKeyPressEvent()
 
272
      widgetKeyReleaseEvent()
 
273
*/
 
274
bool QwtMagnifier::eventFilter( QObject *o, QEvent *e )
 
275
{
 
276
    if ( o && o == parent() )
 
277
    {
 
278
        switch ( e->type() )
 
279
        {
 
280
            case QEvent::MouseButtonPress:
 
281
            {
 
282
                widgetMousePressEvent( ( QMouseEvent * )e );
 
283
                break;
 
284
            }
 
285
            case QEvent::MouseMove:
 
286
            {
 
287
                widgetMouseMoveEvent( ( QMouseEvent * )e );
 
288
                break;
 
289
            }
 
290
            case QEvent::MouseButtonRelease:
 
291
            {
 
292
                widgetMouseReleaseEvent( ( QMouseEvent * )e );
 
293
                break;
 
294
            }
 
295
            case QEvent::Wheel:
 
296
            {
 
297
                widgetWheelEvent( ( QWheelEvent * )e );
 
298
                break;
 
299
            }
 
300
            case QEvent::KeyPress:
 
301
            {
 
302
                widgetKeyPressEvent( ( QKeyEvent * )e );
 
303
                break;
 
304
            }
 
305
            case QEvent::KeyRelease:
 
306
            {
 
307
                widgetKeyReleaseEvent( ( QKeyEvent * )e );
 
308
                break;
 
309
            }
 
310
            default:;
 
311
        }
 
312
    }
 
313
    return QObject::eventFilter( o, e );
 
314
}
 
315
 
 
316
/*!
 
317
  Handle a mouse press event for the observed widget.
 
318
 
 
319
  \param me Mouse event
 
320
  \sa eventFilter(), widgetMouseReleaseEvent(), widgetMouseMoveEvent()
 
321
*/
 
322
void QwtMagnifier::widgetMousePressEvent( QMouseEvent *me )
 
323
{
 
324
    if ( me->button() != d_data->mouseButton || parentWidget() == NULL )
 
325
        return;
 
326
 
 
327
    if ( ( me->modifiers() & Qt::KeyboardModifierMask ) !=
 
328
        ( int )( d_data->mouseButtonState & Qt::KeyboardModifierMask ) )
 
329
    {
 
330
        return;
 
331
    }
 
332
 
 
333
    d_data->hasMouseTracking = parentWidget()->hasMouseTracking();
 
334
    parentWidget()->setMouseTracking( true );
 
335
    d_data->mousePos = me->pos();
 
336
    d_data->mousePressed = true;
 
337
}
 
338
 
 
339
/*!
 
340
  Handle a mouse release event for the observed widget.
 
341
  \sa eventFilter(), widgetMousePressEvent(), widgetMouseMoveEvent(),
 
342
*/
 
343
void QwtMagnifier::widgetMouseReleaseEvent( QMouseEvent * )
 
344
{
 
345
    if ( d_data->mousePressed && parentWidget() )
 
346
    {
 
347
        d_data->mousePressed = false;
 
348
        parentWidget()->setMouseTracking( d_data->hasMouseTracking );
 
349
    }
 
350
}
 
351
 
 
352
/*!
 
353
  Handle a mouse move event for the observed widget.
 
354
 
 
355
  \param me Mouse event
 
356
  \sa eventFilter(), widgetMousePressEvent(), widgetMouseReleaseEvent(),
 
357
*/
 
358
void QwtMagnifier::widgetMouseMoveEvent( QMouseEvent *me )
 
359
{
 
360
    if ( !d_data->mousePressed )
 
361
        return;
 
362
 
 
363
    const int dy = me->pos().y() - d_data->mousePos.y();
 
364
    if ( dy != 0 )
 
365
    {
 
366
        double f = d_data->mouseFactor;
 
367
        if ( dy < 0 )
 
368
            f = 1 / f;
 
369
 
 
370
        rescale( f );
 
371
    }
 
372
 
 
373
    d_data->mousePos = me->pos();
 
374
}
 
375
 
 
376
/*!
 
377
  Handle a wheel event for the observed widget.
 
378
 
 
379
  \param wheelEvent Wheel event
 
380
  \sa eventFilter()
 
381
*/
 
382
void QwtMagnifier::widgetWheelEvent( QWheelEvent *wheelEvent )
 
383
{
 
384
    if ( ( wheelEvent->modifiers() & Qt::KeyboardModifierMask ) !=
 
385
        ( int )( d_data->wheelButtonState & Qt::KeyboardModifierMask ) )
 
386
    {
 
387
        return;
 
388
    }
 
389
 
 
390
    if ( d_data->wheelFactor != 0.0 )
 
391
    {
 
392
        /*
 
393
            A positive delta indicates that the wheel was
 
394
            rotated forwards away from the user; a negative
 
395
            value indicates that the wheel was rotated
 
396
            backwards toward the user.
 
397
            Most mouse types work in steps of 15 degrees,
 
398
            in which case the delta value is a multiple
 
399
            of 120 (== 15 * 8).
 
400
         */
 
401
        double f = qPow( d_data->wheelFactor, 
 
402
            qAbs( wheelEvent->delta() / 120 ) );
 
403
 
 
404
        if ( wheelEvent->delta() > 0 )
 
405
            f = 1 / f;
 
406
 
 
407
        rescale( f );
 
408
    }
 
409
}
 
410
 
 
411
/*!
 
412
  Handle a key press event for the observed widget.
 
413
 
 
414
  \param keyEvent Key event
 
415
  \sa eventFilter(), widgetKeyReleaseEvent()
 
416
*/
 
417
void QwtMagnifier::widgetKeyPressEvent( QKeyEvent *keyEvent )
 
418
{
 
419
    const int key = keyEvent->key();
 
420
    const int state = keyEvent->modifiers();
 
421
 
 
422
    if ( key == d_data->zoomInKey &&
 
423
        state == d_data->zoomInKeyModifiers )
 
424
    {
 
425
        rescale( d_data->keyFactor );
 
426
    }
 
427
    else if ( key == d_data->zoomOutKey &&
 
428
        state == d_data->zoomOutKeyModifiers )
 
429
    {
 
430
        rescale( 1.0 / d_data->keyFactor );
 
431
    }
 
432
}
 
433
 
 
434
/*!
 
435
  Handle a key release event for the observed widget.
 
436
 
 
437
  \param keyEvent Key event
 
438
  \sa eventFilter(), widgetKeyReleaseEvent()
 
439
*/
 
440
void QwtMagnifier::widgetKeyReleaseEvent( QKeyEvent *keyEvent )
 
441
{
 
442
    Q_UNUSED( keyEvent );
 
443
}
 
444
 
 
445
//! \return Parent widget, where the rescaling happens
 
446
QWidget *QwtMagnifier::parentWidget()
 
447
{
 
448
    if ( parent()->inherits( "QWidget" ) )
 
449
        return ( QWidget * )parent();
 
450
 
 
451
    return NULL;
 
452
}
 
453
 
 
454
//! \return Parent widget, where the rescaling happens
 
455
const QWidget *QwtMagnifier::parentWidget() const
 
456
{
 
457
    if ( parent()->inherits( "QWidget" ) )
 
458
        return ( const QWidget * )parent();
 
459
 
 
460
    return NULL;
 
461
}
 
462