00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include <qpainter.h>
00011 #include <qevent.h>
00012 #include <qstyle.h>
00013 #include <qpixmap.h>
00014 #include <qdrawutil.h>
00015 #include "qwt_math.h"
00016 #include "qwt_paint_buffer.h"
00017 #include "qwt_thermo.h"
00018
00020 QwtThermo::QwtThermo(QWidget *parent, const char *name):
00021 QWidget(parent, name, Qt::WRepaintNoErase|Qt::WResizeNoErase)
00022 {
00023 init();
00024 }
00025
00027 QwtThermo::~QwtThermo()
00028 {
00029 }
00030
00032 void QwtThermo::init()
00033 {
00034
00035 d_orient = Qt::Vertical;
00036 d_scalePos = Left;
00037 d_scaleDist = 3;
00038 d_thermoWidth = 10;
00039 d_borderWidth = 2;
00040 d_maxValue = 1.0;
00041 d_minValue = 0.0;
00042 d_value = 0.0;
00043 d_alarmLevel = 0.0;
00044 d_alarmEnabled = 0;
00045
00046
00047 d_fillBrush = QBrush(Qt::black);
00048 d_alarmBrush = QBrush(Qt::white);
00049
00050
00051 d_map.setDblRange(d_minValue, d_maxValue);
00052 scaleDraw()->setScale(d_minValue, d_maxValue,
00053 scaleMaxMajor(), scaleMaxMinor());
00054 }
00055
00056
00058 void QwtThermo::setValue(double v)
00059 {
00060 if (d_value != v)
00061 {
00062 d_value = v;
00063 update();
00064 }
00065 }
00066
00068 void QwtThermo::paintEvent(QPaintEvent *e)
00069 {
00070
00071 const QRect &ur = e->rect();
00072 if ( ur.isValid() )
00073 {
00074 QwtPaintBuffer paintBuffer(this, ur);
00075 draw(paintBuffer.painter(), ur);
00076 }
00077 }
00078
00080 void QwtThermo::draw(QPainter *p, const QRect& ur)
00081 {
00082 if ( !d_thermoRect.contains(ur) )
00083 {
00084 if (d_scalePos != None)
00085 scaleDraw()->draw(p);
00086
00087 qDrawShadePanel(p,
00088 d_thermoRect.x() - d_borderWidth,
00089 d_thermoRect.y() - d_borderWidth,
00090 d_thermoRect.width() + 2*d_borderWidth,
00091 d_thermoRect.height() + 2*d_borderWidth,
00092 colorGroup(), TRUE, d_borderWidth,0);
00093 }
00094 drawThermo(p);
00095 }
00096
00098 void QwtThermo::resizeEvent(QResizeEvent *)
00099 {
00100 layoutThermo( FALSE );
00101 }
00102
00109 void QwtThermo::layoutThermo( bool update_geometry )
00110 {
00111 QRect r = rect();
00112 int mbd = 0;
00113 if ( d_scalePos != None )
00114 {
00115 int d1, d2;
00116 scaleDraw()->minBorderDist(fontMetrics(), d1, d2);
00117 mbd = QMAX(d1, d2);
00118 }
00119
00120 if ( d_orient == Qt::Horizontal )
00121 {
00122 switch ( d_scalePos )
00123 {
00124 case Top:
00125 d_thermoRect.setRect(
00126 r.x() + mbd + d_borderWidth,
00127 r.y() + r.height()
00128 - d_thermoWidth - 2*d_borderWidth,
00129 r.width() - 2*(d_borderWidth + mbd),
00130 d_thermoWidth);
00131 scaleDraw()->setGeometry(
00132 d_thermoRect.x(),
00133 d_thermoRect.y() - d_borderWidth - d_scaleDist,
00134 d_thermoRect.width(),
00135 QwtScaleDraw::Top);
00136 break;
00137
00138 case Bottom:
00139 case None:
00140 default:
00141
00142
00143 d_thermoRect.setRect(
00144 r.x() + mbd + d_borderWidth,
00145 r.y() + d_borderWidth,
00146 r.width() - 2*(d_borderWidth + mbd),
00147 d_thermoWidth);
00148 scaleDraw()->setGeometry(
00149 d_thermoRect.x(),
00150 d_thermoRect.y() + d_thermoRect.height()
00151 + d_borderWidth + d_scaleDist,
00152 d_thermoRect.width(),
00153 QwtScaleDraw::Bottom);
00154 break;
00155 }
00156 d_map.setIntRange(d_thermoRect.x(),
00157 d_thermoRect.x() + d_thermoRect.width() - 1);
00158 }
00159 else
00160 {
00161 switch ( d_scalePos )
00162 {
00163 case Right:
00164 d_thermoRect.setRect(
00165 r.x() + d_borderWidth,
00166 r.y() + mbd + d_borderWidth,
00167 d_thermoWidth,
00168 r.height() - 2*(d_borderWidth + mbd));
00169 scaleDraw()->setGeometry(
00170 d_thermoRect.x() + d_thermoRect.width()
00171 + d_borderWidth + d_scaleDist,
00172 d_thermoRect.y(),
00173 d_thermoRect.height(),
00174 QwtScaleDraw::Right);
00175 break;
00176
00177 case Left:
00178 case None:
00179 default:
00180
00181
00182 d_thermoRect.setRect(
00183 r.x() + r.width() - 2*d_borderWidth - d_thermoWidth,
00184 r.y() + mbd + d_borderWidth,
00185 d_thermoWidth,
00186 r.height() - 2*(d_borderWidth + mbd));
00187 scaleDraw()->setGeometry(
00188 d_thermoRect.x() - d_scaleDist - d_borderWidth,
00189 d_thermoRect.y(),
00190 d_thermoRect.height(),
00191 QwtScaleDraw::Left);
00192 break;
00193 }
00194 d_map.setIntRange(d_thermoRect.y() + d_thermoRect.height() - 1,
00195 d_thermoRect.y());
00196 }
00197 if ( update_geometry )
00198 {
00199 updateGeometry();
00200 update();
00201 }
00202 }
00203
00220 void QwtThermo::setOrientation(Qt::Orientation o, ScalePos s)
00221 {
00222 switch(o)
00223 {
00224 case Qt::Horizontal:
00225 d_orient = Qt::Horizontal;
00226 if ((s == None) || (s == Bottom) || (s == Top))
00227 d_scalePos = s;
00228 else
00229 d_scalePos = None;
00230 break;
00231
00232 case Qt::Vertical:
00233 d_orient = Qt::Vertical;
00234 if ((s == None) || (s == Left) || (s == Right))
00235 d_scalePos = s;
00236 else
00237 d_scalePos = None;
00238 break;
00239 }
00240 layoutThermo();
00241 }
00242
00257 void QwtThermo::setScalePosition(ScalePos s)
00258 {
00259 if ((s == Bottom) || (s == Top))
00260 setOrientation(Qt::Horizontal, s);
00261 else if ((s == Left) || (s == Right))
00262 setOrientation(Qt::Vertical, s);
00263 else
00264 setOrientation(d_orient, None);
00265 }
00266
00268 QwtThermo::ScalePos QwtThermo::scalePosition() const
00269 {
00270 return d_scalePos;
00271 }
00272
00274 void QwtThermo::fontChange(const QFont &f)
00275 {
00276 QWidget::fontChange( f );
00277 layoutThermo();
00278 }
00279
00281 void QwtThermo::scaleChange()
00282 {
00283 update();
00284 layoutThermo();
00285 }
00286
00288 void QwtThermo::drawThermo(QPainter *p)
00289 {
00290 int alarm = 0, taval = 0;
00291
00292 QRect fRect;
00293 QRect aRect;
00294 QRect bRect;
00295
00296 int inverted = ( d_maxValue < d_minValue );
00297
00298
00299
00300
00301
00302
00303 if (d_alarmEnabled)
00304 {
00305 if (inverted)
00306 {
00307 alarm = ((d_alarmLevel >= d_maxValue)
00308 && (d_alarmLevel <= d_minValue)
00309 && (d_value >= d_alarmLevel));
00310
00311 }
00312 else
00313 {
00314 alarm = (( d_alarmLevel >= d_minValue)
00315 && (d_alarmLevel <= d_maxValue)
00316 && (d_value >= d_alarmLevel));
00317 }
00318 }
00319
00320
00321
00322
00323 int tval = d_map.limTransform(d_value);
00324
00325 if (alarm)
00326 taval = d_map.limTransform(d_alarmLevel);
00327
00328
00329
00330
00331 if ( d_orient == Qt::Horizontal )
00332 {
00333 if (inverted)
00334 {
00335 bRect.setRect(d_thermoRect.x(), d_thermoRect.y(),
00336 tval - d_thermoRect.x(),
00337 d_thermoRect.height());
00338
00339 if (alarm)
00340 {
00341 aRect.setRect(tval, d_thermoRect.y(),
00342 taval - tval + 1,
00343 d_thermoRect.height());
00344 fRect.setRect(taval + 1, d_thermoRect.y(),
00345 d_thermoRect.x() + d_thermoRect.width() - (taval + 1),
00346 d_thermoRect.height());
00347 }
00348 else
00349 {
00350 fRect.setRect(tval, d_thermoRect.y(),
00351 d_thermoRect.x() + d_thermoRect.width() - tval,
00352 d_thermoRect.height());
00353 }
00354 }
00355 else
00356 {
00357 bRect.setRect(tval + 1, d_thermoRect.y(),
00358 d_thermoRect.width() - (tval + 1 - d_thermoRect.x()),
00359 d_thermoRect.height());
00360
00361 if (alarm)
00362 {
00363 aRect.setRect(taval, d_thermoRect.y(),
00364 tval - taval + 1,
00365 d_thermoRect.height());
00366 fRect.setRect(d_thermoRect.x(), d_thermoRect.y(),
00367 taval - d_thermoRect.x(),
00368 d_thermoRect.height());
00369 }
00370 else
00371 {
00372 fRect.setRect(d_thermoRect.x(), d_thermoRect.y(),
00373 tval - d_thermoRect.x() + 1,
00374 d_thermoRect.height());
00375 }
00376
00377 }
00378 }
00379 else
00380 {
00381 if (tval < d_thermoRect.y())
00382 tval = d_thermoRect.y();
00383 else
00384 {
00385 if (tval > d_thermoRect.y() + d_thermoRect.height())
00386 tval = d_thermoRect.y() + d_thermoRect.height();
00387 }
00388
00389 if (inverted)
00390 {
00391 bRect.setRect(d_thermoRect.x(), tval + 1,
00392 d_thermoRect.width(),
00393 d_thermoRect.height() - (tval + 1 - d_thermoRect.y()));
00394
00395 if (alarm)
00396 {
00397 aRect.setRect(d_thermoRect.x(), taval,
00398 d_thermoRect.width(),
00399 tval - taval + 1);
00400 fRect.setRect(d_thermoRect.x(), d_thermoRect.y(),
00401 d_thermoRect.width(),
00402 taval - d_thermoRect.y());
00403 }
00404 else
00405 {
00406 fRect.setRect(d_thermoRect.x(), d_thermoRect.y(),
00407 d_thermoRect.width(),
00408 tval - d_thermoRect.y() + 1);
00409 }
00410 }
00411 else
00412 {
00413 bRect.setRect(d_thermoRect.x(), d_thermoRect.y(),
00414 d_thermoRect.width(),
00415 tval - d_thermoRect.y());
00416 if (alarm)
00417 {
00418 aRect.setRect(d_thermoRect.x(),tval,
00419 d_thermoRect.width(),
00420 taval - tval + 1);
00421 fRect.setRect(d_thermoRect.x(),taval + 1,
00422 d_thermoRect.width(),
00423 d_thermoRect.y() + d_thermoRect.height() - (taval + 1));
00424 }
00425 else
00426 {
00427 fRect.setRect(d_thermoRect.x(),tval,
00428 d_thermoRect.width(),
00429 d_thermoRect.y() + d_thermoRect.height() - tval);
00430 }
00431 }
00432 }
00433
00434
00435
00436
00437 p->fillRect(bRect, colorGroup().color(QColorGroup::Background));
00438
00439 if (alarm)
00440 p->fillRect(aRect, d_alarmBrush);
00441
00442 p->fillRect(fRect, d_fillBrush);
00443 }
00444
00446 void QwtThermo::setBorderWidth(int w)
00447 {
00448 if ((w >= 0) && (w < (qwtMin(d_thermoRect.width(),
00449 d_thermoRect.height()) + d_borderWidth) / 2 - 1))
00450 {
00451 d_borderWidth = w;
00452 layoutThermo();
00453 }
00454 }
00455
00457 int QwtThermo::borderWidth() const
00458 {
00459 return d_borderWidth;
00460 }
00461
00468 void QwtThermo::setRange(double vmin, double vmax, bool logarithmic)
00469 {
00470 d_minValue = vmin;
00471 d_maxValue = vmax;
00472
00473 d_map.setDblRange(d_minValue, d_maxValue, logarithmic);
00474 if (!hasUserScale())
00475 {
00476 QwtScaleDiv oldscl(scaleDraw()->scaleDiv());
00477
00478 scaleDraw()->setScale(d_minValue, d_maxValue,
00479 scaleMaxMajor(), scaleMaxMinor(), 0.0, logarithmic);
00480 if (oldscl != scaleDraw()->scaleDiv())
00481 scaleChange();
00482 }
00483 layoutThermo();
00484 }
00485
00490 void QwtThermo::setFillBrush(const QBrush& b)
00491 {
00492 d_fillBrush = b;
00493 update();
00494 }
00495
00497 const QBrush& QwtThermo::fillBrush() const
00498 {
00499 return d_fillBrush;
00500 }
00501
00506 void QwtThermo::setFillColor(const QColor &c)
00507 {
00508 d_fillBrush.setColor(c);
00509 update();
00510 }
00511
00513 const QColor &QwtThermo::fillColor() const
00514 {
00515 return d_fillBrush.color();
00516 }
00517
00522 void QwtThermo::setAlarmBrush(const QBrush& b)
00523 {
00524 d_alarmBrush = b;
00525 update();
00526 }
00527
00529 const QBrush& QwtThermo::alarmBrush() const
00530 {
00531 return d_alarmBrush;
00532 }
00533
00538 void QwtThermo::setAlarmColor(const QColor &c)
00539 {
00540 d_alarmBrush.setColor(c);
00541 update();
00542 }
00543
00545 const QColor &QwtThermo::alarmColor() const
00546 {
00547 return d_alarmBrush.color();
00548 }
00549
00551 void QwtThermo::setAlarmLevel(double v)
00552 {
00553 d_alarmLevel = v;
00554 d_alarmEnabled = 1;
00555 update();
00556 }
00557
00559 double QwtThermo::alarmLevel() const
00560 {
00561 return d_alarmLevel;
00562 }
00563
00565 void QwtThermo::setPipeWidth(int w)
00566 {
00567 if (w > 0)
00568 {
00569 d_thermoWidth = w;
00570 layoutThermo();
00571 }
00572 }
00573
00575 int QwtThermo::pipeWidth() const
00576 {
00577 return d_thermoWidth;
00578 }
00579
00580
00595 void QwtThermo::setMargin(int)
00596 {
00597 }
00598
00599
00604 void QwtThermo::setAlarmEnabled(bool tf)
00605 {
00606 d_alarmEnabled = tf;
00607 update();
00608 }
00609
00611 bool QwtThermo::alarmEnabled() const
00612 {
00613 return d_alarmEnabled;
00614 }
00615
00621 QSizePolicy QwtThermo::sizePolicy() const
00622 {
00623 QSizePolicy sp;
00624 if ( scaleDraw()->orientation() == QwtScaleDraw::Left ||
00625 scaleDraw()->orientation() == QwtScaleDraw::Right )
00626 {
00627 sp.setHorData( QSizePolicy::Fixed );
00628 sp.setVerData( QSizePolicy::MinimumExpanding );
00629 }
00630 else
00631 {
00632 sp.setHorData( QSizePolicy::MinimumExpanding );
00633 sp.setVerData( QSizePolicy::Fixed );
00634 }
00635 return sp;
00636 }
00637
00642 QSize QwtThermo::sizeHint() const
00643 {
00644 return minimumSizeHint();
00645 }
00646
00652 QSize QwtThermo::minimumSizeHint() const
00653 {
00654 int w = 0, h = 0;
00655
00656 if ( d_scalePos != None )
00657 {
00658 int smw = scaleDraw()->minWidth( QPen(), fontMetrics() );
00659 int smh = scaleDraw()->minHeight( QPen(), fontMetrics() );
00660
00661 if ( d_orient == Qt::Vertical )
00662 {
00663 w = d_thermoWidth + smw + 3 * d_borderWidth + d_scaleDist;
00664 h = smh + 2 * d_borderWidth;
00665 }
00666 else
00667 {
00668 w = smw + 2 * d_borderWidth;
00669 h = d_thermoWidth + smh + 3 * d_borderWidth + d_scaleDist;
00670 }
00671
00672 }
00673 else
00674 {
00675 if ( d_orient == Qt::Vertical )
00676 {
00677 w = d_thermoWidth + 2 * d_borderWidth;
00678 h = 200 + 2 * d_borderWidth;
00679 }
00680 else
00681 {
00682 w = 200 + 2 * d_borderWidth;
00683 h = d_thermoWidth + 2 * d_borderWidth;
00684 }
00685 }
00686 return QSize( w, h );
00687 }
00688
00689
00690
00691
00692
00693