← 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_thermo.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_thermo.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 <qpainter.h>
 
11
#include <qevent.h>
 
12
#include <qstyle.h>
 
13
#include <qpixmap.h>
 
14
#include <qdrawutil.h>
 
15
#include "qwt_math.h"
 
16
#include "qwt_scale_engine.h"
 
17
#include "qwt_scale_draw.h"
 
18
#include "qwt_scale_map.h"
 
19
#include "qwt_paint_buffer.h"
 
20
#include "qwt_thermo.h"
 
21
 
 
22
class QwtThermo::PrivateData
 
23
{
 
24
public:
 
25
    PrivateData():
 
26
        fillBrush(Qt::black),
 
27
        alarmBrush(Qt::white),
 
28
        orientation(Qt::Vertical),
 
29
        scalePos(QwtThermo::LeftScale),
 
30
        borderWidth(2),
 
31
        scaleDist(3),
 
32
        thermoWidth(10),
 
33
        minValue(0.0),
 
34
        maxValue(1.0),
 
35
        value(0.0),
 
36
        alarmLevel(0.0),
 
37
        alarmEnabled(false)
 
38
    {
 
39
        map.setScaleInterval(minValue, maxValue);
 
40
    }
 
41
 
 
42
    QwtScaleMap map;
 
43
    QRect thermoRect;
 
44
    QBrush fillBrush;
 
45
    QBrush alarmBrush;
 
46
 
 
47
    Qt::Orientation orientation;
 
48
    ScalePos scalePos;
 
49
    int borderWidth;
 
50
    int scaleDist;
 
51
    int thermoWidth;
 
52
 
 
53
    double minValue;
 
54
    double maxValue;
 
55
    double value;
 
56
    double alarmLevel;
 
57
    bool alarmEnabled;
 
58
};
 
59
 
 
60
/*! 
 
61
  Constructor
 
62
  \param parent Parent widget
 
63
*/
 
64
QwtThermo::QwtThermo(QWidget *parent): 
 
65
    QWidget(parent)
 
66
{
 
67
    initThermo();
 
68
}
 
69
 
 
70
#if QT_VERSION < 0x040000
 
71
/*! 
 
72
  Constructor
 
73
  \param parent Parent widget
 
74
  \param name Object name
 
75
*/
 
76
QwtThermo::QwtThermo(QWidget *parent, const char *name): 
 
77
    QWidget(parent, name)
 
78
{
 
79
    initThermo();
 
80
}
 
81
#endif
 
82
 
 
83
void QwtThermo::initThermo()
 
84
{
 
85
#if QT_VERSION < 0x040000
 
86
    setWFlags(Qt::WNoAutoErase);
 
87
#endif
 
88
    d_data = new PrivateData;
 
89
    setRange(d_data->minValue, d_data->maxValue, false);
 
90
 
 
91
    QSizePolicy policy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
 
92
    if (d_data->orientation == Qt::Vertical) 
 
93
        policy.transpose();
 
94
 
 
95
    setSizePolicy(policy);
 
96
    
 
97
#if QT_VERSION >= 0x040000
 
98
    setAttribute(Qt::WA_WState_OwnSizePolicy, false);
 
99
#else
 
100
    clearWState( WState_OwnSizePolicy );
 
101
#endif
 
102
}
 
103
 
 
104
//! Destructor
 
105
QwtThermo::~QwtThermo()
 
106
{
 
107
    delete d_data;
 
108
}
 
109
 
 
110
//! Set the maximum value.
 
111
void QwtThermo::setMaxValue(double v) 
 
112
{ 
 
113
    setRange(d_data->minValue, v); 
 
114
}
 
115
 
 
116
//! Return the maximum value.
 
117
double QwtThermo::maxValue() const 
 
118
{ 
 
119
    return d_data->maxValue; 
 
120
}
 
121
 
 
122
//! Set the minimum value.
 
123
void QwtThermo::setMinValue(double v) 
 
124
{ 
 
125
    setRange(v, d_data->maxValue); 
 
126
}
 
127
 
 
128
//! Return the minimum value.
 
129
double QwtThermo::minValue() const 
 
130
{ 
 
131
    return d_data->minValue; 
 
132
}
 
133
 
 
134
//! Set the current value.
 
135
void QwtThermo::setValue(double v)
 
136
{
 
137
    if (d_data->value != v)
 
138
    {
 
139
        d_data->value = v;
 
140
        update();
 
141
    }
 
142
}
 
143
 
 
144
//! Return the value.
 
145
double QwtThermo::value() const 
 
146
{ 
 
147
    return d_data->value; 
 
148
}
 
149
 
 
150
/*!
 
151
  \brief Set a scale draw
 
152
 
 
153
  For changing the labels of the scales, it
 
154
  is necessary to derive from QwtScaleDraw and
 
155
  overload QwtScaleDraw::label().
 
156
 
 
157
  \param scaleDraw ScaleDraw object, that has to be created with 
 
158
                   new and will be deleted in ~QwtThermo or the next 
 
159
                   call of setScaleDraw().
 
160
*/
 
161
void QwtThermo::setScaleDraw(QwtScaleDraw *scaleDraw)
 
162
{
 
163
    setAbstractScaleDraw(scaleDraw);
 
164
}
 
165
 
 
166
/*!
 
167
   \return the scale draw of the thermo
 
168
   \sa setScaleDraw()
 
169
*/
 
170
const QwtScaleDraw *QwtThermo::scaleDraw() const
 
171
{
 
172
    return (QwtScaleDraw *)abstractScaleDraw();
 
173
}
 
174
 
 
175
/*!
 
176
   \return the scale draw of the thermo
 
177
   \sa setScaleDraw()
 
178
*/
 
179
QwtScaleDraw *QwtThermo::scaleDraw() 
 
180
{
 
181
    return (QwtScaleDraw *)abstractScaleDraw();
 
182
}
 
183
 
 
184
//! Qt paint event.
 
185
void QwtThermo::paintEvent(QPaintEvent *e)
 
186
{
 
187
    // Use double-buffering
 
188
    const QRect &ur = e->rect();
 
189
    if ( ur.isValid() )
 
190
    {
 
191
#if QT_VERSION < 0x040000
 
192
        QwtPaintBuffer paintBuffer(this, ur);
 
193
        draw(paintBuffer.painter(), ur);
 
194
#else
 
195
        QPainter painter(this);
 
196
        draw(&painter, ur);
 
197
#endif
 
198
    }
 
199
}
 
200
 
 
201
//! Draw the whole QwtThermo.
 
202
void QwtThermo::draw(QPainter *p, const QRect& ur)
 
203
{
 
204
    if ( !d_data->thermoRect.contains(ur) )
 
205
    {
 
206
        if (d_data->scalePos != NoScale)
 
207
        {
 
208
#if QT_VERSION < 0x040000
 
209
            scaleDraw()->draw(p, colorGroup());
 
210
#else
 
211
            scaleDraw()->draw(p, palette());
 
212
#endif
 
213
        }
 
214
 
 
215
        qDrawShadePanel(p,
 
216
            d_data->thermoRect.x() - d_data->borderWidth,
 
217
            d_data->thermoRect.y() - d_data->borderWidth,
 
218
            d_data->thermoRect.width() + 2*d_data->borderWidth,
 
219
            d_data->thermoRect.height() + 2*d_data->borderWidth,
 
220
#if QT_VERSION < 0x040000
 
221
            colorGroup(), 
 
222
#else
 
223
            palette(), 
 
224
#endif
 
225
            true, d_data->borderWidth,0);
 
226
    }
 
227
    drawThermo(p);
 
228
}
 
229
 
 
230
//! Qt resize event handler
 
231
void QwtThermo::resizeEvent(QResizeEvent *)
 
232
{
 
233
    layoutThermo( false );
 
234
}
 
235
 
 
236
/*!
 
237
  Recalculate the QwtThermo geometry and layout based on
 
238
  the QwtThermo::rect() and the fonts.
 
239
  \param update_geometry notify the layout system and call update
 
240
         to redraw the scale
 
241
*/
 
242
void QwtThermo::layoutThermo( bool update_geometry )
 
243
{
 
244
    QRect r = rect();
 
245
    int mbd = 0;
 
246
    if ( d_data->scalePos != NoScale )
 
247
    {
 
248
        int d1, d2;
 
249
        scaleDraw()->getBorderDistHint(font(), d1, d2);
 
250
        mbd = qwtMax(d1, d2);
 
251
    }
 
252
 
 
253
    if ( d_data->orientation == Qt::Horizontal )
 
254
    {
 
255
        switch ( d_data->scalePos )
 
256
        {
 
257
            case TopScale:
 
258
            {
 
259
                d_data->thermoRect.setRect(
 
260
                    r.x() + mbd + d_data->borderWidth,
 
261
                    r.y() + r.height()
 
262
                    - d_data->thermoWidth - 2*d_data->borderWidth,
 
263
                    r.width() - 2*(d_data->borderWidth + mbd),
 
264
                    d_data->thermoWidth);
 
265
                scaleDraw()->setAlignment(QwtScaleDraw::TopScale);
 
266
                scaleDraw()->move( d_data->thermoRect.x(),
 
267
                    d_data->thermoRect.y() - d_data->borderWidth 
 
268
                        - d_data->scaleDist);
 
269
                scaleDraw()->setLength(d_data->thermoRect.width());
 
270
                break;
 
271
            }
 
272
 
 
273
            case BottomScale:
 
274
            case NoScale: // like Bottom but without scale
 
275
            default:   // inconsistent orientation and scale position
 
276
                       // Mapping between values and pixels requires
 
277
                       // initialization of the scale geometry
 
278
            {
 
279
                d_data->thermoRect.setRect(
 
280
                    r.x() + mbd + d_data->borderWidth,
 
281
                    r.y() + d_data->borderWidth,
 
282
                    r.width() - 2*(d_data->borderWidth + mbd),
 
283
                    d_data->thermoWidth);
 
284
                scaleDraw()->setAlignment(QwtScaleDraw::BottomScale);
 
285
                scaleDraw()->move(
 
286
                    d_data->thermoRect.x(),
 
287
                    d_data->thermoRect.y() + d_data->thermoRect.height()
 
288
                        + d_data->borderWidth + d_data->scaleDist );
 
289
                scaleDraw()->setLength(d_data->thermoRect.width());
 
290
                break;
 
291
            }
 
292
        }
 
293
        d_data->map.setPaintInterval(d_data->thermoRect.x(),
 
294
            d_data->thermoRect.x() + d_data->thermoRect.width() - 1);
 
295
    }
 
296
    else // Qt::Vertical
 
297
    {
 
298
        switch ( d_data->scalePos )
 
299
        {
 
300
            case RightScale:
 
301
            {
 
302
                d_data->thermoRect.setRect(
 
303
                    r.x() + d_data->borderWidth,
 
304
                    r.y() + mbd + d_data->borderWidth,
 
305
                    d_data->thermoWidth,
 
306
                    r.height() - 2*(d_data->borderWidth + mbd));
 
307
                scaleDraw()->setAlignment(QwtScaleDraw::RightScale);
 
308
                scaleDraw()->move(
 
309
                    d_data->thermoRect.x() + d_data->thermoRect.width()
 
310
                        + d_data->borderWidth + d_data->scaleDist,
 
311
                    d_data->thermoRect.y());
 
312
                scaleDraw()->setLength(d_data->thermoRect.height());
 
313
                break;
 
314
            }
 
315
 
 
316
            case LeftScale:
 
317
            case NoScale: // like Left but without scale
 
318
            default:   // inconsistent orientation and scale position
 
319
                       // Mapping between values and pixels requires
 
320
                       // initialization of the scale geometry
 
321
            {
 
322
                d_data->thermoRect.setRect(
 
323
                    r.x() + r.width() - 2*d_data->borderWidth - d_data->thermoWidth,
 
324
                    r.y() + mbd + d_data->borderWidth,
 
325
                    d_data->thermoWidth,
 
326
                    r.height() - 2*(d_data->borderWidth + mbd));
 
327
                scaleDraw()->setAlignment(QwtScaleDraw::LeftScale);
 
328
                scaleDraw()->move(
 
329
                    d_data->thermoRect.x() - d_data->scaleDist 
 
330
                        - d_data->borderWidth,
 
331
                    d_data->thermoRect.y() );
 
332
                scaleDraw()->setLength(d_data->thermoRect.height());
 
333
                break;
 
334
            }
 
335
        }
 
336
        d_data->map.setPaintInterval(
 
337
            d_data->thermoRect.y() + d_data->thermoRect.height() - 1,
 
338
            d_data->thermoRect.y());
 
339
    }
 
340
    if ( update_geometry )
 
341
    {
 
342
        updateGeometry();
 
343
        update();
 
344
    }
 
345
}
 
346
 
 
347
/*!
 
348
  \brief Set the thermometer orientation and the scale position.
 
349
 
 
350
  The scale position NoScale disables the scale.
 
351
  \param o orientation. Possible values are Qt::Horizontal and Qt::Vertical.
 
352
         The default value is Qt::Vertical.
 
353
  \param s Position of the scale.
 
354
         The default value is NoScale.
 
355
 
 
356
  A valid combination of scale position and orientation is enforced:
 
357
  - a horizontal thermometer can have the scale positions TopScale, 
 
358
    BottomScale or NoScale;
 
359
  - a vertical thermometer can have the scale positions LeftScale, 
 
360
    RightScale or NoScale;
 
361
  - an invalid scale position will default to NoScale.
 
362
 
 
363
  \sa QwtThermo::setScalePosition()
 
364
*/
 
365
void QwtThermo::setOrientation(Qt::Orientation o, ScalePos s)
 
366
{
 
367
    if ( o == d_data->orientation && s == d_data->scalePos )
 
368
        return;
 
369
 
 
370
    switch(o)
 
371
    {
 
372
        case Qt::Horizontal:
 
373
        {
 
374
            if ((s == NoScale) || (s == BottomScale) || (s == TopScale))
 
375
                d_data->scalePos = s;
 
376
            else
 
377
                d_data->scalePos = NoScale;
 
378
            break;
 
379
        }
 
380
        case Qt::Vertical:
 
381
        {
 
382
            if ((s == NoScale) || (s == LeftScale) || (s == RightScale))
 
383
                d_data->scalePos = s;
 
384
            else
 
385
                d_data->scalePos = NoScale;
 
386
            break;
 
387
        }
 
388
    }
 
389
 
 
390
    if ( o != d_data->orientation )
 
391
    {
 
392
#if QT_VERSION >= 0x040000
 
393
        if ( !testAttribute(Qt::WA_WState_OwnSizePolicy) )
 
394
#else
 
395
        if ( !testWState( WState_OwnSizePolicy ) )
 
396
#endif
 
397
        {
 
398
            QSizePolicy sp = sizePolicy();
 
399
            sp.transpose();
 
400
            setSizePolicy(sp);
 
401
 
 
402
#if QT_VERSION >= 0x040000
 
403
            setAttribute(Qt::WA_WState_OwnSizePolicy, false);
 
404
#else
 
405
            clearWState( WState_OwnSizePolicy );
 
406
#endif
 
407
        }
 
408
    }
 
409
 
 
410
    d_data->orientation = o;
 
411
    layoutThermo();
 
412
}
 
413
 
 
414
/*!
 
415
  \brief Change the scale position (and thermometer orientation).
 
416
 
 
417
  \param s Position of the scale.
 
418
  
 
419
  A valid combination of scale position and orientation is enforced:
 
420
  - if the new scale position is LeftScale or RightScale, the 
 
421
    scale orientation will become Qt::Vertical;
 
422
  - if the new scale position is BottomScale or TopScale, the scale 
 
423
    orientation will become Qt::Horizontal;
 
424
  - if the new scale position is NoScale, the scale orientation will not change.
 
425
 
 
426
  \sa QwtThermo::setOrientation()
 
427
*/
 
428
void QwtThermo::setScalePosition(ScalePos s)
 
429
{
 
430
    if ((s == BottomScale) || (s == TopScale))
 
431
        setOrientation(Qt::Horizontal, s);
 
432
    else if ((s == LeftScale) || (s == RightScale))
 
433
        setOrientation(Qt::Vertical, s);
 
434
    else
 
435
        setOrientation(d_data->orientation, NoScale);
 
436
}
 
437
 
 
438
//! Return the scale position.
 
439
QwtThermo::ScalePos QwtThermo::scalePosition() const
 
440
{
 
441
    return d_data->scalePos;
 
442
}
 
443
 
 
444
//! Notify a font change.
 
445
void QwtThermo::fontChange(const QFont &f)
 
446
{
 
447
    QWidget::fontChange( f );
 
448
    layoutThermo();
 
449
}
 
450
 
 
451
//! Notify a scale change.
 
452
void QwtThermo::scaleChange()
 
453
{
 
454
    update();
 
455
    layoutThermo();
 
456
}
 
457
 
 
458
//! Redraw the liquid in thermometer pipe.
 
459
void QwtThermo::drawThermo(QPainter *p)
 
460
{
 
461
    int alarm  = 0, taval = 0;
 
462
 
 
463
    QRect fRect;
 
464
    QRect aRect;
 
465
    QRect bRect;
 
466
 
 
467
    int inverted = ( d_data->maxValue < d_data->minValue );
 
468
 
 
469
    //
 
470
    //  Determine if value exceeds alarm threshold.
 
471
    //  Note: The alarm value is allowed to lie
 
472
    //        outside the interval (minValue, maxValue).
 
473
    //
 
474
    if (d_data->alarmEnabled)
 
475
    {
 
476
        if (inverted)
 
477
        {
 
478
            alarm = ((d_data->alarmLevel >= d_data->maxValue)
 
479
                 && (d_data->alarmLevel <= d_data->minValue)
 
480
                 && (d_data->value >= d_data->alarmLevel));
 
481
        
 
482
        }
 
483
        else
 
484
        {
 
485
            alarm = (( d_data->alarmLevel >= d_data->minValue)
 
486
                 && (d_data->alarmLevel <= d_data->maxValue)
 
487
                 && (d_data->value >= d_data->alarmLevel));
 
488
        }
 
489
    }
 
490
 
 
491
    //
 
492
    //  transform values
 
493
    //
 
494
    int tval = transform(d_data->value);
 
495
 
 
496
    if (alarm)
 
497
       taval = transform(d_data->alarmLevel);
 
498
 
 
499
    //
 
500
    //  calculate recangles
 
501
    //
 
502
    if ( d_data->orientation == Qt::Horizontal )
 
503
    {
 
504
        if (inverted)
 
505
        {
 
506
            bRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
 
507
                  tval - d_data->thermoRect.x(),
 
508
                  d_data->thermoRect.height());
 
509
        
 
510
            if (alarm)
 
511
            {
 
512
                aRect.setRect(tval, d_data->thermoRect.y(),
 
513
                      taval - tval + 1,
 
514
                      d_data->thermoRect.height());
 
515
                fRect.setRect(taval + 1, d_data->thermoRect.y(),
 
516
                      d_data->thermoRect.x() + d_data->thermoRect.width() - (taval + 1),
 
517
                      d_data->thermoRect.height());
 
518
            }
 
519
            else
 
520
            {
 
521
                fRect.setRect(tval, d_data->thermoRect.y(),
 
522
                      d_data->thermoRect.x() + d_data->thermoRect.width() - tval,
 
523
                      d_data->thermoRect.height());
 
524
            }
 
525
        }
 
526
        else
 
527
        {
 
528
            bRect.setRect(tval + 1, d_data->thermoRect.y(),
 
529
                  d_data->thermoRect.width() - (tval + 1 - d_data->thermoRect.x()),
 
530
                  d_data->thermoRect.height());
 
531
        
 
532
            if (alarm)
 
533
            {
 
534
                aRect.setRect(taval, d_data->thermoRect.y(),
 
535
                      tval - taval + 1,
 
536
                      d_data->thermoRect.height());
 
537
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
 
538
                      taval - d_data->thermoRect.x(),
 
539
                      d_data->thermoRect.height());
 
540
            }
 
541
            else
 
542
            {
 
543
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
 
544
                      tval - d_data->thermoRect.x() + 1,
 
545
                      d_data->thermoRect.height());
 
546
            }
 
547
        
 
548
        }
 
549
    }
 
550
    else // Qt::Vertical
 
551
    {
 
552
        if (tval < d_data->thermoRect.y())
 
553
            tval = d_data->thermoRect.y();
 
554
        else 
 
555
        {
 
556
            if (tval > d_data->thermoRect.y() + d_data->thermoRect.height())
 
557
                tval = d_data->thermoRect.y() + d_data->thermoRect.height();
 
558
        }
 
559
 
 
560
        if (inverted)
 
561
        {
 
562
            bRect.setRect(d_data->thermoRect.x(), tval + 1,
 
563
            d_data->thermoRect.width(),
 
564
            d_data->thermoRect.height() - (tval + 1 - d_data->thermoRect.y()));
 
565
 
 
566
            if (alarm)
 
567
            {
 
568
                aRect.setRect(d_data->thermoRect.x(), taval,
 
569
                    d_data->thermoRect.width(),
 
570
                    tval - taval + 1);
 
571
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
 
572
                    d_data->thermoRect.width(),
 
573
                taval - d_data->thermoRect.y());
 
574
            }
 
575
            else
 
576
            {
 
577
                fRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
 
578
                    d_data->thermoRect.width(),
 
579
                    tval - d_data->thermoRect.y() + 1);
 
580
            }
 
581
        }
 
582
        else
 
583
        {
 
584
            bRect.setRect(d_data->thermoRect.x(), d_data->thermoRect.y(),
 
585
            d_data->thermoRect.width(),
 
586
            tval - d_data->thermoRect.y());
 
587
            if (alarm)
 
588
            {
 
589
                aRect.setRect(d_data->thermoRect.x(),tval,
 
590
                    d_data->thermoRect.width(),
 
591
                    taval - tval + 1);
 
592
                fRect.setRect(d_data->thermoRect.x(),taval + 1,
 
593
                    d_data->thermoRect.width(),
 
594
                    d_data->thermoRect.y() + d_data->thermoRect.height() - (taval + 1));
 
595
            }
 
596
            else
 
597
            {
 
598
                fRect.setRect(d_data->thermoRect.x(),tval,
 
599
                    d_data->thermoRect.width(),
 
600
                d_data->thermoRect.y() + d_data->thermoRect.height() - tval);
 
601
            }
 
602
        }
 
603
    }
 
604
 
 
605
    //
 
606
    // paint thermometer
 
607
    //
 
608
    const QColor bgColor =
 
609
#if QT_VERSION < 0x040000
 
610
        colorGroup().color(QColorGroup::Background);
 
611
#else
 
612
        palette().color(QPalette::Background);
 
613
#endif
 
614
    p->fillRect(bRect, bgColor);
 
615
 
 
616
    if (alarm)
 
617
       p->fillRect(aRect, d_data->alarmBrush);
 
618
 
 
619
    p->fillRect(fRect, d_data->fillBrush);
 
620
}
 
621
 
 
622
//! Set the border width of the pipe.
 
623
void QwtThermo::setBorderWidth(int w)
 
624
{
 
625
    if ((w >= 0) && (w < (qwtMin(d_data->thermoRect.width(), 
 
626
        d_data->thermoRect.height()) + d_data->borderWidth) / 2  - 1))
 
627
    {
 
628
        d_data->borderWidth = w;
 
629
        layoutThermo();
 
630
    }
 
631
}
 
632
 
 
633
//! Return the border width of the thermometer pipe.
 
634
int QwtThermo::borderWidth() const
 
635
{
 
636
    return d_data->borderWidth;
 
637
}
 
638
 
 
639
/*!
 
640
  \brief Set the range
 
641
  \param vmin value corresponding lower or left end of the thermometer
 
642
  \param vmax value corresponding to the upper or right end of the thermometer
 
643
  \param logarithmic logarithmic mapping, true or false 
 
644
*/
 
645
void QwtThermo::setRange(double vmin, double vmax, bool logarithmic)
 
646
{
 
647
    d_data->minValue = vmin;
 
648
    d_data->maxValue = vmax;
 
649
 
 
650
    if ( logarithmic )
 
651
        setScaleEngine(new QwtLog10ScaleEngine);
 
652
    else
 
653
        setScaleEngine(new QwtLinearScaleEngine);
 
654
 
 
655
    /*
 
656
      There are two different maps, one for the scale, the other
 
657
      for the values. This is confusing and will be changed
 
658
      in the future. TODO ...
 
659
     */
 
660
 
 
661
    d_data->map.setTransformation(scaleEngine()->transformation());
 
662
    d_data->map.setScaleInterval(d_data->minValue, d_data->maxValue);
 
663
 
 
664
    if (autoScale())
 
665
        rescale(d_data->minValue, d_data->maxValue);
 
666
 
 
667
    layoutThermo();
 
668
}
 
669
 
 
670
/*!
 
671
  \brief Change the brush of the liquid.
 
672
  \param brush New brush. The default brush is solid black.
 
673
*/
 
674
void QwtThermo::setFillBrush(const QBrush& brush)
 
675
{
 
676
    d_data->fillBrush = brush;
 
677
    update();
 
678
}
 
679
 
 
680
//! Return the liquid brush.
 
681
const QBrush& QwtThermo::fillBrush() const
 
682
{
 
683
    return d_data->fillBrush;
 
684
}
 
685
 
 
686
/*!
 
687
  \brief Change the color of the liquid.
 
688
  \param c New color. The default color is black.
 
689
*/
 
690
void QwtThermo::setFillColor(const QColor &c)
 
691
{
 
692
    d_data->fillBrush.setColor(c);
 
693
    update();
 
694
}
 
695
 
 
696
//! Return the liquid color.
 
697
const QColor &QwtThermo::fillColor() const
 
698
{
 
699
    return d_data->fillBrush.color();
 
700
}
 
701
 
 
702
/*!
 
703
  \brief Specify the liquid brush above the alarm threshold
 
704
  \param brush New brush. The default is solid white.
 
705
*/
 
706
void QwtThermo::setAlarmBrush(const QBrush& brush)
 
707
{
 
708
    d_data->alarmBrush = brush;
 
709
    update();
 
710
}
 
711
 
 
712
//! Return the liquid brush above the alarm threshold.
 
713
const QBrush& QwtThermo::alarmBrush() const
 
714
{
 
715
    return d_data->alarmBrush;
 
716
}
 
717
 
 
718
/*!
 
719
  \brief Specify the liquid color above the alarm threshold
 
720
  \param c New color. The default is white.
 
721
*/
 
722
void QwtThermo::setAlarmColor(const QColor &c)
 
723
{
 
724
    d_data->alarmBrush.setColor(c);
 
725
    update();
 
726
}
 
727
 
 
728
//! Return the liquid color above the alarm threshold.
 
729
const QColor &QwtThermo::alarmColor() const
 
730
{
 
731
    return d_data->alarmBrush.color();
 
732
}
 
733
 
 
734
//! Specify the alarm threshold.
 
735
void QwtThermo::setAlarmLevel(double v)
 
736
{
 
737
    d_data->alarmLevel = v;
 
738
    d_data->alarmEnabled = 1;
 
739
    update();
 
740
}
 
741
 
 
742
//! Return the alarm threshold.
 
743
double QwtThermo::alarmLevel() const
 
744
{
 
745
    return d_data->alarmLevel;
 
746
}
 
747
 
 
748
//! Change the width of the pipe.
 
749
void QwtThermo::setPipeWidth(int w)
 
750
{
 
751
    if (w > 0)
 
752
    {
 
753
        d_data->thermoWidth = w;
 
754
        layoutThermo();
 
755
    }
 
756
}
 
757
 
 
758
//! Return the width of the pipe.
 
759
int QwtThermo::pipeWidth() const
 
760
{
 
761
    return d_data->thermoWidth;
 
762
}
 
763
 
 
764
 
 
765
/*!
 
766
  \brief Specify the distance between the pipe's endpoints
 
767
         and the widget's border
 
768
 
 
769
  The margin is used to leave some space for the scale
 
770
  labels. If a large font is used, it is advisable to
 
771
  adjust the margins.
 
772
  \param m New Margin. The default values are 10 for
 
773
           horizontal orientation and 20 for vertical
 
774
           orientation.
 
775
  \warning The margin has no effect if the scale is disabled.
 
776
  \warning This function is a NOOP because margins are determined
 
777
           automatically.
 
778
*/
 
779
void QwtThermo::setMargin(int)
 
780
{
 
781
}
 
782
 
 
783
 
 
784
/*!
 
785
  \brief Enable or disable the alarm threshold
 
786
  \param tf true (disabled) or false (enabled)
 
787
*/
 
788
void QwtThermo::setAlarmEnabled(bool tf)
 
789
{
 
790
    d_data->alarmEnabled = tf;
 
791
    update();
 
792
}
 
793
 
 
794
//! Return if the alarm threshold is enabled or disabled.
 
795
bool QwtThermo::alarmEnabled() const
 
796
{
 
797
    return d_data->alarmEnabled;
 
798
}
 
799
 
 
800
/*!
 
801
  \return the minimum size hint
 
802
  \sa QwtThermo::minimumSizeHint
 
803
*/
 
804
QSize QwtThermo::sizeHint() const
 
805
{
 
806
    return minimumSizeHint();
 
807
}
 
808
 
 
809
/*!
 
810
  \brief Return a minimum size hint
 
811
  \warning The return value depends on the font and the scale.
 
812
  \sa QwtThermo::sizeHint
 
813
*/
 
814
QSize QwtThermo::minimumSizeHint() const
 
815
{
 
816
    int w = 0, h = 0;
 
817
 
 
818
    if ( d_data->scalePos != NoScale )
 
819
    {
 
820
        const int sdExtent = scaleDraw()->extent( QPen(), font() );
 
821
        const int sdLength = scaleDraw()->minLength( QPen(), font() );
 
822
 
 
823
        w = sdLength;
 
824
        h = d_data->thermoWidth + sdExtent + 
 
825
            d_data->borderWidth + d_data->scaleDist;
 
826
 
 
827
    }
 
828
    else // no scale
 
829
    {
 
830
        w = 200;
 
831
        h = d_data->thermoWidth;
 
832
    }
 
833
 
 
834
    if ( d_data->orientation == Qt::Vertical )
 
835
        qSwap(w, h);
 
836
 
 
837
    w += 2 * d_data->borderWidth;
 
838
    h += 2 * d_data->borderWidth;
 
839
 
 
840
    return QSize( w, h );
 
841
}
 
842
 
 
843
int QwtThermo::transform(double value) const
 
844
{
 
845
    const double min = qwtMin(d_data->map.s1(), d_data->map.s2());
 
846
    const double max = qwtMax(d_data->map.s1(), d_data->map.s2());
 
847
 
 
848
    if ( value > max )
 
849
        value = max;
 
850
    if ( value < min )
 
851
        value = min;
 
852
 
 
853
    return d_data->map.transform(value);
 
854
}