MCL/sf/mw/qt: comparison src/gui/widgets/qcalendarwidget.cpp

equal deleted inserted replaced

--1:000000000000
+:1918ee327afb
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qcalendarwidget.h"
+#ifndef QT_NO_CALENDARWIDGET
+#include <qabstractitemmodel.h>
+#include <qitemdelegate.h>
+#include <qdatetime.h>
+#include <qtableview.h>
+#include <qlayout.h>
+#include <qevent.h>
+#include <qtextformat.h>
+#include <qheaderview.h>
+#include <private/qwidget_p.h>
+#include <qpushbutton.h>
+#include <qtoolbutton.h>
+#include <qlabel.h>
+#include <qspinbox.h>
+#include <qmenu.h>
+#include <qapplication.h>
+#include <qbasictimer.h>
+#include <qstylepainter.h>
+#include <private/qcalendartextnavigator_p.h>
+QT_BEGIN_NAMESPACE
+enum {
+RowCount = 6,
+ColumnCount = 7,
+HeaderColumn = 0,
+HeaderRow = 0,
+MinimumDayOffset = 1
+};
+class QCalendarDateSectionValidator
+{
+public:
+enum Section {
+NextSection,
+ThisSection,
+PrevSection
+};
+QCalendarDateSectionValidator() {}
+virtual ~QCalendarDateSectionValidator() {}
+virtual Section handleKey(int key) = 0;
+virtual QDate applyToDate(const QDate &date) const = 0;
+virtual void setDate(const QDate &date) = 0;
+virtual QString text() const = 0;
+virtual QString text(const QDate &date, int repeat) const = 0;
+QLocale m_locale;
+protected:
+QString highlightString(const QString &str, int pos) const;
+private:
+};
+QString QCalendarDateSectionValidator::highlightString(const QString &str, int pos) const
+{
+if (pos == 0)
+return QLatin1String("<b>") + str + QLatin1String("</b>");
+int startPos = str.length() - pos;
+return str.mid(0, startPos) + QLatin1String("<b>") + str.mid(startPos, pos) + QLatin1String("</b>");
+}
+class QCalendarDayValidator : public QCalendarDateSectionValidator
+{
+public:
+QCalendarDayValidator();
+virtual Section handleKey(int key);
+virtual QDate applyToDate(const QDate &date) const;
+virtual void setDate(const QDate &date);
+virtual QString text() const;
+virtual QString text(const QDate &date, int repeat) const;
+private:
+int m_pos;
+int m_day;
+int m_oldDay;
+};
+QCalendarDayValidator::QCalendarDayValidator()
+: QCalendarDateSectionValidator(), m_pos(0), m_day(1), m_oldDay(1)
+{
+}
+QCalendarDateSectionValidator::Section QCalendarDayValidator::handleKey(int key)
+{
+if (key == Qt::Key_Right || key == Qt::Key_Left) {
+m_pos = 0;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Up) {
+m_pos = 0;
+++m_day;
+if (m_day > 31)
+m_day = 1;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Down) {
+m_pos = 0;
+--m_day;
+if (m_day < 1)
+m_day = 31;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Back || key == Qt::Key_Backspace) {
+--m_pos;
+if (m_pos < 0)
+m_pos = 1;
+if (m_pos == 0)
+m_day = m_oldDay;
+else
+m_day = m_day / 10;
+//m_day = m_oldDay / 10 * 10 + m_day / 10;
+if (m_pos == 0)
+return QCalendarDateSectionValidator::PrevSection;
+return QCalendarDateSectionValidator::ThisSection;
+}
+if (key < Qt::Key_0 || key > Qt::Key_9)
+return QCalendarDateSectionValidator::ThisSection;
+int pressedKey = key - Qt::Key_0;
+if (m_pos == 0)
+m_day = pressedKey;
+else
+m_day = m_day % 10 * 10 + pressedKey;
+if (m_day > 31)
+m_day = 31;
+++m_pos;
+if (m_pos > 1) {
+m_pos = 0;
+return QCalendarDateSectionValidator::NextSection;
+}
+return QCalendarDateSectionValidator::ThisSection;
+}
+QDate QCalendarDayValidator::applyToDate(const QDate &date) const
+{
+int day = m_day;
+if (day < 1)
+day = 1;
+else if (day > 31)
+day = 31;
+if (day > date.daysInMonth())
+day = date.daysInMonth();
+return QDate(date.year(), date.month(), day);
+}
+void QCalendarDayValidator::setDate(const QDate &date)
+{
+m_day = m_oldDay = date.day();
+m_pos = 0;
+}
+QString QCalendarDayValidator::text() const
+{
+QString str;
+if (m_day / 10 == 0)
+str += QLatin1Char('0');
+str += QString::number(m_day);
+return highlightString(str, m_pos);
+}
+QString QCalendarDayValidator::text(const QDate &date, int repeat) const
+{
+if (repeat <= 1) {
+return QString::number(date.day());
+} else if (repeat == 2) {
+QString str;
+if (date.day() / 10 == 0)
+str += QLatin1Char('0');
+return str + QString::number(date.day());
+} else if (repeat == 3) {
+return m_locale.dayName(date.dayOfWeek(), QLocale::ShortFormat);
+} else if (repeat >= 4) {
+return m_locale.dayName(date.dayOfWeek(), QLocale::LongFormat);
+}
+return QString();
+}
+//////////////////////////////////
+class QCalendarMonthValidator : public QCalendarDateSectionValidator
+{
+public:
+QCalendarMonthValidator();
+virtual Section handleKey(int key);
+virtual QDate applyToDate(const QDate &date) const;
+virtual void setDate(const QDate &date);
+virtual QString text() const;
+virtual QString text(const QDate &date, int repeat) const;
+private:
+int m_pos;
+int m_month;
+int m_oldMonth;
+};
+QCalendarMonthValidator::QCalendarMonthValidator()
+: QCalendarDateSectionValidator(), m_pos(0), m_month(1), m_oldMonth(1)
+{
+}
+QCalendarDateSectionValidator::Section QCalendarMonthValidator::handleKey(int key)
+{
+if (key == Qt::Key_Right || key == Qt::Key_Left) {
+m_pos = 0;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Up) {
+m_pos = 0;
+++m_month;
+if (m_month > 12)
+m_month = 1;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Down) {
+m_pos = 0;
+--m_month;
+if (m_month < 1)
+m_month = 12;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Back || key == Qt::Key_Backspace) {
+--m_pos;
+if (m_pos < 0)
+m_pos = 1;
+if (m_pos == 0)
+m_month = m_oldMonth;
+else
+m_month = m_month / 10;
+//m_month = m_oldMonth / 10 * 10 + m_month / 10;
+if (m_pos == 0)
+return QCalendarDateSectionValidator::PrevSection;
+return QCalendarDateSectionValidator::ThisSection;
+}
+if (key < Qt::Key_0 || key > Qt::Key_9)
+return QCalendarDateSectionValidator::ThisSection;
+int pressedKey = key - Qt::Key_0;
+if (m_pos == 0)
+m_month = pressedKey;
+else
+m_month = m_month % 10 * 10 + pressedKey;
+if (m_month > 12)
+m_month = 12;
+++m_pos;
+if (m_pos > 1) {
+m_pos = 0;
+return QCalendarDateSectionValidator::NextSection;
+}
+return QCalendarDateSectionValidator::ThisSection;
+}
+QDate QCalendarMonthValidator::applyToDate(const QDate &date) const
+{
+int month = m_month;
+if (month < 1)
+month = 1;
+else if (month > 12)
+month = 12;
+QDate newDate(date.year(), m_month, 1);
+int day = date.day();
+if (day > newDate.daysInMonth())
+day = newDate.daysInMonth();
+return QDate(date.year(), month, day);
+}
+void QCalendarMonthValidator::setDate(const QDate &date)
+{
+m_month = m_oldMonth = date.month();
+m_pos = 0;
+}
+QString QCalendarMonthValidator::text() const
+{
+QString str;
+if (m_month / 10 == 0)
+str += QLatin1Char('0');
+str += QString::number(m_month);
+return highlightString(str, m_pos);
+}
+QString QCalendarMonthValidator::text(const QDate &date, int repeat) const
+{
+if (repeat <= 1) {
+return QString::number(date.month());
+} else if (repeat == 2) {
+QString str;
+if (date.month() / 10 == 0)
+str += QLatin1Char('0');
+return str + QString::number(date.month());
+} else if (repeat == 3) {
+return m_locale.standaloneMonthName(date.month(), QLocale::ShortFormat);
+} else /*if (repeat >= 4)*/ {
+return m_locale.standaloneMonthName(date.month(), QLocale::LongFormat);
+}
+}
+//////////////////////////////////
+class QCalendarYearValidator : public QCalendarDateSectionValidator
+{
+public:
+QCalendarYearValidator();
+virtual Section handleKey(int key);
+virtual QDate applyToDate(const QDate &date) const;
+virtual void setDate(const QDate &date);
+virtual QString text() const;
+virtual QString text(const QDate &date, int repeat) const;
+private:
+int pow10(int n);
+int m_pos;
+int m_year;
+int m_oldYear;
+};
+QCalendarYearValidator::QCalendarYearValidator()
+: QCalendarDateSectionValidator(), m_pos(0), m_year(2000), m_oldYear(2000)
+{
+}
+int QCalendarYearValidator::pow10(int n)
+{
+int power = 1;
+for (int i = 0; i < n; i++)
+power *= 10;
+return power;
+}
+QCalendarDateSectionValidator::Section QCalendarYearValidator::handleKey(int key)
+{
+if (key == Qt::Key_Right || key == Qt::Key_Left) {
+m_pos = 0;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Up) {
+m_pos = 0;
+++m_year;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Down) {
+m_pos = 0;
+--m_year;
+return QCalendarDateSectionValidator::ThisSection;
+} else if (key == Qt::Key_Back || key == Qt::Key_Backspace) {
+--m_pos;
+if (m_pos < 0)
+m_pos = 3;
+int pow = pow10(m_pos);
+m_year = m_oldYear / pow * pow + m_year % (pow * 10) / 10;
+if (m_pos == 0)
+return QCalendarDateSectionValidator::PrevSection;
+return QCalendarDateSectionValidator::ThisSection;
+}
+if (key < Qt::Key_0 || key > Qt::Key_9)
+return QCalendarDateSectionValidator::ThisSection;
+int pressedKey = key - Qt::Key_0;
+int pow = pow10(m_pos);
+m_year = m_year / (pow * 10) * (pow * 10) + m_year % pow * 10 + pressedKey;
+++m_pos;
+if (m_pos > 3) {
+m_pos = 0;
+return QCalendarDateSectionValidator::NextSection;
+}
+return QCalendarDateSectionValidator::ThisSection;
+}
+QDate QCalendarYearValidator::applyToDate(const QDate &date) const
+{
+int year = m_year;
+if (year < 1)
+year = 1;
+QDate newDate(year, date.month(), 1);
+int day = date.day();
+if (day > newDate.daysInMonth())
+day = newDate.daysInMonth();
+return QDate(year, date.month(), day);
+}
+void QCalendarYearValidator::setDate(const QDate &date)
+{
+m_year = m_oldYear = date.year();
+m_pos = 0;
+}
+QString QCalendarYearValidator::text() const
+{
+QString str;
+int pow = 10;
+for (int i = 0; i < 3; i++) {
+if (m_year / pow == 0)
+str += QLatin1Char('0');
+pow *= 10;
+}
+str += QString::number(m_year);
+return highlightString(str, m_pos);
+}
+QString QCalendarYearValidator::text(const QDate &date, int repeat) const
+{
+if (repeat < 4) {
+QString str;
+int year = date.year() % 100;
+if (year / 10 == 0)
+str = QLatin1Char('0');
+return str + QString::number(year);
+}
+return QString::number(date.year());
+}
+///////////////////////////////////
+class QCalendarDateValidator
+{
+public:
+QCalendarDateValidator();
+~QCalendarDateValidator();
+void handleKeyEvent(QKeyEvent *keyEvent);
+QString currentText() const;
+QDate currentDate() const { return m_currentDate; }
+void setFormat(const QString &format);
+void setInitialDate(const QDate &date);
+void setLocale(const QLocale &locale);
+private:
+struct SectionToken {
+SectionToken(QCalendarDateSectionValidator *val, int rep) : validator(val), repeat(rep) {}
+QCalendarDateSectionValidator *validator;
+int repeat;
+};
+void toNextToken();
+void toPreviousToken();
+void applyToDate();
+int countRepeat(const QString &str, int index) const;
+void clear();
+QStringList m_separators;
+QList<SectionToken *> m_tokens;
+QCalendarDateSectionValidator *m_yearValidator;
+QCalendarDateSectionValidator *m_monthValidator;
+QCalendarDateSectionValidator *m_dayValidator;
+SectionToken *m_currentToken;
+QDate m_initialDate;
+QDate m_currentDate;
+QCalendarDateSectionValidator::Section m_lastSectionMove;
+};
+QCalendarDateValidator::QCalendarDateValidator()
+: m_currentToken(0), m_lastSectionMove(QCalendarDateSectionValidator::ThisSection)
+{
+m_initialDate = m_currentDate = QDate::currentDate();
+m_yearValidator = new QCalendarYearValidator();
+m_monthValidator = new QCalendarMonthValidator();
+m_dayValidator = new QCalendarDayValidator();
+}
+void QCalendarDateValidator::setLocale(const QLocale &locale)
+{
+m_yearValidator->m_locale = locale;
+m_monthValidator->m_locale = locale;
+m_dayValidator->m_locale = locale;
+}
+QCalendarDateValidator::~QCalendarDateValidator()
+{
+delete m_yearValidator;
+delete m_monthValidator;
+delete m_dayValidator;
+clear();
+}
+// from qdatetime.cpp
+int QCalendarDateValidator::countRepeat(const QString &str, int index) const
+{
+Q_ASSERT(index >= 0 && index < str.size());
+int count = 1;
+const QChar ch = str.at(index);
+while (index + count < str.size() && str.at(index + count) == ch)
+++count;
+return count;
+}
+void QCalendarDateValidator::setInitialDate(const QDate &date)
+{
+m_yearValidator->setDate(date);
+m_monthValidator->setDate(date);
+m_dayValidator->setDate(date);
+m_initialDate = date;
+m_currentDate = date;
+m_lastSectionMove = QCalendarDateSectionValidator::ThisSection;
+}
+QString QCalendarDateValidator::currentText() const
+{
+QString str;
+QStringListIterator itSep(m_separators);
+QListIterator<SectionToken *> itTok(m_tokens);
+while (itSep.hasNext()) {
+str += itSep.next();
+if (itTok.hasNext()) {
+SectionToken *token = itTok.next();
+QCalendarDateSectionValidator *validator = token->validator;
+if (m_currentToken == token)
+str += validator->text();
+else
+str += validator->text(m_currentDate, token->repeat);
+}
+}
+return str;
+}
+void QCalendarDateValidator::clear()
+{
+QListIterator<SectionToken *> it(m_tokens);
+while (it.hasNext())
+delete it.next();
+m_tokens.clear();
+m_separators.clear();
+m_currentToken = 0;
+}
+void QCalendarDateValidator::setFormat(const QString &format)
+{
+clear();
+int pos = 0;
+const QLatin1Char quote('\'');
+bool quoting = false;
+QString separator;
+while (pos < format.size()) {
+QString mid = format.mid(pos);
+int offset = 1;
+if (mid.startsWith(quote)) {
+quoting = !quoting;
+} else {
+const QChar nextChar = format.at(pos);
+if (quoting) {
+separator += nextChar;
+} else {
+SectionToken *token = 0;
+if (nextChar == QLatin1Char('d')) {
+offset = qMin(4, countRepeat(format, pos));
+token = new SectionToken(m_dayValidator, offset);
+} else if (nextChar == QLatin1Char('M')) {
+offset = qMin(4, countRepeat(format, pos));
+token = new SectionToken(m_monthValidator, offset);
+} else if (nextChar == QLatin1Char('y')) {
+offset = qMin(4, countRepeat(format, pos));
+token = new SectionToken(m_yearValidator, offset);
+} else {
+separator += nextChar;
+}
+if (token) {
+m_tokens.append(token);
+m_separators.append(separator);
+separator = QString();
+if (!m_currentToken)
+m_currentToken = token;
+}
+}
+}
+pos += offset;
+}
+m_separators += separator;
+}
+void QCalendarDateValidator::applyToDate()
+{
+m_currentDate = m_yearValidator->applyToDate(m_currentDate);
+m_currentDate = m_monthValidator->applyToDate(m_currentDate);
+m_currentDate = m_dayValidator->applyToDate(m_currentDate);
+}
+void QCalendarDateValidator::toNextToken()
+{
+const int idx = m_tokens.indexOf(m_currentToken);
+if (idx == -1)
+return;
+if (idx + 1 >= m_tokens.count())
+m_currentToken = m_tokens.first();
+else
+m_currentToken = m_tokens.at(idx + 1);
+}
+void QCalendarDateValidator::toPreviousToken()
+{
+const int idx = m_tokens.indexOf(m_currentToken);
+if (idx == -1)
+return;
+if (idx - 1 < 0)
+m_currentToken = m_tokens.last();
+else
+m_currentToken = m_tokens.at(idx - 1);
+}
+void QCalendarDateValidator::handleKeyEvent(QKeyEvent *keyEvent)
+{
+if (!m_currentToken)
+return;
+int key = keyEvent->key();
+if (m_lastSectionMove == QCalendarDateSectionValidator::NextSection) {
+if (key == Qt::Key_Back || key == Qt::Key_Backspace)
+toPreviousToken();
+}
+if (key == Qt::Key_Right)
+toNextToken();
+else if (key == Qt::Key_Left)
+toPreviousToken();
+m_lastSectionMove = m_currentToken->validator->handleKey(key);
+applyToDate();
+if (m_lastSectionMove == QCalendarDateSectionValidator::NextSection)
+toNextToken();
+else if (m_lastSectionMove == QCalendarDateSectionValidator::PrevSection)
+toPreviousToken();
+}
+QWidget *QCalendarTextNavigator::widget() const
+{
+return m_widget;
+}
+void QCalendarTextNavigator::setWidget(QWidget *widget)
+{
+m_widget = widget;
+}
+QDate QCalendarTextNavigator::date() const
+{
+return m_date;
+}
+void QCalendarTextNavigator::setDate(const QDate &date)
+{
+m_date = date;
+}
+void QCalendarTextNavigator::updateDateLabel()
+{
+if (!m_widget)
+return;
+m_acceptTimer.start(m_editDelay, this);
+m_dateText->setText(m_dateValidator->currentText());
+QSize s = m_dateFrame->sizeHint();
+QRect r = m_widget->geometry(); // later, just the table section
+QRect newRect((r.width() - s.width()) / 2, (r.height() - s.height()) / 2, s.width(), s.height());
+m_dateFrame->setGeometry(newRect);
+// need to set palette after geometry update as phonestyle sets transparency
+// effect in move event.
+QPalette p = m_dateFrame->palette();
+p.setBrush(QPalette::Window, m_dateFrame->window()->palette().brush(QPalette::Window));
+m_dateFrame->setPalette(p);
+m_dateFrame->raise();
+m_dateFrame->show();
+}
+void QCalendarTextNavigator::applyDate()
+{
+QDate date = m_dateValidator->currentDate();
+if (m_date == date)
+return;
+m_date = date;
+emit dateChanged(date);
+}
+void QCalendarTextNavigator::createDateLabel()
+{
+if (m_dateFrame)
+return;
+m_dateFrame = new QFrame(m_widget);
+QVBoxLayout *vl = new QVBoxLayout;
+m_dateText = new QLabel;
+vl->addWidget(m_dateText);
+m_dateFrame->setLayout(vl);
+m_dateFrame->setFrameShadow(QFrame::Plain);
+m_dateFrame->setFrameShape(QFrame::Box);
+m_dateValidator = new QCalendarDateValidator();
+m_dateValidator->setLocale(m_widget->locale());
+m_dateValidator->setFormat(m_widget->locale().dateFormat(QLocale::ShortFormat));
+m_dateValidator->setInitialDate(m_date);
+m_dateFrame->setAutoFillBackground(true);
+m_dateFrame->setBackgroundRole(QPalette::Window);
+}
+void QCalendarTextNavigator::removeDateLabel()
+{
+if (!m_dateFrame)
+return;
+m_acceptTimer.stop();
+m_dateFrame->hide();
+m_dateFrame->deleteLater();
+delete m_dateValidator;
+m_dateFrame = 0;
+m_dateText = 0;
+m_dateValidator = 0;
+}
+bool QCalendarTextNavigator::eventFilter(QObject *o, QEvent *e)
+{
+if (m_widget) {
+if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
+QKeyEvent* ke = (QKeyEvent*)e;
+if ((ke->text().length() > 0 && ke->text()[0].isPrint()) || m_dateFrame) {
+if (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Select) {
+applyDate();
+emit editingFinished();
+removeDateLabel();
+} else if (ke->key() == Qt::Key_Escape) {
+removeDateLabel();
+} else if (e->type() == QEvent::KeyPress) {
+createDateLabel();
+m_dateValidator->handleKeyEvent(ke);
+updateDateLabel();
+}
+ke->accept();
+return true;
+}
+// If we are navigating let the user finish his date in old locate.
+// If we change our mind and want it to update immediately simply uncomment below
+/*
+} else if (e->type() == QEvent::LocaleChange) {
+if (m_dateValidator) {
+m_dateValidator->setLocale(m_widget->locale());
+m_dateValidator->setFormat(m_widget->locale().dateFormat(QLocale::ShortFormat));
+updateDateLabel();
+}
+*/
+}
+}
+return QObject::eventFilter(o,e);
+}
+void QCalendarTextNavigator::timerEvent(QTimerEvent *e)
+{
+if (e->timerId() == m_acceptTimer.timerId()) {
+applyDate();
+removeDateLabel();
+}
+}
+int QCalendarTextNavigator::dateEditAcceptDelay() const
+{
+return m_editDelay;
+}
+void QCalendarTextNavigator::setDateEditAcceptDelay(int delay)
+{
+m_editDelay = delay;
+}
+class QCalendarView;
+class QCalendarModel : public QAbstractTableModel
+{
+Q_OBJECT
+public:
+QCalendarModel(QObject *parent = 0);
+int rowCount(const QModelIndex &) const
+{ return RowCount + m_firstRow; }
+int columnCount(const QModelIndex &) const
+{ return ColumnCount + m_firstColumn; }
+QVariant data(const QModelIndex &index, int role) const;
+Qt::ItemFlags flags(const QModelIndex &index) const;
+bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex())
+{
+beginInsertRows(parent, row, row + count - 1);
+endInsertRows();
+return true;
+}
+bool insertColumns(int column, int count, const QModelIndex &parent = QModelIndex())
+{
+beginInsertColumns(parent, column, column + count - 1);
+endInsertColumns();
+return true;
+}
+bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex())
+{
+beginRemoveRows(parent, row, row + count - 1);
+endRemoveRows();
+return true;
+}
+bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex())
+{
+beginRemoveColumns(parent, column, column + count - 1);
+endRemoveColumns();
+return true;
+}
+void showMonth(int year, int month);
+void setDate(const QDate &d);
+void setMinimumDate(const QDate &date);
+void setMaximumDate(const QDate &date);
+void setRange(const QDate &min, const QDate &max);
+void setHorizontalHeaderFormat(QCalendarWidget::HorizontalHeaderFormat format);
+void setFirstColumnDay(Qt::DayOfWeek dayOfWeek);
+Qt::DayOfWeek firstColumnDay() const;
+bool weekNumbersShown() const;
+void setWeekNumbersShown(bool show);
+QTextCharFormat formatForCell(int row, int col) const;
+Qt::DayOfWeek dayOfWeekForColumn(int section) const;
+int columnForDayOfWeek(Qt::DayOfWeek day) const;
+QDate dateForCell(int row, int column) const;
+void cellForDate(const QDate &date, int *row, int *column) const;
+QString dayName(Qt::DayOfWeek day) const;
+void setView(QCalendarView *view)
+{ m_view = view; }
+void internalUpdate();
+QDate referenceDate() const;
+int columnForFirstOfMonth(const QDate &date) const;
+int m_firstColumn;
+int m_firstRow;
+QDate m_date;
+QDate m_minimumDate;
+QDate m_maximumDate;
+int m_shownYear;
+int m_shownMonth;
+Qt::DayOfWeek m_firstDay;
+QCalendarWidget::HorizontalHeaderFormat m_horizontalHeaderFormat;
+bool m_weekNumbersShown;
+QMap<Qt::DayOfWeek, QTextCharFormat> m_dayFormats;
+QMap<QDate, QTextCharFormat> m_dateFormats;
+QTextCharFormat m_headerFormat;
+QCalendarView *m_view;
+};
+class QCalendarView : public QTableView
+{
+Q_OBJECT
+public:
+QCalendarView(QWidget *parent = 0);
+void internalUpdate() { updateGeometries(); }
+void setReadOnly(bool enable);
+virtual void keyboardSearch(const QString & search) { Q_UNUSED(search) }
+signals:
+void showDate(const QDate &date);
+void changeDate(const QDate &date, bool changeMonth);
+void clicked(const QDate &date);
+void editingFinished();
+protected:
+QModelIndex moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers);
+void mouseDoubleClickEvent(QMouseEvent *event);
+void mousePressEvent(QMouseEvent *event);
+void mouseMoveEvent(QMouseEvent *event);
+void mouseReleaseEvent(QMouseEvent *event);
+#ifndef QT_NO_WHEELEVENT
+void wheelEvent(QWheelEvent *event);
+#endif
+void keyPressEvent(QKeyEvent *event);
+bool event(QEvent *event);
+QDate handleMouseEvent(QMouseEvent *event);
+public:
+bool readOnly;
+private:
+bool validDateClicked;
+#ifdef QT_KEYPAD_NAVIGATION
+QDate origDate;
+#endif
+};
+QCalendarModel::QCalendarModel(QObject *parent)
+: QAbstractTableModel(parent)
+{
+m_date = QDate::currentDate();
+m_minimumDate = QDate::fromJulianDay(1);
+m_maximumDate = QDate(7999, 12, 31);
+m_shownYear = m_date.year();
+m_shownMonth = m_date.month();
+m_firstDay = Qt::Sunday;
+m_horizontalHeaderFormat = QCalendarWidget::ShortDayNames;
+m_weekNumbersShown = true;
+m_firstColumn = 1;
+m_firstRow = 1;
+m_view = 0;
+}
+Qt::DayOfWeek QCalendarModel::dayOfWeekForColumn(int column) const
+{
+int col = column - m_firstColumn;
+if (col < 0 || col > 6)
+return Qt::Sunday;
+int day = m_firstDay + col;
+if (day > 7)
+day -= 7;
+return Qt::DayOfWeek(day);
+}
+int QCalendarModel::columnForDayOfWeek(Qt::DayOfWeek day) const
+{
+if (day < 1 || day > 7)
+return -1;
+int column = (int)day - (int)m_firstDay;
+if (column < 0)
+column += 7;
+return column + m_firstColumn;
+}
+/*
+This simple algorithm tries to generate a valid date from the month shown.
+Some months don't contain a first day (e.g. Jan of -4713 year,
+so QDate (-4713, 1, 1) would be invalid). In that case we try to generate
+another valid date for that month. Later, returned date's day is the number of cells
+calendar widget will reserve for days before referenceDate. (E.g. if returned date's
+day is 16, that day will be placed in 3rd or 4th row, not in the 1st or 2nd row).
+Depending on referenceData we can change behaviour of Oct 1582. If referenceDate is 1st
+of Oct we render 1 Oct in 1st or 2nd row. If referenceDate is 17 of Oct we show always 16
+dates before 17 of Oct, and since this month contains the hole 5-14 Oct, the first of Oct
+will be rendered in 2nd or 3rd row, showing more dates from previous month.
+*/
+QDate QCalendarModel::referenceDate() const
+{
+int refDay = 1;
+while (refDay <= 31) {
+QDate refDate(m_shownYear, m_shownMonth, refDay);
+if (refDate.isValid())
+return refDate;
+refDay += 1;
+}
+return QDate();
+}
+int QCalendarModel::columnForFirstOfMonth(const QDate &date) const
+{
+return (columnForDayOfWeek(static_cast<Qt::DayOfWeek>(date.dayOfWeek())) - (date.day() % 7) + 8) % 7;
+}
+QDate QCalendarModel::dateForCell(int row, int column) const
+{
+if (row < m_firstRow || row > m_firstRow + RowCount - 1 ||
+column < m_firstColumn || column > m_firstColumn + ColumnCount - 1)
+return QDate();
+const QDate refDate = referenceDate();
+if (!refDate.isValid())
+return QDate();
+const int columnForFirstOfShownMonth = columnForFirstOfMonth(refDate);
+if (columnForFirstOfShownMonth - m_firstColumn < MinimumDayOffset)
+row -= 1;
+const int requestedDay = 7 * (row - m_firstRow) + column - columnForFirstOfShownMonth - refDate.day() + 1;
+return refDate.addDays(requestedDay);
+}
+void QCalendarModel::cellForDate(const QDate &date, int *row, int *column) const
+{
+if (!row && !column)
+return;
+if (row)
+*row = -1;
+if (column)
+*column = -1;
+const QDate refDate = referenceDate();
+if (!refDate.isValid())
+return;
+const int columnForFirstOfShownMonth = columnForFirstOfMonth(refDate);
+const int requestedPosition = refDate.daysTo(date) - m_firstColumn + columnForFirstOfShownMonth + refDate.day() - 1;
+int c = requestedPosition % 7;
+int r = requestedPosition / 7;
+if (c < 0) {
+c += 7;
+r -= 1;
+}
+if (columnForFirstOfShownMonth - m_firstColumn < MinimumDayOffset)
+r += 1;
+if (r < 0 || r > RowCount - 1 || c < 0 || c > ColumnCount - 1)
+return;
+if (row)
+*row = r + m_firstRow;
+if (column)
+*column = c + m_firstColumn;
+}
+QString QCalendarModel::dayName(Qt::DayOfWeek day) const
+{
+switch (m_horizontalHeaderFormat) {
+case QCalendarWidget::SingleLetterDayNames: {
+QString standaloneDayName = m_view->locale().standaloneDayName(day, QLocale::NarrowFormat);
+if (standaloneDayName == m_view->locale().dayName(day, QLocale::NarrowFormat))
+return standaloneDayName.left(1);
+return standaloneDayName;
+}
+case QCalendarWidget::ShortDayNames:
+return m_view->locale().dayName(day, QLocale::ShortFormat);
+case QCalendarWidget::LongDayNames:
+return m_view->locale().dayName(day, QLocale::LongFormat);
+default:
+break;
+}
+return QString();
+}
+QTextCharFormat QCalendarModel::formatForCell(int row, int col) const
+{
+QPalette pal;
+QPalette::ColorGroup cg = QPalette::Active;
+if (m_view) {
+pal = m_view->palette();
+if (!m_view->isEnabled())
+cg = QPalette::Disabled;
+else if (!m_view->isActiveWindow())
+cg = QPalette::Inactive;
+}
+QTextCharFormat format;
+format.setFont(m_view->font());
+bool header = (m_weekNumbersShown && col == HeaderColumn)
+|| (m_horizontalHeaderFormat != QCalendarWidget::NoHorizontalHeader && row == HeaderRow);
+format.setBackground(pal.brush(cg, header ? QPalette::AlternateBase : QPalette::Base));
+format.setForeground(pal.brush(cg, QPalette::Text));
+if (header) {
+format.merge(m_headerFormat);
+}
+if (col >= m_firstColumn && col < m_firstColumn + ColumnCount) {
+Qt::DayOfWeek dayOfWeek = dayOfWeekForColumn(col);
+if (m_dayFormats.contains(dayOfWeek))
+format.merge(m_dayFormats.value(dayOfWeek));
+}
+if (!header) {
+QDate date = dateForCell(row, col);
+format.merge(m_dateFormats.value(date));
+if(date < m_minimumDate || date > m_maximumDate)
+format.setBackground(pal.brush(cg, QPalette::Window));
+if (m_shownMonth != date.month())
+format.setForeground(pal.brush(QPalette::Disabled, QPalette::Text));
+}
+return format;
+}
+QVariant QCalendarModel::data(const QModelIndex &index, int role) const
+{
+if (role == Qt::TextAlignmentRole)
+return (int) Qt::AlignCenter;
+int row = index.row();
+int column = index.column();
+if(role == Qt::DisplayRole) {
+if (m_weekNumbersShown && column == HeaderColumn
+&& row >= m_firstRow && row < m_firstRow + RowCount) {
+QDate date = dateForCell(row, columnForDayOfWeek(Qt::Monday));
+if (date.isValid())
+return date.weekNumber();
+}
+if (m_horizontalHeaderFormat != QCalendarWidget::NoHorizontalHeader && row == HeaderRow
+&& column >= m_firstColumn && column < m_firstColumn + ColumnCount)
+return dayName(dayOfWeekForColumn(column));
+QDate date = dateForCell(row, column);
+if (date.isValid())
+return date.day();
+return QString();
+}
+QTextCharFormat fmt = formatForCell(row, column);
+if (role == Qt::BackgroundColorRole)
+return fmt.background().color();
+if (role == Qt::TextColorRole)
+return fmt.foreground().color();
+if (role == Qt::FontRole)
+return fmt.font();
+if (role == Qt::ToolTipRole)
+return fmt.toolTip();
+return QVariant();
+}
+Qt::ItemFlags QCalendarModel::flags(const QModelIndex &index) const
+{
+QDate date = dateForCell(index.row(), index.column());
+if (!date.isValid())
+return QAbstractTableModel::flags(index);
+if (date < m_minimumDate)
+return 0;
+if (date > m_maximumDate)
+return 0;
+return QAbstractTableModel::flags(index);
+}
+void QCalendarModel::setDate(const QDate &d)
+{
+m_date = d;
+if (m_date < m_minimumDate)
+m_date = m_minimumDate;
+else if (m_date > m_maximumDate)
+m_date = m_maximumDate;
+}
+void QCalendarModel::showMonth(int year, int month)
+{
+if (m_shownYear == year && m_shownMonth == month)
+return;
+m_shownYear = year;
+m_shownMonth = month;
+internalUpdate();
+}
+void QCalendarModel::setMinimumDate(const QDate &d)
+{
+if (!d.isValid() || d == m_minimumDate)
+return;
+m_minimumDate = d;
+if (m_maximumDate < m_minimumDate)
+m_maximumDate = m_minimumDate;
+if (m_date < m_minimumDate)
+m_date = m_minimumDate;
+internalUpdate();
+}
+void QCalendarModel::setMaximumDate(const QDate &d)
+{
+if (!d.isValid() || d == m_maximumDate)
+return;
+m_maximumDate = d;
+if (m_minimumDate > m_maximumDate)
+m_minimumDate = m_maximumDate;
+if (m_date > m_maximumDate)
+m_date = m_maximumDate;
+internalUpdate();
+}
+void QCalendarModel::setRange(const QDate &min, const QDate &max)
+{
+m_minimumDate = min;
+m_maximumDate = max;
+if (m_minimumDate > m_maximumDate)
+qSwap(m_minimumDate, m_maximumDate);
+if (m_date < m_minimumDate)
+m_date = m_minimumDate;
+if (m_date > m_maximumDate)
+m_date = m_maximumDate;
+internalUpdate();
+}
+void QCalendarModel::internalUpdate()
+{
+QModelIndex begin = index(0, 0);
+QModelIndex end = index(m_firstRow + RowCount - 1, m_firstColumn + ColumnCount - 1);
+emit dataChanged(begin, end);
+emit headerDataChanged(Qt::Vertical, 0, m_firstRow + RowCount - 1);
+emit headerDataChanged(Qt::Horizontal, 0, m_firstColumn + ColumnCount - 1);
+}
+void QCalendarModel::setHorizontalHeaderFormat(QCalendarWidget::HorizontalHeaderFormat format)
+{
+if (m_horizontalHeaderFormat == format)
+return;
+int oldFormat = m_horizontalHeaderFormat;
+m_horizontalHeaderFormat = format;
+if (oldFormat == QCalendarWidget::NoHorizontalHeader) {
+m_firstRow = 1;
+insertRow(0);
+} else if (m_horizontalHeaderFormat == QCalendarWidget::NoHorizontalHeader) {
+m_firstRow = 0;
+removeRow(0);
+}
+internalUpdate();
+}
+void QCalendarModel::setFirstColumnDay(Qt::DayOfWeek dayOfWeek)
+{
+if (m_firstDay == dayOfWeek)
+return;
+m_firstDay = dayOfWeek;
+internalUpdate();
+}
+Qt::DayOfWeek QCalendarModel::firstColumnDay() const
+{
+return m_firstDay;
+}
+bool QCalendarModel::weekNumbersShown() const
+{
+return m_weekNumbersShown;
+}
+void QCalendarModel::setWeekNumbersShown(bool show)
+{
+if (m_weekNumbersShown == show)
+return;
+m_weekNumbersShown = show;
+if (show) {
+m_firstColumn = 1;
+insertColumn(0);
+} else {
+m_firstColumn = 0;
+removeColumn(0);
+}
+internalUpdate();
+}
+QCalendarView::QCalendarView(QWidget *parent)
+: QTableView(parent),
+readOnly(false),
+validDateClicked(false)
+{
+setTabKeyNavigation(false);
+setShowGrid(false);
+verticalHeader()->setVisible(false);
+horizontalHeader()->setVisible(false);
+setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+}
+QModelIndex QCalendarView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
+{
+QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
+if (!calendarModel)
+return QTableView::moveCursor(cursorAction, modifiers);
+if (readOnly)
+return currentIndex();
+QModelIndex index = currentIndex();
+QDate currentDate = static_cast<QCalendarModel*>(model())->dateForCell(index.row(), index.column());
+switch (cursorAction) {
+case QAbstractItemView::MoveUp:
+currentDate = currentDate.addDays(-7);
+break;
+case QAbstractItemView::MoveDown:
+currentDate = currentDate.addDays(7);
+break;
+case QAbstractItemView::MoveLeft:
+currentDate = currentDate.addDays(isRightToLeft() ? 1 : -1);
+break;
+case QAbstractItemView::MoveRight:
+currentDate = currentDate.addDays(isRightToLeft() ? -1 : 1);
+break;
+case QAbstractItemView::MoveHome:
+currentDate = QDate(currentDate.year(), currentDate.month(), 1);
+break;
+case QAbstractItemView::MoveEnd:
+currentDate = QDate(currentDate.year(), currentDate.month(), currentDate.daysInMonth());
+break;
+case QAbstractItemView::MovePageUp:
+currentDate = currentDate.addMonths(-1);
+break;
+case QAbstractItemView::MovePageDown:
+currentDate = currentDate.addMonths(1);
+break;
+case QAbstractItemView::MoveNext:
+case QAbstractItemView::MovePrevious:
+return currentIndex();
+default:
+break;
+}
+emit changeDate(currentDate, true);
+return currentIndex();
+}
+void QCalendarView::keyPressEvent(QKeyEvent *event)
+{
+#ifdef QT_KEYPAD_NAVIGATION
+if (event->key() == Qt::Key_Select) {
+if (QApplication::keypadNavigationEnabled()) {
+if (!hasEditFocus()) {
+setEditFocus(true);
+return;
+}
+}
+} else if (event->key() == Qt::Key_Back) {
+if (QApplication::keypadNavigationEnabled() && hasEditFocus()) {
+if (qobject_cast<QCalendarModel *>(model())) {
+emit changeDate(origDate, true); //changes selection back to origDate, but doesn't activate
+setEditFocus(false);
+return;
+}
+}
+}
+#endif
+if (!readOnly) {
+switch (event->key()) {
+case Qt::Key_Return:
+case Qt::Key_Enter:
+case Qt::Key_Select:
+emit editingFinished();
+return;
+default:
+break;
+}
+}
+QTableView::keyPressEvent(event);
+}
+#ifndef QT_NO_WHEELEVENT
+void QCalendarView::wheelEvent(QWheelEvent *event)
+{
+const int numDegrees = event->delta() / 8;
+const int numSteps = numDegrees / 15;
+const QModelIndex index = currentIndex();
+QDate currentDate = static_cast<QCalendarModel*>(model())->dateForCell(index.row(), index.column());
+currentDate = currentDate.addMonths(-numSteps);
+emit showDate(currentDate);
+}
+#endif
+bool QCalendarView::event(QEvent *event)
+{
+#ifdef QT_KEYPAD_NAVIGATION
+if (event->type() == QEvent::FocusIn) {
+if (QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model())) {
+origDate = calendarModel->m_date;
+}
+}
+#endif
+return QTableView::event(event);
+}
+QDate QCalendarView::handleMouseEvent(QMouseEvent *event)
+{
+QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
+if (!calendarModel)
+return QDate();
+QPoint pos = event->pos();
+QModelIndex index = indexAt(pos);
+QDate date = calendarModel->dateForCell(index.row(), index.column());
+if (date.isValid() && date >= calendarModel->m_minimumDate
+&& date <= calendarModel->m_maximumDate) {
+return date;
+}
+return QDate();
+}
+void QCalendarView::mouseDoubleClickEvent(QMouseEvent *event)
+{
+QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
+if (!calendarModel) {
+QTableView::mouseDoubleClickEvent(event);
+return;
+}
+if (readOnly)
+return;
+QDate date = handleMouseEvent(event);
+validDateClicked = false;
+if (date == calendarModel->m_date && !style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)) {
+emit editingFinished();
+}
+}
+void QCalendarView::mousePressEvent(QMouseEvent *event)
+{
+QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
+if (!calendarModel) {
+QTableView::mousePressEvent(event);
+return;
+}
+if (readOnly)
+return;
+if (event->button() != Qt::LeftButton)
+return;
+QDate date = handleMouseEvent(event);
+if (date.isValid()) {
+validDateClicked = true;
+int row = -1, col = -1;
+static_cast<QCalendarModel *>(model())->cellForDate(date, &row, &col);
+if (row != -1 && col != -1) {
+selectionModel()->setCurrentIndex(model()->index(row, col), QItemSelectionModel::NoUpdate);
+}
+} else {
+validDateClicked = false;
+event->ignore();
+}
+}
+void QCalendarView::mouseMoveEvent(QMouseEvent *event)
+{
+QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
+if (!calendarModel) {
+QTableView::mouseMoveEvent(event);
+return;
+}
+if (readOnly)
+return;
+if (validDateClicked) {
+QDate date = handleMouseEvent(event);
+if (date.isValid()) {
+int row = -1, col = -1;
+static_cast<QCalendarModel *>(model())->cellForDate(date, &row, &col);
+if (row != -1 && col != -1) {
+selectionModel()->setCurrentIndex(model()->index(row, col), QItemSelectionModel::NoUpdate);
+}
+}
+} else {
+event->ignore();
+}
+}
+void QCalendarView::mouseReleaseEvent(QMouseEvent *event)
+{
+QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
+if (!calendarModel) {
+QTableView::mouseReleaseEvent(event);
+return;
+}
+if (event->button() != Qt::LeftButton)
+return;
+if (readOnly)
+return;
+if (validDateClicked) {
+QDate date = handleMouseEvent(event);
+if (date.isValid()) {
+emit changeDate(date, true);
+emit clicked(date);
+if (style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick))
+emit editingFinished();
+}
+validDateClicked = false;
+} else {
+event->ignore();
+}
+}
+class QCalendarDelegate : public QItemDelegate
+{
+Q_OBJECT
+public:
+QCalendarDelegate(QCalendarWidgetPrivate *w, QObject *parent = 0)
+: QItemDelegate(parent), calendarWidgetPrivate(w)
+{ }
+virtual void paint(QPainter *painter, const QStyleOptionViewItem &option,
+const QModelIndex &index) const;
+void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const;
+private:
+QCalendarWidgetPrivate *calendarWidgetPrivate;
+mutable QStyleOptionViewItemV4 storedOption;
+};
+//Private tool button class
+class QCalToolButton: public QToolButton
+{
+public:
+QCalToolButton(QWidget * parent)
+: QToolButton(parent)
+{  }
+protected:
+void paintEvent(QPaintEvent *e)
+{
+Q_UNUSED(e)
+#ifndef Q_WS_MAC
+QStyleOptionToolButton opt;
+initStyleOption(&opt);
+if (opt.state & QStyle::State_MouseOver || isDown()) {
+//act as normal button
+setPalette(QPalette());
+} else {
+//set the highlight color for button text
+QPalette toolPalette = palette();
+toolPalette.setColor(QPalette::ButtonText, toolPalette.color(QPalette::HighlightedText));
+setPalette(toolPalette);
+}
+#endif
+QToolButton::paintEvent(e);
+}
+};
+class QPrevNextCalButton : public QToolButton
+{
+Q_OBJECT
+public:
+QPrevNextCalButton(QWidget *parent) : QToolButton(parent) {}
+protected:
+void paintEvent(QPaintEvent *) {
+QStylePainter painter(this);
+QStyleOptionToolButton opt;
+initStyleOption(&opt);
+opt.state &= ~QStyle::State_HasFocus;
+painter.drawComplexControl(QStyle::CC_ToolButton, opt);
+}
+};
+class QCalendarWidgetPrivate : public QWidgetPrivate
+{
+Q_DECLARE_PUBLIC(QCalendarWidget)
+public:
+QCalendarWidgetPrivate();
+void showMonth(int year, int month);
+void update();
+void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const;
+void _q_slotShowDate(const QDate &date);
+void _q_slotChangeDate(const QDate &date);
+void _q_slotChangeDate(const QDate &date, bool changeMonth);
+void _q_editingFinished();
+void _q_monthChanged(QAction*);
+void _q_prevMonthClicked();
+void _q_nextMonthClicked();
+void _q_yearEditingFinished();
+void _q_yearClicked();
+void createNavigationBar(QWidget *widget);
+void updateButtonIcons();
+void updateMonthMenu();
+void updateMonthMenuNames();
+void updateNavigationBar();
+void updateCurrentPage(const QDate &newDate);
+inline QDate getCurrentDate();
+void setNavigatorEnabled(bool enable);
+QCalendarModel *m_model;
+QCalendarView *m_view;
+QCalendarDelegate *m_delegate;
+QItemSelectionModel *m_selection;
+QCalendarTextNavigator *m_navigator;
+bool m_dateEditEnabled;
+QToolButton *nextMonth;
+QToolButton *prevMonth;
+QCalToolButton *monthButton;
+QMenu *monthMenu;
+QMap<int, QAction *> monthToAction;
+QCalToolButton *yearButton;
+QSpinBox *yearEdit;
+QWidget *navBarBackground;
+QSpacerItem *spaceHolder;
+bool navBarVisible;
+mutable QSize cachedSizeHint;
+Qt::FocusPolicy oldFocusPolicy;
+};
+void QCalendarDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
+const QModelIndex &index) const
+{
+QDate date = calendarWidgetPrivate->m_model->dateForCell(index.row(), index.column());
+if (date.isValid()) {
+storedOption = option;
+QRect rect = option.rect;
+calendarWidgetPrivate->paintCell(painter, rect, date);
+} else {
+QItemDelegate::paint(painter, option, index);
+}
+}
+void QCalendarDelegate::paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
+{
+storedOption.rect = rect;
+int row = -1;
+int col = -1;
+calendarWidgetPrivate->m_model->cellForDate(date, &row, &col);
+QModelIndex idx = calendarWidgetPrivate->m_model->index(row, col);
+QItemDelegate::paint(painter, storedOption, idx);
+}
+QCalendarWidgetPrivate::QCalendarWidgetPrivate()
+: QWidgetPrivate()
+{
+m_model = 0;
+m_view = 0;
+m_delegate = 0;
+m_selection = 0;
+m_navigator = 0;
+m_dateEditEnabled = false;
+navBarVisible = true;
+oldFocusPolicy = Qt::StrongFocus;
+}
+void QCalendarWidgetPrivate::setNavigatorEnabled(bool enable)
+{
+Q_Q(QCalendarWidget);
+bool navigatorEnabled = (m_navigator->widget() != 0);
+if (enable == navigatorEnabled)
+return;
+if (enable) {
+m_navigator->setWidget(q);
+q->connect(m_navigator, SIGNAL(dateChanged(QDate)),
+q, SLOT(_q_slotChangeDate(QDate)));
+q->connect(m_navigator, SIGNAL(editingFinished()),
+q, SLOT(_q_editingFinished()));
+m_view->installEventFilter(m_navigator);
+} else {
+m_navigator->setWidget(0);
+q->disconnect(m_navigator, SIGNAL(dateChanged(QDate)),
+q, SLOT(_q_slotChangeDate(QDate)));
+q->disconnect(m_navigator, SIGNAL(editingFinished()),
+q, SLOT(_q_editingFinished()));
+m_view->removeEventFilter(m_navigator);
+}
+}
+void QCalendarWidgetPrivate::createNavigationBar(QWidget *widget)
+{
+Q_Q(QCalendarWidget);
+navBarBackground = new QWidget(widget);
+navBarBackground->setObjectName(QLatin1String("qt_calendar_navigationbar"));
+navBarBackground->setAutoFillBackground(true);
+navBarBackground->setBackgroundRole(QPalette::Highlight);
+prevMonth = new QPrevNextCalButton(navBarBackground);
+nextMonth = new QPrevNextCalButton(navBarBackground);
+prevMonth->setAutoRaise(true);
+nextMonth->setAutoRaise(true);
+prevMonth->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
+nextMonth->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
+nextMonth->setAutoRaise(true);
+updateButtonIcons();
+prevMonth->setAutoRepeat(true);
+nextMonth->setAutoRepeat(true);
+monthButton = new QCalToolButton(navBarBackground);
+monthButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
+monthButton->setAutoRaise(true);
+monthButton->setPopupMode(QToolButton::InstantPopup);
+monthMenu = new QMenu(monthButton);
+for (int i = 1; i <= 12; i++) {
+QString monthName(q->locale().standaloneMonthName(i, QLocale::LongFormat));
+QAction *act = monthMenu->addAction(monthName);
+act->setData(i);
+monthToAction[i] = act;
+}
+monthButton->setMenu(monthMenu);
+yearButton = new QCalToolButton(navBarBackground);
+yearButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
+yearButton->setAutoRaise(true);
+yearEdit = new QSpinBox(navBarBackground);
+QFont font = q->font();
+font.setBold(true);
+monthButton->setFont(font);
+yearButton->setFont(font);
+yearEdit->setFrame(false);
+yearEdit->setMinimum(m_model->m_minimumDate.year());
+yearEdit->setMaximum(m_model->m_maximumDate.year());
+yearEdit->hide();
+spaceHolder = new QSpacerItem(0,0);
+QHBoxLayout *headerLayout = new QHBoxLayout;
+headerLayout->setMargin(0);
+headerLayout->setSpacing(0);
+headerLayout->addWidget(prevMonth);
+headerLayout->insertStretch(headerLayout->count());
+headerLayout->addWidget(monthButton);
+headerLayout->addItem(spaceHolder);
+headerLayout->addWidget(yearButton);
+headerLayout->insertStretch(headerLayout->count());
+headerLayout->addWidget(nextMonth);
+navBarBackground->setLayout(headerLayout);
+yearEdit->setFocusPolicy(Qt::StrongFocus);
+prevMonth->setFocusPolicy(Qt::NoFocus);
+nextMonth->setFocusPolicy(Qt::NoFocus);
+yearButton->setFocusPolicy(Qt::NoFocus);
+monthButton->setFocusPolicy(Qt::NoFocus);
+//set names for the header controls.
+prevMonth->setObjectName(QLatin1String("qt_calendar_prevmonth"));
+nextMonth->setObjectName(QLatin1String("qt_calendar_nextmonth"));
+monthButton->setObjectName(QLatin1String("qt_calendar_monthbutton"));
+yearButton->setObjectName(QLatin1String("qt_calendar_yearbutton"));
+yearEdit->setObjectName(QLatin1String("qt_calendar_yearedit"));
+updateMonthMenu();
+showMonth(m_model->m_date.year(), m_model->m_date.month());
+}
+void QCalendarWidgetPrivate::updateButtonIcons()
+{
+Q_Q(QCalendarWidget);
+prevMonth->setIcon(q->style()->standardIcon(q->isRightToLeft() ? QStyle::SP_ArrowRight : QStyle::SP_ArrowLeft, 0, q));
+nextMonth->setIcon(q->style()->standardIcon(q->isRightToLeft() ? QStyle::SP_ArrowLeft : QStyle::SP_ArrowRight, 0, q));
+}
+void QCalendarWidgetPrivate::updateMonthMenu()
+{
+int beg = 1, end = 12;
+bool prevEnabled = true;
+bool nextEnabled = true;
+if (m_model->m_shownYear == m_model->m_minimumDate.year()) {
+beg = m_model->m_minimumDate.month();
+if (m_model->m_shownMonth == m_model->m_minimumDate.month())
+prevEnabled = false;
+}
+if (m_model->m_shownYear == m_model->m_maximumDate.year()) {
+end = m_model->m_maximumDate.month();
+if (m_model->m_shownMonth == m_model->m_maximumDate.month())
+nextEnabled = false;
+}
+prevMonth->setEnabled(prevEnabled);
+nextMonth->setEnabled(nextEnabled);
+for (int i = 1; i <= 12; i++) {
+bool monthEnabled = true;
+if (i < beg || i > end)
+monthEnabled = false;
+monthToAction[i]->setEnabled(monthEnabled);
+}
+}
+void QCalendarWidgetPrivate::updateMonthMenuNames()
+{
+Q_Q(QCalendarWidget);
+for (int i = 1; i <= 12; i++) {
+QString monthName(q->locale().standaloneMonthName(i, QLocale::LongFormat));
+monthToAction[i]->setText(monthName);
+}
+}
+void QCalendarWidgetPrivate::updateCurrentPage(const QDate &date)
+{
+Q_Q(QCalendarWidget);
+QDate newDate = date;
+QDate minDate = q->minimumDate();
+QDate maxDate = q->maximumDate();
+if (minDate.isValid()&& minDate.daysTo(newDate) < 0)
+newDate = minDate;
+if (maxDate.isValid()&& maxDate.daysTo(newDate) > 0)
+newDate = maxDate;
+showMonth(newDate.year(), newDate.month());
+int row = -1, col = -1;
+m_model->cellForDate(newDate, &row, &col);
+if (row != -1 && col != -1)
+{
+m_view->selectionModel()->setCurrentIndex(m_model->index(row, col),
+QItemSelectionModel::NoUpdate);
+}
+}
+void QCalendarWidgetPrivate::_q_monthChanged(QAction *act)
+{
+monthButton->setText(act->text());
+QDate currentDate = getCurrentDate();
+QDate newDate = currentDate.addMonths(act->data().toInt()-currentDate.month());
+updateCurrentPage(newDate);
+}
+QDate QCalendarWidgetPrivate::getCurrentDate()
+{
+QModelIndex index = m_view->currentIndex();
+return m_model->dateForCell(index.row(), index.column());
+}
+void QCalendarWidgetPrivate::_q_prevMonthClicked()
+{
+QDate currentDate = getCurrentDate().addMonths(-1);
+updateCurrentPage(currentDate);
+}
+void QCalendarWidgetPrivate::_q_nextMonthClicked()
+{
+QDate currentDate = getCurrentDate().addMonths(1);
+updateCurrentPage(currentDate);
+}
+void QCalendarWidgetPrivate::_q_yearEditingFinished()
+{
+Q_Q(QCalendarWidget);
+yearButton->setText(yearEdit->text());
+yearEdit->hide();
+q->setFocusPolicy(oldFocusPolicy);
+qApp->removeEventFilter(q);
+spaceHolder->changeSize(0, 0);
+yearButton->show();
+QDate currentDate = getCurrentDate();
+currentDate = currentDate.addYears(yearEdit->text().toInt() - currentDate.year());
+updateCurrentPage(currentDate);
+}
+void QCalendarWidgetPrivate::_q_yearClicked()
+{
+Q_Q(QCalendarWidget);
+//show the spinbox on top of the button
+yearEdit->setGeometry(yearButton->x(), yearButton->y(),
+yearEdit->sizeHint().width(), yearButton->height());
+spaceHolder->changeSize(yearButton->width(), 0);
+yearButton->hide();
+oldFocusPolicy = q->focusPolicy();
+q->setFocusPolicy(Qt::NoFocus);
+yearEdit->show();
+qApp->installEventFilter(q);
+yearEdit->raise();
+yearEdit->selectAll();
+yearEdit->setFocus(Qt::MouseFocusReason);
+}
+void QCalendarWidgetPrivate::showMonth(int year, int month)
+{
+if (m_model->m_shownYear == year && m_model->m_shownMonth == month)
+return;
+Q_Q(QCalendarWidget);
+m_model->showMonth(year, month);
+updateNavigationBar();
+emit q->currentPageChanged(year, month);
+m_view->internalUpdate();
+cachedSizeHint = QSize();
+update();
+updateMonthMenu();
+}
+void QCalendarWidgetPrivate::updateNavigationBar()
+{
+Q_Q(QCalendarWidget);
+QString monthName = q->locale().standaloneMonthName(m_model->m_shownMonth, QLocale::LongFormat);
+monthButton->setText(monthName);
+yearButton->setText(QString::number(m_model->m_shownYear));
+yearEdit->setValue(m_model->m_shownYear);
+}
+void QCalendarWidgetPrivate::update()
+{
+QDate currentDate = m_model->m_date;
+int row, column;
+m_model->cellForDate(currentDate, &row, &column);
+QModelIndex idx;
+m_selection->clear();
+if (row != -1 && column != -1) {
+idx = m_model->index(row, column);
+m_selection->setCurrentIndex(idx, QItemSelectionModel::SelectCurrent);
+}
+}
+void QCalendarWidgetPrivate::paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
+{
+Q_Q(const QCalendarWidget);
+q->paintCell(painter, rect, date);
+}
+void QCalendarWidgetPrivate::_q_slotShowDate(const QDate &date)
+{
+updateCurrentPage(date);
+}
+void QCalendarWidgetPrivate::_q_slotChangeDate(const QDate &date)
+{
+_q_slotChangeDate(date, true);
+}
+void QCalendarWidgetPrivate::_q_slotChangeDate(const QDate &date, bool changeMonth)
+{
+QDate oldDate = m_model->m_date;
+m_model->setDate(date);
+QDate newDate = m_model->m_date;
+if (changeMonth)
+showMonth(newDate.year(), newDate.month());
+if (oldDate != newDate) {
+update();
+Q_Q(QCalendarWidget);
+m_navigator->setDate(newDate);
+emit q->selectionChanged();
+}
+}
+void QCalendarWidgetPrivate::_q_editingFinished()
+{
+Q_Q(QCalendarWidget);
+emit q->activated(m_model->m_date);
+}
+/*!
+\class QCalendarWidget
+\brief The QCalendarWidget class provides a monthly based
+calendar widget allowing the user to select a date.
+\since 4.2
+\ingroup advanced
+\image cleanlooks-calendarwidget.png
+The widget is initialized with the current month and year, but
+QCalendarWidget provides several public slots to change the year
+and month that is shown.
+By default, today's date is selected, and the user can select a
+date using both mouse and keyboard. The currently selected date
+can be retrieved using the selectedDate() function. It is
+possible to constrain the user selection to a given date range by
+setting the minimumDate and maximumDate properties.
+Alternatively, both properties can be set in one go using the
+setDateRange() convenience slot. Set the \l selectionMode
+property to NoSelection to prohibit the user from selecting at
+all. Note that a date also can be selected programmatically using
+the setSelectedDate() slot.
+The currently displayed month and year can be retrieved using the
+monthShown() and yearShown() functions, respectively.
+A newly created calendar widget uses abbreviated day names, and
+both Saturdays and Sundays are marked in red. The calendar grid is
+not visible. The week numbers are displayed, and the first column
+day is Sunday.
+The notation of the days can be altered to a single letter
+abbreviations ("M" for "Monday") by setting the
+horizontalHeaderFormat property to
+QCalendarWidget::SingleLetterDayNames. Setting the same property
+to QCalendarWidget::LongDayNames makes the header display the
+complete day names. The week numbers can be removed by setting
+the verticalHeaderFormat property to
+QCalendarWidget::NoVerticalHeader.  The calendar grid can be
+turned on by setting the gridVisible property to true using the
+setGridVisible() function:
+\table
+\row \o
+\image qcalendarwidget-grid.png
+\row \o
+\snippet doc/src/snippets/code/src_gui_widgets_qcalendarwidget.cpp 0
+\endtable
+Finally, the day in the first column can be altered using the
+setFirstDayOfWeek() function.
+The QCalendarWidget class also provides three signals,
+selectionChanged(), activated() and currentPageChanged() making it
+possible to respond to user interaction.
+The rendering of the headers, weekdays or single days can be
+largely customized by setting QTextCharFormat's for some special
+weekday, a special date or for the rendering of the headers.
+Only a subset of the properties in QTextCharFormat are used by the
+calendar widget. Currently, the foreground, background and font
+properties are used to determine the rendering of individual cells
+in the widget.
+\sa QDate, QDateEdit, QTextCharFormat
+*/
+/*!
+\enum QCalendarWidget::SelectionMode
+This enum describes the types of selection offered to the user for
+selecting dates in the calendar.
+\value NoSelection      Dates cannot be selected.
+\value SingleSelection  Single dates can be selected.
+\sa selectionMode
+*/
+/*!
+Constructs a calendar widget with the given \a parent.
+The widget is initialized with the current month and year, and the
+currently selected date is today.
+\sa setCurrentPage()
+*/
+QCalendarWidget::QCalendarWidget(QWidget *parent)
+: QWidget(*new QCalendarWidgetPrivate, parent, 0)
+{
+Q_D(QCalendarWidget);
+setAutoFillBackground(true);
+setBackgroundRole(QPalette::Window);
+QVBoxLayout *layoutV = new QVBoxLayout(this);
+layoutV->setMargin(0);
+d->m_model = new QCalendarModel(this);
+QTextCharFormat fmt;
+fmt.setForeground(QBrush(Qt::red));
+d->m_model->m_dayFormats.insert(Qt::Saturday, fmt);
+d->m_model->m_dayFormats.insert(Qt::Sunday, fmt);
+d->m_view = new QCalendarView(this);
+d->m_view->setObjectName(QLatin1String("qt_calendar_calendarview"));
+d->m_view->setModel(d->m_model);
+d->m_model->setView(d->m_view);
+d->m_view->setSelectionBehavior(QAbstractItemView::SelectItems);
+d->m_view->setSelectionMode(QAbstractItemView::SingleSelection);
+d->m_view->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
+d->m_view->horizontalHeader()->setClickable(false);
+d->m_view->verticalHeader()->setResizeMode(QHeaderView::Stretch);
+d->m_view->verticalHeader()->setClickable(false);
+d->m_selection = d->m_view->selectionModel();
+d->createNavigationBar(this);
+d->m_view->setFrameStyle(QFrame::NoFrame);
+d->m_delegate = new QCalendarDelegate(d, this);
+d->m_view->setItemDelegate(d->m_delegate);
+d->update();
+d->updateNavigationBar();
+setFocusPolicy(Qt::StrongFocus);
+setFocusProxy(d->m_view);
+setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+connect(d->m_view, SIGNAL(showDate(QDate)),
+this, SLOT(_q_slotShowDate(QDate)));
+connect(d->m_view, SIGNAL(changeDate(QDate,bool)),
+this, SLOT(_q_slotChangeDate(QDate,bool)));
+connect(d->m_view, SIGNAL(clicked(QDate)),
+this, SIGNAL(clicked(QDate)));
+connect(d->m_view, SIGNAL(editingFinished()),
+this, SLOT(_q_editingFinished()));
+connect(d->prevMonth, SIGNAL(clicked(bool)),
+this, SLOT(_q_prevMonthClicked()));
+connect(d->nextMonth, SIGNAL(clicked(bool)),
+this, SLOT(_q_nextMonthClicked()));
+connect(d->yearButton, SIGNAL(clicked(bool)),
+this, SLOT(_q_yearClicked()));
+connect(d->monthMenu, SIGNAL(triggered(QAction*)),
+this, SLOT(_q_monthChanged(QAction*)));
+connect(d->yearEdit, SIGNAL(editingFinished()),
+this, SLOT(_q_yearEditingFinished()));
+layoutV->setMargin(0);
+layoutV->setSpacing(0);
+layoutV->addWidget(d->navBarBackground);
+layoutV->addWidget(d->m_view);
+d->m_navigator = new QCalendarTextNavigator(this);
+setDateEditEnabled(true);
+}
+/*!
+Destroys the calendar widget.
+*/
+QCalendarWidget::~QCalendarWidget()
+{
+}
+/*!
+\reimp
+*/
+QSize QCalendarWidget::sizeHint() const
+{
+return minimumSizeHint();
+}
+/*!
+\reimp
+*/
+QSize QCalendarWidget::minimumSizeHint() const
+{
+Q_D(const QCalendarWidget);
+if (d->cachedSizeHint.isValid())
+return d->cachedSizeHint;
+ensurePolished();
+int w = 0;
+int h = 0;
+int end = 53;
+int rows = 7;
+int cols = 8;
+const int marginH = (style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1) * 2;
+if (horizontalHeaderFormat() == QCalendarWidget::NoHorizontalHeader) {
+rows = 6;
+} else {
+for (int i = 1; i <= 7; i++) {
+QFontMetrics fm(d->m_model->formatForCell(0, i).font());
+w = qMax(w, fm.width(d->m_model->dayName(d->m_model->dayOfWeekForColumn(i))) + marginH);
+h = qMax(h, fm.height());
+}
+}
+if (verticalHeaderFormat() == QCalendarWidget::NoVerticalHeader) {
+cols = 7;
+} else {
+for (int i = 1; i <= 6; i++) {
+QFontMetrics fm(d->m_model->formatForCell(i, 0).font());
+for (int j = 1; j < end; j++)
+w = qMax(w, fm.width(QString::number(j)) + marginH);
+h = qMax(h, fm.height());
+}
+}
+QFontMetrics fm(d->m_model->formatForCell(1, 1).font());
+for (int i = 1; i <= end; i++) {
+w = qMax(w, fm.width(QString::number(i)) + marginH);
+h = qMax(h, fm.height());
+}
+if (d->m_view->showGrid()) {
+// hardcoded in tableview
+w += 1;
+h += 1;
+}
+w += 1; // default column span
+h = qMax(h, d->m_view->verticalHeader()->minimumSectionSize());
+w = qMax(w, d->m_view->horizontalHeader()->minimumSectionSize());
+//add the size of the header.
+QSize headerSize(0, 0);
+if (d->navBarVisible) {
+int headerH = d->navBarBackground->sizeHint().height();
+int headerW = 0;
+headerW += d->prevMonth->sizeHint().width();
+headerW += d->nextMonth->sizeHint().width();
+QFontMetrics fm = d->monthButton->fontMetrics();
+int monthW = 0;
+for (int i = 1; i < 12; i++) {
+QString monthName = locale().standaloneMonthName(i, QLocale::LongFormat);
+monthW = qMax(monthW, fm.boundingRect(monthName).width());
+}
+const int buttonDecoMargin = d->monthButton->sizeHint().width() - fm.boundingRect(d->monthButton->text()).width();
+headerW += monthW + buttonDecoMargin;
+fm = d->yearButton->fontMetrics();
+headerW += fm.boundingRect(QLatin1String("5555")).width() + buttonDecoMargin;
+headerSize = QSize(headerW, headerH);
+}
+w *= cols;
+w = qMax(headerSize.width(), w);
+h = (h * rows) + headerSize.height();
+d->cachedSizeHint = QSize(w, h);
+return d->cachedSizeHint;
+}
+/*!
+Paints the cell specified by the given \a date, using the given \a painter and \a rect.
+*/
+void QCalendarWidget::paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
+{
+Q_D(const QCalendarWidget);
+d->m_delegate->paintCell(painter, rect, date);
+}
+/*!
+\property QCalendarWidget::selectedDate
+\brief the currently selected date.
+The selected date must be within the date range specified by the
+minimumDate and maximumDate properties. By default, the selected
+date is the current date.
+\sa setDateRange()
+*/
+QDate QCalendarWidget::selectedDate() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_date;
+}
+void QCalendarWidget::setSelectedDate(const QDate &date)
+{
+Q_D(QCalendarWidget);
+if (d->m_model->m_date == date && date == d->getCurrentDate())
+return;
+if (!date.isValid())
+return;
+d->m_model->setDate(date);
+d->update();
+QDate newDate = d->m_model->m_date;
+d->showMonth(newDate.year(), newDate.month());
+emit selectionChanged();
+}
+/*!
+Returns the year of the currently displayed month. Months are
+numbered from 1 to 12.
+\sa monthShown(), setCurrentPage()
+*/
+int QCalendarWidget::yearShown() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_shownYear;
+}
+/*!
+Returns the currently displayed month. Months are numbered from 1 to
+12.
+\sa yearShown(), setCurrentPage()
+*/
+int QCalendarWidget::monthShown() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_shownMonth;
+}
+/*!
+Displays the given \a month of the given \a year without changing
+the selected date. Use the setSelectedDate() function to alter the
+selected date.
+The currently displayed month and year can be retrieved using the
+monthShown() and yearShown() functions respectively.
+\sa yearShown(), monthShown(), showPreviousMonth(), showNextMonth(),
+showPreviousYear(), showNextYear()
+*/
+void QCalendarWidget::setCurrentPage(int year, int month)
+{
+Q_D(QCalendarWidget);
+d->showMonth(year, month);
+}
+/*!
+Shows the next month relative to the currently displayed
+month. Note that the selected date is not changed.
+\sa showPreviousMonth(), setCurrentPage(), setSelectedDate()
+*/
+void QCalendarWidget::showNextMonth()
+{
+int year = yearShown();
+int month = monthShown();
+if (month == 12) {
+++year;
+month = 1;
+} else {
+++month;
+}
+setCurrentPage(year, month);
+}
+/*!
+Shows the previous month relative to the currently displayed
+month. Note that the selected date is not changed.
+\sa showNextMonth(), setCurrentPage(), setSelectedDate()
+*/
+void QCalendarWidget::showPreviousMonth()
+{
+int year = yearShown();
+int month = monthShown();
+if (month == 1) {
+--year;
+month = 12;
+} else {
+--month;
+}
+setCurrentPage(year, month);
+}
+/*!
+Shows the currently displayed month in the \e next year relative
+to the currently displayed year. Note that the selected date is
+not changed.
+\sa showPreviousYear(), setCurrentPage(), setSelectedDate()
+*/
+void QCalendarWidget::showNextYear()
+{
+int year = yearShown();
+int month = monthShown();
+++year;
+setCurrentPage(year, month);
+}
+/*!
+Shows the currently displayed month in the \e previous year
+relative to the currently displayed year. Note that the selected
+date is not changed.
+\sa showNextYear(), setCurrentPage(), setSelectedDate()
+*/
+void QCalendarWidget::showPreviousYear()
+{
+int year = yearShown();
+int month = monthShown();
+--year;
+setCurrentPage(year, month);
+}
+/*!
+Shows the month of the selected date.
+\sa selectedDate(), setCurrentPage()
+*/
+void QCalendarWidget::showSelectedDate()
+{
+QDate currentDate = selectedDate();
+setCurrentPage(currentDate.year(), currentDate.month());
+}
+/*!
+Shows the month of the today's date.
+\sa selectedDate(), setCurrentPage()
+*/
+void QCalendarWidget::showToday()
+{
+QDate currentDate = QDate::currentDate();
+setCurrentPage(currentDate.year(), currentDate.month());
+}
+/*!
+\property QCalendarWidget::minimumDate
+\brief the minimum date of the currently specified date range.
+The user will not be able to select a date that is before the
+currently set minimum date.
+\table
+\row
+\o \image qcalendarwidget-minimum.png
+\row
+\o
+\snippet doc/src/snippets/code/src_gui_widgets_qcalendarwidget.cpp 1
+\endtable
+By default, the minimum date is the earliest date that the QDate
+class can handle.
+When setting a minimum date, the maximumDate and selectedDate
+properties are adjusted if the selection range becomes invalid. If
+the provided date is not a valid QDate object, the
+setMinimumDate() function does nothing.
+\sa setDateRange()
+*/
+QDate QCalendarWidget::minimumDate() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_minimumDate;
+}
+void QCalendarWidget::setMinimumDate(const QDate &date)
+{
+Q_D(QCalendarWidget);
+if (!date.isValid() || d->m_model->m_minimumDate == date)
+return;
+QDate oldDate = d->m_model->m_date;
+d->m_model->setMinimumDate(date);
+d->yearEdit->setMinimum(d->m_model->m_minimumDate.year());
+d->updateMonthMenu();
+QDate newDate = d->m_model->m_date;
+if (oldDate != newDate) {
+d->update();
+d->showMonth(newDate.year(), newDate.month());
+d->m_navigator->setDate(newDate);
+emit selectionChanged();
+}
+}
+/*!
+\property QCalendarWidget::maximumDate
+\brief the maximum date of the currently specified date range.
+The user will not be able to select a date which is after the
+currently set maximum date.
+\table
+\row
+\o \image qcalendarwidget-maximum.png
+\row
+\o
+\snippet doc/src/snippets/code/src_gui_widgets_qcalendarwidget.cpp 2
+\endtable
+By default, the maximum date is the last day the QDate class can
+handle.
+When setting a maximum date, the minimumDate and selectedDate
+properties are adjusted if the selection range becomes invalid. If
+the provided date is not a valid QDate object, the
+setMaximumDate() function does nothing.
+\sa setDateRange()
+*/
+QDate QCalendarWidget::maximumDate() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_maximumDate;
+}
+void QCalendarWidget::setMaximumDate(const QDate &date)
+{
+Q_D(QCalendarWidget);
+if (!date.isValid() || d->m_model->m_maximumDate == date)
+return;
+QDate oldDate = d->m_model->m_date;
+d->m_model->setMaximumDate(date);
+d->yearEdit->setMaximum(d->m_model->m_maximumDate.year());
+d->updateMonthMenu();
+QDate newDate = d->m_model->m_date;
+if (oldDate != newDate) {
+d->update();
+d->showMonth(newDate.year(), newDate.month());
+d->m_navigator->setDate(newDate);
+emit selectionChanged();
+}
+}
+/*!
+Defines a date range by setting the minimumDate and maximumDate
+properties.
+The date range restricts the user selection, i.e. the user can
+only select dates within the specified date range. Note that
+\snippet doc/src/snippets/code/src_gui_widgets_qcalendarwidget.cpp 3
+is analogous to
+\snippet doc/src/snippets/code/src_gui_widgets_qcalendarwidget.cpp 4
+If either the \a min or \a max parameters are not valid QDate
+objects, this function does nothing.
+\sa setMinimumDate(), setMaximumDate()
+*/
+void QCalendarWidget::setDateRange(const QDate &min, const QDate &max)
+{
+Q_D(QCalendarWidget);
+if (d->m_model->m_minimumDate == min && d->m_model->m_maximumDate == max)
+return;
+if (!min.isValid() || !max.isValid())
+return;
+QDate oldDate = d->m_model->m_date;
+d->m_model->setRange(min, max);
+d->yearEdit->setMinimum(d->m_model->m_minimumDate.year());
+d->yearEdit->setMaximum(d->m_model->m_maximumDate.year());
+d->updateMonthMenu();
+QDate newDate = d->m_model->m_date;
+if (oldDate != newDate) {
+d->update();
+d->showMonth(newDate.year(), newDate.month());
+d->m_navigator->setDate(newDate);
+emit selectionChanged();
+}
+}
+/*! \enum QCalendarWidget::HorizontalHeaderFormat
+This enum type defines the various formats the horizontal header can display.
+\value SingleLetterDayNames The header displays a single letter abbreviation for day names (e.g. M for Monday).
+\value ShortDayNames The header displays a short abbreviation for day names (e.g. Mon for Monday).
+\value LongDayNames The header displays complete day names (e.g. Monday).
+\value NoHorizontalHeader The header is hidden.
+\sa horizontalHeaderFormat(), VerticalHeaderFormat
+*/
+/*!
+\property QCalendarWidget::horizontalHeaderFormat
+\brief the format of the horizontal header.
+The default value is QCalendarWidget::ShortDayNames.
+*/
+void QCalendarWidget::setHorizontalHeaderFormat(QCalendarWidget::HorizontalHeaderFormat format)
+{
+Q_D(QCalendarWidget);
+if (d->m_model->m_horizontalHeaderFormat == format)
+return;
+d->m_model->setHorizontalHeaderFormat(format);
+d->cachedSizeHint = QSize();
+d->m_view->viewport()->update();
+d->m_view->updateGeometry();
+}
+QCalendarWidget::HorizontalHeaderFormat QCalendarWidget::horizontalHeaderFormat() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_horizontalHeaderFormat;
+}
+/*!
+\enum QCalendarWidget::VerticalHeaderFormat
+This enum type defines the various formats the vertical header can display.
+\value ISOWeekNumbers The header displays ISO week numbers as described by \l QDate::weekNumber().
+\value NoVerticalHeader The header is hidden.
+\sa verticalHeaderFormat(), HorizontalHeaderFormat
+*/
+/*!
+\property QCalendarWidget::verticalHeaderFormat
+\brief the format of the vertical header.
+The default value is QCalendarWidget::ISOWeekNumber.
+*/
+QCalendarWidget::VerticalHeaderFormat QCalendarWidget::verticalHeaderFormat() const
+{
+Q_D(const QCalendarWidget);
+bool shown = d->m_model->weekNumbersShown();
+if (shown)
+return QCalendarWidget::ISOWeekNumbers;
+return QCalendarWidget::NoVerticalHeader;
+}
+void QCalendarWidget::setVerticalHeaderFormat(QCalendarWidget::VerticalHeaderFormat format)
+{
+Q_D(QCalendarWidget);
+bool show = false;
+if (format == QCalendarWidget::ISOWeekNumbers)
+show = true;
+if (d->m_model->weekNumbersShown() == show)
+return;
+d->m_model->setWeekNumbersShown(show);
+d->cachedSizeHint = QSize();
+d->m_view->viewport()->update();
+d->m_view->updateGeometry();
+}
+/*!
+\property QCalendarWidget::gridVisible
+\brief whether the table grid is displayed.
+\table
+\row
+\o \inlineimage qcalendarwidget-grid.png
+\row
+\o
+\snippet doc/src/snippets/code/src_gui_widgets_qcalendarwidget.cpp 5
+\endtable
+The default value is false.
+*/
+bool QCalendarWidget::isGridVisible() const
+{
+Q_D(const QCalendarWidget);
+return d->m_view->showGrid();
+}
+void QCalendarWidget::setGridVisible(bool show)
+{
+Q_D(QCalendarWidget);
+d->m_view->setShowGrid(show);
+d->cachedSizeHint = QSize();
+d->m_view->viewport()->update();
+d->m_view->updateGeometry();
+}
+/*!
+\property QCalendarWidget::selectionMode
+\brief the type of selection the user can make in the calendar
+When this property is set to SingleSelection, the user can select a date
+within the minimum and maximum allowed dates, using either the mouse or
+the keyboard.
+When the property is set to NoSelection, the user will be unable to select
+dates, but they can still be selected programmatically. Note that the date
+that is selected when the property is set to NoSelection will still be
+the selected date of the calendar.
+The default value is SingleSelection.
+*/
+QCalendarWidget::SelectionMode QCalendarWidget::selectionMode() const
+{
+Q_D(const QCalendarWidget);
+return d->m_view->readOnly ? QCalendarWidget::NoSelection : QCalendarWidget::SingleSelection;
+}
+void QCalendarWidget::setSelectionMode(SelectionMode mode)
+{
+Q_D(QCalendarWidget);
+d->m_view->readOnly = (mode == QCalendarWidget::NoSelection);
+d->setNavigatorEnabled(isDateEditEnabled() && (selectionMode() != QCalendarWidget::NoSelection));
+d->update();
+}
+/*!
+\property QCalendarWidget::firstDayOfWeek
+\brief a value identifying the day displayed in the first column.
+By default, the day displayed in the first column is Sunday
+*/
+void QCalendarWidget::setFirstDayOfWeek(Qt::DayOfWeek dayOfWeek)
+{
+Q_D(QCalendarWidget);
+if ((Qt::DayOfWeek)d->m_model->firstColumnDay() == dayOfWeek)
+return;
+d->m_model->setFirstColumnDay(dayOfWeek);
+d->update();
+}
+Qt::DayOfWeek QCalendarWidget::firstDayOfWeek() const
+{
+Q_D(const QCalendarWidget);
+return (Qt::DayOfWeek)d->m_model->firstColumnDay();
+}
+/*!
+Returns the text char format for rendering the header.
+*/
+QTextCharFormat QCalendarWidget::headerTextFormat() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_headerFormat;
+}
+/*!
+Sets the text char format for rendering the header to \a format.
+If you also set a weekday text format, this format's foreground and
+background color will take precedence over the header's format.
+The other formatting information will still be decided by
+the header's format.
+*/
+void QCalendarWidget::setHeaderTextFormat(const QTextCharFormat &format)
+{
+Q_D(QCalendarWidget);
+d->m_model->m_headerFormat = format;
+d->cachedSizeHint = QSize();
+d->m_view->viewport()->update();
+d->m_view->updateGeometry();
+}
+/*!
+Returns the text char format for rendering of day in the week \a dayOfWeek.
+\sa headerTextFormat()
+*/
+QTextCharFormat QCalendarWidget::weekdayTextFormat(Qt::DayOfWeek dayOfWeek) const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_dayFormats.value(dayOfWeek);
+}
+/*!
+Sets the text char format for rendering of day in the week \a dayOfWeek to \a format.
+The format will take precedence over the header format in case of foreground
+and background color. Other text formatting information is taken from the headers format.
+\sa setHeaderTextFormat()
+*/
+void QCalendarWidget::setWeekdayTextFormat(Qt::DayOfWeek dayOfWeek, const QTextCharFormat &format)
+{
+Q_D(QCalendarWidget);
+d->m_model->m_dayFormats[dayOfWeek] = format;
+d->cachedSizeHint = QSize();
+d->m_view->viewport()->update();
+d->m_view->updateGeometry();
+}
+/*!
+Returns a QMap from QDate to QTextCharFormat showing all dates
+that use a special format that alters their rendering.
+*/
+QMap<QDate, QTextCharFormat> QCalendarWidget::dateTextFormat() const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_dateFormats;
+}
+/*!
+Returns a QTextCharFormat for \a date. The char format can be be
+empty if the date is not renderd specially.
+*/
+QTextCharFormat QCalendarWidget::dateTextFormat(const QDate &date) const
+{
+Q_D(const QCalendarWidget);
+return d->m_model->m_dateFormats.value(date);
+}
+/*!
+Sets the format used to render the given \a date to that specified by \a format.
+If \a date is null, all date formats are cleared.
+*/
+void QCalendarWidget::setDateTextFormat(const QDate &date, const QTextCharFormat &format)
+{
+Q_D(QCalendarWidget);
+if (date.isNull())
+d->m_model->m_dateFormats.clear();
+else
+d->m_model->m_dateFormats[date] = format;
+d->m_view->viewport()->update();
+d->m_view->updateGeometry();
+}
+/*!
+\property QCalendarWidget::dateEditEnabled
+\brief whether the date edit popup is enabled
+\since 4.3
+If this property is enabled, pressing a non-modifier key will cause a
+date edit to popup if the calendar widget has focus, allowing the user
+to specify a date in the form specified by the current locale.
+By default, this property is enabled.
+The date edit is simpler in appearance than QDateEdit, but allows the
+user to navigate between fields using the left and right cursor keys,
+increment and decrement individual fields using the up and down cursor
+keys, and enter values directly using the number keys.
+\sa QCalendarWidget::dateEditAcceptDelay
+*/
+bool QCalendarWidget::isDateEditEnabled() const
+{
+Q_D(const QCalendarWidget);
+return d->m_dateEditEnabled;
+}
+void QCalendarWidget::setDateEditEnabled(bool enable)
+{
+Q_D(QCalendarWidget);
+if (isDateEditEnabled() == enable)
+return;
+d->m_dateEditEnabled = enable;
+d->setNavigatorEnabled(enable && (selectionMode() != QCalendarWidget::NoSelection));
+}
+/*!
+\property QCalendarWidget::dateEditAcceptDelay
+\brief the time an inactive date edit is shown before its contents are accepted
+\since 4.3
+If the calendar widget's \l{dateEditEnabled}{date edit is enabled}, this
+property specifies the amount of time (in millseconds) that the date edit
+remains open after the most recent user input. Once this time has elapsed,
+the date specified in the date edit is accepted and the popup is closed.
+By default, the delay is defined to be 1500 milliseconds (1.5 seconds).
+*/
+int QCalendarWidget::dateEditAcceptDelay() const
+{
+Q_D(const QCalendarWidget);
+return d->m_navigator->dateEditAcceptDelay();
+}
+void QCalendarWidget::setDateEditAcceptDelay(int delay)
+{
+Q_D(QCalendarWidget);
+d->m_navigator->setDateEditAcceptDelay(delay);
+}
+/*!
+\since 4.4
+Updates the cell specified by the given \a date unless updates
+are disabled or the cell is hidden.
+\sa updateCells(), yearShown(), monthShown()
+*/
+void QCalendarWidget::updateCell(const QDate &date)
+{
+if (!date.isValid()) {
+qWarning("QCalendarWidget::updateCell: Invalid date");
+return;
+}
+if (!isVisible())
+return;
+Q_D(QCalendarWidget);
+int row, column;
+d->m_model->cellForDate(date, &row, &column);
+if (row == -1 || column == -1)
+return;
+QModelIndex modelIndex = d->m_model->index(row, column);
+if (!modelIndex.isValid())
+return;
+d->m_view->viewport()->update(d->m_view->visualRect(modelIndex));
+}
+/*!
+\since 4.4
+Updates all visible cells unless updates are disabled.
+\sa updateCell()
+*/
+void QCalendarWidget::updateCells()
+{
+Q_D(QCalendarWidget);
+if (isVisible())
+d->m_view->viewport()->update();
+}
+/*!
+\fn void QCalendarWidget::selectionChanged()
+This signal is emitted when the currently selected date is
+changed.
+The currently selected date can be changed by the user using the
+mouse or keyboard, or by the programmer using setSelectedDate().
+\sa selectedDate()
+*/
+/*!
+\fn void QCalendarWidget::currentPageChanged(int year, int month)
+This signal is emitted when the currently shown month is changed.
+The new \a year and \a month are passed as parameters.
+\sa setCurrentPage()
+*/
+/*!
+\fn void QCalendarWidget::activated(const QDate &date)
+This signal is emitted whenever the user presses the Return or
+Enter key or double-clicks a \a date in the calendar
+widget.
+*/
+/*!
+\fn void QCalendarWidget::clicked(const QDate &date)
+This signal is emitted when a mouse button is clicked. The date
+the mouse was clicked on is specified by \a date. The signal is
+only emitted when clicked on a valid date, e.g., dates are not
+outside the minimumDate() and maximumDate(). If the selection mode
+is NoSelection, this signal will not be emitted.
+*/
+/*!
+\property QCalendarWidget::headerVisible
+\brief whether the navigation bar is shown or not
+\obsolete
+Use navigationBarVisible() instead.
+By default, this property is true.
+*/
+/*!
+\obsolete
+Use setNavigationBarVisible() instead.
+*/
+bool QCalendarWidget::isHeaderVisible() const
+{
+Q_D(const QCalendarWidget);
+return d->navBarVisible;
+}
+/*!
+\obsolete
+Use setNavigationBarVisible() instead.
+*/
+void QCalendarWidget::setHeaderVisible(bool visible)
+{
+setNavigationBarVisible(visible);
+}
+/*!
+\property QCalendarWidget::navigationBarVisible
+\brief whether the navigation bar is shown or not
+\since 4.3
+When this property is true (the default), the next month,
+previous month, month selection, year selection controls are
+shown on top.
+When the property is set to false, these controls are hidden.
+*/
+void QCalendarWidget::setNavigationBarVisible(bool visible)
+{
+Q_D(QCalendarWidget);
+d->navBarVisible = visible;
+d->cachedSizeHint = QSize();
+d->navBarBackground->setVisible(visible);
+updateGeometry();
+}
+/*!
+\reimp
+*/
+bool QCalendarWidget::event(QEvent *event)
+{
+Q_D(QCalendarWidget);
+switch (event->type()) {
+case QEvent::LayoutDirectionChange:
+d->updateButtonIcons();
+case QEvent::LocaleChange:
+d->cachedSizeHint = QSize();
+d->updateMonthMenuNames();
+d->updateNavigationBar();
+d->m_view->updateGeometry();
+break;
+case QEvent::FontChange:
+case QEvent::ApplicationFontChange:
+d->cachedSizeHint = QSize();
+d->m_view->updateGeometry();
+break;
+case QEvent::StyleChange:
+d->cachedSizeHint = QSize();
+d->m_view->updateGeometry();
+default:
+break;
+}
+return QWidget::event(event);
+}
+/*!
+\reimp
+*/
+bool QCalendarWidget::eventFilter(QObject *watched, QEvent *event)
+{
+Q_D(QCalendarWidget);
+if (event->type() == QEvent::MouseButtonPress && d->yearEdit->hasFocus()) {
+QWidget *tlw = window();
+QWidget *widget = static_cast<QWidget*>(watched);
+//as we have a event filter on the whole application we first make sure that the top level widget
+//of both this and the watched widget are the same to decide if we should finish the year edition.
+if (widget->window() == tlw) {
+QPoint mousePos = widget->mapTo(tlw, static_cast<QMouseEvent *>(event)->pos());
+QRect geom = QRect(d->yearEdit->mapTo(tlw, QPoint(0, 0)), d->yearEdit->size());
+if (!geom.contains(mousePos)) {
+event->accept();
+d->_q_yearEditingFinished();
+setFocus();
+return true;
+}
+}
+}
+return QWidget::eventFilter(watched, event);
+}
+/*!
+\reimp
+*/
+void QCalendarWidget::mousePressEvent(QMouseEvent *event)
+{
+setAttribute(Qt::WA_NoMouseReplay);
+QWidget::mousePressEvent(event);
+setFocus();
+}
+/*!
+\reimp
+*/
+void QCalendarWidget::resizeEvent(QResizeEvent * event)
+{
+Q_D(QCalendarWidget);
+// XXX Should really use a QWidgetStack for yearEdit and yearButton,
+// XXX here we hide the year edit when the layout is likely to break
+// XXX the manual positioning of the yearEdit over the yearButton.
+if(d->yearEdit->isVisible() && event->size().width() != event->oldSize().width())
+d->_q_yearEditingFinished();
+QWidget::resizeEvent(event);
+}
+/*!
+\reimp
+*/
+void QCalendarWidget::keyPressEvent(QKeyEvent * event)
+{
+Q_D(QCalendarWidget);
+if(d->yearEdit->isVisible()&& event->key() == Qt::Key_Escape)
+{
+d->yearEdit->setValue(yearShown());
+d->_q_yearEditingFinished();
+return;
+}
+QWidget::keyPressEvent(event);
+}
+QT_END_NAMESPACE
+#include "qcalendarwidget.moc"
+#include "moc_qcalendarwidget.cpp"
+#endif //QT_NO_CALENDARWIDGET

changeset 0	1918ee327afb
child 3	41300fa6a67c