← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/qwt_plot_item.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_plot_item.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_plot_item.h"
 
11
#include "qwt_text.h"
 
12
#include "qwt_plot.h"
 
13
#include "qwt_legend.h"
 
14
#include "qwt_legend_item.h"
 
15
#include "qwt_scale_div.h"
 
16
#include <qpainter.h>
 
17
 
 
18
class QwtPlotItem::PrivateData
 
19
{
 
20
public:
 
21
    PrivateData():
 
22
        plot( NULL ),
 
23
        isVisible( true ),
 
24
        attributes( 0 ),
 
25
        renderHints( 0 ),
 
26
        z( 0.0 ),
 
27
        xAxis( QwtPlot::xBottom ),
 
28
        yAxis( QwtPlot::yLeft )
 
29
    {
 
30
    }
 
31
 
 
32
    mutable QwtPlot *plot;
 
33
 
 
34
    bool isVisible;
 
35
    QwtPlotItem::ItemAttributes attributes;
 
36
    QwtPlotItem::RenderHints renderHints;
 
37
    double z;
 
38
 
 
39
    int xAxis;
 
40
    int yAxis;
 
41
 
 
42
    QwtText title;
 
43
};
 
44
 
 
45
/*!
 
46
   Constructor
 
47
   \param title Title of the item
 
48
*/
 
49
QwtPlotItem::QwtPlotItem( const QwtText &title )
 
50
{
 
51
    d_data = new PrivateData;
 
52
    d_data->title = title;
 
53
}
 
54
 
 
55
//! Destroy the QwtPlotItem
 
56
QwtPlotItem::~QwtPlotItem()
 
57
{
 
58
    attach( NULL );
 
59
    delete d_data;
 
60
}
 
61
 
 
62
/*!
 
63
  \brief Attach the item to a plot.
 
64
 
 
65
  This method will attach a QwtPlotItem to the QwtPlot argument. It will first
 
66
  detach the QwtPlotItem from any plot from a previous call to attach (if
 
67
  necessary). If a NULL argument is passed, it will detach from any QwtPlot it
 
68
  was attached to.
 
69
 
 
70
  \param plot Plot widget
 
71
  \sa detach()
 
72
*/
 
73
void QwtPlotItem::attach( QwtPlot *plot )
 
74
{
 
75
    if ( plot == d_data->plot )
 
76
        return;
 
77
 
 
78
    // remove the item from the previous plot
 
79
 
 
80
    if ( d_data->plot )
 
81
    {
 
82
        if ( d_data->plot->legend() )
 
83
            d_data->plot->legend()->remove( this );
 
84
 
 
85
        d_data->plot->attachItem( this, false );
 
86
 
 
87
        if ( d_data->plot->autoReplot() )
 
88
            d_data->plot->update();
 
89
    }
 
90
 
 
91
    d_data->plot = plot;
 
92
 
 
93
    if ( d_data->plot )
 
94
    {
 
95
        // insert the item into the current plot
 
96
 
 
97
        d_data->plot->attachItem( this, true );
 
98
        itemChanged();
 
99
    }
 
100
}
 
101
 
 
102
/*!
 
103
   \brief This method detaches a QwtPlotItem from any 
 
104
          QwtPlot it has been associated with.
 
105
 
 
106
   detach() is equivalent to calling attach( NULL )
 
107
   \sa attach()
 
108
*/
 
109
void QwtPlotItem::detach()
 
110
{
 
111
    attach( NULL );
 
112
}
 
113
 
 
114
/*!
 
115
   Return rtti for the specific class represented. QwtPlotItem is simply
 
116
   a virtual interface class, and base classes will implement this method
 
117
   with specific rtti values so a user can differentiate them.
 
118
 
 
119
   The rtti value is useful for environments, where the
 
120
   runtime type information is disabled and it is not possible
 
121
   to do a dynamic_cast<...>.
 
122
 
 
123
   \return rtti value
 
124
   \sa RttiValues
 
125
*/
 
126
int QwtPlotItem::rtti() const
 
127
{
 
128
    return Rtti_PlotItem;
 
129
}
 
130
 
 
131
//! Return attached plot
 
132
QwtPlot *QwtPlotItem::plot() const
 
133
{
 
134
    return d_data->plot;
 
135
}
 
136
 
 
137
/*!
 
138
   Plot items are painted in increasing z-order.
 
139
 
 
140
   \return setZ(), QwtPlotDict::itemList()
 
141
*/
 
142
double QwtPlotItem::z() const
 
143
{
 
144
    return d_data->z;
 
145
}
 
146
 
 
147
/*!
 
148
   \brief Set the z value
 
149
 
 
150
   Plot items are painted in increasing z-order.
 
151
 
 
152
   \param z Z-value
 
153
   \sa z(), QwtPlotDict::itemList()
 
154
*/
 
155
void QwtPlotItem::setZ( double z )
 
156
{
 
157
    if ( d_data->z != z )
 
158
    {
 
159
        if ( d_data->plot ) // update the z order
 
160
            d_data->plot->attachItem( this, false );
 
161
 
 
162
        d_data->z = z;
 
163
 
 
164
        if ( d_data->plot )
 
165
            d_data->plot->attachItem( this, true );
 
166
 
 
167
        itemChanged();
 
168
    }
 
169
}
 
170
 
 
171
/*!
 
172
   Set a new title
 
173
 
 
174
   \param title Title
 
175
   \sa title()
 
176
*/
 
177
void QwtPlotItem::setTitle( const QString &title )
 
178
{
 
179
    setTitle( QwtText( title ) );
 
180
}
 
181
 
 
182
/*!
 
183
   Set a new title
 
184
 
 
185
   \param title Title
 
186
   \sa title()
 
187
*/
 
188
void QwtPlotItem::setTitle( const QwtText &title )
 
189
{
 
190
    if ( d_data->title != title )
 
191
    {
 
192
        d_data->title = title;
 
193
        itemChanged();
 
194
    }
 
195
}
 
196
 
 
197
/*!
 
198
   \return Title of the item
 
199
   \sa setTitle()
 
200
*/
 
201
const QwtText &QwtPlotItem::title() const
 
202
{
 
203
    return d_data->title;
 
204
}
 
205
 
 
206
/*!
 
207
   Toggle an item attribute
 
208
 
 
209
   \param attribute Attribute type
 
210
   \param on true/false
 
211
 
 
212
   \sa testItemAttribute(), ItemAttribute
 
213
*/
 
214
void QwtPlotItem::setItemAttribute( ItemAttribute attribute, bool on )
 
215
{
 
216
    if ( bool( d_data->attributes & attribute ) != on )
 
217
    {
 
218
        if ( on )
 
219
            d_data->attributes |= attribute;
 
220
        else
 
221
            d_data->attributes &= ~attribute;
 
222
 
 
223
        itemChanged();
 
224
    }
 
225
}
 
226
 
 
227
/*!
 
228
   Test an item attribute
 
229
 
 
230
   \param attribute Attribute type
 
231
   \return true/false
 
232
   \sa setItemAttribute(), ItemAttribute
 
233
*/
 
234
bool QwtPlotItem::testItemAttribute( ItemAttribute attribute ) const
 
235
{
 
236
    return ( d_data->attributes & attribute );
 
237
}
 
238
 
 
239
/*!
 
240
   Toggle an render hint
 
241
 
 
242
   \param hint Render hint
 
243
   \param on true/false
 
244
 
 
245
   \sa testRenderHint(), RenderHint
 
246
*/
 
247
void QwtPlotItem::setRenderHint( RenderHint hint, bool on )
 
248
{
 
249
    if ( ( ( d_data->renderHints & hint ) != 0 ) != on )
 
250
    {
 
251
        if ( on )
 
252
            d_data->renderHints |= hint;
 
253
        else
 
254
            d_data->renderHints &= ~hint;
 
255
 
 
256
        itemChanged();
 
257
    }
 
258
}
 
259
 
 
260
/*!
 
261
   Test a render hint
 
262
 
 
263
   \param hint Render hint
 
264
   \return true/false
 
265
   \sa setRenderHint(), RenderHint
 
266
*/
 
267
bool QwtPlotItem::testRenderHint( RenderHint hint ) const
 
268
{
 
269
    return ( d_data->renderHints & hint );
 
270
}
 
271
 
 
272
//! Show the item
 
273
void QwtPlotItem::show()
 
274
{
 
275
    setVisible( true );
 
276
}
 
277
 
 
278
//! Hide the item
 
279
void QwtPlotItem::hide()
 
280
{
 
281
    setVisible( false );
 
282
}
 
283
 
 
284
/*!
 
285
    Show/Hide the item
 
286
 
 
287
    \param on Show if true, otherwise hide
 
288
    \sa isVisible(), show(), hide()
 
289
*/
 
290
void QwtPlotItem::setVisible( bool on )
 
291
{
 
292
    if ( on != d_data->isVisible )
 
293
    {
 
294
        d_data->isVisible = on;
 
295
        itemChanged();
 
296
    }
 
297
}
 
298
 
 
299
/*!
 
300
    \return true if visible
 
301
    \sa setVisible(), show(), hide()
 
302
*/
 
303
bool QwtPlotItem::isVisible() const
 
304
{
 
305
    return d_data->isVisible;
 
306
}
 
307
 
 
308
/*!
 
309
   Update the legend and call QwtPlot::autoRefresh for the
 
310
   parent plot.
 
311
 
 
312
   \sa updateLegend()
 
313
*/
 
314
void QwtPlotItem::itemChanged()
 
315
{
 
316
    if ( d_data->plot )
 
317
    {
 
318
        if ( d_data->plot->legend() )
 
319
            updateLegend( d_data->plot->legend() );
 
320
 
 
321
        d_data->plot->autoRefresh();
 
322
    }
 
323
}
 
324
 
 
325
/*!
 
326
   Set X and Y axis
 
327
 
 
328
   The item will painted according to the coordinates its Axes.
 
329
 
 
330
   \param xAxis X Axis
 
331
   \param yAxis Y Axis
 
332
 
 
333
   \sa setXAxis(), setYAxis(), xAxis(), yAxis()
 
334
*/
 
335
void QwtPlotItem::setAxes( int xAxis, int yAxis )
 
336
{
 
337
    if ( xAxis == QwtPlot::xBottom || xAxis == QwtPlot::xTop )
 
338
        d_data->xAxis = xAxis;
 
339
 
 
340
    if ( yAxis == QwtPlot::yLeft || yAxis == QwtPlot::yRight )
 
341
        d_data->yAxis = yAxis;
 
342
 
 
343
    itemChanged();
 
344
}
 
345
 
 
346
/*!
 
347
   Set the X axis
 
348
 
 
349
   The item will painted according to the coordinates its Axes.
 
350
 
 
351
   \param axis X Axis
 
352
   \sa setAxes(), setYAxis(), xAxis()
 
353
*/
 
354
void QwtPlotItem::setXAxis( int axis )
 
355
{
 
356
    if ( axis == QwtPlot::xBottom || axis == QwtPlot::xTop )
 
357
    {
 
358
        d_data->xAxis = axis;
 
359
        itemChanged();
 
360
    }
 
361
}
 
362
 
 
363
/*!
 
364
   Set the Y axis
 
365
 
 
366
   The item will painted according to the coordinates its Axes.
 
367
 
 
368
   \param axis Y Axis
 
369
   \sa setAxes(), setXAxis(), yAxis()
 
370
*/
 
371
void QwtPlotItem::setYAxis( int axis )
 
372
{
 
373
    if ( axis == QwtPlot::yLeft || axis == QwtPlot::yRight )
 
374
    {
 
375
        d_data->yAxis = axis;
 
376
        itemChanged();
 
377
    }
 
378
}
 
379
 
 
380
//! Return xAxis
 
381
int QwtPlotItem::xAxis() const
 
382
{
 
383
    return d_data->xAxis;
 
384
}
 
385
 
 
386
//! Return yAxis
 
387
int QwtPlotItem::yAxis() const
 
388
{
 
389
    return d_data->yAxis;
 
390
}
 
391
 
 
392
/*!
 
393
   \return An invalid bounding rect: QRectF(1.0, 1.0, -2.0, -2.0)
 
394
*/
 
395
QRectF QwtPlotItem::boundingRect() const
 
396
{
 
397
    return QRectF( 1.0, 1.0, -2.0, -2.0 ); // invalid
 
398
}
 
399
 
 
400
/*!
 
401
   \brief Allocate the widget that represents the item on the legend
 
402
 
 
403
   The default implementation returns a QwtLegendItem(), but an item 
 
404
   could be represented by any type of widget,
 
405
   by overloading legendItem() and updateLegend().
 
406
 
 
407
   \return QwtLegendItem()
 
408
   \sa updateLegend() QwtLegend()
 
409
*/
 
410
QWidget *QwtPlotItem::legendItem() const
 
411
{
 
412
    QwtLegendItem *item = new QwtLegendItem;
 
413
    if ( d_data->plot )
 
414
    {
 
415
        QObject::connect( item, SIGNAL( clicked() ),
 
416
            d_data->plot, SLOT( legendItemClicked() ) );
 
417
        QObject::connect( item, SIGNAL( checked( bool ) ),
 
418
            d_data->plot, SLOT( legendItemChecked( bool ) ) );
 
419
    }
 
420
    return item;
 
421
}
 
422
 
 
423
/*!
 
424
   \brief Update the widget that represents the item on the legend
 
425
 
 
426
   updateLegend() is called from itemChanged() to adopt the widget
 
427
   representing the item on the legend to its new configuration.
 
428
 
 
429
   The default implementation updates a QwtLegendItem(), 
 
430
   but an item could be represented by any type of widget,
 
431
   by overloading legendItem() and updateLegend().
 
432
 
 
433
   \param legend Legend
 
434
 
 
435
   \sa legendItem(), itemChanged(), QwtLegend()
 
436
*/
 
437
void QwtPlotItem::updateLegend( QwtLegend *legend ) const
 
438
{
 
439
    if ( legend == NULL )
 
440
        return;
 
441
 
 
442
    QWidget *lgdItem = legend->find( this );
 
443
    if ( testItemAttribute( QwtPlotItem::Legend ) )
 
444
    {
 
445
        if ( lgdItem == NULL )
 
446
        {
 
447
            lgdItem = legendItem();
 
448
            if ( lgdItem )
 
449
                legend->insert( this, lgdItem );
 
450
        }
 
451
        if ( lgdItem && lgdItem->inherits( "QwtLegendItem" ) )
 
452
        {
 
453
            QwtLegendItem* label = ( QwtLegendItem* )lgdItem;
 
454
            if ( label )
 
455
            {
 
456
                // paint the identifier
 
457
                const QSize sz = label->identifierSize();
 
458
 
 
459
                QPixmap identifier( sz.width(), sz.height() );
 
460
                identifier.fill( Qt::transparent );
 
461
 
 
462
                QPainter painter( &identifier );
 
463
                painter.setRenderHint( QPainter::Antialiasing,
 
464
                    testRenderHint( QwtPlotItem::RenderAntialiased ) );
 
465
                drawLegendIdentifier( &painter,
 
466
                    QRect( 0, 0, sz.width(), sz.height() ) );
 
467
                painter.end();
 
468
 
 
469
                const bool doUpdate = label->updatesEnabled();
 
470
                if ( doUpdate )
 
471
                    label->setUpdatesEnabled( false );
 
472
 
 
473
                label->setText( title() );
 
474
                label->setIdentifier( identifier );
 
475
                label->setItemMode( legend->itemMode() );
 
476
 
 
477
                if ( doUpdate )
 
478
                    label->setUpdatesEnabled( true );
 
479
 
 
480
                label->update();
 
481
            }
 
482
        }
 
483
    }
 
484
    else
 
485
    {
 
486
        if ( lgdItem )
 
487
        {
 
488
            lgdItem->hide();
 
489
            lgdItem->deleteLater();
 
490
        }
 
491
    }
 
492
}
 
493
 
 
494
/*!
 
495
   \brief Update the item to changes of the axes scale division
 
496
 
 
497
   Update the item, when the axes of plot have changed.
 
498
   The default implementation does nothing, but items that depend
 
499
   on the scale division (like QwtPlotGrid()) have to reimplement
 
500
   updateScaleDiv()
 
501
 
 
502
   \param xScaleDiv Scale division of the x-axis
 
503
   \param yScaleDiv Scale division of the y-axis
 
504
 
 
505
   \sa QwtPlot::updateAxes()
 
506
*/
 
507
void QwtPlotItem::updateScaleDiv( const QwtScaleDiv &xScaleDiv,
 
508
    const QwtScaleDiv &yScaleDiv )
 
509
{
 
510
    Q_UNUSED( xScaleDiv );
 
511
    Q_UNUSED( yScaleDiv );
 
512
}
 
513
 
 
514
/*!
 
515
   \brief Calculate the bounding scale rect of 2 maps
 
516
 
 
517
   \param xMap X map
 
518
   \param yMap X map
 
519
 
 
520
   \return Bounding scale rect of the scale maps, normalized
 
521
*/
 
522
QRectF QwtPlotItem::scaleRect( const QwtScaleMap &xMap,
 
523
    const QwtScaleMap &yMap ) const
 
524
{
 
525
    return QRectF( xMap.s1(), yMap.s1(),
 
526
        xMap.sDist(), yMap.sDist() );
 
527
}
 
528
 
 
529
/*!
 
530
   \brief Calculate the bounding paint rect of 2 maps
 
531
 
 
532
   \param xMap X map
 
533
   \param yMap X map
 
534
 
 
535
   \return Bounding paint rect of the scale maps, normalized
 
536
*/
 
537
QRectF QwtPlotItem::paintRect( const QwtScaleMap &xMap,
 
538
    const QwtScaleMap &yMap ) const
 
539
{
 
540
    const QRectF rect( xMap.p1(), yMap.p1(),
 
541
        xMap.pDist(), yMap.pDist() );
 
542
 
 
543
    return rect;
 
544
}