| Line | Source | Count | 
| 1 |  | - | 
| 2 |  | - | 
| 3 |  | - | 
| 4 |  | - | 
| 5 | class QLCDNumberPrivate : public QFramePrivate | - | 
| 6 | { | - | 
| 7 |     inline QLCDNumber* q_func() { return static_cast<QLCDNumber *>(q_ptr); } inline const QLCDNumber* q_func() const { return static_cast<const QLCDNumber *>(q_ptr); } friend class QLCDNumber; | - | 
| 8 | public: | - | 
| 9 |     void init(); | - | 
| 10 |     void internalSetString(const QString& s); | - | 
| 11 |     void drawString(const QString& s, QPainter &, QBitArray * = 0, bool = true); | - | 
| 12 |  | - | 
| 13 |     void drawDigit(const QPoint &, QPainter &, int, char, char = ' '); | - | 
| 14 |     void drawSegment(const QPoint &, char, QPainter &, int, bool = false); | - | 
| 15 |  | - | 
| 16 |     int ndigits; | - | 
| 17 |     double val; | - | 
| 18 |     uint base : 2; | - | 
| 19 |     uint smallPoint : 1; | - | 
| 20 |     uint fill : 1; | - | 
| 21 |     uint shadow : 1; | - | 
| 22 |     QString digitStr; | - | 
| 23 |     QBitArray points; | - | 
| 24 | }; | - | 
| 25 | static QString int2string(int num, int base, int ndigits, bool *oflow) | - | 
| 26 | { | - | 
| 27 |     QString s; | - | 
| 28 |     bool negative; | - | 
| 29 |     if (num < 0) { | - | 
| 30 |         negative = true; | - | 
| 31 |         num = -num; | - | 
| 32 |     } else { | - | 
| 33 |         negative = false; | - | 
| 34 |     } | - | 
| 35 |     switch(base) { | - | 
| 36 |         case QLCDNumber::Hex: | - | 
| 37 |             s = QString::asprintf("%*x", ndigits, num); | - | 
| 38 |             break; | - | 
| 39 |         case QLCDNumber::Dec: | - | 
| 40 |             s = QString::asprintf("%*i", ndigits, num); | - | 
| 41 |             break; | - | 
| 42 |         case QLCDNumber::Oct: | - | 
| 43 |             s = QString::asprintf("%*o", ndigits, num); | - | 
| 44 |             break; | - | 
| 45 |         case QLCDNumber::Bin: | - | 
| 46 |             { | - | 
| 47 |                 char buf[42]; | - | 
| 48 |                 char *p = &buf[41]; | - | 
| 49 |                 uint n = num; | - | 
| 50 |                 int len = 0; | - | 
| 51 |                 *p = '\0'; | - | 
| 52 |                 do { | - | 
| 53 |                     *--p = (char)((n&1)+'0'); | - | 
| 54 |                     n >>= 1; | - | 
| 55 |                     len++; | - | 
| 56 |                 } while (n != 0); | - | 
| 57 |                 len = ndigits - len; | - | 
| 58 |                 if (len > 0) | - | 
| 59 |                 s.fill(QLatin1Char(' '), len); | - | 
| 60 |                 s += QString::fromLatin1(p); | - | 
| 61 |             } | - | 
| 62 |             break; | - | 
| 63 |     } | - | 
| 64 |     if (negative) { | - | 
| 65 |         for (int i=0; i<(int)s.length(); i++) { | - | 
| 66 |             if (s[i] != QLatin1Char(' ')) { | - | 
| 67 |                 if (i != 0) { | - | 
| 68 |                     s[i-1] = QLatin1Char('-'); | - | 
| 69 |                 } else { | - | 
| 70 |                     s.insert(0, QLatin1Char('-')); | - | 
| 71 |                 } | - | 
| 72 |                 break; | - | 
| 73 |             } | - | 
| 74 |         } | - | 
| 75 |     } | - | 
| 76 |     if (oflow) | - | 
| 77 |         *oflow = (int)s.length() > ndigits; | - | 
| 78 |     return s; | - | 
| 79 | } | - | 
| 80 |  | - | 
| 81 |  | - | 
| 82 | static QString double2string(double num, int base, int ndigits, bool *oflow) | - | 
| 83 | { | - | 
| 84 |     QString s; | - | 
| 85 |     if (base != QLCDNumber::Dec) { | - | 
| 86 |         bool of = num >= 2147483648.0 || num < -2147483648.0; | - | 
| 87 |         if (of) { | - | 
| 88 |             if (oflow) | - | 
| 89 |                 *oflow = true; | - | 
| 90 |             return s; | - | 
| 91 |         } | - | 
| 92 |         s = int2string((int)num, base, ndigits, 0); | - | 
| 93 |     } else { | - | 
| 94 |         int nd = ndigits; | - | 
| 95 |         do { | - | 
| 96 |             s = QString::asprintf("%*.*g", ndigits, nd, num); | - | 
| 97 |             int i = s.indexOf(QLatin1Char('e')); | - | 
| 98 |             if (i > 0 && s[i+1]==QLatin1Char('+')) { | - | 
| 99 |                 s[i] = QLatin1Char(' '); | - | 
| 100 |                 s[i+1] = QLatin1Char('e'); | - | 
| 101 |             } | - | 
| 102 |         } while (nd-- && (int)s.length() > ndigits); | - | 
| 103 |     } | - | 
| 104 |     if (oflow) | - | 
| 105 |         *oflow = (int)s.length() > ndigits; | - | 
| 106 |     return s; | - | 
| 107 | } | - | 
| 108 |  | - | 
| 109 |  | - | 
| 110 | static const char *getSegments(char ch) | - | 
| 111 | { | - | 
| 112 |     static const char segments[30][8] = | - | 
| 113 |        { { 0, 1, 2, 4, 5, 6,99, 0}, | - | 
| 114 |          { 2, 5,99, 0, 0, 0, 0, 0}, | - | 
| 115 |          { 0, 2, 3, 4, 6,99, 0, 0}, | - | 
| 116 |          { 0, 2, 3, 5, 6,99, 0, 0}, | - | 
| 117 |          { 1, 2, 3, 5,99, 0, 0, 0}, | - | 
| 118 |          { 0, 1, 3, 5, 6,99, 0, 0}, | - | 
| 119 |          { 0, 1, 3, 4, 5, 6,99, 0}, | - | 
| 120 |          { 0, 2, 5,99, 0, 0, 0, 0}, | - | 
| 121 |          { 0, 1, 2, 3, 4, 5, 6,99}, | - | 
| 122 |          { 0, 1, 2, 3, 5, 6,99, 0}, | - | 
| 123 |          { 3,99, 0, 0, 0, 0, 0, 0}, | - | 
| 124 |          { 7,99, 0, 0, 0, 0, 0, 0}, | - | 
| 125 |          { 0, 1, 2, 3, 4, 5,99, 0}, | - | 
| 126 |          { 1, 3, 4, 5, 6,99, 0, 0}, | - | 
| 127 |          { 0, 1, 4, 6,99, 0, 0, 0}, | - | 
| 128 |          { 2, 3, 4, 5, 6,99, 0, 0}, | - | 
| 129 |          { 0, 1, 3, 4, 6,99, 0, 0}, | - | 
| 130 |          { 0, 1, 3, 4,99, 0, 0, 0}, | - | 
| 131 |          { 1, 3, 4, 5,99, 0, 0, 0}, | - | 
| 132 |          { 1, 2, 3, 4, 5,99, 0, 0}, | - | 
| 133 |          { 1, 4, 6,99, 0, 0, 0, 0}, | - | 
| 134 |          { 3, 4, 5, 6,99, 0, 0, 0}, | - | 
| 135 |          { 0, 1, 2, 3, 4,99, 0, 0}, | - | 
| 136 |          { 3, 4,99, 0, 0, 0, 0, 0}, | - | 
| 137 |          { 4, 5, 6,99, 0, 0, 0, 0}, | - | 
| 138 |          { 1, 2, 4, 5, 6,99, 0, 0}, | - | 
| 139 |          { 1, 2, 3, 5, 6,99, 0, 0}, | - | 
| 140 |          { 8, 9,99, 0, 0, 0, 0, 0}, | - | 
| 141 |          { 0, 1, 2, 3,99, 0, 0, 0}, | - | 
| 142 |          {99, 0, 0, 0, 0, 0, 0, 0} }; | - | 
| 143 |  | - | 
| 144 |     if (ch >= '0' && ch <= '9') | - | 
| 145 |         return segments[ch - '0']; | - | 
| 146 |     if (ch >= 'A' && ch <= 'F') | - | 
| 147 |         return segments[ch - 'A' + 12]; | - | 
| 148 |     if (ch >= 'a' && ch <= 'f') | - | 
| 149 |         return segments[ch - 'a' + 12]; | - | 
| 150 |  | - | 
| 151 |     int n; | - | 
| 152 |     switch (ch) { | - | 
| 153 |         case '-': | - | 
| 154 |             n = 10; break; | - | 
| 155 |         case 'O': | - | 
| 156 |             n = 0; break; | - | 
| 157 |         case 'g': | - | 
| 158 |             n = 9; break; | - | 
| 159 |         case '.': | - | 
| 160 |             n = 11; break; | - | 
| 161 |         case 'h': | - | 
| 162 |             n = 18; break; | - | 
| 163 |         case 'H': | - | 
| 164 |             n = 19; break; | - | 
| 165 |         case 'l': | - | 
| 166 |         case 'L': | - | 
| 167 |             n = 20; break; | - | 
| 168 |         case 'o': | - | 
| 169 |             n = 21; break; | - | 
| 170 |         case 'p': | - | 
| 171 |         case 'P': | - | 
| 172 |             n = 22; break; | - | 
| 173 |         case 'r': | - | 
| 174 |         case 'R': | - | 
| 175 |             n = 23; break; | - | 
| 176 |         case 's': | - | 
| 177 |         case 'S': | - | 
| 178 |             n = 5; break; | - | 
| 179 |         case 'u': | - | 
| 180 |             n = 24; break; | - | 
| 181 |         case 'U': | - | 
| 182 |             n = 25; break; | - | 
| 183 |         case 'y': | - | 
| 184 |         case 'Y': | - | 
| 185 |             n = 26; break; | - | 
| 186 |         case ':': | - | 
| 187 |             n = 27; break; | - | 
| 188 |         case '\'': | - | 
| 189 |             n = 28; break; | - | 
| 190 |         default: | - | 
| 191 |             n = 29; break; | - | 
| 192 |     } | - | 
| 193 |     return segments[n]; | - | 
| 194 | } | - | 
| 195 | QLCDNumber::QLCDNumber(QWidget *parent) | - | 
| 196 |         : QFrame(*new QLCDNumberPrivate, parent) | - | 
| 197 | { | - | 
| 198 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 199 |     d->ndigits = 5; | - | 
| 200 |     d->init(); | - | 
| 201 | } | - | 
| 202 | QLCDNumber::QLCDNumber(uint numDigits, QWidget *parent) | - | 
| 203 |         : QFrame(*new QLCDNumberPrivate, parent) | - | 
| 204 | { | - | 
| 205 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 206 |     d->ndigits = numDigits; | - | 
| 207 |     d->init(); | - | 
| 208 | } | - | 
| 209 |  | - | 
| 210 | void QLCDNumberPrivate::init() | - | 
| 211 | { | - | 
| 212 |     QLCDNumber * const q = q_func(); | - | 
| 213 |  | - | 
| 214 |     q->setFrameStyle(QFrame::Box | QFrame::Raised); | - | 
| 215 |     val = 0; | - | 
| 216 |     base = QLCDNumber::Dec; | - | 
| 217 |     smallPoint = false; | - | 
| 218 |     q->setDigitCount(ndigits); | - | 
| 219 |     q->setSegmentStyle(QLCDNumber::Filled); | - | 
| 220 |     q->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum)); | - | 
| 221 | } | - | 
| 222 |  | - | 
| 223 |  | - | 
| 224 |  | - | 
| 225 |  | - | 
| 226 |  | - | 
| 227 | QLCDNumber::~QLCDNumber() | - | 
| 228 | { | - | 
| 229 | } | - | 
| 230 | void QLCDNumber::setDigitCount(int numDigits) | - | 
| 231 | { | - | 
| 232 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 233 |     if (__builtin_expect(!!(| TRUE | never evaluated |  | FALSE | never evaluated |  
  numDigits > 99)), false)| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 234 |         QMessageLogger(__FILE__, 406412, __PRETTY_FUNCTION__).warning("QLCDNumber::setNumDigits: (%s) Max 99 digits allowed", | - | 
| 235 |                  objectName().toLocal8Bit().constData()); | - | 
| 236 |         numDigits = 99; | - | 
| 237 |     } never executed: end of block  | 0 | 
| 238 |     if (__builtin_expect(!!(| TRUE | never evaluated |  | FALSE | never evaluated |  
  numDigits < 0)), false)| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 239 |         QMessageLogger(__FILE__, 411417, __PRETTY_FUNCTION__).warning("QLCDNumber::setNumDigits: (%s) Min 0 digits allowed", | - | 
| 240 |                  objectName().toLocal8Bit().constData()); | - | 
| 241 |         numDigits = 0; | - | 
| 242 |     } never executed: end of block  | 0 | 
| 243 |     if (d->digitStr.isNull()| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 244 |         d->ndigits = numDigits; | - | 
| 245 |         d->digitStr.fill(QLatin1Char(' '), d->ndigits); | - | 
| 246 |         d->points.fill(0, d->ndigits); | - | 
| 247 |         d->digitStr[d->ndigits - 1] = QLatin1Char('0'); | - | 
| 248 |     } never executed: end of block  else { | 0 | 
| 249 |         bool doDisplay = d->ndigits == 0; | - | 
| 250 |         if (numDigits == d->ndigits| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) | 0 | 
| 251 |             return; never executed: return;  | 0 | 
| 252 |         int i; | - | 
| 253 |         int dif; | - | 
| 254 |         if (numDigits > d->ndigits| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) { | 0 | 
| 255 |             dif = numDigits - d->ndigits; | - | 
| 256 |             QString buf; | - | 
| 257 |             buf.fill(QLatin1Char(' '), dif); | - | 
| 258 |             d->digitStr.insert(0, buf); | - | 
| 259 |             d->points.resize(numDigits); | - | 
| 260 |             for (i=numDigits-1; i>=dif| TRUE | never evaluated |  | FALSE | never evaluated |  
  ; i--) | 0 | 
| 261 |                 d->points.setBit(i, d->points.testBit(i-dif)); never executed: d->points.setBit(i, d->points.testBit(i-dif));  | 0 | 
| 262 |             for (i=0; i<dif| TRUE | never evaluated |  | FALSE | never evaluated |  
  ; i++) | 0 | 
| 263 |                 d->points.clearBit(i); never executed: d->points.clearBit(i);  | 0 | 
| 264 |         } never executed: end of block  else { | 0 | 
| 265 |             dif = d->ndigits - numDigits; | - | 
| 266 |             d->digitStr = d->digitStr.right(numDigits); | - | 
| 267 |             QBitArray tmpPoints = d->points; | - | 
| 268 |             d->points.resize(numDigits); | - | 
| 269 |             for (i=0; i<(int)numDigits| TRUE | never evaluated |  | FALSE | never evaluated |  
  ; i++) | 0 | 
| 270 |                 d->points.setBit(i, tmpPoints.testBit(i+dif)); never executed: d->points.setBit(i, tmpPoints.testBit(i+dif));  | 0 | 
| 271 |         } never executed: end of block  | 0 | 
| 272 |         d->ndigits = numDigits; | - | 
| 273 |         if (doDisplay| TRUE | never evaluated |  | FALSE | never evaluated |  
  ) | 0 | 
| 274 |             display(value()); never executed: display(value());  | 0 | 
| 275 |         update(); | - | 
| 276 |     } never executed: end of block  | 0 | 
| 277 | } | - | 
| 278 |  | - | 
| 279 |  | - | 
| 280 |  | - | 
| 281 |  | - | 
| 282 | int QLCDNumber::digitCount() const | - | 
| 283 | { | - | 
| 284 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 285 |     return d->ndigits; | - | 
| 286 | } | - | 
| 287 | bool QLCDNumber::checkOverflow(int num) const | - | 
| 288 | { | - | 
| 289 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 290 |     bool of; | - | 
| 291 |     int2string(num, d->base, d->ndigits, &of); | - | 
| 292 |     return of; | - | 
| 293 | } | - | 
| 294 | bool QLCDNumber::checkOverflow(double num) const | - | 
| 295 | { | - | 
| 296 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 297 |     bool of; | - | 
| 298 |     double2string(num, d->base, d->ndigits, &of); | - | 
| 299 |     return of; | - | 
| 300 | } | - | 
| 301 | QLCDNumber::Mode QLCDNumber::mode() const | - | 
| 302 | { | - | 
| 303 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 304 |     return (QLCDNumber::Mode) d->base; | - | 
| 305 | } | - | 
| 306 |  | - | 
| 307 | void QLCDNumber::setMode(Mode m) | - | 
| 308 | { | - | 
| 309 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 310 |     d->base = m; | - | 
| 311 |     display(d->val); | - | 
| 312 | } | - | 
| 313 | double QLCDNumber::value() const | - | 
| 314 | { | - | 
| 315 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 316 |     return d->val; | - | 
| 317 | } | - | 
| 318 |  | - | 
| 319 |  | - | 
| 320 |  | - | 
| 321 |  | - | 
| 322 |  | - | 
| 323 |  | - | 
| 324 | void QLCDNumber::display(double num) | - | 
| 325 | { | - | 
| 326 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 327 |     d->val = num; | - | 
| 328 |     bool of; | - | 
| 329 |     QString s = double2string(d->val, d->base, d->ndigits, &of); | - | 
| 330 |     if (of) | - | 
| 331 |         overflow(); | - | 
| 332 |     else | - | 
| 333 |         d->internalSetString(s); | - | 
| 334 | } | - | 
| 335 | int QLCDNumber::intValue() const | - | 
| 336 | { | - | 
| 337 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 338 |     return qRound(d->val); | - | 
| 339 | } | - | 
| 340 |  | - | 
| 341 |  | - | 
| 342 |  | - | 
| 343 |  | - | 
| 344 |  | - | 
| 345 |  | - | 
| 346 |  | - | 
| 347 | void QLCDNumber::display(int num) | - | 
| 348 | { | - | 
| 349 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 350 |     d->val = (double)num; | - | 
| 351 |     bool of; | - | 
| 352 |     QString s = int2string(num, d->base, d->ndigits, &of); | - | 
| 353 |     if (of) | - | 
| 354 |         overflow(); | - | 
| 355 |     else | - | 
| 356 |         d->internalSetString(s); | - | 
| 357 | } | - | 
| 358 | void QLCDNumber::display(const QString &s) | - | 
| 359 | { | - | 
| 360 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 361 |     d->val = 0; | - | 
| 362 |     bool ok = false; | - | 
| 363 |     double v = s.toDouble(&ok); | - | 
| 364 |     if (ok) | - | 
| 365 |         d->val = v; | - | 
| 366 |     d->internalSetString(s); | - | 
| 367 | } | - | 
| 368 | void QLCDNumber::setHexMode() | - | 
| 369 | { | - | 
| 370 |     setMode(Hex); | - | 
| 371 | } | - | 
| 372 | void QLCDNumber::setDecMode() | - | 
| 373 | { | - | 
| 374 |     setMode(Dec); | - | 
| 375 | } | - | 
| 376 | void QLCDNumber::setOctMode() | - | 
| 377 | { | - | 
| 378 |     setMode(Oct); | - | 
| 379 | } | - | 
| 380 | void QLCDNumber::setBinMode() | - | 
| 381 | { | - | 
| 382 |     setMode(Bin); | - | 
| 383 | } | - | 
| 384 | void QLCDNumber::setSmallDecimalPoint(bool b) | - | 
| 385 | { | - | 
| 386 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 387 |     d->smallPoint = b; | - | 
| 388 |     update(); | - | 
| 389 | } | - | 
| 390 |  | - | 
| 391 | bool QLCDNumber::smallDecimalPoint() const | - | 
| 392 | { | - | 
| 393 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 394 |     return d->smallPoint; | - | 
| 395 | } | - | 
| 396 |  | - | 
| 397 |  | - | 
| 398 |  | - | 
| 399 |  | - | 
| 400 |  | - | 
| 401 |  | - | 
| 402 |  | - | 
| 403 | void QLCDNumber::paintEvent(QPaintEvent *) | - | 
| 404 | { | - | 
| 405 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 406 |     QPainter p(this); | - | 
| 407 |     drawFrame(&p); | - | 
| 408 |     p.setRenderHint(QPainter::Antialiasing); | - | 
| 409 |     if (d->shadow) | - | 
| 410 |         p.translate(0.5, 0.5); | - | 
| 411 |  | - | 
| 412 |     if (d->smallPoint) | - | 
| 413 |         d->drawString(d->digitStr, p, &d->points, false); | - | 
| 414 |     else | - | 
| 415 |         d->drawString(d->digitStr, p, 0, false); | - | 
| 416 | } | - | 
| 417 |  | - | 
| 418 |  | - | 
| 419 | void QLCDNumberPrivate::internalSetString(const QString& s) | - | 
| 420 | { | - | 
| 421 |     QLCDNumber * const q = q_func(); | - | 
| 422 |     QString buffer; | - | 
| 423 |     int i; | - | 
| 424 |     int len = s.length(); | - | 
| 425 |     QBitArray newPoints(ndigits); | - | 
| 426 |  | - | 
| 427 |     if (!smallPoint) { | - | 
| 428 |         if (len == ndigits) | - | 
| 429 |             buffer = s; | - | 
| 430 |         else | - | 
| 431 |             buffer = s.right(ndigits).rightJustified(ndigits, QLatin1Char(' ')); | - | 
| 432 |     } else { | - | 
| 433 |         int index = -1; | - | 
| 434 |         bool lastWasPoint = true; | - | 
| 435 |         newPoints.clearBit(0); | - | 
| 436 |         for (i=0; i<len; i++) { | - | 
| 437 |             if (s[i] == QLatin1Char('.')) { | - | 
| 438 |                 if (lastWasPoint) { | - | 
| 439 |                     if (index == ndigits - 1) | - | 
| 440 |                         break; | - | 
| 441 |                     index++; | - | 
| 442 |                     buffer[index] = QLatin1Char(' '); | - | 
| 443 |                 } | - | 
| 444 |                 newPoints.setBit(index); | - | 
| 445 |                 lastWasPoint = true; | - | 
| 446 |             } else { | - | 
| 447 |                 if (index == ndigits - 1) | - | 
| 448 |                     break; | - | 
| 449 |                 index++; | - | 
| 450 |                 buffer[index] = s[i]; | - | 
| 451 |                 newPoints.clearBit(index); | - | 
| 452 |                 lastWasPoint = false; | - | 
| 453 |             } | - | 
| 454 |         } | - | 
| 455 |         if (index < ((int) ndigits) - 1) { | - | 
| 456 |             for(i=index; i>=0; i--) { | - | 
| 457 |                 buffer[ndigits - 1 - index + i] = buffer[i]; | - | 
| 458 |                 newPoints.setBit(ndigits - 1 - index + i, | - | 
| 459 |                                    newPoints.testBit(i)); | - | 
| 460 |             } | - | 
| 461 |             for(i=0; i<ndigits-index-1; i++) { | - | 
| 462 |                 buffer[i] = QLatin1Char(' '); | - | 
| 463 |                 newPoints.clearBit(i); | - | 
| 464 |             } | - | 
| 465 |         } | - | 
| 466 |     } | - | 
| 467 |  | - | 
| 468 |     if (buffer == digitStr) | - | 
| 469 |         return; | - | 
| 470 |  | - | 
| 471 |     digitStr = buffer; | - | 
| 472 |     if (smallPoint) | - | 
| 473 |         points = newPoints; | - | 
| 474 |     q->update(); | - | 
| 475 | } | - | 
| 476 |  | - | 
| 477 |  | - | 
| 478 |  | - | 
| 479 |  | - | 
| 480 |  | - | 
| 481 | void QLCDNumberPrivate::drawString(const QString &s, QPainter &p, | - | 
| 482 |                                    QBitArray *newPoints, bool newString) | - | 
| 483 | { | - | 
| 484 |     QLCDNumber * const q = q_func(); | - | 
| 485 |     QPoint pos; | - | 
| 486 |  | - | 
| 487 |     int digitSpace = smallPoint ? 2 : 1; | - | 
| 488 |     int xSegLen = q->width()*5/(ndigits*(5 + digitSpace) + digitSpace); | - | 
| 489 |     int ySegLen = q->height()*5/12; | - | 
| 490 |     int segLen = ySegLen > xSegLen ? xSegLen : ySegLen; | - | 
| 491 |     int xAdvance = segLen*(5 + digitSpace)/5; | - | 
| 492 |     int xOffset = (q->width() - ndigits*xAdvance + segLen/5)/2; | - | 
| 493 |     int yOffset = (q->height() - segLen*2)/2; | - | 
| 494 |  | - | 
| 495 |     for (int i=0; i<ndigits; i++) { | - | 
| 496 |         pos = QPoint(xOffset + xAdvance*i, yOffset); | - | 
| 497 |         if (newString) | - | 
| 498 |             drawDigit(pos, p, segLen, s[i].toLatin1(), digitStr[i].toLatin1()); | - | 
| 499 |         else | - | 
| 500 |             drawDigit(pos, p, segLen, s[i].toLatin1()); | - | 
| 501 |         if (newPoints) { | - | 
| 502 |             char newPoint = newPoints->testBit(i) ? '.' : ' '; | - | 
| 503 |             if (newString) { | - | 
| 504 |                 char oldPoint = points.testBit(i) ? '.' : ' '; | - | 
| 505 |                 drawDigit(pos, p, segLen, newPoint, oldPoint); | - | 
| 506 |             } else { | - | 
| 507 |                 drawDigit(pos, p, segLen, newPoint); | - | 
| 508 |             } | - | 
| 509 |         } | - | 
| 510 |     } | - | 
| 511 |     if (newString) { | - | 
| 512 |         digitStr = s; | - | 
| 513 |         digitStr.truncate(ndigits); | - | 
| 514 |         if (newPoints) | - | 
| 515 |             points = *newPoints; | - | 
| 516 |     } | - | 
| 517 | } | - | 
| 518 |  | - | 
| 519 |  | - | 
| 520 |  | - | 
| 521 |  | - | 
| 522 |  | - | 
| 523 |  | - | 
| 524 | void QLCDNumberPrivate::drawDigit(const QPoint &pos, QPainter &p, int segLen, | - | 
| 525 |                                   char newCh, char oldCh) | - | 
| 526 | { | - | 
| 527 |  | - | 
| 528 |  | - | 
| 529 |  | - | 
| 530 |     char updates[18][2]; | - | 
| 531 |  | - | 
| 532 |     int nErases; | - | 
| 533 |     int nUpdates; | - | 
| 534 |     const char *segs; | - | 
| 535 |     int i,j; | - | 
| 536 |  | - | 
| 537 |     const char erase = 0; | - | 
| 538 |     const char draw = 1; | - | 
| 539 |     const char leaveAlone = 2; | - | 
| 540 |  | - | 
| 541 |     segs = getSegments(oldCh); | - | 
| 542 |     for (nErases=0; segs[nErases] != 99; nErases++) { | - | 
| 543 |         updates[nErases][0] = erase; | - | 
| 544 |         updates[nErases][1] = segs[nErases]; | - | 
| 545 |     } | - | 
| 546 |     nUpdates = nErases; | - | 
| 547 |     segs = getSegments(newCh); | - | 
| 548 |     for(i = 0 ; segs[i] != 99 ; i++) { | - | 
| 549 |         for (j=0; j<nErases; j++) | - | 
| 550 |             if (segs[i] == updates[j][1]) { | - | 
| 551 |                 updates[j][0] = leaveAlone; | - | 
| 552 |                 break; | - | 
| 553 |             } | - | 
| 554 |         if (j == nErases) { | - | 
| 555 |             updates[nUpdates][0] = draw; | - | 
| 556 |             updates[nUpdates][1] = segs[i]; | - | 
| 557 |             nUpdates++; | - | 
| 558 |         } | - | 
| 559 |     } | - | 
| 560 |     for (i=0; i<nUpdates; i++) { | - | 
| 561 |         if (updates[i][0] == draw) | - | 
| 562 |             drawSegment(pos, updates[i][1], p, segLen); | - | 
| 563 |         if (updates[i][0] == erase) | - | 
| 564 |             drawSegment(pos, updates[i][1], p, segLen, true); | - | 
| 565 |     } | - | 
| 566 | } | - | 
| 567 |  | - | 
| 568 |  | - | 
| 569 | static void addPoint(QPolygon &a, const QPoint &p) | - | 
| 570 | { | - | 
| 571 |     uint n = a.size(); | - | 
| 572 |     a.resize(n + 1); | - | 
| 573 |     a.setPoint(n, p); | - | 
| 574 | } | - | 
| 575 |  | - | 
| 576 |  | - | 
| 577 |  | - | 
| 578 |  | - | 
| 579 |  | - | 
| 580 | void QLCDNumberPrivate::drawSegment(const QPoint &pos, char segmentNo, QPainter &p, | - | 
| 581 |                                     int segLen, bool erase) | - | 
| 582 | { | - | 
| 583 |     QLCDNumber * const q = q_func(); | - | 
| 584 |     QPoint ppt; | - | 
| 585 |     QPoint pt = pos; | - | 
| 586 |     int width = segLen/5; | - | 
| 587 |  | - | 
| 588 |     const QPalette &pal = q->palette(); | - | 
| 589 |     QColor lightColor,darkColor,fgColor; | - | 
| 590 |     if (erase){ | - | 
| 591 |         lightColor = pal.color(q->backgroundRole()); | - | 
| 592 |         darkColor = lightColor; | - | 
| 593 |         fgColor = lightColor; | - | 
| 594 |     } else { | - | 
| 595 |         lightColor = pal.light().color(); | - | 
| 596 |         darkColor = pal.dark().color(); | - | 
| 597 |         fgColor = pal.color(q->foregroundRole()); | - | 
| 598 |     } | - | 
| 599 |  | - | 
| 600 |  | - | 
| 601 |  | - | 
| 602 |  | - | 
| 603 |  | - | 
| 604 |  | - | 
| 605 |     if (fill) { | - | 
| 606 |         QPolygon a(0); | - | 
| 607 |  | - | 
| 608 |  | - | 
| 609 |         switch (segmentNo) { | - | 
| 610 |         case 0 : | - | 
| 611 |             ppt = pt; | - | 
| 612 |             ; | - | 
| 613 |             addPoint(a, QPoint(pt.x() + (segLen - 1),pt.y() + (0))); | - | 
| 614 |             ; | - | 
| 615 |             addPoint(a, QPoint(pt.x() + (segLen - width - 1),pt.y() + (width))); | - | 
| 616 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (width))); | - | 
| 617 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 618 |             break; | - | 
| 619 |         case 1 : | - | 
| 620 |             pt += QPoint(0 , 1); | - | 
| 621 |             ppt = pt; | - | 
| 622 |             ; | - | 
| 623 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (width))); | - | 
| 624 |             ; | - | 
| 625 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (segLen - width/2 - 2))); | - | 
| 626 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (segLen - 2))); | - | 
| 627 |             ; | - | 
| 628 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 629 |             break; | - | 
| 630 |         case 2 : | - | 
| 631 |             pt += QPoint(segLen - 1 , 1); | - | 
| 632 |             ppt = pt; | - | 
| 633 |             ; | - | 
| 634 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (segLen - 2))); | - | 
| 635 |             addPoint(a, QPoint(pt.x() + (-width),pt.y() + (segLen - width/2 - 2))); | - | 
| 636 |             ; | - | 
| 637 |             addPoint(a, QPoint(pt.x() + (-width),pt.y() + (width))); | - | 
| 638 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 639 |             break; | - | 
| 640 |         case 3 : | - | 
| 641 |             pt += QPoint(0 , segLen); | - | 
| 642 |             ppt = pt; | - | 
| 643 |             ; | - | 
| 644 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (-width/2))); | - | 
| 645 |             addPoint(a, QPoint(pt.x() + (segLen - width - 1),pt.y() + (-width/2))); | - | 
| 646 |             addPoint(a, QPoint(pt.x() + (segLen - 1),pt.y() + (0))); | - | 
| 647 |             ; | - | 
| 648 |             if (width & 1) { | - | 
| 649 |                 addPoint(a, QPoint(pt.x() + (segLen - width - 3),pt.y() + (width/2 + 1))); | - | 
| 650 |                 addPoint(a, QPoint(pt.x() + (width + 2),pt.y() + (width/2 + 1))); | - | 
| 651 |             } else { | - | 
| 652 |                 addPoint(a, QPoint(pt.x() + (segLen - width - 1),pt.y() + (width/2))); | - | 
| 653 |                 addPoint(a, QPoint(pt.x() + (width),pt.y() + (width/2))); | - | 
| 654 |             } | - | 
| 655 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 656 |             break; | - | 
| 657 |         case 4 : | - | 
| 658 |             pt += QPoint(0 , segLen + 1); | - | 
| 659 |             ppt = pt; | - | 
| 660 |             ; | - | 
| 661 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (width/2))); | - | 
| 662 |             ; | - | 
| 663 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (segLen - width - 2))); | - | 
| 664 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (segLen - 2))); | - | 
| 665 |             ; | - | 
| 666 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 667 |             break; | - | 
| 668 |         case 5 : | - | 
| 669 |             pt += QPoint(segLen - 1 , segLen + 1); | - | 
| 670 |             ppt = pt; | - | 
| 671 |             ; | - | 
| 672 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (segLen - 2))); | - | 
| 673 |             addPoint(a, QPoint(pt.x() + (-width),pt.y() + (segLen - width - 2))); | - | 
| 674 |             ; | - | 
| 675 |             addPoint(a, QPoint(pt.x() + (-width),pt.y() + (width/2))); | - | 
| 676 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 677 |             break; | - | 
| 678 |         case 6 : | - | 
| 679 |             pt += QPoint(0 , segLen*2); | - | 
| 680 |             ppt = pt; | - | 
| 681 |             ; | - | 
| 682 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (-width))); | - | 
| 683 |             addPoint(a, QPoint(pt.x() + (segLen - width - 1),pt.y() + (-width))); | - | 
| 684 |             addPoint(a, QPoint(pt.x() + (segLen - 1),pt.y() + (0))); | - | 
| 685 |             ; | - | 
| 686 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 687 |             break; | - | 
| 688 |         case 7 : | - | 
| 689 |             if (smallPoint) | - | 
| 690 |                 pt += QPoint(segLen + width/2 , segLen*2); | - | 
| 691 |             else | - | 
| 692 |                 pt += QPoint(segLen/2 , segLen*2); | - | 
| 693 |             ppt = pt; | - | 
| 694 |             ; | - | 
| 695 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (0))); | - | 
| 696 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (-width))); | - | 
| 697 |             ; | - | 
| 698 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (-width))); | - | 
| 699 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 700 |             break; | - | 
| 701 |         case 8 : | - | 
| 702 |             pt += QPoint(segLen/2 - width/2 + 1 , segLen/2 + width); | - | 
| 703 |             ppt = pt; | - | 
| 704 |             ; | - | 
| 705 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (0))); | - | 
| 706 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (-width))); | - | 
| 707 |             ; | - | 
| 708 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (-width))); | - | 
| 709 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 710 |             break; | - | 
| 711 |         case 9 : | - | 
| 712 |             pt += QPoint(segLen/2 - width/2 + 1 , 3*segLen/2 + width); | - | 
| 713 |             ppt = pt; | - | 
| 714 |             ; | - | 
| 715 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (0))); | - | 
| 716 |             addPoint(a, QPoint(pt.x() + (width),pt.y() + (-width))); | - | 
| 717 |             ; | - | 
| 718 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (-width))); | - | 
| 719 |             addPoint(a, QPoint(pt.x() + (0),pt.y() + (0))); | - | 
| 720 |             break; | - | 
| 721 |         default : | - | 
| 722 |             QMessageLogger(__FILE__, 10221028, __PRETTY_FUNCTION__).warning("QLCDNumber::drawSegment: (%s) Illegal segment id: %d\n", | - | 
| 723 |                      q->objectName().toLocal8Bit().constData(), segmentNo); | - | 
| 724 |         } | - | 
| 725 |  | - | 
| 726 |         p.setPen(Qt::NoPen); | - | 
| 727 |         p.setBrush(fgColor); | - | 
| 728 |         p.drawPolygon(a); | - | 
| 729 |         p.setBrush(Qt::NoBrush); | - | 
| 730 |  | - | 
| 731 |         pt = pos; | - | 
| 732 |     } | - | 
| 733 |     if (shadow) | - | 
| 734 |         switch (segmentNo) { | - | 
| 735 |         case 0 : | - | 
| 736 |             ppt = pt; | - | 
| 737 |             p.setPen(lightColor); | - | 
| 738 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - 1), pt.y()+(0)); ppt = QPoint(pt.x()+(segLen - 1), pt.y()+(0)); | - | 
| 739 |             p.setPen(darkColor); | - | 
| 740 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - width - 1), pt.y()+(width)); ppt = QPoint(pt.x()+(segLen - width - 1), pt.y()+(width)); | - | 
| 741 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(width)); ppt = QPoint(pt.x()+(width), pt.y()+(width)); | - | 
| 742 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 743 |             break; | - | 
| 744 |         case 1 : | - | 
| 745 |             pt += QPoint(0,1); | - | 
| 746 |             ppt = pt; | - | 
| 747 |             p.setPen(lightColor); | - | 
| 748 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(width)); ppt = QPoint(pt.x()+(width), pt.y()+(width)); | - | 
| 749 |             p.setPen(darkColor); | - | 
| 750 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(segLen - width/2 - 2)); ppt = QPoint(pt.x()+(width), pt.y()+(segLen - width/2 - 2)); | - | 
| 751 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(segLen - 2)); ppt = QPoint(pt.x()+(0), pt.y()+(segLen - 2)); | - | 
| 752 |             p.setPen(lightColor); | - | 
| 753 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 754 |             break; | - | 
| 755 |         case 2 : | - | 
| 756 |             pt += QPoint(segLen - 1 , 1); | - | 
| 757 |             ppt = pt; | - | 
| 758 |             p.setPen(darkColor); | - | 
| 759 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(segLen - 2)); ppt = QPoint(pt.x()+(0), pt.y()+(segLen - 2)); | - | 
| 760 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(-width), pt.y()+(segLen - width/2 - 2)); ppt = QPoint(pt.x()+(-width), pt.y()+(segLen - width/2 - 2)); | - | 
| 761 |             p.setPen(lightColor); | - | 
| 762 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(-width), pt.y()+(width)); ppt = QPoint(pt.x()+(-width), pt.y()+(width)); | - | 
| 763 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 764 |             break; | - | 
| 765 |         case 3 : | - | 
| 766 |             pt += QPoint(0 , segLen); | - | 
| 767 |             ppt = pt; | - | 
| 768 |             p.setPen(lightColor); | - | 
| 769 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(-width/2)); ppt = QPoint(pt.x()+(width), pt.y()+(-width/2)); | - | 
| 770 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - width - 1), pt.y()+(-width/2)); ppt = QPoint(pt.x()+(segLen - width - 1), pt.y()+(-width/2)); | - | 
| 771 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - 1), pt.y()+(0)); ppt = QPoint(pt.x()+(segLen - 1), pt.y()+(0)); | - | 
| 772 |             p.setPen(darkColor); | - | 
| 773 |             if (width & 1) { | - | 
| 774 |                 p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - width - 3), pt.y()+(width/2 + 1)); ppt = QPoint(pt.x()+(segLen - width - 3), pt.y()+(width/2 + 1)); | - | 
| 775 |                 p.drawLine(ppt.x(), ppt.y(), pt.x()+(width + 2), pt.y()+(width/2 + 1)); ppt = QPoint(pt.x()+(width + 2), pt.y()+(width/2 + 1)); | - | 
| 776 |             } else { | - | 
| 777 |                 p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - width - 1), pt.y()+(width/2)); ppt = QPoint(pt.x()+(segLen - width - 1), pt.y()+(width/2)); | - | 
| 778 |                 p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(width/2)); ppt = QPoint(pt.x()+(width), pt.y()+(width/2)); | - | 
| 779 |             } | - | 
| 780 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 781 |             break; | - | 
| 782 |         case 4 : | - | 
| 783 |             pt += QPoint(0 , segLen + 1); | - | 
| 784 |             ppt = pt; | - | 
| 785 |             p.setPen(lightColor); | - | 
| 786 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(width/2)); ppt = QPoint(pt.x()+(width), pt.y()+(width/2)); | - | 
| 787 |             p.setPen(darkColor); | - | 
| 788 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(segLen - width - 2)); ppt = QPoint(pt.x()+(width), pt.y()+(segLen - width - 2)); | - | 
| 789 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(segLen - 2)); ppt = QPoint(pt.x()+(0), pt.y()+(segLen - 2)); | - | 
| 790 |             p.setPen(lightColor); | - | 
| 791 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 792 |             break; | - | 
| 793 |         case 5 : | - | 
| 794 |             pt += QPoint(segLen - 1 , segLen + 1); | - | 
| 795 |             ppt = pt; | - | 
| 796 |             p.setPen(darkColor); | - | 
| 797 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(segLen - 2)); ppt = QPoint(pt.x()+(0), pt.y()+(segLen - 2)); | - | 
| 798 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(-width), pt.y()+(segLen - width - 2)); ppt = QPoint(pt.x()+(-width), pt.y()+(segLen - width - 2)); | - | 
| 799 |             p.setPen(lightColor); | - | 
| 800 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(-width), pt.y()+(width/2)); ppt = QPoint(pt.x()+(-width), pt.y()+(width/2)); | - | 
| 801 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 802 |             break; | - | 
| 803 |         case 6 : | - | 
| 804 |             pt += QPoint(0 , segLen*2); | - | 
| 805 |             ppt = pt; | - | 
| 806 |             p.setPen(lightColor); | - | 
| 807 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(-width)); ppt = QPoint(pt.x()+(width), pt.y()+(-width)); | - | 
| 808 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - width - 1), pt.y()+(-width)); ppt = QPoint(pt.x()+(segLen - width - 1), pt.y()+(-width)); | - | 
| 809 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(segLen - 1), pt.y()+(0)); ppt = QPoint(pt.x()+(segLen - 1), pt.y()+(0)); | - | 
| 810 |             p.setPen(darkColor); | - | 
| 811 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 812 |             break; | - | 
| 813 |         case 7 : | - | 
| 814 |             if (smallPoint) | - | 
| 815 |                 pt += QPoint(segLen + width/2 , segLen*2); | - | 
| 816 |             else | - | 
| 817 |                 pt += QPoint(segLen/2 , segLen*2); | - | 
| 818 |             ppt = pt; | - | 
| 819 |             p.setPen(darkColor); | - | 
| 820 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(0)); ppt = QPoint(pt.x()+(width), pt.y()+(0)); | - | 
| 821 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(-width)); ppt = QPoint(pt.x()+(width), pt.y()+(-width)); | - | 
| 822 |             p.setPen(lightColor); | - | 
| 823 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(-width)); ppt = QPoint(pt.x()+(0), pt.y()+(-width)); | - | 
| 824 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 825 |             break; | - | 
| 826 |         case 8 : | - | 
| 827 |             pt += QPoint(segLen/2 - width/2 + 1 , segLen/2 + width); | - | 
| 828 |             ppt = pt; | - | 
| 829 |             p.setPen(darkColor); | - | 
| 830 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(0)); ppt = QPoint(pt.x()+(width), pt.y()+(0)); | - | 
| 831 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(-width)); ppt = QPoint(pt.x()+(width), pt.y()+(-width)); | - | 
| 832 |             p.setPen(lightColor); | - | 
| 833 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(-width)); ppt = QPoint(pt.x()+(0), pt.y()+(-width)); | - | 
| 834 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 835 |             break; | - | 
| 836 |         case 9 : | - | 
| 837 |             pt += QPoint(segLen/2 - width/2 + 1 , 3*segLen/2 + width); | - | 
| 838 |             ppt = pt; | - | 
| 839 |             p.setPen(darkColor); | - | 
| 840 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(0)); ppt = QPoint(pt.x()+(width), pt.y()+(0)); | - | 
| 841 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(width), pt.y()+(-width)); ppt = QPoint(pt.x()+(width), pt.y()+(-width)); | - | 
| 842 |             p.setPen(lightColor); | - | 
| 843 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(-width)); ppt = QPoint(pt.x()+(0), pt.y()+(-width)); | - | 
| 844 |             p.drawLine(ppt.x(), ppt.y(), pt.x()+(0), pt.y()+(0)); ppt = QPoint(pt.x()+(0), pt.y()+(0)); | - | 
| 845 |             break; | - | 
| 846 |         default : | - | 
| 847 |             QMessageLogger(__FILE__, 11551161, __PRETTY_FUNCTION__).warning("QLCDNumber::drawSegment: (%s) Illegal segment id: %d\n", | - | 
| 848 |                      q->objectName().toLocal8Bit().constData(), segmentNo); | - | 
| 849 |         } | - | 
| 850 |  | - | 
| 851 |  | - | 
| 852 |  | - | 
| 853 |  | - | 
| 854 | } | - | 
| 855 | void QLCDNumber::setSegmentStyle(SegmentStyle s) | - | 
| 856 | { | - | 
| 857 |     QLCDNumberPrivate * const d = d_func(); | - | 
| 858 |     d->fill = (s == Flat || s == Filled); | - | 
| 859 |     d->shadow = (s == Outline || s == Filled); | - | 
| 860 |     update(); | - | 
| 861 | } | - | 
| 862 |  | - | 
| 863 | QLCDNumber::SegmentStyle QLCDNumber::segmentStyle() const | - | 
| 864 | { | - | 
| 865 |     const QLCDNumberPrivate * const d = d_func(); | - | 
| 866 |     ((!(d->fill || d->shadow)) ? qt_assert("d->fill || d->shadow",__FILE__,11951201) : qt_noop()); | - | 
| 867 |     if (!d->fill && d->shadow) | - | 
| 868 |         return Outline; | - | 
| 869 |     if (d->fill && d->shadow) | - | 
| 870 |         return Filled; | - | 
| 871 |     return Flat; | - | 
| 872 | } | - | 
| 873 |  | - | 
| 874 |  | - | 
| 875 |  | - | 
| 876 |  | - | 
| 877 | QSize QLCDNumber::sizeHint() const | - | 
| 878 | { | - | 
| 879 |     return QSize(10 + 9 * (digitCount() + (smallDecimalPoint() ? 0 : 1)), 23); | - | 
| 880 | } | - | 
| 881 |  | - | 
| 882 |  | - | 
| 883 | bool QLCDNumber::event(QEvent *e) | - | 
| 884 | { | - | 
| 885 |     return QFrame::event(e); | - | 
| 886 | } | - | 
| 887 |  | - | 
| 888 |  | - | 
| 889 |  | - | 
 |  |  |