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

     2 **

     3 ** Copyright (C) 2009 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 Qt3Support 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 "q3datetimeedit.h"

    43 

    44 #ifndef QT_NO_DATETIMEEDIT

    45 

    46 #include <private/q3richtext_p.h>

    47 #include "qevent.h"

    48 #include "q3rangecontrol.h"

    49 #include "qapplication.h"

    50 #include "qpixmap.h"

    51 #include "qlist.h"

    52 #include "qstring.h"

    53 #include "qstyle.h"

    54 

    55 #if defined(Q_WS_WIN)

    56 #include "qt_windows.h"

    57 #endif

    58 

    59 QT_BEGIN_NAMESPACE

    60 

    61 #define QDATETIMEEDIT_HIDDEN_CHAR QLatin1Char('0')

    62 

    63 class Q_COMPAT_EXPORT QNumberSection

    64 {

    65 public:

    66     QNumberSection(int selStart = 0, int selEnd = 0, bool separat = true, int actual = -1)

    67         : selstart(selStart), selend(selEnd), act(actual), sep(separat)

    68     {}

    69     int selectionStart() const { return selstart; }

    70     void setSelectionStart(int s) { selstart = s; }

    71     int selectionEnd() const { return selend; }

    72     void setSelectionEnd(int s) { selend = s; }

    73     int width() const { return selend - selstart; }

    74     int index() const { return act; }

    75     bool separator() const { return sep; }

    76     Q_DUMMY_COMPARISON_OPERATOR(QNumberSection)

    77 private:

    78     signed int selstart :12;

    79     signed int selend         :12;

    80     signed int act         :7;

    81     bool sep         :1;

    82 };

    83 

    84 static QString        *lDateSep = 0;

    85 static QString        *lTimeSep = 0;

    86 static bool        lAMPM          = false;

    87 static QString        *lAM          = 0;

    88 static QString        *lPM          = 0;

    89 static Q3DateEdit::Order        lOrder = Q3DateEdit::YMD;

    90 static int refcount = 0;

    91 

    92 static void cleanup()

    93 {

    94     delete lDateSep;

    95     lDateSep = 0;

    96     delete lTimeSep;

    97     lTimeSep = 0;

    98     delete lAM;

    99     lAM = 0;

   100     delete lPM;

   101     lPM = 0;

   102 }

   103 

   104 /*!

   105 \internal

   106 try to get the order of DMY and the date/time separator from the locale settings

   107 */

   108 static void readLocaleSettings()

   109 {

   110     int dpos, mpos, ypos;

   111     cleanup();

   112 

   113     lDateSep = new QString();

   114     lTimeSep = new QString();

   115 

   116 #if defined(Q_WS_WIN)

   117     wchar_t data[10];

   118     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDATE, data, 10);

   119     *lDateSep = QString::fromWCharArray(data);

   120     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STIME, data, 10);

   121     *lTimeSep = QString::fromWCharArray(data);

   122     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITIME, data, 10);

   123     lAMPM = QString::fromWCharArray(data).toInt() == 0;

   124     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_S1159, data, 10);

   125     QString am = QString::fromWCharArray(data);

   126     if (!am.isEmpty())

   127         lAM = new QString(am);

   128     GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_S2359, data, 10);

   129     QString pm = QString::fromWCharArray(data);

   130     if (!pm.isEmpty() )

   131         lPM = new QString(pm);

   132 #else

   133     *lDateSep = QLatin1Char('-');

   134     *lTimeSep = QLatin1Char(':');

   135 #endif

   136     QString d = QDate(1999, 11, 22).toString(Qt::LocalDate);

   137     dpos = d.indexOf(QLatin1String("22"));

   138     mpos = d.indexOf(QLatin1String("11"));

   139     ypos = d.indexOf(QLatin1String("99"));

   140     if (dpos > -1 && mpos > -1 && ypos > -1) {

   141         // test for DMY, MDY, YMD, YDM

   142         if (dpos < mpos && mpos < ypos) {

   143             lOrder = Q3DateEdit::DMY;

   144         } else if (mpos < dpos && dpos < ypos) {

   145             lOrder = Q3DateEdit::MDY;

   146         } else if (ypos < mpos && mpos < dpos) {

   147             lOrder = Q3DateEdit::YMD;

   148         } else if (ypos < dpos && dpos < mpos) {

   149             lOrder = Q3DateEdit::YDM;

   150         } else {

   151             // cannot determine the dateformat - use the default

   152             return;

   153         }

   154 

   155         // this code needs to change if new formats are added

   156 

   157 #ifndef Q_WS_WIN

   158         QString sep = d.mid(qMin(dpos, mpos) + 2, QABS(dpos - mpos) - 2);

   159         if (d.count(sep) == 2) {

   160             *lDateSep = sep;

   161         }

   162 #endif

   163     }

   164 

   165 #ifndef Q_WS_WIN

   166     QString t = QTime(11, 22, 33).toString(Qt::LocalDate);

   167     dpos = t.indexOf(QLatin1String("11"));

   168     mpos = t.indexOf(QLatin1String("22"));

   169     ypos = t.indexOf(QLatin1String("33"));

   170     // We only allow hhmmss

   171     if (dpos > -1 && dpos < mpos && mpos < ypos) {

   172         QString sep = t.mid(dpos + 2, mpos - dpos - 2);

   173         if (sep == t.mid(mpos + 2, ypos - mpos - 2)) {

   174             *lTimeSep = sep;

   175         }

   176     }

   177 #endif

   178 }

   179 

   180 static Q3DateEdit::Order localOrder() {

   181     if (!lDateSep) {

   182         readLocaleSettings();

   183     }

   184     return lOrder;

   185 }

   186 

   187 static QString localDateSep() {

   188     if (!lDateSep) {

   189         readLocaleSettings();

   190     }

   191     return *lDateSep;

   192 }

   193 

   194 static QString localTimeSep() {

   195     if (!lTimeSep) {

   196         readLocaleSettings();

   197     }

   198     return *lTimeSep;

   199 }

   200 

   201 class Q3DateTimeEditorPrivate

   202 {

   203 public:

   204     Q3DateTimeEditorPrivate()

   205         : frm(true),

   206           parag(new Q3TextParagraph(0, 0, 0, false)),

   207           focusSec(0)

   208     {

   209         parag->formatter()->setWrapEnabled(false);

   210         cursor = new Q3TextCursor(0);

   211         cursor->setParagraph(parag);

   212         offset = 0;

   213         sep = localDateSep();

   214         refcount++;

   215     }

   216     ~Q3DateTimeEditorPrivate()

   217     {

   218         delete parag;

   219         delete cursor;

   220         if (!--refcount)

   221             cleanup();

   222     }

   223 

   224     void appendSection(const QNumberSection& sec)

   225     {

   226         sections.append(sec);

   227 

   228     }

   229     void clearSections()

   230     {

   231         sections.clear();

   232     }

   233     void setSectionSelection(int sec, int selstart, int selend)

   234     {

   235         if (sec < 0 || sec >= sections.count())

   236             return;

   237         sections[sec].setSelectionStart(selstart);

   238         sections[sec].setSelectionEnd(selend);

   239     }

   240     uint sectionCount() const { return (uint)sections.count(); }

   241     void setSeparator(const QString& s) { sep = s; }

   242     QString separator() const { return sep; }

   243 

   244     void setFrame(bool f) { frm = f; }

   245     bool frame() const { return frm; }

   246 

   247     int focusSection() const { return focusSec; }

   248     int section(const QPoint& p)

   249     {

   250         cursor->place(p + QPoint(offset, 0), parag);

   251         int idx = cursor->index();

   252         for (int i = 0; i < sections.count(); ++i) {

   253             if (idx >= sections[i].selectionStart() &&

   254                  idx <= sections[i].selectionEnd())

   255                 return i;

   256         }

   257         return -1;

   258     }

   259     QNumberSection section(int idx) const

   260     {

   261         return sections[idx];

   262     }

   263     bool setFocusSection(int idx)

   264     {

   265         if (idx > (int)sections.count()-1 || idx < 0)

   266             return false;

   267         if (idx != focusSec) {

   268             focusSec = idx;

   269             applyFocusSelection();

   270             return true;

   271         }

   272         return false;

   273     }

   274 

   275     bool inSectionSelection(int idx)

   276     {

   277         for (int i = 0; i < sections.count(); ++i) {

   278             if (idx >= sections[i].selectionStart() &&

   279                  idx <= sections[i].selectionEnd())

   280                 return true;

   281         }

   282         return false;

   283     }

   284 

   285     void paint(const QString& txt, bool focus, QPainter& p,

   286                 const QPalette&pal, const QRect& rect, QStyle *style)

   287     {

   288         int fw = 0;

   289         if (frm)

   290             fw = style->pixelMetric(QStyle::PM_DefaultFrameWidth);

   291 

   292         parag->truncate(0);

   293         parag->append(txt);

   294         if (!focus)

   295             parag->removeSelection(Q3TextDocument::Standard);

   296         else {

   297             applyFocusSelection();

   298         }

   299 

   300         /* color all QDATETIMEEDIT_HIDDEN_CHAR chars to background color */

   301         Q3TextFormat *fb = parag->formatCollection()->format(p.font(),

   302                                                              pal.base().color());

   303         Q3TextFormat *nf = parag->formatCollection()->format(p.font(),

   304                                                              pal.text().color());

   305         for (int i = 0; i < txt.length(); ++i) {

   306             parag->setFormat(i, 1, nf);

   307             if (inSectionSelection(i))

   308                 continue;

   309             if (txt.at(i) == QDATETIMEEDIT_HIDDEN_CHAR)

   310                 parag->setFormat(i, 1, fb);

   311             else

   312                 parag->setFormat(i, 1, nf);

   313         }

   314         fb->removeRef();

   315         nf->removeRef();

   316 

   317         QRect r(rect.x(), rect.y(), rect.width() - 2 * (2 + fw), rect.height());

   318         parag->pseudoDocument()->docRect = r;

   319         parag->invalidate(0);

   320         parag->format();

   321 

   322         int xoff = 2 + fw - offset;

   323         int yoff = (rect.height() - parag->rect().height() + 1) / 2;

   324         if (yoff < 0)

   325             yoff = 0;

   326 

   327         p.translate(xoff, yoff);

   328         parag->paint(p, pal, 0, true);

   329         if (frm)

   330             p.translate(-xoff, -yoff);

   331     }

   332 

   333     void resize(const QSize& size) { sz = size; }

   334 

   335     int mapSection(int sec)

   336     {

   337         return (sec >= 0 && sec < sections.count() ? sections[sec].index() : -1);

   338     }

   339 

   340 protected:

   341     void applyFocusSelection()

   342     {

   343         if (focusSec > -1 && focusSec < sections.count()) {

   344             int selstart = sections[focusSec].selectionStart();

   345             int selend = sections[focusSec].selectionEnd();

   346             parag->setSelection(Q3TextDocument::Standard, selstart, selend);

   347             parag->format();

   348             if (parag->at(selstart)->x < offset ||

   349                  parag->at(selend)->x + parag->string()->width(selend) > offset + sz.width()) {

   350                 offset = parag->at(selstart)->x;

   351             }

   352         }

   353     }

   354 private:

   355     bool frm;

   356     Q3TextParagraph *parag;

   357     Q3TextCursor *cursor;

   358     QSize sz;

   359     int focusSec;

   360     QList< QNumberSection > sections;

   361     QString sep;

   362     int offset;

   363 };

   364 

   365 class Q3DateTimeEditor : public QWidget

   366 {

   367     Q_OBJECT

   368 public:

   369     Q3DateTimeEditor(Q3DateTimeEditBase *widget, QWidget *parent, const char* name=0);

   370     ~Q3DateTimeEditor();

   371 

   372     void setControlWidget(Q3DateTimeEditBase * widget);

   373     Q3DateTimeEditBase * controlWidget() const;

   374 

   375     void setSeparator(const QString& s);

   376     QString separator() const;

   377 

   378     int  focusSection() const;

   379     bool setFocusSection(int s);

   380     void appendSection(const QNumberSection& sec);

   381     void clearSections();

   382     void setSectionSelection(int sec, int selstart, int selend);

   383     bool eventFilter(QObject *o, QEvent *e);

   384     int  sectionAt(const QPoint &p);

   385     int mapSection(int sec);

   386 

   387 protected:

   388     void init();

   389     bool event(QEvent *e);

   390     void resizeEvent(QResizeEvent *);

   391     void paintEvent(QPaintEvent *);

   392     void mousePressEvent(QMouseEvent *e);

   393 

   394 private:

   395     Q3DateTimeEditBase* cw;

   396     Q3DateTimeEditorPrivate* d;

   397 };

   398 

   399 class QDateTimeSpinWidget : public Q3SpinWidget

   400 {

   401     Q_OBJECT

   402 public:

   403     QDateTimeSpinWidget(QWidget *parent, const char *name)

   404         : Q3SpinWidget(parent, name)

   405     {

   406     }

   407 

   408     void changeEvent(QEvent *e)

   409     {

   410 	if (e->type() == QEvent::EnabledChange && isEnabled()) {

   411 	    Q3DateEdit *de = qobject_cast<Q3DateEdit*>(parentWidget());

   412 	    if (de) {

   413 		setUpEnabled(de->date() < de->maxValue());

   414 		setDownEnabled(de->date() > de->minValue());

   415 	    } else {

   416 		setUpEnabled(true);

   417 		setDownEnabled(true);

   418 	    }

   419 	}

   420     }

   421     void enabledChange(bool notenabled)

   422     {

   423 	Q3DateEdit *de = qobject_cast<Q3DateEdit*>(parentWidget());

   424 	if (de && !notenabled) {

   425 	    setUpEnabled(de->date() < de->maxValue());

   426 	    setDownEnabled(de->date() > de->minValue());

   427 	} else {

   428 	    setUpEnabled(!notenabled);

   429 	    setDownEnabled(!notenabled);

   430 	}

   431     }

   432 

   433 

   434 protected:

   435 #ifndef QT_NO_WHEELEVENT

   436     void wheelEvent(QWheelEvent *e)

   437     {

   438         Q3DateTimeEditor *editor = qobject_cast<Q3DateTimeEditor*>(editWidget());

   439         Q_ASSERT(editor);

   440         if (!editor)

   441             return;

   442 

   443         int section = editor->sectionAt(e->pos());

   444         editor->setFocusSection(section);

   445 

   446         if (section == -1)

   447             return;

   448         Q3SpinWidget::wheelEvent(e);

   449     }

   450 #endif

   451 };

   452 

   453 /*!

   454     Constructs an empty datetime editor with parent \a parent and

   455     called \a name.

   456 */

   457 Q3DateTimeEditor::Q3DateTimeEditor(Q3DateTimeEditBase *widget, QWidget *parent, const char * name)

   458     : QWidget(parent, name)

   459 {

   460     d = new Q3DateTimeEditorPrivate();

   461     cw = widget;

   462     init();

   463 }

   464 

   465 /*!

   466     Destroys the object and frees any allocated resources.

   467 */

   468 

   469 Q3DateTimeEditor::~Q3DateTimeEditor()

   470 {

   471     delete d;

   472 }

   473 

   474 /*! \internal

   475 

   476 */

   477 

   478 void Q3DateTimeEditor::init()

   479 {

   480     setBackgroundRole(QPalette::Base);

   481     setFocusSection(-1);

   482     installEventFilter(this);

   483     setFocusPolicy(Qt::WheelFocus);

   484 }

   485 

   486 

   487 /*! \reimp

   488 

   489 */

   490 

   491 bool Q3DateTimeEditor::event(QEvent *e)

   492 {

   493     if (e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut) {

   494         if (e->type() == QEvent::FocusOut)

   495             qApp->sendEvent(cw, e);

   496         update(rect());

   497     } else if (e->type() == QEvent::ShortcutOverride) {

   498         QKeyEvent* ke = (QKeyEvent*) e;

   499         switch (ke->key()) {

   500         case Qt::Key_Delete:

   501         case Qt::Key_Backspace:

   502         case Qt::Key_Up:

   503         case Qt::Key_Down:

   504         case Qt::Key_Left:

   505         case Qt::Key_Right:

   506             ke->accept();

   507         default:

   508             break;

   509         }

   510     }

   511     return QWidget::event(e);

   512 }

   513 

   514 /*! \reimp

   515 

   516 */

   517 

   518 void Q3DateTimeEditor::resizeEvent(QResizeEvent *e)

   519 {

   520     d->resize(e->size());

   521     QWidget::resizeEvent(e);

   522 }

   523 

   524 

   525 /*! \reimp

   526 

   527 */

   528 

   529 void Q3DateTimeEditor::paintEvent(QPaintEvent *)

   530 {

   531     QString txt;

   532     for (uint i = 0; i < d->sectionCount(); ++i) {

   533         txt += cw->sectionFormattedText(i);

   534         if (i < d->sectionCount()-1) {

   535             if (d->section(i+1).separator())

   536                 txt += d->separator();

   537             else

   538                 txt += QLatin1Char(' ');

   539         }

   540     }

   541 

   542     QPainter p(this);

   543     const QBrush &bg = palette().brush(isEnabled() ? QPalette::Base : QPalette::Window);

   544     p.fillRect(0, 0, width(), height(), bg);

   545     d->paint(txt, hasFocus(), p, palette(), rect(), style());

   546 }

   547 

   548 

   549 /*!

   550     Returns the section index at point \a p.

   551 */

   552 int Q3DateTimeEditor::sectionAt(const QPoint &p)

   553 {

   554     return d->section(p);

   555 }

   556 

   557 int Q3DateTimeEditor::mapSection(int sec)

   558 {

   559     return d->mapSection(sec);

   560 }

   561 

   562 

   563 /*! \reimp

   564 

   565 */

   566 

   567 void Q3DateTimeEditor::mousePressEvent(QMouseEvent *e)

   568 {

   569     QPoint p(e->pos().x(), 0);

   570     int sec = sectionAt(p);

   571     if (sec != -1) {

   572         cw->setFocusSection(sec);

   573         repaint(rect());

   574     }

   575 }

   576 

   577 /*! \reimp

   578 

   579 */

   580 bool Q3DateTimeEditor::eventFilter(QObject *o, QEvent *e)

   581 {

   582     if (o == this) {

   583         if (e->type() == QEvent::KeyPress) {

   584             QKeyEvent *ke = (QKeyEvent*)e;

   585             switch (ke->key()) {

   586             case Qt::Key_Right:

   587                 if (d->focusSection() < (int)d->sectionCount()-1) {

   588                     if (cw->setFocusSection(focusSection()+1))

   589                         repaint(rect());

   590                 }

   591                 return true;

   592             case Qt::Key_Left:

   593                 if (d->focusSection() > 0) {

   594                     if (cw->setFocusSection(focusSection()-1))

   595                         repaint(rect());

   596                 }

   597                 return true;

   598             case Qt::Key_Up:

   599                 cw->stepUp();

   600                 return true;

   601             case Qt::Key_Down:

   602                 cw->stepDown();

   603                 return true;

   604             case Qt::Key_Backspace:

   605                 if (qobject_cast<Q3DateEdit*>(cw))

   606                     ((Q3DateEdit*)cw)->removeFirstNumber(d->focusSection());

   607                 else if (qobject_cast<Q3TimeEdit*>(cw))

   608                     ((Q3TimeEdit*)cw)->removeFirstNumber(d->focusSection());

   609                 return true;

   610             case Qt::Key_Delete:

   611                 cw->removeLastNumber(d->focusSection());

   612                 return true;

   613             case Qt::Key_Tab:

   614             case Qt::Key_BackTab: {

   615                 if (ke->state() == Qt::ControlButton)

   616                     return false;

   617                 QWidget *w = this;

   618                 bool hadDateEdit = false;

   619                 while (w) {

   620                     if (qobject_cast<QDateTimeSpinWidget*>(w) || qobject_cast<Q3DateTimeEdit*>(w))

   621                         break;

   622                     hadDateEdit = hadDateEdit || qobject_cast<Q3DateEdit*>(w);

   623                     w = w->parentWidget();

   624                 }

   625                 if (w) {

   626                     if (!qobject_cast<Q3DateTimeEdit*>(w)) {

   627                         w = w->parentWidget();

   628                     } else {

   629                         Q3DateTimeEdit *ed = (Q3DateTimeEdit*)w;

   630                         if (hadDateEdit && ke->key() == Qt::Key_Tab) {

   631                             ed->timeEdit()->setFocus();

   632                             return true;

   633                         } else if (!hadDateEdit && ke->key() == Qt::Key_BackTab) {

   634                             ed->dateEdit()->setFocus();

   635                             return true;

   636                         } else {

   637                             while (w && !qobject_cast<Q3DateTimeEdit*>(w))

   638                                 w = w->parentWidget();

   639                         }

   640                     }

   641                     qApp->sendEvent(w, e);

   642                     return true;

   643                 }

   644             } break;

   645             default:

   646                 QString txt = ke->text().toLower();

   647                 if (!txt.isEmpty() && !separator().isEmpty() && txt[0] == separator()[0]) {

   648                     // do the same thing as KEY_RIGHT when the user presses the separator key

   649                     if (d->focusSection() < 2) {

   650                         if (cw->setFocusSection(focusSection()+1))

   651                             repaint(rect());

   652                     }

   653                     return true;

   654                 } else if (!txt.isEmpty() && qobject_cast<Q3TimeEdit*>(cw) && focusSection() == (int) d->sectionCount()-1) {

   655                     // the first character of the AM/PM indicator toggles if the section has focus

   656                     Q3TimeEdit *te = (Q3TimeEdit*)cw;

   657                     QTime time = te->time();

   658                     if (lAMPM && lAM && lPM && (te->display()&Q3TimeEdit::AMPM)) {

   659                         if (txt[0] == (*lAM).toLower()[0] && time.hour() >= 12) {

   660                             time.setHMS(time.hour()-12, time.minute(), time.second(), time.msec());

   661                             te->setTime(time);

   662                         } else if (txt[0] == (*lPM).toLower()[0] && time.hour() < 12) {

   663                             time.setHMS(time.hour()+12, time.minute(), time.second(), time.msec());

   664                             te->setTime(time);

   665                         }

   666                     }

   667                 }

   668 

   669                 int num = txt[0].digitValue();

   670                 if (num != -1) {

   671                     cw->addNumber(d->focusSection(), num);

   672                     return true;

   673                 }

   674             }

   675         }

   676     }

   677     return false;

   678 }

   679 

   680 

   681 /*!

   682     Appends the number section \a sec to the editor.

   683 */

   684 

   685 void Q3DateTimeEditor::appendSection(const QNumberSection& sec)

   686 {

   687     d->appendSection(sec);

   688 }

   689 

   690 /*!

   691     Removes all sections from the editor.

   692 */

   693 

   694 void Q3DateTimeEditor::clearSections()

   695 {

   696     d->clearSections();

   697 }

   698 

   699 /*!

   700     Sets the selection of \a sec to start at \a selstart and end at \a

   701     selend.

   702 */

   703 

   704 void Q3DateTimeEditor::setSectionSelection(int sec, int selstart, int selend)

   705 {

   706     d->setSectionSelection(sec, selstart, selend);

   707 }

   708 

   709 /*!

   710     Sets the separator for all numbered sections to \a s. Note that

   711     currently, only the first character of \a s is used.

   712 */

   713 

   714 void Q3DateTimeEditor::setSeparator(const QString& s)

   715 {

   716     d->setSeparator(s);

   717     update();

   718 }

   719 

   720 

   721 /*!

   722     Returns the editor's separator.

   723 */

   724 

   725 QString Q3DateTimeEditor::separator() const

   726 {

   727     return d->separator();

   728 }

   729 

   730 /*!

   731     Returns the number of the section that has focus.

   732 */

   733 

   734 int Q3DateTimeEditor::focusSection() const

   735 {

   736     return d->focusSection();

   737 }

   738 

   739 

   740 /*!

   741     Sets the focus to section \a sec. If \a sec does not exist,

   742     nothing happens.

   743 */

   744 

   745 bool Q3DateTimeEditor::setFocusSection(int sec)

   746 {

   747     return d->setFocusSection(sec);

   748 }

   749 

   750 /*!

   751     \class Q3DateTimeEditBase

   752     \brief The Q3DateTimeEditBase class provides an abstraction for date and edit editors.

   753 

   754     \compat

   755 

   756     Small abstract class that provides some functions that are common

   757     for both Q3DateEdit and Q3TimeEdit. It is used internally by

   758     Q3DateTimeEditor.

   759 */

   760 

   761 /*!

   762     \fn Q3DateTimeEditBase::Q3DateTimeEditBase(QWidget *, const char*)

   763     \internal

   764 */

   765 

   766 /*!

   767     \fn Q3DateTimeEditBase::setFocusSection(int)

   768     \internal

   769 */

   770 

   771 /*! \fn QString Q3DateTimeEditBase::sectionFormattedText(int sec)

   772     \internal

   773 

   774   Pure virtual function which returns the formatted text of section \a

   775   sec.

   776 

   777 */

   778 

   779 /*! \fn void Q3DateTimeEditBase::stepUp()

   780     \internal

   781 

   782   Pure virtual slot which is called whenever the user increases the

   783   number in a section by pressing the widget's arrow buttons or the

   784   keyboard's arrow keys.

   785 */

   786 

   787 /*! \fn void Q3DateTimeEditBase::stepDown()

   788     \internal

   789 

   790   Pure virtual slot which is called whenever the user decreases the

   791   number in a section by pressing the widget's arrow buttons or the

   792   keyboard's arrow keys.

   793 

   794 */

   795 

   796 /*! \fn void Q3DateTimeEditBase::addNumber(int sec, int num)

   797     \internal

   798 

   799   Pure virtual function which is called whenever the user types a number.

   800   \a sec indicates the section where the number should be added. \a

   801   num is the number that was pressed.

   802 */

   803 

   804 /*! \fn void Q3DateTimeEditBase::removeLastNumber(int sec)

   805     \internal

   806 

   807   Pure virtual function which is called whenever the user tries to

   808   remove the last number from \a sec by pressing the delete key.

   809 */

   810 

   811 ////////////////

   812 

   813 class Q3DateEditPrivate

   814 {

   815 public:

   816     int y;

   817     int m;

   818     int d;

   819     // remembers the last entry for the day.

   820     // if the day is 31 and you cycle through the months,

   821     // the day will be 31 again if you reach a month with 31 days

   822     // otherwise it will be the highest day in the month

   823     int dayCache;

   824     int yearSection;

   825     int monthSection;

   826     int daySection;

   827     Q3DateEdit::Order ord;

   828     bool overwrite;

   829     bool adv;

   830     int timerId;

   831     bool typing;

   832     QDate min;

   833     QDate max;

   834     bool changed;

   835     Q3DateTimeEditor *ed;

   836     Q3SpinWidget *controls;

   837 };

   838 

   839 

   840 /*!

   841     \class Q3DateEdit

   842     \brief The Q3DateEdit class provides a date editor.

   843 

   844     \compat

   845 

   846     Q3DateEdit allows the user to edit dates by using the keyboard or

   847     the arrow keys to increase/decrease date values. The arrow keys

   848     can be used to move from section to section within the Q3DateEdit

   849     box. Dates appear in accordance with the local date/time settings

   850     or in year, month, day order if the system doesn't provide this

   851     information. It is recommended that the Q3DateEdit be initialised

   852     with a date, e.g.

   853 

   854     \snippet doc/src/snippets/code/src_qt3support_widgets_q3datetimeedit.cpp 0

   855 

   856     Here we've created a new Q3DateEdit object initialised with today's

   857     date and restricted the valid date range to today plus or minus

   858     365 days. We've set the order to month, day, year. If the auto

   859     advance property is true (as we've set it here) when the user

   860     completes a section of the date, e.g. enters two digits for the

   861     month, they are automatically taken to the next section.

   862 

   863     The maximum and minimum values for a date value in the date editor

   864     default to the maximum and minimum values for a QDate. You can

   865     change this by calling setMinValue(), setMaxValue() or setRange().

   866 

   867     Terminology: A Q3DateEdit widget comprises three 'sections', one

   868     each for the year, month and day. You can change the separator

   869     character using Q3DateTimeEditor::setSeparator(), by default the

   870     separator will be taken from the systems settings. If that is

   871     not possible, it defaults to "-".

   872 

   873     \img datetimewidgets.png Date Time Widgets

   874 

   875     \sa QDate Q3TimeEdit Q3DateTimeEdit

   876 */

   877 

   878 /*!

   879     \enum Q3DateEdit::Order

   880 

   881     This enum defines the order in which the sections that comprise a

   882     date appear.

   883 

   884     \value MDY month-day-year

   885     \value DMY day-month-year

   886     \value YMD year-month-day (the default)

   887     \omitvalue YDM

   888 */

   889 

   890 /*!

   891     \enum Q3TimeEdit::Display

   892 

   893     This enum defines the sections that comprise a time

   894 

   895     \value Hours The hours section

   896     \value Minutes The minutes section

   897     \value Seconds The seconds section

   898     \value AMPM The AM/PM section

   899 

   900     The values can be or'ed together to show any combination.

   901 */

   902 

   903 /*!

   904     Constructs an empty date editor which is a child of \a parent and

   905     called name \a name.

   906 */

   907 

   908 Q3DateEdit::Q3DateEdit(QWidget * parent, const char * name)

   909     : Q3DateTimeEditBase(parent, name)

   910 {

   911     init();

   912     updateButtons();

   913 }

   914 

   915 /*!

   916     \overload

   917 

   918     Constructs a date editor with the initial value \a date, parent \a

   919     parent and called \a name.

   920 

   921     The date editor is initialized with \a date.

   922 */

   923 

   924 Q3DateEdit::Q3DateEdit(const QDate& date, QWidget * parent, const char * name)

   925     : Q3DateTimeEditBase(parent, name)

   926 {

   927     init();

   928     setDate(date);

   929 }

   930 

   931 /*! \internal

   932 */

   933 void Q3DateEdit::init()

   934 {

   935     d = new Q3DateEditPrivate();

   936     d->controls = new QDateTimeSpinWidget(this, 0);

   937     d->ed = new Q3DateTimeEditor(this, d->controls);

   938     d->controls->setEditWidget(d->ed);

   939     setFocusProxy(d->ed);

   940     connect(d->controls, SIGNAL(stepUpPressed()), SLOT(stepUp()));

   941     connect(d->controls, SIGNAL(stepDownPressed()), SLOT(stepDown()));

   942     connect(this, SIGNAL(valueChanged(QDate)), SLOT(updateButtons()));

   943     d->ed->appendSection(QNumberSection(0,4));

   944     d->ed->appendSection(QNumberSection(5,7));

   945     d->ed->appendSection(QNumberSection(8,10));

   946 

   947     d->yearSection = -1;

   948     d->monthSection = -1;

   949     d->daySection = -1;

   950 

   951     d->y = 0;

   952     d->m = 0;

   953     d->d = 0;

   954     d->dayCache = 0;

   955     setOrder(localOrder());

   956     setFocusSection(0);

   957     d->overwrite = true;

   958     d->adv = false;

   959     d->timerId = 0;

   960     d->typing = false;

   961     d->min = QDate(1752, 9, 14);

   962     d->max = QDate(8000, 12, 31);

   963     d->changed = false;

   964 

   965     setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);

   966 

   967     refcount++;

   968 }

   969 

   970 /*!

   971     Destroys the object and frees any allocated resources.

   972 */

   973 

   974 Q3DateEdit::~Q3DateEdit()

   975 {

   976     delete d;

   977     if (!--refcount)

   978         cleanup();

   979 }

   980 

   981 /*!

   982     \property Q3DateEdit::minValue

   983 

   984     \brief the editor's minimum value

   985 

   986     Setting the minimum date value is equivalent to calling

   987     Q3DateEdit::setRange(\e d, maxValue()), where \e d is the minimum

   988     date. The default minimum date is 1752-09-14.

   989 

   990     \sa maxValue setRange()

   991 */

   992 

   993 QDate Q3DateEdit::minValue() const

   994 {

   995     return d->min;

   996 }

   997 

   998 /*!

   999     \property Q3DateEdit::maxValue

  1000 

  1001     \brief the editor's maximum value

  1002 

  1003     Setting the maximum date value for the editor is equivalent to

  1004     calling Q3DateEdit::setRange(minValue(), \e d), where \e d is the

  1005     maximum date. The default maximum date is 8000-12-31.

  1006 

  1007     \sa minValue setRange()

  1008 */

  1009 

  1010 QDate Q3DateEdit::maxValue() const

  1011 {

  1012     return d->max;

  1013 }

  1014 

  1015 

  1016 /*!

  1017     Sets the valid input range for the editor to be from \a min to \a

  1018     max inclusive. If \a min is invalid no minimum date will be set.

  1019     Similarly, if \a max is invalid no maximum date will be set.

  1020 */

  1021 

  1022 void Q3DateEdit::setRange(const QDate& min, const QDate& max)

  1023 {

  1024     if (min.isValid())

  1025         d->min = min;

  1026     if (max.isValid())

  1027         d->max = max;

  1028 }

  1029 

  1030 /*!

  1031     Sets the separator to \a s. Note that currently only the first

  1032     character of \a s is used.

  1033 */

  1034 

  1035 void Q3DateEdit::setSeparator(const QString& s)

  1036 {

  1037     d->ed->setSeparator(s);

  1038 }

  1039 

  1040 /*!

  1041     Returns the editor's separator.

  1042 */

  1043 

  1044 QString Q3DateEdit::separator() const

  1045 {

  1046     return d->ed->separator();

  1047 }

  1048 

  1049 

  1050 /*!

  1051     Enables/disables the push buttons according to the min/max date

  1052     for this widget.

  1053 */

  1054 

  1055 void Q3DateEdit::updateButtons()

  1056 {

  1057     if (!isEnabled())

  1058         return;

  1059 

  1060     bool upEnabled = date() < maxValue();

  1061     bool downEnabled = date() > minValue();

  1062 

  1063     d->controls->setUpEnabled(upEnabled);

  1064     d->controls->setDownEnabled(downEnabled);

  1065 }

  1066 

  1067 /*! \reimp

  1068  */

  1069 void Q3DateEdit::resizeEvent(QResizeEvent *)

  1070 {

  1071     d->controls->resize(width(), height());

  1072 }

  1073 

  1074 /*! \reimp

  1075 

  1076 */

  1077 QSize Q3DateEdit::sizeHint() const

  1078 {

  1079     ensurePolished();

  1080     QFontMetrics fm(font());

  1081     int fw = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, 0, this);

  1082     int h = qMax(fm.lineSpacing(), 14) + 2;

  1083     int w = 2 + fm.width(QLatin1Char('9')) * 8 + fm.width(d->ed->separator()) * 2 + d->controls->upRect().width() + fw * 4;

  1084 

  1085     return QSize(w, qMax(h + fw * 2,20)).expandedTo(QApplication::globalStrut());

  1086 }

  1087 

  1088 /*! \reimp

  1089 

  1090 */

  1091 QSize Q3DateEdit::minimumSizeHint() const

  1092 {

  1093     return sizeHint();

  1094 }

  1095 

  1096 

  1097 /*!

  1098     Returns the formatted number for section \a sec. This will

  1099     correspond to either the year, month or day section, depending on

  1100     the current display order.

  1101 

  1102     \sa setOrder()

  1103 */

  1104 

  1105 QString Q3DateEdit::sectionFormattedText(int sec)

  1106 {

  1107     QString txt;

  1108     txt = sectionText(sec);

  1109     if (d->typing && sec == d->ed->focusSection())

  1110         d->ed->setSectionSelection(sec, sectionOffsetEnd(sec) - txt.length(),

  1111                              sectionOffsetEnd(sec));

  1112     else

  1113         d->ed->setSectionSelection(sec, sectionOffsetEnd(sec) - sectionLength(sec),

  1114                              sectionOffsetEnd(sec));

  1115     txt = txt.rightJustified(sectionLength(sec), QDATETIMEEDIT_HIDDEN_CHAR);

  1116     return txt;

  1117 }

  1118 

  1119 

  1120 /*!

  1121     Returns the desired length (number of digits) of section \a sec.

  1122     This will correspond to either the year, month or day section,

  1123     depending on the current display order.

  1124 

  1125     \sa setOrder()

  1126 */

  1127 

  1128 int Q3DateEdit::sectionLength(int sec) const

  1129 {

  1130     int val = 0;

  1131     if (sec == d->yearSection) {

  1132         val = 4;

  1133     } else if (sec == d->monthSection) {

  1134         val = 2;