← Back to branch summary

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

« back to all changes in this revision

Viewing changes to qwt-5.1.2/src/qwt_magnifier.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Fathi Boudra
  • Date: 2009-04-12 23:25:58 UTC
  • mfrom: (1.1.4 upstream) (2.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090412232558-3bl06x785yr8xm8u
Tags: 5.1.2-1
* New upstream release.
* Bump compat/debhelper to 7.
* Bump Standards-Version to 3.8.1. No changes needed.
* Invert Maintainers and Uploaders field.
* Fix lintian warnings:
  - dh_clean _k deprecated.
  - missing dependency on libc.

Show diffs side-by-side

added added

removed removed

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