1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qlcdnumber.h"

    43 #ifndef QT_NO_LCDNUMBER

    44 #include "qbitarray.h"

    45 #include "qpainter.h"

    46 #include "private/qframe_p.h"

    47 

    48 QT_BEGIN_NAMESPACE

    49 

    50 class QLCDNumberPrivate : public QFramePrivate

    51 {

    52     Q_DECLARE_PUBLIC(QLCDNumber)

    53 public:

    54     void init();

    55     void internalSetString(const QString& s);

    56     void drawString(const QString& s, QPainter &, QBitArray * = 0, bool = true);

    57     //void drawString(const QString &, QPainter &, QBitArray * = 0) const;

    58     void drawDigit(const QPoint &, QPainter &, int, char, char = ' ');

    59     void drawSegment(const QPoint &, char, QPainter &, int, bool = false);

    60 

    61     int ndigits;

    62     double val;

    63     uint base : 2;

    64     uint smallPoint : 1;

    65     uint fill : 1;

    66     uint shadow : 1;

    67     QString digitStr;

    68     QBitArray points;

    69 };

    70 

    71 /*!

    72     \class QLCDNumber

    73 

    74     \brief The QLCDNumber widget displays a number with LCD-like digits.

    75 

    76     \ingroup basicwidgets

    77 

    78 

    79     It can display a number in just about any size. It can display

    80     decimal, hexadecimal, octal or binary numbers. It is easy to

    81     connect to data sources using the display() slot, which is

    82     overloaded to take any of five argument types.

    83 

    84     There are also slots to change the base with setMode() and the

    85     decimal point with setSmallDecimalPoint().

    86 

    87     QLCDNumber emits the overflow() signal when it is asked to display

    88     something beyond its range. The range is set by setDigitCount(),

    89     but setSmallDecimalPoint() also influences it. If the display is

    90     set to hexadecimal, octal or binary, the integer equivalent of the

    91     value is displayed.

    92 

    93     These digits and other symbols can be shown: 0/O, 1, 2, 3, 4, 5/S,

    94     6, 7, 8, 9/g, minus, decimal point, A, B, C, D, E, F, h, H, L, o,

    95     P, r, u, U, Y, colon, degree sign (which is specified as single

    96     quote in the string) and space. QLCDNumber substitutes spaces for

    97     illegal characters.

    98 

    99     It is not possible to retrieve the contents of a QLCDNumber

   100     object, although you can retrieve the numeric value with value().

   101     If you really need the text, we recommend that you connect the

   102     signals that feed the display() slot to another slot as well and

   103     store the value there.

   104 

   105     Incidentally, QLCDNumber is the very oldest part of Qt, tracing

   106     its roots back to a BASIC program on the \link

   107     http://www.nvg.ntnu.no/sinclair/computers/zxspectrum/zxspectrum.htm

   108     Sinclair Spectrum\endlink.

   109 

   110     \table

   111     \row \o \inlineimage motif-lcdnumber.png Screenshot of a Motif style LCD number widget

   112     \inlineimage cde-lcdnumber.png Screenshot of a CDE style LCD number widget

   113     \inlineimage windows-lcdnumber.png Screenshot of a Windows style LCD number widget

   114     \inlineimage windowsxp-lcdnumber.png Screenshot of a Windows XP style LCD number widget

   115     \inlineimage macintosh-lcdnumber.png Screenshot of a Macintosh style LCD number widget

   116     \inlineimage plastique-lcdnumber.png Screenshot of a Plastique style LCD number widget

   117     \row \o LCD number widgets shown in various widget styles (from left to right):

   118     \l{Motif Style Widget Gallery}{Motif}, \l{CDE Style Widget Gallery}{CDE},

   119     \l{Windows Style Widget Gallery}{Windows}, \l{Windows XP Style Widget Gallery}{Windows XP},

   120     \l{Macintosh Style Widget Gallery}{Macintosh}, \l{Plastique Style Widget Gallery}{Plastique}.

   121     \endtable

   122 

   123     \sa QLabel, QFrame, {Digital Clock Example}, {Tetrix Example}

   124 */

   125 

   126 /*!

   127     \enum QLCDNumber::Mode

   128 

   129     This type determines how numbers are shown.

   130 

   131     \value Hex  Hexadecimal

   132     \value Dec  Decimal

   133     \value Oct  Octal

   134     \value Bin  Binary

   135     \omitvalue HEX

   136     \omitvalue DEC

   137     \omitvalue OCT

   138     \omitvalue BIN

   139 

   140     If the display is set to hexadecimal, octal or binary, the integer

   141     equivalent of the value is displayed.

   142 */

   143 

   144 /*!

   145     \enum QLCDNumber::SegmentStyle

   146 

   147     This type determines the visual appearance of the QLCDNumber

   148     widget.

   149 

   150     \value Outline gives raised segments filled with the background color.

   151     \value Filled gives raised segments filled with the windowText color.

   152     \value Flat gives flat segments filled with the windowText color.

   153 */

   154 

   155 

   156 

   157 /*!

   158     \fn void QLCDNumber::overflow()

   159 

   160     This signal is emitted whenever the QLCDNumber is asked to display

   161     a too-large number or a too-long string.

   162 

   163     It is never emitted by setDigitCount().

   164 */

   165 

   166 

   167 static QString int2string(int num, int base, int ndigits, bool *oflow)

   168 {

   169     QString s;

   170     bool negative;

   171     if (num < 0) {

   172         negative = true;

   173         num      = -num;

   174     } else {

   175         negative = false;

   176     }

   177     switch(base) {

   178         case QLCDNumber::Hex:

   179             s.sprintf("%*x", ndigits, num);

   180             break;

   181         case QLCDNumber::Dec:

   182             s.sprintf("%*i", ndigits, num);

   183             break;

   184         case QLCDNumber::Oct:

   185             s.sprintf("%*o", ndigits, num);

   186             break;

   187         case QLCDNumber::Bin:

   188             {

   189                 char buf[42];

   190                 char *p = &buf[41];

   191                 uint n = num;

   192                 int len = 0;

   193                 *p = '\0';

   194                 do {

   195                     *--p = (char)((n&1)+'0');

   196                     n >>= 1;

   197                     len++;

   198                 } while (n != 0);

   199                 len = ndigits - len;

   200                 if (len > 0)

   201                 s.fill(QLatin1Char(' '), len);

   202                 s += QString::fromLatin1(p);

   203             }

   204             break;

   205     }

   206     if (negative) {

   207         for (int i=0; i<(int)s.length(); i++) {

   208             if (s[i] != QLatin1Char(' ')) {

   209                 if (i != 0) {

   210                     s[i-1] = QLatin1Char('-');

   211                 } else {

   212                     s.insert(0, QLatin1Char('-'));

   213                 }

   214                 break;

   215             }

   216         }

   217     }

   218     if (oflow)

   219         *oflow = (int)s.length() > ndigits;

   220     return s;

   221 }

   222 

   223 

   224 static QString double2string(double num, int base, int ndigits, bool *oflow)

   225 {

   226     QString s;

   227     if (base != QLCDNumber::Dec) {

   228         bool of = num >= 2147483648.0 || num < -2147483648.0;

   229         if (of) {                             // oops, integer overflow

   230             if (oflow)

   231                 *oflow = true;

   232             return s;

   233         }

   234         s = int2string((int)num, base, ndigits, 0);

   235     } else {                                    // decimal base

   236         int nd = ndigits;

   237         do {

   238             s.sprintf("%*.*g", ndigits, nd, num);

   239             int i = s.indexOf(QLatin1Char('e'));

   240             if (i > 0 && s[i+1]==QLatin1Char('+')) {

   241                 s[i] = QLatin1Char(' ');

   242                 s[i+1] = QLatin1Char('e');

   243             }

   244         } while (nd-- && (int)s.length() > ndigits);

   245     }

   246     if (oflow)

   247         *oflow = (int)s.length() > ndigits;

   248     return s;

   249 }

   250 

   251 

   252 static const char *getSegments(char ch)               // gets list of segments for ch

   253 {

   254     static const char segments[30][8] =

   255        { { 0, 1, 2, 4, 5, 6,99, 0},             // 0    0 / O

   256          { 2, 5,99, 0, 0, 0, 0, 0},             // 1    1

   257          { 0, 2, 3, 4, 6,99, 0, 0},             // 2    2

   258          { 0, 2, 3, 5, 6,99, 0, 0},             // 3    3

   259          { 1, 2, 3, 5,99, 0, 0, 0},             // 4    4

   260          { 0, 1, 3, 5, 6,99, 0, 0},             // 5    5 / S

   261          { 0, 1, 3, 4, 5, 6,99, 0},             // 6    6

   262          { 0, 2, 5,99, 0, 0, 0, 0},             // 7    7

   263          { 0, 1, 2, 3, 4, 5, 6,99},             // 8    8

   264          { 0, 1, 2, 3, 5, 6,99, 0},             // 9    9 / g

   265          { 3,99, 0, 0, 0, 0, 0, 0},             // 10   -

   266          { 7,99, 0, 0, 0, 0, 0, 0},             // 11   .

   267          { 0, 1, 2, 3, 4, 5,99, 0},             // 12   A

   268          { 1, 3, 4, 5, 6,99, 0, 0},             // 13   B

   269          { 0, 1, 4, 6,99, 0, 0, 0},             // 14   C

   270          { 2, 3, 4, 5, 6,99, 0, 0},             // 15   D

   271          { 0, 1, 3, 4, 6,99, 0, 0},             // 16   E

   272          { 0, 1, 3, 4,99, 0, 0, 0},             // 17   F

   273          { 1, 3, 4, 5,99, 0, 0, 0},             // 18   h

   274          { 1, 2, 3, 4, 5,99, 0, 0},             // 19   H

   275          { 1, 4, 6,99, 0, 0, 0, 0},             // 20   L

   276          { 3, 4, 5, 6,99, 0, 0, 0},             // 21   o

   277          { 0, 1, 2, 3, 4,99, 0, 0},             // 22   P

   278          { 3, 4,99, 0, 0, 0, 0, 0},             // 23   r

   279          { 4, 5, 6,99, 0, 0, 0, 0},             // 24   u

   280          { 1, 2, 4, 5, 6,99, 0, 0},             // 25   U

   281          { 1, 2, 3, 5, 6,99, 0, 0},             // 26   Y

   282          { 8, 9,99, 0, 0, 0, 0, 0},             // 27   :

   283          { 0, 1, 2, 3,99, 0, 0, 0},             // 28   '

   284          {99, 0, 0, 0, 0, 0, 0, 0} };           // 29   empty

   285 

   286     if (ch >= '0' && ch <= '9')

   287         return segments[ch - '0'];

   288     if (ch >= 'A' && ch <= 'F')

   289         return segments[ch - 'A' + 12];

   290     if (ch >= 'a' && ch <= 'f')

   291         return segments[ch - 'a' + 12];

   292 

   293     int n;

   294     switch (ch) {

   295         case '-':

   296             n = 10;  break;

   297         case 'O':

   298             n = 0;   break;

   299         case 'g':

   300             n = 9;   break;

   301         case '.':

   302             n = 11;  break;

   303         case 'h':

   304             n = 18;  break;

   305         case 'H':

   306             n = 19;  break;

   307         case 'l':

   308         case 'L':

   309             n = 20;  break;

   310         case 'o':

   311             n = 21;  break;

   312         case 'p':

   313         case 'P':

   314             n = 22;  break;

   315         case 'r':

   316         case 'R':

   317             n = 23;  break;

   318         case 's':

   319         case 'S':

   320             n = 5;   break;

   321         case 'u':

   322             n = 24;  break;

   323         case 'U':

   324             n = 25;  break;

   325         case 'y':

   326         case 'Y':

   327             n = 26;  break;

   328         case ':':

   329             n = 27;  break;

   330         case '\'':

   331             n = 28;  break;

   332         default:

   333             n = 29;  break;

   334     }

   335     return segments[n];

   336 }

   337 

   338 

   339 #ifdef QT3_SUPPORT

   340 /*! \obsolete

   341     Constructs an LCD number, sets the number of digits to 5, the base

   342     to decimal, the decimal point mode to 'small' and the frame style

   343     to a raised box. The segmentStyle() is set to \c Outline.

   344 

   345     The \a parent and \a name arguments are passed to the QFrame

   346     constructor.

   347 

   348     \sa setDigitCount(), setSmallDecimalPoint()

   349 */

   350 

   351 QLCDNumber::QLCDNumber(QWidget *parent, const char *name)

   352         : QFrame(*new QLCDNumberPrivate, parent)

   353 {

   354     setObjectName(QString::fromAscii(name));

   355     Q_D(QLCDNumber);

   356     d->ndigits = 5;

   357     d->init();

   358 }

   359 

   360 

   361 /*! \obsolete

   362     Constructs an LCD number, sets the number of digits to \a

   363     numDigits, the base to decimal, the decimal point mode to 'small'

   364     and the frame style to a raised box. The segmentStyle() is set to

   365     \c Outline.

   366 

   367     The \a parent and \a name arguments are passed to the QFrame

   368     constructor.

   369 

   370     \sa setDigitCount(), setSmallDecimalPoint()

   371 */

   372 

   373 QLCDNumber::QLCDNumber(uint numDigits, QWidget *parent, const char *name)

   374         : QFrame(*new QLCDNumberPrivate, parent)

   375 {

   376     setObjectName(QString::fromAscii(name));

   377     Q_D(QLCDNumber);

   378     d->ndigits = numDigits;

   379     d->init();

   380 }

   381 #endif //QT3_SUPPORT

   382 

   383 /*!

   384     Constructs an LCD number, sets the number of digits to 5, the base

   385     to decimal, the decimal point mode to 'small' and the frame style

   386     to a raised box. The segmentStyle() is set to \c Outline.

   387 

   388     The \a parent argument is passed to the QFrame constructor.

   389 

   390     \sa setDigitCount(), setSmallDecimalPoint()

   391 */

   392 

   393 QLCDNumber::QLCDNumber(QWidget *parent)

   394         : QFrame(*new QLCDNumberPrivate, parent)

   395 {

   396     Q_D(QLCDNumber);

   397     d->ndigits = 5;

   398     d->init();

   399 }

   400 

   401 

   402 /*!

   403     Constructs an LCD number, sets the number of digits to \a

   404     numDigits, the base to decimal, the decimal point mode to 'small'

   405     and the frame style to a raised box. The segmentStyle() is set to

   406     \c Filled.

   407 

   408     The \a parent argument is passed to the QFrame constructor.

   409 

   410     \sa setDigitCount(), setSmallDecimalPoint()

   411 */

   412 

   413 QLCDNumber::QLCDNumber(uint numDigits, QWidget *parent)

   414         : QFrame(*new QLCDNumberPrivate, parent)

   415 {

   416     Q_D(QLCDNumber);

   417     d->ndigits = numDigits;

   418     d->init();

   419 }

   420 

   421 void QLCDNumberPrivate::init()

   422 {

   423     Q_Q(QLCDNumber);

   424 

   425     q->setFrameStyle(QFrame::Box | QFrame::Raised);

   426     val        = 0;

   427     base       = QLCDNumber::Dec;

   428     smallPoint = false;

   429     q->setDigitCount(ndigits);

   430     q->setSegmentStyle(QLCDNumber::Filled);

   431     q->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));

   432 }

   433 

   434 /*!

   435     Destroys the LCD number.

   436 */

   437 

   438 QLCDNumber::~QLCDNumber()

   439 {

   440 }

   441 

   442 

   443 /*!

   444     \deprecated

   445     \property QLCDNumber::numDigits

   446     \brief the current number of digits displayed

   447     \sa digitCount

   448 */

   449 

   450 void QLCDNumber::setNumDigits(int numDigits)

   451 {

   452     setDigitCount(numDigits);

   453 }

   454 

   455 /*!

   456     \since 4.6

   457     \property QLCDNumber::digitCount

   458     \brief the current number of digits displayed

   459 

   460     Corresponds to the current number of digits. If \l

   461     QLCDNumber::smallDecimalPoint is false, the decimal point occupies

   462     one digit position.

   463 

   464     By default, this property contains a value of 5.

   465 

   466     \sa smallDecimalPoint

   467 */

   468 

   469 /*!

   470   Sets the current number of digits to \a numDigits. Must

   471   be in the range 0..99.

   472  */

   473 void QLCDNumber::setDigitCount(int numDigits)

   474 {

   475     Q_D(QLCDNumber);

   476     if (numDigits > 99) {

   477         qWarning("QLCDNumber::setNumDigits: (%s) Max 99 digits allowed",

   478                  objectName().toLocal8Bit().constData());

   479         numDigits = 99;

   480     }

   481     if (numDigits < 0) {

   482         qWarning("QLCDNumber::setNumDigits: (%s) Min 0 digits allowed",

   483                  objectName().toLocal8Bit().constData());

   484         numDigits = 0;

   485     }

   486     if (d->digitStr.isNull()) {                  // from constructor

   487         d->ndigits = numDigits;

   488         d->digitStr.fill(QLatin1Char(' '), d->ndigits);

   489         d->points.fill(0, d->ndigits);

   490         d->digitStr[d->ndigits - 1] = QLatin1Char('0'); // "0" is the default number

   491     } else {

   492         bool doDisplay = d->ndigits == 0;

   493         if (numDigits == d->ndigits)             // no change

   494             return;

   495         register int i;

   496         int dif;

   497         if (numDigits > d->ndigits) {            // expand

   498             dif = numDigits - d->ndigits;

   499             QString buf;

   500             buf.fill(QLatin1Char(' '), dif);

   501             d->digitStr.insert(0, buf);

   502             d->points.resize(numDigits);

   503             for (i=numDigits-1; i>=dif; i--)

   504                 d->points.setBit(i, d->points.testBit(i-dif));

   505             for (i=0; i<dif; i++)

   506                 d->points.clearBit(i);

   507         } else {                                        // shrink

   508             dif = d->ndigits - numDigits;

   509             d->digitStr = d->digitStr.right(numDigits);

   510             QBitArray tmpPoints = d->points;

   511             d->points.resize(numDigits);

   512             for (i=0; i<(int)numDigits; i++)

   513                 d->points.setBit(i, tmpPoints.testBit(i+dif));

   514         }

   515         d->ndigits = numDigits;

   516         if (doDisplay)

   517             display(value());

   518         update();

   519     }

   520 }

   521 

   522 int QLCDNumber::numDigits() const

   523 {

   524     Q_D(const QLCDNumber);

   525     return d->ndigits;

   526 }

   527 

   528 /*!

   529   Returns the current number of digits.

   530  */

   531 int QLCDNumber::digitCount() const

   532 {

   533     Q_D(const QLCDNumber);

   534     return d->ndigits;

   535 }

   536 

   537 /*!

   538     \overload

   539 

   540     Returns true if \a num is too big to be displayed in its entirety;

   541     otherwise returns false.

   542 

   543     \sa display(), digitCount(), smallDecimalPoint()

   544 */

   545 

   546 bool QLCDNumber::checkOverflow(int num) const

   547 {

   548     Q_D(const QLCDNumber);

   549     bool of;

   550     int2string(num, d->base, d->ndigits, &of);

   551     return of;

   552 }

   553 

   554 

   555 /*!

   556     Returns true if \a num is too big to be displayed in its entirety;

   557     otherwise returns false.

   558 

   559     \sa display(), digitCount(), smallDecimalPoint()

   560 */

   561 

   562 bool QLCDNumber::checkOverflow(double num) const

   563 {

   564     Q_D(const QLCDNumber);

   565     bool of;

   566     double2string(num, d->base, d->ndigits, &of);

   567     return of;

   568 }

   569 

   570 

   571 /*!

   572     \property QLCDNumber::mode

   573     \brief the current display mode (number base)

   574 

   575     Corresponds to the current display mode, which is one of \c Bin,

   576     \c Oct, \c Dec (the default) and \c Hex. \c Dec mode can display

   577     floating point values, the other modes display the integer

   578     equivalent.

   579 

   580     \sa smallDecimalPoint(), setHexMode(), setDecMode(), setOctMode(), setBinMode()

   581 */

   582 

   583 QLCDNumber::Mode QLCDNumber::mode() const

   584 {

   585     Q_D(const QLCDNumber);

   586     return (QLCDNumber::Mode) d->base;

   587 }

   588 

   589 void QLCDNumber::setMode(Mode m)

   590 {

   591     Q_D(QLCDNumber);

   592     d->base = m;

   593     display(d->val);

   594 }

   595 

   596 

   597 /*!

   598     \property QLCDNumber::value

   599     \brief the displayed value

   600 

   601     This property corresponds to the current value displayed by the

   602     LCDNumber.

   603 

   604     If the displayed value is not a number, the property has a value

   605     of 0.

   606 

   607     By default, this property contains a value of 0.

   608 */

   609 

   610 double QLCDNumber::value() const

   611 {

   612     Q_D(const QLCDNumber);

   613     return d->val;

   614 }

   615 

   616 /*!

   617     \overload

   618 

   619     Displays the number \a num.

   620 */

   621 void QLCDNumber::display(double num)

   622 {

   623     Q_D(QLCDNumber);

   624     d->val = num;

   625     bool of;

   626     QString s = double2string(d->val, d->base, d->ndigits, &of);

   627     if (of)

   628         emit overflow();

   629     else

   630         d->internalSetString(s);

   631 }

   632 

   633 /*!

   634     \property QLCDNumber::intValue

   635     \brief the displayed value rounded to the nearest integer

   636 

   637     This property corresponds to the nearest integer to the current

   638     value displayed by the LCDNumber. This is the value used for

   639     hexadecimal, octal and binary modes.

   640 

   641     If the displayed value is not a number, the property has a value

   642     of 0.

   643 

   644     By default, this property contains a value of 0.

   645 */

   646 int QLCDNumber::intValue() const

   647 {

   648     Q_D(const QLCDNumber);

   649     return qRound(d->val);

   650 }

   651 

   652 

   653 /*!

   654     \overload

   655 

   656     Displays the number \a num.

   657 */

   658 void QLCDNumber::display(int num)

   659 {

   660     Q_D(QLCDNumber);

   661     d->val = (double)num;

   662     bool of;

   663     QString s = int2string(num, d->base, d->ndigits, &of);

   664     if (of)

   665         emit overflow();

   666     else

   667         d->internalSetString(s);

   668 }

   669 

   670 

   671 /*!

   672     Displays the number represented by the string \a s.

   673 

   674     This version of the function disregards mode() and

   675     smallDecimalPoint().

   676 

   677     These digits and other symbols can be shown: 0/O, 1, 2, 3, 4, 5/S,

   678     6, 7, 8, 9/g, minus, decimal point, A, B, C, D, E, F, h, H, L, o,

   679     P, r, u, U, Y, colon, degree sign (which is specified as single

   680     quote in the string) and space. QLCDNumber substitutes spaces for

   681     illegal characters.

   682 */

   683 

   684 void QLCDNumber::display(const QString &s)

   685 {

   686     Q_D(QLCDNumber);

   687     d->val = 0;

   688     bool ok = false;

   689     double v = s.toDouble(&ok);

   690     if (ok)

   691         d->val = v;

   692     d->internalSetString(s);

   693 }

   694 

   695 /*!

   696     Calls setMode(Hex). Provided for convenience (e.g. for

   697     connecting buttons to it).

   698 

   699     \sa setMode(), setDecMode(), setOctMode(), setBinMode(), mode()

   700 */

   701 

   702 void QLCDNumber::setHexMode()

   703 {

   704     setMode(Hex);

   705 }

   706 

   707 

   708 /*!

   709     Calls setMode(Dec). Provided for convenience (e.g. for

   710     connecting buttons to it).

   711 

   712     \sa setMode(), setHexMode(), setOctMode(), setBinMode(), mode()

   713 */

   714 

   715 void QLCDNumber::setDecMode()

   716 {

   717     setMode(Dec);

   718 }

   719 

   720 

   721 /*!

   722     Calls setMode(Oct). Provided for convenience (e.g. for

   723     connecting buttons to it).

   724 

   725     \sa setMode(), setHexMode(), setDecMode(), setBinMode(), mode()

   726 */

   727 

   728 void QLCDNumber::setOctMode()

   729 {

   730     setMode(Oct);

   731 }

   732 

   733 

   734 /*!

   735     Calls setMode(Bin). Provided for convenience (e.g. for

   736     connecting buttons to it).

   737 

   738     \sa setMode(), setHexMode(), setDecMode(), setOctMode(), mode()

   739 */

   740 

   741 void QLCDNumber::setBinMode()

   742 {

   743     setMode(Bin);

   744 }

   745 

   746 

   747 /*!

   748     \property QLCDNumber::smallDecimalPoint

   749     \brief the style of the decimal point

   750 

   751     If true the decimal point is drawn between two digit positions.

   752     Otherwise it occupies a digit position of its own, i.e. is drawn

   753     in a digit position. The default is false.

   754 

   755     The inter-digit space is made slightly wider when the decimal

   756     point is drawn between the digits.

   757 

   758     \sa mode

   759 */

   760 

   761 void QLCDNumber::setSmallDecimalPoint(bool b)

   762 {

   763     Q_D(QLCDNumber);

   764     d->smallPoint = b;

   765     update();

   766 }

   767 

   768 bool QLCDNumber::smallDecimalPoint() const

   769 {

   770     Q_D(const QLCDNumber);

   771     return d->smallPoint;

   772 }

   773 

   774 

   775 

   776 /*!\reimp

   777 */

   778 

   779 

   780 void QLCDNumber::paintEvent(QPaintEvent *)

   781 {

   782     Q_D(QLCDNumber);

   783     QPainter p(this);

   784     drawFrame(&p);

   785     p.setRenderHint(QPainter::Antialiasing);

   786     if (d->shadow)

   787         p.translate(0.5, 0.5);

   788 

   789     if (d->smallPoint)

   790         d->drawString(d->digitStr, p, &d->points, false);

   791     else

   792         d->drawString(d->digitStr, p, 0, false);

   793 }

   794 

   795 

   796 void QLCDNumberPrivate::internalSetString(const QString& s)

   797 {

   798     Q_Q(QLCDNumber);

   799     QString buffer;

   800     int i;

   801     int len = s.length();

   802     QBitArray newPoints(ndigits);

   803 

   804     if (!smallPoint) {

   805         if (len == ndigits)

   806             buffer = s;

   807         else

   808             buffer = s.right(ndigits).rightJustified(ndigits, QLatin1Char(' '));

   809     } else {

   810         int  index = -1;

   811         bool lastWasPoint = true;

   812         newPoints.clearBit(0);

   813         for (i=0; i<len; i++) {

   814             if (s[i] == QLatin1Char('.')) {

   815                 if (lastWasPoint) {           // point already set for digit?

   816                     if (index == ndigits - 1) // no more digits

   817                         break;

   818                     index++;

   819                     buffer[index] = QLatin1Char(' ');        // 2 points in a row, add space

   820                 }

   821                 newPoints.setBit(index);        // set decimal point

   822                 lastWasPoint = true;

   823             } else {

   824                 if (index == ndigits - 1)

   825                     break;

   826                 index++;

   827                 buffer[index] = s[i];

   828                 newPoints.clearBit(index);      // decimal point default off

   829                 lastWasPoint = false;

   830             }

   831         }

   832         if (index < ((int) ndigits) - 1) {

   833             for(i=index; i>=0; i--) {

   834                 buffer[ndigits - 1 - index + i] = buffer[i];

   835                 newPoints.setBit(ndigits - 1 - index + i,

   836                                    newPoints.testBit(i));

   837             }

   838             for(i=0; i<ndigits-index-1; i++) {

   839                 buffer[i] = QLatin1Char(' ');

   840                 newPoints.clearBit(i);

   841             }

   842         }

   843     }

   844 

   845     if (buffer == digitStr)

   846         return;

   847 

   848     digitStr = buffer;

   849     if (smallPoint)

   850         points = newPoints;

   851     q->update();

   852 }

   853 

   854 /*!

   855   \internal

   856 */

   857 

   858 void QLCDNumberPrivate::drawString(const QString &s, QPainter &p,

   859                                    QBitArray *newPoints, bool newString)

   860 {

   861     Q_Q(QLCDNumber);

   862     QPoint  pos;

   863 

   864     int digitSpace = smallPoint ? 2 : 1;

   865     int xSegLen    = q->width()*5/(ndigits*(5 + digitSpace) + digitSpace);

   866     int ySegLen    = q->height()*5/12;

   867     int segLen     = ySegLen > xSegLen ? xSegLen : ySegLen;

   868     int xAdvance   = segLen*(5 + digitSpace)/5;

   869     int xOffset    = (q->width() - ndigits*xAdvance + segLen/5)/2;

   870     int yOffset    = (q->height() - segLen*2)/2;

   871 

   872     for (int i=0;  i<ndigits; i++) {

   873         pos = QPoint(xOffset + xAdvance*i, yOffset);

   874         if (newString)

   875             drawDigit(pos, p, segLen, s[i].toLatin1(), digitStr[i].toLatin1());

   876         else

   877             drawDigit(pos, p, segLen, s[i].toLatin1());

   878         if (newPoints) {

   879             char newPoint = newPoints->testBit(i) ? '.' : ' ';

   880             if (newString) {

   881                 char oldPoint = points.testBit(i) ? '.' : ' ';

   882                 drawDigit(pos, p, segLen, newPoint, oldPoint);

   883             } else {

   884                 drawDigit(pos, p, segLen, newPoint);

   885             }

   886         }

   887     }

   888     if (newString) {

   889         digitStr = s;

   890         digitStr.truncate(ndigits);

   891         if (newPoints)

   892             points = *newPoints;

   893     }

   894 }

   895 

   896 

   897 /*!

   898   \internal

   899 */

   900 

   901 void QLCDNumberPrivate::drawDigit(const QPoint &pos, QPainter &p, int segLen,

   902                                   char newCh, char oldCh)

   903 {

   904 // Draws and/or erases segments to change display of a single digit

   905 // from oldCh to newCh

   906 

   907     char updates[18][2];        // can hold 2 times number of segments, only

   908                                 // first 9 used if segment table is correct

   909     int  nErases;

   910     int  nUpdates;

   911     const char *segs;

   912     int  i,j;

   913 

   914     const char erase      = 0;

   915     const char draw       = 1;

   916     const char leaveAlone = 2;

   917 

   918     segs = getSegments(oldCh);

   919     for (nErases=0; segs[nErases] != 99; nErases++) {

   920         updates[nErases][0] = erase;            // get segments to erase to

   921         updates[nErases][1] = segs[nErases];    // remove old char

   922     }

   923     nUpdates = nErases;

   924     segs = getSegments(newCh);

   925     for(i = 0 ; segs[i] != 99 ; i++) {

   926         for (j=0;  j<nErases; j++)

   927             if (segs[i] == updates[j][1]) {   // same segment ?

   928                 updates[j][0] = leaveAlone;     // yes, already on screen

   929                 break;

   930             }

   931         if (j == nErases) {                   // if not already on screen

   932             updates[nUpdates][0] = draw;

   933             updates[nUpdates][1] = segs[i];

   934             nUpdates++;

   935         }

   936     }

   937     for (i=0; i<nUpdates; i++) {

   938         if (updates[i][0] == draw)

   939             drawSegment(pos, updates[i][1], p, segLen);

   940         if (updates[i][0] == erase)

   941             drawSegment(pos, updates[i][1], p, segLen, true);

   942     }

   943 }

   944 

   945 

   946 static void addPoint(QPolygon &a, const QPoint &p)

   947 {

   948     uint n = a.size();

   949     a.resize(n + 1);

   950     a.setPoint(n, p);

   951 }

   952 

   953 /*!

   954   \internal

   955 */

   956 

   957 void QLCDNumberPrivate::drawSegment(const QPoint &pos, char segmentNo, QPainter &p,

   958                                     int segLen, bool erase)

   959 {

   960     Q_Q(QLCDNumber);

   961     QPoint ppt;

   962     QPoint pt = pos;

   963     int width = segLen/5;

   964 

   965     const QPalette &pal = q->palette();

   966     QColor lightColor,darkColor,fgColor;

   967     if (erase){

   968         lightColor = pal.color(q->backgroundRole());

   969         darkColor  = lightColor;

   970         fgColor    = lightColor;

   971     } else {

   972         lightColor = pal.light().color();

   973         darkColor  = pal.dark().color();

   974         fgColor    = pal.color(q->foregroundRole());

   975     }

   976 

   977 

   978 #define LINETO(X,Y) addPoint(a, QPoint(pt.x() + (X),pt.y() + (Y)))

   979 #define LIGHT

   980 #define DARK

   981 

   982     if (fill) {

   983         QPolygon a(0);

   984         //The following is an exact copy of the switch below.

   985         //don't make any changes here

   986         switch (segmentNo) {

   987         case 0 :

   988             ppt = pt;

   989             LIGHT;

   990             LINETO(segLen - 1,0);

   991             DARK;

   992             LINETO(segLen - width - 1,width);

   993             LINETO(width,width);

   994             LINETO(0,0);

   995             break;

   996         case 1 :

   997             pt += QPoint(0 , 1);

   998             ppt = pt;

   999             LIGHT;

  1000             LINETO(width,width);

  1001             DARK;

  1002             LINETO(width,segLen - width/2 - 2);

  1003             LINETO(0,segLen - 2);

  1004             LIGHT;

  1005             LINETO(0,0);

  1006             break;

  1007         case 2 :

  1008             pt += QPoint(segLen - 1 , 1);

  1009             ppt = pt;

  1010             DARK;

  1011             LINETO(0,segLen - 2);

  1012             LINETO(-width,segLen - width/2 - 2);

  1013             LIGHT;

  1014             LINETO(-width,width);

  1015             LINETO(0,0);

  1016             break;

  1017         case 3 :

  1018             pt += QPoint(0 , segLen);

  1019             ppt = pt;

  1020             LIGHT;

  1021             LINETO(width,-width/2);

  1022             LINETO(segLen - width - 1,-width/2);

  1023             LINETO(segLen - 1,0);

  1024             DARK;

  1025             if (width & 1) {            // adjust for integer division error

  1026                 LINETO(segLen - width - 3,width/2 + 1);

  1027                 LINETO(width + 2,width/2 + 1);

  1028             } else {

  1029                 LINETO(segLen - width - 1,width/2);

  1030                 LINETO(width,width/2);

  1031             }

  1032             LINETO(0,0);

  1033             break;

  1034         case 4 :

  1035             pt += QPoint(0 , segLen + 1);

  1036             ppt = pt;

  1037             LIGHT;

  1038             LINETO(width,width/2);

  1039             DARK;

  1040             LINETO(width,segLen - width - 2);

  1041             LINETO(0,segLen - 2);

  1042             LIGHT;

  1043             LINETO(0,0);

  1044             break;

  1045         case 5 :

  1046             pt += QPoint(segLen - 1 , segLen + 1);

  1047             ppt = pt;

  1048             DARK;

  1049             LINETO(0,segLen - 2);

  1050             LINETO(-width,segLen - width - 2);

  1051             LIGHT;

  1052             LINETO(-width,width/2);

  1053             LINETO(0,0);

  1054             break;

  1055         case 6 :

  1056             pt += QPoint(0 , segLen*2);

  1057             ppt = pt;

  1058             LIGHT;

  1059             LINETO(width,-width);

  1060             LINETO(segLen - width - 1,-width);

  1061             LINETO(segLen - 1,0);

  1062             DARK;

  1063             LINETO(0,0);

  1064             break;

  1065         case 7 :

  1066             if (smallPoint)   // if smallpoint place'.' between other digits

  1067                 pt += QPoint(segLen + width/2 , segLen*2);

  1068             else

  1069                 pt += QPoint(segLen/2 , segLen*2);

  1070             ppt = pt;

  1071             DARK;

  1072             LINETO(width,0);

  1073             LINETO(width,-width);

  1074             LIGHT;

  1075             LINETO(0,-width);

  1076             LINETO(0,0);

  1077             break;

  1078         case 8 :

  1079             pt += QPoint(segLen/2 - width/2 + 1 , segLen/2 + width);

  1080             ppt = pt;

  1081             DARK;

  1082             LINETO(width,0);

  1083             LINETO(width,-width);

  1084             LIGHT;

  1085             LINETO(0,-width);

  1086             LINETO(0,0);

  1087             break;

  1088         case 9 :

  1089             pt += QPoint(segLen/2 - width/2 + 1 , 3*segLen/2 + width);

  1090             ppt = pt;

  1091             DARK;

  1092             LINETO(width,0);

  1093             LINETO(width,-width);

  1094             LIGHT;

  1095             LINETO(0,-width);

  1096             LINETO(0,0);

  1097             break;

  1098         default :

  1099             qWarning("QLCDNumber::drawSegment: (%s) Illegal segment id: %d\n",

  1100                      q->objectName().toLocal8Bit().constData(), segmentNo);

  1101         }

  1102         // End exact copy

  1103         p.setPen(Qt::NoPen);

  1104         p.setBrush(fgColor);

  1105         p.drawPolygon(a);

  1106         p.setBrush(Qt::NoBrush);

  1107 

  1108         pt = pos;

  1109     }

  1110 #undef LINETO

  1111 #undef LIGHT

  1112 #undef DARK

  1113 

  1114 #define LINETO(X,Y) p.drawLine(ppt.x(), ppt.y(), pt.x()+(X), pt.y()+(Y)); \

  1115                     ppt = QPoint(pt.x()+(X), pt.y()+(Y))

  1116 #define LIGHT p.setPen(lightColor)

  1117 #define DARK  p.setPen(darkColor)

  1118     if (shadow)

  1119         switch (segmentNo) {

  1120         case 0 :

  1121             ppt = pt;

  1122             LIGHT;

  1123             LINETO(segLen - 1,0);

  1124             DARK;

  1125             LINETO(segLen - width - 1,width);

  1126             LINETO(width,width);

  1127             LINETO(0,0);

  1128             break;

  1129         case 1 :

  1130             pt += QPoint(0,1);

  1131             ppt = pt;

  1132             LIGHT;

  1133             LINETO(width,width);

  1134             DARK;

  1135             LINETO(width,segLen - width/2 - 2);