← Back to branch summary

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

« back to all changes in this revision

Viewing changes to examples/realtime/scrollzoomer.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:
examples/realtime/scrollzoomer.cpp
 
1
#include <qevent.h>
 
2
#include <qwt_plot_canvas.h>
 
3
#include <qwt_plot_layout.h>
 
4
#include <qwt_scale_engine.h>
 
5
#include <qwt_scale_widget.h>
 
6
#include "scrollbar.h"
 
7
#include "scrollzoomer.h"
 
8
 
 
9
class ScrollData
 
10
{
 
11
public:
 
12
    ScrollData():
 
13
        scrollBar(NULL),
 
14
        position(ScrollZoomer::OppositeToScale),
 
15
        mode(Qt::ScrollBarAsNeeded)
 
16
    {
 
17
    }
 
18
 
 
19
    ~ScrollData()
 
20
    {
 
21
        delete scrollBar;
 
22
    }
 
23
 
 
24
    ScrollBar *scrollBar;
 
25
    ScrollZoomer::ScrollBarPosition position;
 
26
    Qt::ScrollBarPolicy mode;
 
27
};
 
28
 
 
29
ScrollZoomer::ScrollZoomer(QwtPlotCanvas *canvas):
 
30
    QwtPlotZoomer(canvas),
 
31
    d_cornerWidget(NULL),
 
32
    d_hScrollData(NULL),
 
33
    d_vScrollData(NULL),
 
34
    d_inZoom(false),
 
35
    d_alignCanvasToScales(false)
 
36
{
 
37
    if ( !canvas )
 
38
        return;
 
39
 
 
40
    d_hScrollData = new ScrollData;
 
41
    d_vScrollData = new ScrollData;
 
42
}
 
43
 
 
44
ScrollZoomer::~ScrollZoomer()
 
45
{
 
46
    delete d_cornerWidget;
 
47
    delete d_vScrollData;
 
48
    delete d_hScrollData;
 
49
}
 
50
 
 
51
void ScrollZoomer::rescale()
 
52
{
 
53
    QwtScaleWidget *xScale = plot()->axisWidget(xAxis());
 
54
    QwtScaleWidget *yScale = plot()->axisWidget(yAxis());
 
55
 
 
56
    if ( zoomRectIndex() <= 0 )
 
57
    {
 
58
        if ( d_inZoom )
 
59
        {
 
60
            xScale->setMinBorderDist(0, 0);
 
61
            yScale->setMinBorderDist(0, 0);
 
62
 
 
63
            QwtPlotLayout *layout = plot()->plotLayout();
 
64
            layout->setAlignCanvasToScales(d_alignCanvasToScales);
 
65
 
 
66
            d_inZoom = false;
 
67
        }
 
68
    }
 
69
    else
 
70
    {
 
71
        if ( !d_inZoom )
 
72
        {
 
73
            /*
 
74
             We set a minimum border distance. 
 
75
             Otherwise the canvas size changes when scrolling, 
 
76
             between situations where the major ticks are at
 
77
             the canvas borders (requiring extra space for the label)
 
78
             and situations where all labels can be painted below/top
 
79
             or left/right of the canvas.
 
80
             */
 
81
            int start, end;
 
82
 
 
83
            xScale->getBorderDistHint(start, end);
 
84
            xScale->setMinBorderDist(start, end);
 
85
 
 
86
            yScale->getBorderDistHint(start, end);
 
87
            yScale->setMinBorderDist(start, end);
 
88
 
 
89
            QwtPlotLayout *layout = plot()->plotLayout();
 
90
            d_alignCanvasToScales = layout->alignCanvasToScales();
 
91
            layout->setAlignCanvasToScales(false);
 
92
 
 
93
            d_inZoom = true;
 
94
        }
 
95
    }
 
96
 
 
97
    QwtPlotZoomer::rescale();
 
98
    updateScrollBars();
 
99
}
 
100
 
 
101
ScrollBar *ScrollZoomer::scrollBar(Qt::Orientation o)
 
102
{
 
103
    ScrollBar *&sb = (o == Qt::Vertical) 
 
104
        ? d_vScrollData->scrollBar : d_hScrollData->scrollBar;
 
105
 
 
106
    if ( sb == NULL )
 
107
    {
 
108
        sb = new ScrollBar(o, canvas());
 
109
        sb->hide();
 
110
        connect(sb,
 
111
            SIGNAL(valueChanged(Qt::Orientation, double, double)),
 
112
            SLOT(scrollBarMoved(Qt::Orientation, double, double)));
 
113
    }
 
114
    return sb;
 
115
}
 
116
 
 
117
ScrollBar *ScrollZoomer::horizontalScrollBar() const
 
118
{
 
119
    return d_hScrollData->scrollBar;
 
120
}
 
121
 
 
122
ScrollBar *ScrollZoomer::verticalScrollBar() const
 
123
{
 
124
    return d_vScrollData->scrollBar;
 
125
}
 
126
    
 
127
void ScrollZoomer::setHScrollBarMode(Qt::ScrollBarPolicy mode)
 
128
{
 
129
    if ( hScrollBarMode() != mode )
 
130
    {
 
131
        d_hScrollData->mode = mode;
 
132
        updateScrollBars();
 
133
    }
 
134
}
 
135
 
 
136
void ScrollZoomer::setVScrollBarMode(Qt::ScrollBarPolicy mode)
 
137
{
 
138
    if ( vScrollBarMode() != mode )
 
139
    {
 
140
        d_vScrollData->mode = mode;
 
141
        updateScrollBars();
 
142
    }
 
143
}
 
144
 
 
145
Qt::ScrollBarPolicy ScrollZoomer::hScrollBarMode() const
 
146
{
 
147
    return d_hScrollData->mode;
 
148
}
 
149
 
 
150
Qt::ScrollBarPolicy ScrollZoomer::vScrollBarMode() const
 
151
{
 
152
    return d_vScrollData->mode;
 
153
}
 
154
 
 
155
void ScrollZoomer::setHScrollBarPosition(ScrollBarPosition pos)
 
156
{
 
157
    if ( d_hScrollData->position != pos )
 
158
    {
 
159
        d_hScrollData->position = pos;
 
160
        updateScrollBars();
 
161
    }
 
162
}
 
163
 
 
164
void ScrollZoomer::setVScrollBarPosition(ScrollBarPosition pos)
 
165
{
 
166
    if ( d_vScrollData->position != pos )
 
167
    {
 
168
        d_vScrollData->position = pos;
 
169
        updateScrollBars();
 
170
    }
 
171
}
 
172
 
 
173
ScrollZoomer::ScrollBarPosition ScrollZoomer::hScrollBarPosition() const
 
174
{
 
175
    return d_hScrollData->position;
 
176
}
 
177
 
 
178
ScrollZoomer::ScrollBarPosition ScrollZoomer::vScrollBarPosition() const
 
179
{
 
180
    return d_vScrollData->position;
 
181
}
 
182
 
 
183
void ScrollZoomer::setCornerWidget(QWidget *w)
 
184
{
 
185
    if ( w != d_cornerWidget )
 
186
    {
 
187
        if ( canvas() )
 
188
        {
 
189
            delete d_cornerWidget;
 
190
            d_cornerWidget = w;
 
191
            if ( d_cornerWidget->parent() != canvas() )
 
192
                d_cornerWidget->setParent(canvas());
 
193
 
 
194
            updateScrollBars();
 
195
        }
 
196
    }
 
197
}
 
198
 
 
199
QWidget *ScrollZoomer::cornerWidget() const
 
200
{
 
201
    return d_cornerWidget;
 
202
}
 
203
 
 
204
bool ScrollZoomer::eventFilter(QObject *o, QEvent *e)
 
205
{
 
206
    if (  o == canvas() )
 
207
    {
 
208
        switch(e->type())
 
209
        {
 
210
            case QEvent::Resize:
 
211
            {
 
212
                const int fw = ((QwtPlotCanvas *)canvas())->frameWidth();
 
213
 
 
214
                QRect rect;
 
215
                rect.setSize(((QResizeEvent *)e)->size());
 
216
                rect.setRect(rect.x() + fw, rect.y() + fw,
 
217
                    rect.width() - 2 * fw, rect.height() - 2 * fw);
 
218
 
 
219
                layoutScrollBars(rect);
 
220
                break;
 
221
            }
 
222
            case QEvent::ChildRemoved:
 
223
            {
 
224
                const QObject *child = ((QChildEvent *)e)->child();
 
225
                if ( child == d_cornerWidget )
 
226
                    d_cornerWidget = NULL;
 
227
                else if ( child == d_hScrollData->scrollBar )
 
228
                    d_hScrollData->scrollBar = NULL;
 
229
                else if ( child == d_vScrollData->scrollBar )
 
230
                    d_vScrollData->scrollBar = NULL;
 
231
                break;
 
232
            }
 
233
            default:
 
234
                break;
 
235
        }
 
236
    }
 
237
    return QwtPlotZoomer::eventFilter(o, e);
 
238
}
 
239
 
 
240
bool ScrollZoomer::needScrollBar(Qt::Orientation o) const
 
241
{
 
242
    Qt::ScrollBarPolicy mode;
 
243
    double zoomMin, zoomMax, baseMin, baseMax;
 
244
 
 
245
    if ( o == Qt::Horizontal )
 
246
    {
 
247
        mode = d_hScrollData->mode;
 
248
        baseMin = zoomBase().left();
 
249
        baseMax = zoomBase().right();
 
250
        zoomMin = zoomRect().left();
 
251
        zoomMax = zoomRect().right();
 
252
    }
 
253
    else
 
254
    {
 
255
        mode = d_vScrollData->mode;
 
256
        baseMin = zoomBase().top();
 
257
        baseMax = zoomBase().bottom();
 
258
        zoomMin = zoomRect().top();
 
259
        zoomMax = zoomRect().bottom();
 
260
    }
 
261
 
 
262
    bool needed = false;
 
263
    switch(mode)
 
264
    {
 
265
        case Qt::ScrollBarAlwaysOn:
 
266
            needed = true;
 
267
            break;
 
268
        case Qt::ScrollBarAlwaysOff:
 
269
            needed = false;
 
270
            break;
 
271
        default:
 
272
        {
 
273
            if ( baseMin < zoomMin || baseMax > zoomMax )
 
274
                needed = true;
 
275
            break;
 
276
        }
 
277
    }
 
278
    return needed;
 
279
}
 
280
 
 
281
void ScrollZoomer::updateScrollBars()
 
282
{
 
283
    if ( !canvas() )
 
284
        return;
 
285
 
 
286
    const int xAxis = QwtPlotZoomer::xAxis();
 
287
    const int yAxis = QwtPlotZoomer::yAxis();
 
288
 
 
289
    int xScrollBarAxis = xAxis;
 
290
    if ( hScrollBarPosition() == OppositeToScale )
 
291
        xScrollBarAxis = oppositeAxis(xScrollBarAxis);
 
292
 
 
293
    int yScrollBarAxis = yAxis;
 
294
    if ( vScrollBarPosition() == OppositeToScale ) 
 
295
        yScrollBarAxis = oppositeAxis(yScrollBarAxis); 
 
296
 
 
297
 
 
298
    QwtPlotLayout *layout = plot()->plotLayout();
 
299
 
 
300
    bool showHScrollBar = needScrollBar(Qt::Horizontal);
 
301
    if ( showHScrollBar )
 
302
    {
 
303
        ScrollBar *sb = scrollBar(Qt::Horizontal);
 
304
 
 
305
        sb->setPalette(plot()->palette());
 
306
 
 
307
        const QwtScaleDiv *sd = plot()->axisScaleDiv(xAxis);
 
308
        sb->setInverted(sd->lowerBound() > sd->upperBound() );
 
309
 
 
310
        sb->setBase(zoomBase().left(), zoomBase().right());
 
311
        sb->moveSlider(zoomRect().left(), zoomRect().right());
 
312
 
 
313
        if ( !sb->isVisibleTo(canvas()) )
 
314
        {
 
315
            sb->show();
 
316
            layout->setCanvasMargin(layout->canvasMargin(xScrollBarAxis) 
 
317
                + sb->extent(), xScrollBarAxis);
 
318
        }
 
319
    }
 
320
    else
 
321
    {
 
322
        if ( horizontalScrollBar() )
 
323
        {
 
324
            horizontalScrollBar()->hide();
 
325
            layout->setCanvasMargin(layout->canvasMargin(xScrollBarAxis) 
 
326
                - horizontalScrollBar()->extent(), xScrollBarAxis);
 
327
        }
 
328
    }
 
329
 
 
330
    bool showVScrollBar = needScrollBar(Qt::Vertical);
 
331
    if ( showVScrollBar )
 
332
    {
 
333
        ScrollBar *sb = scrollBar(Qt::Vertical);
 
334
 
 
335
        sb->setPalette(plot()->palette());
 
336
 
 
337
        const QwtScaleDiv *sd = plot()->axisScaleDiv(yAxis);
 
338
        sb->setInverted(sd->lowerBound() < sd->upperBound() );
 
339
 
 
340
        sb->setBase(zoomBase().top(), zoomBase().bottom());
 
341
        sb->moveSlider(zoomRect().top(), zoomRect().bottom());
 
342
 
 
343
        if ( !sb->isVisibleTo(canvas()) )
 
344
        {
 
345
            sb->show();
 
346
            layout->setCanvasMargin(layout->canvasMargin(yScrollBarAxis) 
 
347
                + sb->extent(), yScrollBarAxis);
 
348
        }
 
349
    }
 
350
    else
 
351
    {
 
352
        if ( verticalScrollBar() )
 
353
        {
 
354
            verticalScrollBar()->hide();
 
355
            layout->setCanvasMargin(layout->canvasMargin(yScrollBarAxis) 
 
356
                - verticalScrollBar()->extent(), yScrollBarAxis);
 
357
        }
 
358
    }
 
359
 
 
360
    if ( showHScrollBar && showVScrollBar )
 
361
    {
 
362
        if ( d_cornerWidget == NULL )
 
363
        {
 
364
            d_cornerWidget = new QWidget(canvas());
 
365
            d_cornerWidget->setAutoFillBackground(true);
 
366
            d_cornerWidget->setPalette(plot()->palette());
 
367
        }
 
368
        d_cornerWidget->show();
 
369
    }
 
370
    else
 
371
    {
 
372
        if ( d_cornerWidget )
 
373
            d_cornerWidget->hide();
 
374
    }
 
375
 
 
376
    layoutScrollBars(((QwtPlotCanvas *)canvas())->contentsRect());
 
377
    plot()->updateLayout();
 
378
}
 
379
 
 
380
void ScrollZoomer::layoutScrollBars(const QRect &rect)
 
381
{
 
382
    int hPos = xAxis();
 
383
    if ( hScrollBarPosition() == OppositeToScale )
 
384
        hPos = oppositeAxis(hPos);
 
385
 
 
386
    int vPos = yAxis();
 
387
    if ( vScrollBarPosition() == OppositeToScale )
 
388
        vPos = oppositeAxis(vPos);
 
389
 
 
390
    ScrollBar *hScrollBar = horizontalScrollBar();
 
391
    ScrollBar *vScrollBar = verticalScrollBar();
 
392
 
 
393
    const int hdim = hScrollBar ? hScrollBar->extent() : 0;
 
394
    const int vdim = vScrollBar ? vScrollBar->extent() : 0;
 
395
    
 
396
    if ( hScrollBar && hScrollBar->isVisible() )
 
397
    {
 
398
        int x = rect.x();
 
399
        int y = (hPos == QwtPlot::xTop) 
 
400
            ? rect.top() : rect.bottom() - hdim + 1;
 
401
        int w = rect.width();
 
402
 
 
403
        if ( vScrollBar && vScrollBar->isVisible() )
 
404
        {
 
405
            if ( vPos == QwtPlot::yLeft )
 
406
                x += vdim;
 
407
            w -= vdim;
 
408
        }
 
409
 
 
410
        hScrollBar->setGeometry(x, y, w, hdim);
 
411
    }
 
412
    if ( vScrollBar && vScrollBar->isVisible() )
 
413
    {
 
414
        int pos = yAxis();
 
415
        if ( vScrollBarPosition() == OppositeToScale )
 
416
            pos = oppositeAxis(pos);
 
417
 
 
418
        int x = (vPos == QwtPlot::yLeft)
 
419
            ? rect.left() : rect.right() - vdim + 1;
 
420
        int y = rect.y();
 
421
 
 
422
        int h = rect.height();
 
423
 
 
424
        if ( hScrollBar && hScrollBar->isVisible() )
 
425
        {
 
426
            if ( hPos == QwtPlot::xTop )
 
427
                y += hdim;
 
428
                
 
429
            h -= hdim;
 
430
        }
 
431
 
 
432
        vScrollBar->setGeometry(x, y, vdim, h);
 
433
    }
 
434
    if ( hScrollBar && hScrollBar->isVisible() &&
 
435
        vScrollBar && vScrollBar->isVisible() )
 
436
    {
 
437
        if ( d_cornerWidget )
 
438
        {
 
439
            QRect cornerRect(
 
440
                vScrollBar->pos().x(), hScrollBar->pos().y(),
 
441
                vdim, hdim);
 
442
            d_cornerWidget->setGeometry(cornerRect);
 
443
        }
 
444
    }
 
445
}
 
446
 
 
447
void ScrollZoomer::scrollBarMoved(
 
448
    Qt::Orientation o, double min, double max)
 
449
{
 
450
    Q_UNUSED(max);
 
451
 
 
452
    if ( o == Qt::Horizontal )
 
453
        moveTo( QPointF( min, zoomRect().top() ) );
 
454
    else
 
455
        moveTo( QPointF( zoomRect().left(), min ) );
 
456
 
 
457
    Q_EMIT zoomed(zoomRect());
 
458
}
 
459
 
 
460
int ScrollZoomer::oppositeAxis(int axis) const
 
461
{
 
462
    switch(axis)
 
463
    {
 
464
        case QwtPlot::xBottom:
 
465
            return QwtPlot::xTop;
 
466
        case QwtPlot::xTop:
 
467
            return QwtPlot::xBottom;
 
468
        case QwtPlot::yLeft:
 
469
            return QwtPlot::yRight;
 
470
        case QwtPlot::yRight:
 
471
            return QwtPlot::yLeft;
 
472
        default:
 
473
            break;
 
474
    }
 
475
 
 
476
    return axis;
 
477
}