00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <stdio.h>
00013 #include <qpainter.h>
00014 #include "qwt_math.h"
00015 #include "qwt_painter.h"
00016 #include "qwt_scldraw.h"
00017 #include "qwt_layout_metrics.h"
00018
00019 static const double step_eps = 1.0e-6;
00020
00029 QwtScaleDraw::QwtScaleDraw():
00030 d_options(Backbone),
00031 d_hpad(4),
00032 d_vpad(4),
00033 d_medLen(6),
00034 d_majLen(8),
00035 d_minLen(4),
00036 d_minAngle(-135 * 16),
00037 d_maxAngle(135 * 16),
00038 d_fmt('g'),
00039 d_prec(4),
00040 d_fieldwidth(0),
00041 d_labelAlignment(0),
00042 d_labelRotation(0.0)
00043 {
00044
00045
00046 sprintf(d_formatBuffer, "%%%d.%d%c", d_fieldwidth, d_prec, d_fmt);
00047 setGeometry(0,0,100,Bottom);
00048 setScale(0,100,0,0,10);
00049 }
00050
00052 QwtScaleDraw::~QwtScaleDraw()
00053 {
00054 }
00055
00057 void QwtScaleDraw::setOptions(int opt)
00058 {
00059 d_options = opt;
00060 }
00061
00065 int QwtScaleDraw::options() const
00066 {
00067 return d_options;
00068 }
00069
00082 void QwtScaleDraw::setScale(double x1, double x2, int maxMajIntv,
00083 int maxMinIntv, double step, int logscale)
00084 {
00085 d_scldiv.rebuild( x1, x2, maxMajIntv, maxMinIntv, logscale, step, FALSE );
00086 setDblRange( d_scldiv.lBound(), d_scldiv.hBound(), d_scldiv.logScale());
00087 }
00088
00089
00094 void QwtScaleDraw::setScale(const QwtScaleDiv &sd)
00095 {
00096 d_scldiv = sd;
00097 setDblRange(d_scldiv.lBound(),d_scldiv.hBound(),d_scldiv.logScale());
00098 }
00099
00104 void QwtScaleDraw::draw(QPainter *p) const
00105 {
00106 uint i;
00107
00108 for (i=0; i< d_scldiv.majCnt(); i++)
00109 {
00110 const double val = d_scldiv.majMark(i);
00111 drawTick(p, val, d_majLen);
00112 drawLabel(p, val);
00113 }
00114
00115 if (d_scldiv.logScale())
00116 {
00117 for (i=0; i< d_scldiv.minCnt(); i++)
00118 drawTick(p, d_scldiv.minMark(i), d_minLen);
00119 }
00120 else
00121 {
00122 const int kmax = d_scldiv.majCnt() - 1;
00123 if (kmax > 0)
00124 {
00125 double majTick = d_scldiv.majMark(0);
00126 double hval = majTick - 0.5 * d_scldiv.majStep();
00127
00128 int k = 0;
00129 for (i=0; i< d_scldiv.minCnt(); i++)
00130 {
00131 const double val = d_scldiv.minMark(i);
00132 if (val > majTick)
00133 {
00134 if (k < kmax)
00135 {
00136 k++;
00137 majTick = d_scldiv.majMark(k);
00138 }
00139 else
00140 {
00141 majTick += d_scldiv.majMark(kmax) + d_scldiv.majStep();
00142 }
00143 hval = majTick - 0.5 * d_scldiv.majStep();
00144
00145 }
00146 if (qwtAbs(val-hval) < step_eps * d_scldiv.majStep())
00147 drawTick(p, val, d_medLen);
00148 else
00149 drawTick(p, val, d_minLen);
00150 }
00151 }
00152 }
00153
00154 if ( options() & Backbone )
00155 drawBackbone(p);
00156 }
00157
00158
00160 void QwtScaleDraw::drawTick(QPainter *p, double val, int len) const
00161 {
00162 if ( len <= 0 )
00163 return;
00164
00165 const int tval = transform(val);
00166
00167 switch(d_orient)
00168 {
00169 case Left:
00170 QwtPainter::drawLine(p, d_xorg, tval, d_xorg - len, tval);
00171 break;
00172
00173 case Right:
00174 QwtPainter::drawLine(p, d_xorg, tval, d_xorg + len, tval);
00175 break;
00176
00177 case Bottom:
00178 QwtPainter::drawLine(p, tval, d_yorg, tval, d_yorg + len);
00179 break;
00180
00181 case Top:
00182 QwtPainter::drawLine(p, tval, d_yorg, tval, d_yorg - len);
00183 break;
00184
00185 case Round:
00186 if ((tval <= d_minAngle + 359 * 16)
00187 || (tval >= d_minAngle - 359 * 16))
00188 {
00189 const double arc = double(tval) / 16.0 * M_PI / 180.0;
00190 const int x1 = qwtInt(d_xCenter + sin(arc) * d_radius);
00191 const int x2 = qwtInt(d_xCenter + sin(arc)
00192 * (d_radius + double(len)));
00193 const int y1 = qwtInt(d_yCenter - cos(arc) * d_radius);
00194 const int y2 = qwtInt(d_yCenter - cos(arc)
00195 * (d_radius + double(len)));
00196
00197 QwtPainter::drawLine(p, x1, y1, x2, y2);
00198 }
00199 break;
00200 }
00201 }
00202
00204 void QwtScaleDraw::drawLabel(QPainter *p, double val) const
00205 {
00206 QPoint pos;
00207 int alignment;
00208 double rotation;
00209 labelPlacement(QFontMetrics(p->font()), val, pos, alignment, rotation);
00210
00211 if ( alignment )
00212 {
00213 const QString txt = label(val);
00214 if ( !txt.isEmpty() )
00215 {
00216 QWMatrix m = labelWorldMatrix(QFontMetrics(p->font()),
00217 pos, alignment, rotation, txt);
00218
00219 p->save();
00220 #ifndef QT_NO_TRANSFORMATIONS
00221 p->setWorldMatrix(m, TRUE);
00222 #else
00223 p->translate(m.dx(), m.dy());
00224 #endif
00225 QwtPainter::drawText(p, 0, 0, txt);
00226 p->restore();
00227 }
00228 }
00229 }
00230
00232 void QwtScaleDraw::labelPlacement( const QFontMetrics &fm, double val,
00233 QPoint &pos, int &alignment, double &rotation) const
00234 {
00235
00236 if ((!d_scldiv.logScale())
00237 && (qwtAbs(val) < qwtAbs(step_eps * d_scldiv.majStep())))
00238 {
00239 val = 0.0;
00240 }
00241
00242 const int tval = transform(val);
00243
00244 int x = 0;
00245 int y = 0;
00246 int align = 0;
00247
00248 switch(d_orient)
00249 {
00250 case Right:
00251 {
00252 x = d_xorg + d_majLen + d_hpad + 1;
00253 y = tval;
00254 align = d_labelAlignment;
00255 if ( align == 0 )
00256 align = Qt::AlignRight | Qt::AlignVCenter;
00257 break;
00258 }
00259 case Left:
00260 {
00261 x = d_xorg - d_majLen - d_hpad - 1;
00262 y = tval;
00263 align = d_labelAlignment;
00264 if ( align == 0 )
00265 align = Qt::AlignLeft | Qt::AlignVCenter;
00266 break;
00267 }
00268 case Bottom:
00269 {
00270 x = tval;
00271 y = d_yorg + d_majLen + d_vpad + 1;
00272 align = d_labelAlignment;
00273 if ( align == 0 )
00274 align = Qt::AlignHCenter | Qt::AlignBottom;
00275 break;
00276 }
00277 case Top:
00278 {
00279 x = tval;
00280 y = d_yorg - d_majLen - d_vpad - 1;
00281 align = d_labelAlignment;
00282 if ( align == 0 )
00283 align = Qt::AlignHCenter | Qt::AlignTop;
00284 break;
00285 }
00286 case Round:
00287 {
00288 if ((tval > d_minAngle + 359 * 16)
00289 || (tval < d_minAngle - 359 * 16))
00290 {
00291 break;
00292 }
00293
00294 const int fmh = fm.ascent() - 2;
00295 const double arc = tval / 16.0 / 360.0 * 2 * M_PI;
00296 const double radius = d_radius + d_majLen + d_vpad;
00297
00298
00299
00300
00301 double xOffset = ( radius + fmh / 2 ) * sin(arc);
00302 double yOffset = ( radius + fmh / 2 ) * cos(arc);
00303
00304 if ( qwtInt(xOffset) != 0 )
00305 {
00306
00307
00308
00309
00310
00311
00312 const int fmw = fm.width(label(val));
00313
00314 const double circleX = radius * sin(arc);
00315 if ( xOffset < 0 )
00316 xOffset = circleX - fmw / 2;
00317 else
00318 xOffset = circleX + fmw / 2;
00319 }
00320 x = qwtInt(d_xCenter + xOffset);
00321 y = qwtInt(d_yCenter - yOffset);
00322 align = Qt::AlignHCenter | Qt::AlignVCenter;
00323
00324 break;
00325 }
00326 }
00327
00328 pos = QPoint(x, y);
00329 alignment = align;
00330 rotation = d_labelRotation;
00331 }
00332
00334
00335 QWMatrix QwtScaleDraw::labelWorldMatrix(const QFontMetrics &fm,
00336 const QPoint &pos, int alignment,
00337 #ifdef QT_NO_TRANSFORMATIONS
00338 double,
00339 #else
00340 double rotation,
00341 #endif
00342 const QString &txt) const
00343 {
00344 const int w = fm.boundingRect(0, 0,
00345 QCOORD_MAX, QCOORD_MAX, 0, txt).width() - 2;
00346 const int h = fm.ascent() - 2;
00347
00348 int x, y;
00349 if ( alignment & Qt::AlignLeft )
00350 x = -w;
00351 else if ( alignment & Qt::AlignRight )
00352 x = 0 - w % 2;
00353 else
00354 x = -(w / 2);
00355
00356 if ( alignment & Qt::AlignTop )
00357 y = 0;
00358 else if ( alignment & Qt::AlignBottom )
00359 y = h - 1;
00360 else
00361 y = h / 2;
00362
00363 QWMatrix m;
00364 m.translate(pos.x(), pos.y());
00365 #ifndef QT_NO_TRANSFORMATIONS
00366 m.rotate(rotation);
00367 #endif
00368 m.translate(x, y);
00369
00370 return m;
00371 }
00372
00374 void QwtScaleDraw::drawBackbone(QPainter *p) const
00375 {
00376 const int bw2 = p->pen().width() / 2;
00377
00378 switch(d_orient)
00379 {
00380 case Left:
00381 QwtPainter::drawLine(p, d_xorg - bw2,
00382 d_yorg, d_xorg - bw2, d_yorg + d_len - 1);
00383 break;
00384 case Right:
00385 QwtPainter::drawLine(p, d_xorg + bw2,
00386 d_yorg, d_xorg + bw2, d_yorg + d_len - 1);
00387 break;
00388 case Top:
00389 QwtPainter::drawLine(p, d_xorg, d_yorg - bw2,
00390 d_xorg + d_len - 1, d_yorg - bw2);
00391 break;
00392 case Bottom:
00393 QwtPainter::drawLine(p, d_xorg, d_yorg + bw2,
00394 d_xorg + d_len - 1, d_yorg + bw2);
00395 break;
00396 case Round:
00397 {
00398 const int a1 = qwtMin(i1(), i2()) - 90 * 16;
00399 const int a2 = qwtMax(i1(), i2()) - 90 * 16;
00400
00401 p->drawArc(d_xorg, d_yorg, d_len, d_len,
00402 -a2, a2 - a1 + 1);
00403 break;
00404 }
00405 }
00406 }
00407
00408
00448 void QwtScaleDraw::setGeometry(int xorigin, int yorigin,
00449 int length, Orientation o)
00450 {
00451 static int minLen = 10;
00452
00453 d_xorg = xorigin;
00454 d_yorg = yorigin;
00455 d_radius = double(length) * 0.5;
00456 d_xCenter = double(xorigin) + double(length) * 0.5;
00457 d_yCenter = double(yorigin) + double(length) * 0.5;
00458
00459 if (length > minLen)
00460 d_len = length;
00461 else
00462 d_len = minLen;
00463
00464 d_orient = o;
00465
00466 switch(d_orient)
00467 {
00468 case Left:
00469 case Right:
00470 setIntRange(d_yorg + d_len - 1, d_yorg);
00471 break;
00472 case Round:
00473 setIntRange(d_minAngle, d_maxAngle);
00474 break;
00475 case Top:
00476 case Bottom:
00477 setIntRange(d_xorg, d_xorg + d_len - 1);
00478 break;
00479 }
00480 }
00481
00487 int QwtScaleDraw::maxWidth(const QPen &pen, const QFontMetrics &fm) const
00488 {
00489 int w = 0;
00490
00491 switch (d_orient)
00492 {
00493 case Left:
00494 case Right:
00495 w += pen.width() + d_majLen + d_hpad + maxLabelWidth(fm);
00496 break;
00497 case Round:
00498 w += pen.width() + d_majLen + d_vpad + maxLabelWidth(fm);
00499 break;
00500 case Top:
00501 case Bottom:
00502 w = d_len + maxLabelWidth(fm);
00503 break;
00504 }
00505 return w;
00506 }
00507
00513 int QwtScaleDraw::maxHeight(const QPen &pen, const QFontMetrics &fm) const
00514 {
00515 int h = 0;
00516
00517 switch (d_orient)
00518 {
00519 case Top:
00520 case Bottom:
00521 h = pen.width() + d_vpad + d_majLen + maxLabelHeight(fm);
00522 break;
00523 case Left:
00524 case Right:
00525 h = d_len + maxLabelHeight(fm);
00526 break;
00527 case Round:
00528 h = d_vpad + d_majLen;
00529 if ( maxLabelHeight(fm) > 0 )
00530 h += fm.ascent() - 2;
00531 break;
00532 }
00533
00534 return h;
00535 }
00536
00546 void QwtScaleDraw::setLabelRotation(double rotation)
00547 {
00548 d_labelRotation = rotation;
00549 }
00550
00555 double QwtScaleDraw::labelRotation() const
00556 {
00557 return d_labelRotation;
00558 }
00559
00579 void QwtScaleDraw::setLabelAlignment(int alignment)
00580 {
00581 d_labelAlignment = alignment;
00582 }
00583
00588 int QwtScaleDraw::labelAlignment() const
00589 {
00590 return d_labelAlignment;
00591 }
00592
00611 void QwtScaleDraw::setAngleRange(double angle1, double angle2)
00612 {
00613 angle1 = qwtLim(angle1, -360.0, 360.0);
00614 angle2 = qwtLim(angle2, -360.0, 360.0);
00615
00616 int amin = int(floor (qwtMin(angle1, angle2) * 16.0 + 0.5));
00617 int amax = int(floor (qwtMax(angle1, angle2) * 16.0 + 0.5));
00618
00619 if (amin == amax)
00620 {
00621 amin -= 1;
00622 amax += 1;
00623 }
00624
00625 d_minAngle = amin;
00626 d_maxAngle = amax;
00627 setIntRange(d_minAngle, d_maxAngle);
00628 }
00629
00646 void QwtScaleDraw::setLabelFormat(char f, int prec, int fieldwidth)
00647 {
00648 switch(f)
00649 {
00650 case 'e':
00651 case 'f':
00652 case 'g':
00653 d_fmt = f;
00654 break;
00655 default:
00656 break;
00657 }
00658 if ((prec > -1) && (prec < 99))
00659 d_prec = prec;
00660 if ((fieldwidth > -1) && (fieldwidth < 99))
00661 d_fieldwidth = fieldwidth;
00662
00663 sprintf(d_formatBuffer, "%%%d.%d%c", d_fieldwidth, d_prec, d_fmt);
00664 }
00665
00679 void QwtScaleDraw::labelFormat(char &f, int &prec, int &fieldwidth) const
00680 {
00681 f = d_fmt;
00682 prec = d_prec;
00683 fieldwidth = d_fieldwidth;
00684 }
00685
00692 void QwtScaleDraw::setMargin(uint hMargin, uint vMargin)
00693 {
00694 d_hpad = hMargin;
00695 d_vpad = vMargin;
00696 }
00697
00701 void QwtScaleDraw::setTickLength(unsigned int minLen,
00702 unsigned int medLen, unsigned int majLen)
00703 {
00704 const unsigned int maxTickLen = 1000;
00705
00706 d_minLen = QMIN(minLen, maxTickLen);
00707 d_medLen = QMIN(medLen, maxTickLen);
00708 d_majLen = QMIN(majLen, maxTickLen);
00709 }
00710
00715 void QwtScaleDraw::tickLength(unsigned int &minLen,
00716 unsigned int &medLen, unsigned int &majLen) const
00717 {
00718 minLen = d_minLen;
00719 medLen = d_medLen;
00720 majLen = d_majLen;
00721 }
00722
00727 unsigned int QwtScaleDraw::majTickLength() const
00728 {
00729 return d_majLen;
00730 }
00731
00736 int QwtScaleDraw::maxLabelWidth(const QFontMetrics &fm) const
00737 {
00738 int maxWidth = 0;
00739
00740 for (uint i = 0; i < d_scldiv.majCnt(); i++)
00741 {
00742 double val = d_scldiv.majMark(i);
00743
00744
00745
00746 if ((!d_scldiv.logScale())
00747 && (qwtAbs(val) < step_eps * qwtAbs(d_scldiv.majStep())))
00748 {
00749 val = 0.0;
00750 }
00751
00752 const int w = labelBoundingRect(fm, val).width();
00753 if ( w > maxWidth )
00754 maxWidth = w;
00755 }
00756
00757 return maxWidth;
00758 }
00759
00764 int QwtScaleDraw::maxLabelHeight(const QFontMetrics &fm) const
00765 {
00766 int maxHeight = 0;
00767
00768 for (uint i = 0; i < d_scldiv.majCnt(); i++)
00769 {
00770 double val = d_scldiv.majMark(i);
00771
00772
00773
00774 if ((!d_scldiv.logScale())
00775 && (qwtAbs(val) < step_eps * qwtAbs(d_scldiv.majStep())))
00776 {
00777 val = 0.0;
00778 }
00779
00780 const int h = labelBoundingRect(fm, val).height();
00781 if ( h > maxHeight )
00782 maxHeight = h;
00783 }
00784
00785 return maxHeight;
00786 }
00787
00793 QRect QwtScaleDraw::labelBoundingRect(
00794 const QFontMetrics &fm, double val) const
00795 {
00796 QString zeroString;
00797 if ( d_fieldwidth > 0 )
00798 zeroString.fill('0', d_fieldwidth);
00799
00800 const QString lbl = label(val);
00801
00802 const QString &txt = fm.width(zeroString) > fm.width(lbl)
00803 ? zeroString : lbl;
00804 if ( txt.isEmpty() )
00805 return QRect(0, 0, 0, 0);
00806
00807 QRect br;
00808
00809 QPoint pos;
00810 int alignment;
00811 double rotation;
00812
00813 labelPlacement(fm, val, pos, alignment, rotation);
00814 if ( alignment )
00815 {
00816
00817 const int w = fm.boundingRect(0, 0,
00818 QCOORD_MAX, QCOORD_MAX, 0, txt).width();
00819 const int h = -(fm.ascent() - 2);
00820
00821 QWMatrix m = labelWorldMatrix(fm, pos, alignment, rotation, txt);
00822 br = QwtMetricsMap::translate(m, QRect(0, 0, w, h));
00823 br.moveBy(-pos.x(), -pos.y());
00824 }
00825
00826 return br;
00827 }
00828
00839 void QwtScaleDraw::minBorderDist(const QFontMetrics &fm,
00840 int &start, int &end ) const
00841 {
00842 start = 0;
00843 end = 0;
00844
00845 if ( d_scldiv.majCnt() > 0 )
00846 {
00847 const QRect labelRectMin = labelBoundingRect(fm, d_scldiv.majMark(0));
00848 const QRect labelRectMax = labelBoundingRect(fm,
00849 d_scldiv.majMark(d_scldiv.majCnt() - 1));
00850
00851 switch (d_orient)
00852 {
00853 case Left:
00854 case Right:
00855 end = -labelRectMin.y();
00856 start = labelRectMax.height() + labelRectMax.y();
00857 break;
00858 case Top:
00859 case Bottom:
00860 start = -labelRectMin.x();
00861 end = labelRectMax.width() + labelRectMax.x();
00862 break;
00863 case Round:
00864 start = labelRectMin.width();
00865 end = labelRectMax.width();
00866 break;
00867 }
00868 }
00869 }
00870
00880 int QwtScaleDraw::minLabelDist(const QFontMetrics &fm) const
00881 {
00882 if ( d_orient == Round )
00883 return 0;
00884
00885 if (0 == d_scldiv.majCnt())
00886 {
00887 return 0;
00888 }
00889
00890 const bool vertical = (d_orient == Left || d_orient == Right);
00891
00892 QRect bRect1;
00893 QRect bRect2 = labelBoundingRect(fm, d_scldiv.majMark(0));
00894 if ( vertical )
00895 {
00896 bRect2.setRect(-bRect2.bottom(), 0, bRect2.height(), bRect2.width());
00897 }
00898 int maxDist = 0;
00899
00900 for (uint i = 1; i < d_scldiv.majCnt(); i++ )
00901 {
00902 bRect1 = bRect2;
00903 bRect2 = labelBoundingRect(fm, d_scldiv.majMark(i));
00904 if ( vertical )
00905 {
00906 bRect2.setRect(-bRect2.bottom(), 0,
00907 bRect2.height(), bRect2.width());
00908 }
00909
00910 int dist = fm.leading();
00911 if ( bRect1.right() > 0 )
00912 dist += bRect1.right();
00913 if ( bRect2.left() < 0 )
00914 dist += -bRect2.left();
00915
00916 if ( dist > maxDist )
00917 maxDist = dist;
00918 }
00919
00920 double angle = d_labelRotation / 180.0 * M_PI;
00921 if ( vertical )
00922 angle += M_PI / 2;
00923
00924 if ( sin(angle) == 0.0 )
00925 return maxDist;
00926
00927 const int fmHeight = fm.ascent() - 2;
00928
00929
00930
00931
00932
00933 int labelDist = (int)(fmHeight / sin(angle) * cos(angle));
00934 if ( labelDist < 0 )
00935 labelDist = -labelDist;
00936
00937
00938 labelDist++;
00939
00940
00941
00942 if ( labelDist > maxDist )
00943 labelDist = maxDist;
00944
00945
00946
00947
00948 if ( labelDist < fmHeight )
00949 labelDist = fmHeight;
00950
00951 return labelDist;
00952 }
00953
00960 int QwtScaleDraw::minHeight( const QPen &pen, const QFontMetrics &fm ) const
00961 {
00962 const int pw = QMAX( 1, pen.width() );
00963
00964 int h = 0;
00965 switch ( d_orient )
00966 {
00967 case Left:
00968 case Right:
00969 {
00970 int bottomDist, topDist;
00971 minBorderDist(fm, bottomDist, topDist);
00972
00973 h = bottomDist + topDist;
00974 if ( d_scldiv.majCnt() >= 2 )
00975 h += minLabelDist(fm) * (d_scldiv.majCnt() - 1);
00976
00977 int th = 2 * (d_scldiv.majCnt() + d_scldiv.minCnt()) * pw;
00978 if ( th > h )
00979 h = th;
00980 break;
00981 }
00982 case Round:
00983
00984 h = pw + d_vpad + d_majLen + maxLabelWidth(fm);
00985 break;
00986 case Top:
00987 case Bottom:
00988 h = pw + d_vpad + d_majLen + maxLabelHeight(fm);
00989 break;
00990 }
00991 return h;
00992 }
00993
01000 int QwtScaleDraw::minWidth( const QPen &pen, const QFontMetrics &fm ) const
01001 {
01002 const int pw = QMAX( 1, pen.width() );
01003
01004 int w = 0;
01005
01006 switch(d_orient)
01007 {
01008 case Left:
01009 case Right:
01010 {
01011 w = pw + d_hpad + d_majLen + maxLabelWidth(fm);
01012 break;
01013 }
01014 case Round:
01015 {
01016 w = pw + d_vpad + d_majLen + maxLabelWidth(fm);
01017 break;
01018 }
01019 case Top:
01020 case Bottom:
01021 {
01022 int leftDist, rightDist;
01023 minBorderDist(fm, leftDist, rightDist);
01024
01025 w = leftDist + rightDist +
01026 minLabelDist(fm) * (d_scldiv.majCnt() - 1);
01027
01028 int tw = 2 * (d_scldiv.majCnt() + d_scldiv.minCnt()) * pw;
01029 if ( tw > w )
01030 w = tw;
01031
01032 break;
01033 }
01034 }
01035 return w;
01036 }
01037
01045 QString QwtScaleDraw::label(double value) const
01046 {
01047 #if 1
01048 if ( value == -0 )
01049 value = 0;
01050 #endif
01051
01052
01053
01054
01055
01056
01057 char buffer[128];
01058 sprintf(buffer, d_formatBuffer, value);
01059
01060 return QString::fromLatin1(buffer);
01061 }
01062
01064 int QwtScaleDraw::x() const
01065 {
01066 return d_xorg;
01067 }
01068
01070 int QwtScaleDraw::y() const
01071 {
01072 return d_yorg;
01073 }
01074
01076 int QwtScaleDraw::length() const
01077 {
01078 return d_len;
01079 }
01080
01082 QwtScaleDraw::Orientation QwtScaleDraw::orientation() const
01083 {
01084 return d_orient;
01085 }
01086
01087
01088
01089
01090
01091