Qt 4.8
qcalendarwidget.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the QtGui module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 #include "qcalendarwidget.h"
43 
44 #ifndef QT_NO_CALENDARWIDGET
45 
46 #include <qabstractitemmodel.h>
47 #include <qitemdelegate.h>
48 #include <qdatetime.h>
49 #include <qtableview.h>
50 #include <qlayout.h>
51 #include <qevent.h>
52 #include <qtextformat.h>
53 #include <qheaderview.h>
54 #include <private/qwidget_p.h>
55 #include <qpushbutton.h>
56 #include <qtoolbutton.h>
57 #include <qlabel.h>
58 #include <qspinbox.h>
59 #include <qmenu.h>
60 #include <qapplication.h>
61 #include <qbasictimer.h>
62 #include <qstylepainter.h>
63 #include <private/qcalendartextnavigator_p.h>
64 
66 
67 enum {
68  RowCount = 6,
71  HeaderRow = 0,
73 };
74 
76 {
77 public:
78 
79  enum Section {
83  };
84 
87  virtual Section handleKey(int key) = 0;
88  virtual QDate applyToDate(const QDate &date) const = 0;
89  virtual void setDate(const QDate &date) = 0;
90  virtual QString text() const = 0;
91  virtual QString text(const QDate &date, int repeat) const = 0;
92 
94 
95 protected:
96  QString highlightString(const QString &str, int pos) const;
97 private:
98 };
99 
101 {
102  if (pos == 0)
103  return QLatin1String("<b>") + str + QLatin1String("</b>");
104  int startPos = str.length() - pos;
105  return str.mid(0, startPos) + QLatin1String("<b>") + str.mid(startPos, pos) + QLatin1String("</b>");
106 
107 }
108 
110 {
111 
112 public:
114  virtual Section handleKey(int key);
115  virtual QDate applyToDate(const QDate &date) const;
116  virtual void setDate(const QDate &date);
117  virtual QString text() const;
118  virtual QString text(const QDate &date, int repeat) const;
119 private:
120  int m_pos;
121  int m_day;
122  int m_oldDay;
123 };
124 
126  : QCalendarDateSectionValidator(), m_pos(0), m_day(1), m_oldDay(1)
127 {
128 }
129 
131 {
132  if (key == Qt::Key_Right || key == Qt::Key_Left) {
133  m_pos = 0;
135  } else if (key == Qt::Key_Up) {
136  m_pos = 0;
137  ++m_day;
138  if (m_day > 31)
139  m_day = 1;
141  } else if (key == Qt::Key_Down) {
142  m_pos = 0;
143  --m_day;
144  if (m_day < 1)
145  m_day = 31;
147  } else if (key == Qt::Key_Back || key == Qt::Key_Backspace) {
148  --m_pos;
149  if (m_pos < 0)
150  m_pos = 1;
151 
152  if (m_pos == 0)
153  m_day = m_oldDay;
154  else
155  m_day = m_day / 10;
156  //m_day = m_oldDay / 10 * 10 + m_day / 10;
157 
158  if (m_pos == 0)
161  }
162  if (key < Qt::Key_0 || key > Qt::Key_9)
164  int pressedKey = key - Qt::Key_0;
165  if (m_pos == 0)
166  m_day = pressedKey;
167  else
168  m_day = m_day % 10 * 10 + pressedKey;
169  if (m_day > 31)
170  m_day = 31;
171  ++m_pos;
172  if (m_pos > 1) {
173  m_pos = 0;
175  }
177 }
178 
180 {
181  int day = m_day;
182  if (day < 1)
183  day = 1;
184  else if (day > 31)
185  day = 31;
186  if (day > date.daysInMonth())
187  day = date.daysInMonth();
188  return QDate(date.year(), date.month(), day);
189 }
190 
192 {
193  m_day = m_oldDay = date.day();
194  m_pos = 0;
195 }
196 
198 {
199  QString str;
200  if (m_day / 10 == 0)
201  str += QLatin1Char('0');
202  str += QString::number(m_day);
203  return highlightString(str, m_pos);
204 }
205 
206 QString QCalendarDayValidator::text(const QDate &date, int repeat) const
207 {
208  if (repeat <= 1) {
209  return QString::number(date.day());
210  } else if (repeat == 2) {
211  QString str;
212  if (date.day() / 10 == 0)
213  str += QLatin1Char('0');
214  return str + QString::number(date.day());
215  } else if (repeat == 3) {
217  } else if (repeat >= 4) {
219  }
220  return QString();
221 }
222 
224 
226 {
227 
228 public:
230  virtual Section handleKey(int key);
231  virtual QDate applyToDate(const QDate &date) const;
232  virtual void setDate(const QDate &date);
233  virtual QString text() const;
234  virtual QString text(const QDate &date, int repeat) const;
235 private:
236  int m_pos;
237  int m_month;
239 };
240 
242  : QCalendarDateSectionValidator(), m_pos(0), m_month(1), m_oldMonth(1)
243 {
244 }
245 
247 {
248  if (key == Qt::Key_Right || key == Qt::Key_Left) {
249  m_pos = 0;
251  } else if (key == Qt::Key_Up) {
252  m_pos = 0;
253  ++m_month;
254  if (m_month > 12)
255  m_month = 1;
257  } else if (key == Qt::Key_Down) {
258  m_pos = 0;
259  --m_month;
260  if (m_month < 1)
261  m_month = 12;
263  } else if (key == Qt::Key_Back || key == Qt::Key_Backspace) {
264  --m_pos;
265  if (m_pos < 0)
266  m_pos = 1;
267 
268  if (m_pos == 0)
270  else
271  m_month = m_month / 10;
272  //m_month = m_oldMonth / 10 * 10 + m_month / 10;
273 
274  if (m_pos == 0)
277  }
278  if (key < Qt::Key_0 || key > Qt::Key_9)
280  int pressedKey = key - Qt::Key_0;
281  if (m_pos == 0)
282  m_month = pressedKey;
283  else
284  m_month = m_month % 10 * 10 + pressedKey;
285  if (m_month > 12)
286  m_month = 12;
287  ++m_pos;
288  if (m_pos > 1) {
289  m_pos = 0;
291  }
293 }
294 
296 {
297  int month = m_month;
298  if (month < 1)
299  month = 1;
300  else if (month > 12)
301  month = 12;
302  QDate newDate(date.year(), m_month, 1);
303  int day = date.day();
304  if (day > newDate.daysInMonth())
305  day = newDate.daysInMonth();
306  return QDate(date.year(), month, day);
307 }
308 
310 {
311  m_month = m_oldMonth = date.month();
312  m_pos = 0;
313 }
314 
316 {
317  QString str;
318  if (m_month / 10 == 0)
319  str += QLatin1Char('0');
320  str += QString::number(m_month);
321  return highlightString(str, m_pos);
322 }
323 
324 QString QCalendarMonthValidator::text(const QDate &date, int repeat) const
325 {
326  if (repeat <= 1) {
327  return QString::number(date.month());
328  } else if (repeat == 2) {
329  QString str;
330  if (date.month() / 10 == 0)
331  str += QLatin1Char('0');
332  return str + QString::number(date.month());
333  } else if (repeat == 3) {
335  } else /*if (repeat >= 4)*/ {
337  }
338 }
339 
341 
343 {
344 
345 public:
347  virtual Section handleKey(int key);
348  virtual QDate applyToDate(const QDate &date) const;
349  virtual void setDate(const QDate &date);
350  virtual QString text() const;
351  virtual QString text(const QDate &date, int repeat) const;
352 private:
353  int pow10(int n);
354  int m_pos;
355  int m_year;
357 };
358 
360  : QCalendarDateSectionValidator(), m_pos(0), m_year(2000), m_oldYear(2000)
361 {
362 }
363 
365 {
366  int power = 1;
367  for (int i = 0; i < n; i++)
368  power *= 10;
369  return power;
370 }
371 
373 {
374  if (key == Qt::Key_Right || key == Qt::Key_Left) {
375  m_pos = 0;
377  } else if (key == Qt::Key_Up) {
378  m_pos = 0;
379  ++m_year;
381  } else if (key == Qt::Key_Down) {
382  m_pos = 0;
383  --m_year;
385  } else if (key == Qt::Key_Back || key == Qt::Key_Backspace) {
386  --m_pos;
387  if (m_pos < 0)
388  m_pos = 3;
389 
390  int pow = pow10(m_pos);
391  m_year = m_oldYear / pow * pow + m_year % (pow * 10) / 10;
392 
393  if (m_pos == 0)
396  }
397  if (key < Qt::Key_0 || key > Qt::Key_9)
399  int pressedKey = key - Qt::Key_0;
400  int pow = pow10(m_pos);
401  m_year = m_year / (pow * 10) * (pow * 10) + m_year % pow * 10 + pressedKey;
402  ++m_pos;
403  if (m_pos > 3) {
404  m_pos = 0;
406  }
408 }
409 
411 {
412  int year = m_year;
413  if (year < 1)
414  year = 1;
415  QDate newDate(year, date.month(), 1);
416  int day = date.day();
417  if (day > newDate.daysInMonth())
418  day = newDate.daysInMonth();
419  return QDate(year, date.month(), day);
420 }
421 
423 {
424  m_year = m_oldYear = date.year();
425  m_pos = 0;
426 }
427 
429 {
430  QString str;
431  int pow = 10;
432  for (int i = 0; i < 3; i++) {
433  if (m_year / pow == 0)
434  str += QLatin1Char('0');
435  pow *= 10;
436  }
437  str += QString::number(m_year);
438  return highlightString(str, m_pos);
439 }
440 
441 QString QCalendarYearValidator::text(const QDate &date, int repeat) const
442 {
443  if (repeat < 4) {
444  QString str;
445  int year = date.year() % 100;
446  if (year / 10 == 0)
447  str = QLatin1Char('0');
448  return str + QString::number(year);
449  }
450  return QString::number(date.year());
451 }
452 
454 
456 {
457 public:
460 
461  void handleKeyEvent(QKeyEvent *keyEvent);
462  QString currentText() const;
463  QDate currentDate() const { return m_currentDate; }
464  void setFormat(const QString &format);
465  void setInitialDate(const QDate &date);
466 
467  void setLocale(const QLocale &locale);
468 
469 private:
470 
471  struct SectionToken {
472  SectionToken(QCalendarDateSectionValidator *val, int rep) : validator(val), repeat(rep) {}
474  int repeat;
475  };
476 
477  void toNextToken();
478  void toPreviousToken();
479  void applyToDate();
480 
481  int countRepeat(const QString &str, int index) const;
482  void clear();
483 
489 
491 
494 
496 };
497 
499  : m_currentToken(0), m_lastSectionMove(QCalendarDateSectionValidator::ThisSection)
500 {
505 }
506 
508 {
509  m_yearValidator->m_locale = locale;
510  m_monthValidator->m_locale = locale;
511  m_dayValidator->m_locale = locale;
512 }
513 
515 {
516  delete m_yearValidator;
517  delete m_monthValidator;
518  delete m_dayValidator;
519  clear();
520 }
521 
522 // from qdatetime.cpp
524 {
525  Q_ASSERT(index >= 0 && index < str.size());
526  int count = 1;
527  const QChar ch = str.at(index);
528  while (index + count < str.size() && str.at(index + count) == ch)
529  ++count;
530  return count;
531 }
532 
534 {
535  m_yearValidator->setDate(date);
536  m_monthValidator->setDate(date);
537  m_dayValidator->setDate(date);
538  m_initialDate = date;
539  m_currentDate = date;
541 }
542 
544 {
545  QString str;
547  QListIterator<SectionToken *> itTok(m_tokens);
548  while (itSep.hasNext()) {
549  str += itSep.next();
550  if (itTok.hasNext()) {
551  SectionToken *token = itTok.next();
552  QCalendarDateSectionValidator *validator = token->validator;
553  if (m_currentToken == token)
554  str += validator->text();
555  else
556  str += validator->text(m_currentDate, token->repeat);
557  }
558  }
559  return str;
560 }
561 
563 {
564  QListIterator<SectionToken *> it(m_tokens);
565  while (it.hasNext())
566  delete it.next();
567 
568  m_tokens.clear();
570 
571  m_currentToken = 0;
572 }
573 
575 {
576  clear();
577 
578  int pos = 0;
579  const QLatin1Char quote('\'');
580  bool quoting = false;
581  QString separator;
582  while (pos < format.size()) {
583  QString mid = format.mid(pos);
584  int offset = 1;
585 
586  if (mid.startsWith(quote)) {
587  quoting = !quoting;
588  } else {
589  const QChar nextChar = format.at(pos);
590  if (quoting) {
591  separator += nextChar;
592  } else {
593  SectionToken *token = 0;
594  if (nextChar == QLatin1Char('d')) {
595  offset = qMin(4, countRepeat(format, pos));
596  token = new SectionToken(m_dayValidator, offset);
597  } else if (nextChar == QLatin1Char('M')) {
598  offset = qMin(4, countRepeat(format, pos));
599  token = new SectionToken(m_monthValidator, offset);
600  } else if (nextChar == QLatin1Char('y')) {
601  offset = qMin(4, countRepeat(format, pos));
602  token = new SectionToken(m_yearValidator, offset);
603  } else {
604  separator += nextChar;
605  }
606  if (token) {
607  m_tokens.append(token);
608  m_separators.append(separator);
609  separator = QString();
610  if (!m_currentToken)
611  m_currentToken = token;
612 
613  }
614  }
615  }
616  pos += offset;
617  }
618  m_separators += separator;
619 }
620 
622 {
626 }
627 
629 {
630  const int idx = m_tokens.indexOf(m_currentToken);
631  if (idx == -1)
632  return;
633  if (idx + 1 >= m_tokens.count())
634  m_currentToken = m_tokens.first();
635  else
636  m_currentToken = m_tokens.at(idx + 1);
637 }
638 
640 {
641  const int idx = m_tokens.indexOf(m_currentToken);
642  if (idx == -1)
643  return;
644  if (idx - 1 < 0)
645  m_currentToken = m_tokens.last();
646  else
647  m_currentToken = m_tokens.at(idx - 1);
648 }
649 
651 {
652  if (!m_currentToken)
653  return;
654 
655  int key = keyEvent->key();
657  if (key == Qt::Key_Back || key == Qt::Key_Backspace)
658  toPreviousToken();
659  }
660  if (key == Qt::Key_Right)
661  toNextToken();
662  else if (key == Qt::Key_Left)
663  toPreviousToken();
664 
666 
667  applyToDate();
669  toNextToken();
671  toPreviousToken();
672 }
673 
675 {
676  return m_widget;
677 }
678 
680 {
681  m_widget = widget;
682 }
683 
685 {
686  return m_date;
687 }
688 
690 {
691  m_date = date;
692 }
693 
695 {
696  if (!m_widget)
697  return;
698 
699  m_acceptTimer.start(m_editDelay, this);
700 
701  m_dateText->setText(m_dateValidator->currentText());
702 
703  QSize s = m_dateFrame->sizeHint();
704  QRect r = m_widget->geometry(); // later, just the table section
705  QRect newRect((r.width() - s.width()) / 2, (r.height() - s.height()) / 2, s.width(), s.height());
706  m_dateFrame->setGeometry(newRect);
707  // need to set palette after geometry update as phonestyle sets transparency
708  // effect in move event.
709  QPalette p = m_dateFrame->palette();
710  p.setBrush(QPalette::Window, m_dateFrame->window()->palette().brush(QPalette::Window));
711  m_dateFrame->setPalette(p);
712 
713  m_dateFrame->raise();
714  m_dateFrame->show();
715 }
716 
718 {
719  QDate date = m_dateValidator->currentDate();
720  if (m_date == date)
721  return;
722 
723  m_date = date;
724  emit dateChanged(date);
725 }
726 
728 {
729  if (m_dateFrame)
730  return;
731  m_dateFrame = new QFrame(m_widget);
732  QVBoxLayout *vl = new QVBoxLayout;
733  m_dateText = new QLabel;
734  vl->addWidget(m_dateText);
735  m_dateFrame->setLayout(vl);
736  m_dateFrame->setFrameShadow(QFrame::Plain);
737  m_dateFrame->setFrameShape(QFrame::Box);
738  m_dateValidator = new QCalendarDateValidator();
739  m_dateValidator->setLocale(m_widget->locale());
740  m_dateValidator->setFormat(m_widget->locale().dateFormat(QLocale::ShortFormat));
741  m_dateValidator->setInitialDate(m_date);
742 
743  m_dateFrame->setAutoFillBackground(true);
744  m_dateFrame->setBackgroundRole(QPalette::Window);
745 }
746 
748 {
749  if (!m_dateFrame)
750  return;
751  m_acceptTimer.stop();
752  m_dateFrame->hide();
753  m_dateFrame->deleteLater();
754  delete m_dateValidator;
755  m_dateFrame = 0;
756  m_dateText = 0;
757  m_dateValidator = 0;
758 }
759 
761 {
762  if (m_widget) {
763  if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
764  QKeyEvent* ke = (QKeyEvent*)e;
765  if ((ke->text().length() > 0 && ke->text()[0].isPrint()) || m_dateFrame) {
766  if (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Select) {
767  applyDate();
768  emit editingFinished();
769  removeDateLabel();
770  } else if (ke->key() == Qt::Key_Escape) {
771  removeDateLabel();
772  } else if (e->type() == QEvent::KeyPress) {
773  createDateLabel();
774  m_dateValidator->handleKeyEvent(ke);
775  updateDateLabel();
776  }
777  ke->accept();
778  return true;
779  }
780  // If we are navigating let the user finish his date in old locate.
781  // If we change our mind and want it to update immediately simply uncomment below
782  /*
783  } else if (e->type() == QEvent::LocaleChange) {
784  if (m_dateValidator) {
785  m_dateValidator->setLocale(m_widget->locale());
786  m_dateValidator->setFormat(m_widget->locale().dateFormat(QLocale::ShortFormat));
787  updateDateLabel();
788  }
789  */
790  }
791  }
792  return QObject::eventFilter(o,e);
793 }
794 
796 {
797  if (e->timerId() == m_acceptTimer.timerId()) {
798  applyDate();
799  removeDateLabel();
800  }
801 }
802 
804 {
805  return m_editDelay;
806 }
807 
809 {
810  m_editDelay = delay;
811 }
812 
813 class QCalendarView;
814 
816 {
817  Q_OBJECT
818 public:
819  QCalendarModel(QObject *parent = 0);
820 
821  int rowCount(const QModelIndex &) const
822  { return RowCount + m_firstRow; }
823  int columnCount(const QModelIndex &) const
824  { return ColumnCount + m_firstColumn; }
825  QVariant data(const QModelIndex &index, int role) const;
826  Qt::ItemFlags flags(const QModelIndex &index) const;
827 
828  bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex())
829  {
830  beginInsertRows(parent, row, row + count - 1);
831  endInsertRows();
832  return true;
833  }
834  bool insertColumns(int column, int count, const QModelIndex &parent = QModelIndex())
835  {
836  beginInsertColumns(parent, column, column + count - 1);
837  endInsertColumns();
838  return true;
839  }
840  bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex())
841  {
842  beginRemoveRows(parent, row, row + count - 1);
843  endRemoveRows();
844  return true;
845  }
846  bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex())
847  {
848  beginRemoveColumns(parent, column, column + count - 1);
849  endRemoveColumns();
850  return true;
851  }
852 
853  void showMonth(int year, int month);
854  void setDate(const QDate &d);
855 
856  void setMinimumDate(const QDate &date);
857  void setMaximumDate(const QDate &date);
858 
859  void setRange(const QDate &min, const QDate &max);
860 
861  void setHorizontalHeaderFormat(QCalendarWidget::HorizontalHeaderFormat format);
862 
863  void setFirstColumnDay(Qt::DayOfWeek dayOfWeek);
864  Qt::DayOfWeek firstColumnDay() const;
865 
866  bool weekNumbersShown() const;
867  void setWeekNumbersShown(bool show);
868 
869  QTextCharFormat formatForCell(int row, int col) const;
870  Qt::DayOfWeek dayOfWeekForColumn(int section) const;
871  int columnForDayOfWeek(Qt::DayOfWeek day) const;
872  QDate dateForCell(int row, int column) const;
873  void cellForDate(const QDate &date, int *row, int *column) const;
874  QString dayName(Qt::DayOfWeek day) const;
875 
876  void setView(QCalendarView *view)
877  { m_view = view; }
878 
879  void internalUpdate();
880  QDate referenceDate() const;
881  int columnForFirstOfMonth(const QDate &date) const;
882 
897 };
898 
899 class QCalendarView : public QTableView
900 {
901  Q_OBJECT
902 public:
903  QCalendarView(QWidget *parent = 0);
904 
905  void internalUpdate() { updateGeometries(); }
906  void setReadOnly(bool enable);
907  virtual void keyboardSearch(const QString & search) { Q_UNUSED(search) }
908 
909 signals:
910  void showDate(const QDate &date);
911  void changeDate(const QDate &date, bool changeMonth);
912  void clicked(const QDate &date);
913  void editingFinished();
914 protected:
915  QModelIndex moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers);
916  void mouseDoubleClickEvent(QMouseEvent *event);
917  void mousePressEvent(QMouseEvent *event);
918  void mouseMoveEvent(QMouseEvent *event);
919  void mouseReleaseEvent(QMouseEvent *event);
920 #ifndef QT_NO_WHEELEVENT
921  void wheelEvent(QWheelEvent *event);
922 #endif
923  void keyPressEvent(QKeyEvent *event);
924  bool event(QEvent *event);
925 
926  QDate handleMouseEvent(QMouseEvent *event);
927 public:
928  bool readOnly;
929 private:
931 #ifdef QT_KEYPAD_NAVIGATION
932  QDate origDate;
933 #endif
934 };
935 
937  : QAbstractTableModel(parent)
938 {
941  m_maximumDate = QDate(7999, 12, 31);
942  m_shownYear = m_date.year();
946  m_weekNumbersShown = true;
947  m_firstColumn = 1;
948  m_firstRow = 1;
949  m_view = 0;
950 }
951 
953 {
954  int col = column - m_firstColumn;
955  if (col < 0 || col > 6)
956  return Qt::Sunday;
957  int day = m_firstDay + col;
958  if (day > 7)
959  day -= 7;
960  return Qt::DayOfWeek(day);
961 }
962 
964 {
965  if (day < 1 || day > 7)
966  return -1;
967  int column = (int)day - (int)m_firstDay;
968  if (column < 0)
969  column += 7;
970  return column + m_firstColumn;
971 }
972 
973 /*
974 This simple algorithm tries to generate a valid date from the month shown.
975 Some months don't contain a first day (e.g. Jan of -4713 year,
976 so QDate (-4713, 1, 1) would be invalid). In that case we try to generate
977 another valid date for that month. Later, returned date's day is the number of cells
978 calendar widget will reserve for days before referenceDate. (E.g. if returned date's
979 day is 16, that day will be placed in 3rd or 4th row, not in the 1st or 2nd row).
980 Depending on referenceData we can change behaviour of Oct 1582. If referenceDate is 1st
981 of Oct we render 1 Oct in 1st or 2nd row. If referenceDate is 17 of Oct we show always 16
982 dates before 17 of Oct, and since this month contains the hole 5-14 Oct, the first of Oct
983 will be rendered in 2nd or 3rd row, showing more dates from previous month.
984 */
986 {
987  int refDay = 1;
988  while (refDay <= 31) {
989  QDate refDate(m_shownYear, m_shownMonth, refDay);
990  if (refDate.isValid())
991  return refDate;
992  refDay += 1;
993  }
994  return QDate();
995 }
996 
998 {
999  return (columnForDayOfWeek(static_cast<Qt::DayOfWeek>(date.dayOfWeek())) - (date.day() % 7) + 8) % 7;
1000 }
1001 
1002 QDate QCalendarModel::dateForCell(int row, int column) const
1003 {
1004  if (row < m_firstRow || row > m_firstRow + RowCount - 1 ||
1005  column < m_firstColumn || column > m_firstColumn + ColumnCount - 1)
1006  return QDate();
1007  const QDate refDate = referenceDate();
1008  if (!refDate.isValid())
1009  return QDate();
1010 
1011  const int columnForFirstOfShownMonth = columnForFirstOfMonth(refDate);
1012  if (columnForFirstOfShownMonth - m_firstColumn < MinimumDayOffset)
1013  row -= 1;
1014 
1015  const int requestedDay = 7 * (row - m_firstRow) + column - columnForFirstOfShownMonth - refDate.day() + 1;
1016  return refDate.addDays(requestedDay);
1017 }
1018 
1019 void QCalendarModel::cellForDate(const QDate &date, int *row, int *column) const
1020 {
1021  if (!row && !column)
1022  return;
1023 
1024  if (row)
1025  *row = -1;
1026  if (column)
1027  *column = -1;
1028 
1029  const QDate refDate = referenceDate();
1030  if (!refDate.isValid())
1031  return;
1032 
1033  const int columnForFirstOfShownMonth = columnForFirstOfMonth(refDate);
1034  const int requestedPosition = refDate.daysTo(date) - m_firstColumn + columnForFirstOfShownMonth + refDate.day() - 1;
1035 
1036  int c = requestedPosition % 7;
1037  int r = requestedPosition / 7;
1038  if (c < 0) {
1039  c += 7;
1040  r -= 1;
1041  }
1042 
1043  if (columnForFirstOfShownMonth - m_firstColumn < MinimumDayOffset)
1044  r += 1;
1045 
1046  if (r < 0 || r > RowCount - 1 || c < 0 || c > ColumnCount - 1)
1047  return;
1048 
1049  if (row)
1050  *row = r + m_firstRow;
1051  if (column)
1052  *column = c + m_firstColumn;
1053 }
1054 
1056 {
1057  switch (m_horizontalHeaderFormat) {
1059  QString standaloneDayName = m_view->locale().standaloneDayName(day, QLocale::NarrowFormat);
1060  if (standaloneDayName == m_view->locale().dayName(day, QLocale::NarrowFormat))
1061  return standaloneDayName.left(1);
1062  return standaloneDayName;
1063  }
1065  return m_view->locale().dayName(day, QLocale::ShortFormat);
1067  return m_view->locale().dayName(day, QLocale::LongFormat);
1068  default:
1069  break;
1070  }
1071  return QString();
1072 }
1073 
1075 {
1076  QPalette pal;
1078  if (m_view) {
1079  pal = m_view->palette();
1080  if (!m_view->isEnabled())
1081  cg = QPalette::Disabled;
1082  else if (!m_view->isActiveWindow())
1083  cg = QPalette::Inactive;
1084  }
1085 
1087  format.setFont(m_view->font());
1088  bool header = (m_weekNumbersShown && col == HeaderColumn)
1090  format.setBackground(pal.brush(cg, header ? QPalette::AlternateBase : QPalette::Base));
1091  format.setForeground(pal.brush(cg, QPalette::Text));
1092  if (header) {
1093  format.merge(m_headerFormat);
1094  }
1095 
1096  if (col >= m_firstColumn && col < m_firstColumn + ColumnCount) {
1097  Qt::DayOfWeek dayOfWeek = dayOfWeekForColumn(col);
1098  if (m_dayFormats.contains(dayOfWeek))
1099  format.merge(m_dayFormats.value(dayOfWeek));
1100  }
1101 
1102  if (!header) {
1103  QDate date = dateForCell(row, col);
1104  format.merge(m_dateFormats.value(date));
1105  if(date < m_minimumDate || date > m_maximumDate)
1106  format.setBackground(pal.brush(cg, QPalette::Window));
1107  if (m_shownMonth != date.month())
1109  }
1110  return format;
1111 }
1112 
1113 QVariant QCalendarModel::data(const QModelIndex &index, int role) const
1114 {
1115  if (role == Qt::TextAlignmentRole)
1116  return (int) Qt::AlignCenter;
1117 
1118  int row = index.row();
1119  int column = index.column();
1120 
1121  if(role == Qt::DisplayRole) {
1122  if (m_weekNumbersShown && column == HeaderColumn
1123  && row >= m_firstRow && row < m_firstRow + RowCount) {
1125  if (date.isValid())
1126  return date.weekNumber();
1127  }
1129  && column >= m_firstColumn && column < m_firstColumn + ColumnCount)
1130  return dayName(dayOfWeekForColumn(column));
1131  QDate date = dateForCell(row, column);
1132  if (date.isValid())
1133  return date.day();
1134  return QString();
1135  }
1136 
1137  QTextCharFormat fmt = formatForCell(row, column);
1138  if (role == Qt::BackgroundColorRole)
1139  return fmt.background().color();
1140  if (role == Qt::TextColorRole)
1141  return fmt.foreground().color();
1142  if (role == Qt::FontRole)
1143  return fmt.font();
1144  if (role == Qt::ToolTipRole)
1145  return fmt.toolTip();
1146  return QVariant();
1147 }
1148 
1149 Qt::ItemFlags QCalendarModel::flags(const QModelIndex &index) const
1150 {
1151  QDate date = dateForCell(index.row(), index.column());
1152  if (!date.isValid())
1153  return QAbstractTableModel::flags(index);
1154  if (date < m_minimumDate)
1155  return 0;
1156  if (date > m_maximumDate)
1157  return 0;
1158  return QAbstractTableModel::flags(index);
1159 }
1160 
1162 {
1163  m_date = d;
1164  if (m_date < m_minimumDate)
1166  else if (m_date > m_maximumDate)
1168 }
1169 
1170 void QCalendarModel::showMonth(int year, int month)
1171 {
1172  if (m_shownYear == year && m_shownMonth == month)
1173  return;
1174 
1175  m_shownYear = year;
1176  m_shownMonth = month;
1177 
1178  internalUpdate();
1179 }
1180 
1182 {
1183  if (!d.isValid() || d == m_minimumDate)
1184  return;
1185 
1186  m_minimumDate = d;
1189  if (m_date < m_minimumDate)
1191  internalUpdate();
1192 }
1193 
1195 {
1196  if (!d.isValid() || d == m_maximumDate)
1197  return;
1198 
1199  m_maximumDate = d;
1202  if (m_date > m_maximumDate)
1204  internalUpdate();
1205 }
1206 
1207 void QCalendarModel::setRange(const QDate &min, const QDate &max)
1208 {
1209  m_minimumDate = min;
1210  m_maximumDate = max;
1213  if (m_date < m_minimumDate)
1215  if (m_date > m_maximumDate)
1217  internalUpdate();
1218 }
1219 
1221 {
1222  QModelIndex begin = index(0, 0);
1224  emit dataChanged(begin, end);
1227 }
1228 
1230 {
1231  if (m_horizontalHeaderFormat == format)
1232  return;
1233 
1234  int oldFormat = m_horizontalHeaderFormat;
1236  if (oldFormat == QCalendarWidget::NoHorizontalHeader) {
1237  m_firstRow = 1;
1238  insertRow(0);
1240  m_firstRow = 0;
1241  removeRow(0);
1242  }
1243  internalUpdate();
1244 }
1245 
1247 {
1248  if (m_firstDay == dayOfWeek)
1249  return;
1250 
1251  m_firstDay = dayOfWeek;
1252  internalUpdate();
1253 }
1254 
1256 {
1257  return m_firstDay;
1258 }
1259 
1261 {
1262  return m_weekNumbersShown;
1263 }
1264 
1266 {
1267  if (m_weekNumbersShown == show)
1268  return;
1269 
1270  m_weekNumbersShown = show;
1271  if (show) {
1272  m_firstColumn = 1;
1273  insertColumn(0);
1274  } else {
1275  m_firstColumn = 0;
1276  removeColumn(0);
1277  }
1278  internalUpdate();
1279 }
1280 
1282  : QTableView(parent),
1283  readOnly(false),
1284  validDateClicked(false)
1285 {
1286  setTabKeyNavigation(false);
1287  setShowGrid(false);
1288  verticalHeader()->setVisible(false);
1289  horizontalHeader()->setVisible(false);
1292 }
1293 
1294 QModelIndex QCalendarView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
1295 {
1296  QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
1297  if (!calendarModel)
1298  return QTableView::moveCursor(cursorAction, modifiers);
1299 
1300  if (readOnly)
1301  return currentIndex();
1302 
1303  QModelIndex index = currentIndex();
1304  QDate currentDate = static_cast<QCalendarModel*>(model())->dateForCell(index.row(), index.column());
1305  switch (cursorAction) {
1307  currentDate = currentDate.addDays(-7);
1308  break;
1310  currentDate = currentDate.addDays(7);
1311  break;
1313  currentDate = currentDate.addDays(isRightToLeft() ? 1 : -1);
1314  break;
1316  currentDate = currentDate.addDays(isRightToLeft() ? -1 : 1);
1317  break;
1319  currentDate = QDate(currentDate.year(), currentDate.month(), 1);
1320  break;
1322  currentDate = QDate(currentDate.year(), currentDate.month(), currentDate.daysInMonth());
1323  break;
1325  currentDate = currentDate.addMonths(-1);
1326  break;
1328  currentDate = currentDate.addMonths(1);
1329  break;
1332  return currentIndex();
1333  default:
1334  break;
1335  }
1336  emit changeDate(currentDate, true);
1337  return currentIndex();
1338 }
1339 
1341 {
1342 #ifdef QT_KEYPAD_NAVIGATION
1343  if (event->key() == Qt::Key_Select) {
1344  if (QApplication::keypadNavigationEnabled()) {
1345  if (!hasEditFocus()) {
1346  setEditFocus(true);
1347  return;
1348  }
1349  }
1350  } else if (event->key() == Qt::Key_Back) {
1351  if (QApplication::keypadNavigationEnabled() && hasEditFocus()) {
1352  if (qobject_cast<QCalendarModel *>(model())) {
1353  emit changeDate(origDate, true); //changes selection back to origDate, but doesn't activate
1354  setEditFocus(false);
1355  return;
1356  }
1357  }
1358  }
1359 #endif
1360 
1361  if (!readOnly) {
1362  switch (event->key()) {
1363  case Qt::Key_Return:
1364  case Qt::Key_Enter:
1365  case Qt::Key_Select:
1367  return;
1368  default:
1369  break;
1370  }
1371  }
1373 }
1374 
1375 #ifndef QT_NO_WHEELEVENT
1377 {
1378  const int numDegrees = event->delta() / 8;
1379  const int numSteps = numDegrees / 15;
1380  const QModelIndex index = currentIndex();
1381  QDate currentDate = static_cast<QCalendarModel*>(model())->dateForCell(index.row(), index.column());
1382  currentDate = currentDate.addMonths(-numSteps);
1383  emit showDate(currentDate);
1384 }
1385 #endif
1386 
1388 {
1389 #ifdef QT_KEYPAD_NAVIGATION
1390  if (event->type() == QEvent::FocusIn) {
1391  if (QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model())) {
1392  origDate = calendarModel->m_date;
1393  }
1394  }
1395 #endif
1396 
1397  return QTableView::event(event);
1398 }
1399 
1401 {
1402  QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
1403  if (!calendarModel)
1404  return QDate();
1405 
1406  QPoint pos = event->pos();
1407  QModelIndex index = indexAt(pos);
1408  QDate date = calendarModel->dateForCell(index.row(), index.column());
1409  if (date.isValid() && date >= calendarModel->m_minimumDate
1410  && date <= calendarModel->m_maximumDate) {
1411  return date;
1412  }
1413  return QDate();
1414 }
1415 
1417 {
1418  QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
1419  if (!calendarModel) {
1421  return;
1422  }
1423 
1424  if (readOnly)
1425  return;
1426 
1427  QDate date = handleMouseEvent(event);
1428  validDateClicked = false;
1429  if (date == calendarModel->m_date && !style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)) {
1431  }
1432 }
1433 
1435 {
1436  QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
1437  if (!calendarModel) {
1439  return;
1440  }
1441 
1442  if (readOnly)
1443  return;
1444 
1445  if (event->button() != Qt::LeftButton)
1446  return;
1447 
1448  QDate date = handleMouseEvent(event);
1449  if (date.isValid()) {
1450  validDateClicked = true;
1451  int row = -1, col = -1;
1452  static_cast<QCalendarModel *>(model())->cellForDate(date, &row, &col);
1453  if (row != -1 && col != -1) {
1455  }
1456  } else {
1457  validDateClicked = false;
1458  event->ignore();
1459  }
1460 }
1461 
1463 {
1464  QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
1465  if (!calendarModel) {
1467  return;
1468  }
1469 
1470  if (readOnly)
1471  return;
1472 
1473  if (validDateClicked) {
1474  QDate date = handleMouseEvent(event);
1475  if (date.isValid()) {
1476  int row = -1, col = -1;
1477  static_cast<QCalendarModel *>(model())->cellForDate(date, &row, &col);
1478  if (row != -1 && col != -1) {
1480  }
1481  }
1482  } else {
1483  event->ignore();
1484  }
1485 }
1486 
1488 {
1489  QCalendarModel *calendarModel = qobject_cast<QCalendarModel *>(model());
1490  if (!calendarModel) {
1492  return;
1493  }
1494 
1495  if (event->button() != Qt::LeftButton)
1496  return;
1497 
1498  if (readOnly)
1499  return;
1500 
1501  if (validDateClicked) {
1502  QDate date = handleMouseEvent(event);
1503  if (date.isValid()) {
1504  emit changeDate(date, true);
1505  emit clicked(date);
1508  }
1509  validDateClicked = false;
1510  } else {
1511  event->ignore();
1512  }
1513 }
1514 
1516 {
1517  Q_OBJECT
1518 public:
1520  : QItemDelegate(parent), calendarWidgetPrivate(w)
1521  { }
1522  virtual void paint(QPainter *painter, const QStyleOptionViewItem &option,
1523  const QModelIndex &index) const;
1524  void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const;
1525 
1526 private:
1529 };
1530 
1531 //Private tool button class
1533 {
1534 public:
1536  : QToolButton(parent)
1537  { }
1538 protected:
1540  {
1541  Q_UNUSED(e)
1542 
1543 #ifndef Q_WS_MAC
1545  initStyleOption(&opt);
1546 
1547  if (opt.state & QStyle::State_MouseOver || isDown()) {
1548  //act as normal button
1549  setPalette(QPalette());
1550  } else {
1551  //set the highlight color for button text
1552  QPalette toolPalette = palette();
1553  toolPalette.setColor(QPalette::ButtonText, toolPalette.color(QPalette::HighlightedText));
1554  setPalette(toolPalette);
1555  }
1556 #endif
1558  }
1559 };
1560 
1562 {
1563  Q_OBJECT
1564 public:
1566 protected:
1568  QStylePainter painter(this);
1570  initStyleOption(&opt);
1571  opt.state &= ~QStyle::State_HasFocus;
1573  }
1574 };
1575 
1577 {
1579 public:
1581 
1582  void showMonth(int year, int month);
1583  void update();
1584  void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const;
1585 
1586  void _q_slotShowDate(const QDate &date);
1587  void _q_slotChangeDate(const QDate &date);
1588  void _q_slotChangeDate(const QDate &date, bool changeMonth);
1589  void _q_editingFinished();
1590  void _q_monthChanged(QAction*);
1591  void _q_prevMonthClicked();
1592  void _q_nextMonthClicked();
1593  void _q_yearEditingFinished();
1594  void _q_yearClicked();
1595 
1596  void createNavigationBar(QWidget *widget);
1597  void updateButtonIcons();
1598  void updateMonthMenu();
1599  void updateMonthMenuNames();
1600  void updateNavigationBar();
1601  void updateCurrentPage(const QDate &newDate);
1602  inline QDate getCurrentDate();
1603  void setNavigatorEnabled(bool enable);
1604 
1611 
1621 
1625 };
1626 
1628  const QModelIndex &index) const
1629 {
1630  QDate date = calendarWidgetPrivate->m_model->dateForCell(index.row(), index.column());
1631  if (date.isValid()) {
1632  storedOption = option;
1633  QRect rect = option.rect;
1634  calendarWidgetPrivate->paintCell(painter, rect, date);
1635  } else {
1636  QItemDelegate::paint(painter, option, index);
1637  }
1638 }
1639 
1640 void QCalendarDelegate::paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
1641 {
1642  storedOption.rect = rect;
1643  int row = -1;
1644  int col = -1;
1645  calendarWidgetPrivate->m_model->cellForDate(date, &row, &col);
1646  QModelIndex idx = calendarWidgetPrivate->m_model->index(row, col);
1647  QItemDelegate::paint(painter, storedOption, idx);
1648 }
1649 
1651  : QWidgetPrivate()
1652 {
1653  m_model = 0;
1654  m_view = 0;
1655  m_delegate = 0;
1656  m_selection = 0;
1657  m_navigator = 0;
1658  m_dateEditEnabled = false;
1659  navBarVisible = true;
1661 }
1662 
1664 {
1666 
1667  bool navigatorEnabled = (m_navigator->widget() != 0);
1668  if (enable == navigatorEnabled)
1669  return;
1670 
1671  if (enable) {
1672  m_navigator->setWidget(q);
1673  q->connect(m_navigator, SIGNAL(dateChanged(QDate)),
1675  q->connect(m_navigator, SIGNAL(editingFinished()),
1676  q, SLOT(_q_editingFinished()));
1678  } else {
1679  m_navigator->setWidget(0);
1680  q->disconnect(m_navigator, SIGNAL(dateChanged(QDate)),
1682  q->disconnect(m_navigator, SIGNAL(editingFinished()),
1683  q, SLOT(_q_editingFinished()));
1685  }
1686 }
1687 
1689 {
1691  navBarBackground = new QWidget(widget);
1692  navBarBackground->setObjectName(QLatin1String("qt_calendar_navigationbar"));
1695 
1698  prevMonth->setAutoRaise(true);
1699  nextMonth->setAutoRaise(true);
1702  nextMonth->setAutoRaise(true);
1704  prevMonth->setAutoRepeat(true);
1705  nextMonth->setAutoRepeat(true);
1706 
1709  monthButton->setAutoRaise(true);
1711  monthMenu = new QMenu(monthButton);
1712  for (int i = 1; i <= 12; i++) {
1713  QString monthName(q->locale().standaloneMonthName(i, QLocale::LongFormat));
1714  QAction *act = monthMenu->addAction(monthName);
1715  act->setData(i);
1716  monthToAction[i] = act;
1717  }
1721  yearButton->setAutoRaise(true);
1723 
1724  QFont font = q->font();
1725  font.setBold(true);
1726  monthButton->setFont(font);
1727  yearButton->setFont(font);
1728  yearEdit->setFrame(false);
1731  yearEdit->hide();
1732  spaceHolder = new QSpacerItem(0,0);
1733 
1734  QHBoxLayout *headerLayout = new QHBoxLayout;
1735  headerLayout->setMargin(0);
1736  headerLayout->setSpacing(0);
1737  headerLayout->addWidget(prevMonth);
1738  headerLayout->insertStretch(headerLayout->count());
1739  headerLayout->addWidget(monthButton);
1740  headerLayout->addItem(spaceHolder);
1741  headerLayout->addWidget(yearButton);
1742  headerLayout->insertStretch(headerLayout->count());
1743  headerLayout->addWidget(nextMonth);
1744  navBarBackground->setLayout(headerLayout);
1745 
1751 
1752  //set names for the header controls.
1753  prevMonth->setObjectName(QLatin1String("qt_calendar_prevmonth"));
1754  nextMonth->setObjectName(QLatin1String("qt_calendar_nextmonth"));
1755  monthButton->setObjectName(QLatin1String("qt_calendar_monthbutton"));
1756  yearButton->setObjectName(QLatin1String("qt_calendar_yearbutton"));
1757  yearEdit->setObjectName(QLatin1String("qt_calendar_yearedit"));
1758 
1759  updateMonthMenu();
1761 }
1762 
1764 {
1766  prevMonth->setIcon(q->style()->standardIcon(q->isRightToLeft() ? QStyle::SP_ArrowRight : QStyle::SP_ArrowLeft, 0, q));
1767  nextMonth->setIcon(q->style()->standardIcon(q->isRightToLeft() ? QStyle::SP_ArrowLeft : QStyle::SP_ArrowRight, 0, q));
1768 }
1769 
1771 {
1772  int beg = 1, end = 12;
1773  bool prevEnabled = true;
1774  bool nextEnabled = true;
1776  beg = m_model->m_minimumDate.month();
1778  prevEnabled = false;
1779  }
1783  nextEnabled = false;
1784  }
1785  prevMonth->setEnabled(prevEnabled);
1786  nextMonth->setEnabled(nextEnabled);
1787  for (int i = 1; i <= 12; i++) {
1788  bool monthEnabled = true;
1789  if (i < beg || i > end)
1790  monthEnabled = false;
1791  monthToAction[i]->setEnabled(monthEnabled);
1792  }
1793 }
1794 
1796 {
1798 
1799  for (int i = 1; i <= 12; i++) {
1800  QString monthName(q->locale().standaloneMonthName(i, QLocale::LongFormat));
1801  monthToAction[i]->setText(monthName);
1802  }
1803 }
1804 
1806 {
1808 
1809  QDate newDate = date;
1810  QDate minDate = q->minimumDate();
1811  QDate maxDate = q->maximumDate();
1812  if (minDate.isValid()&& minDate.daysTo(newDate) < 0)
1813  newDate = minDate;
1814  if (maxDate.isValid()&& maxDate.daysTo(newDate) > 0)
1815  newDate = maxDate;
1816  showMonth(newDate.year(), newDate.month());
1817  int row = -1, col = -1;
1818  m_model->cellForDate(newDate, &row, &col);
1819  if (row != -1 && col != -1)
1820  {
1823  }
1824 }
1825 
1827 {
1828  monthButton->setText(act->text());
1829  QDate currentDate = getCurrentDate();
1830  QDate newDate = currentDate.addMonths(act->data().toInt()-currentDate.month());
1831  updateCurrentPage(newDate);
1832 }
1833 
1835 {
1836  QModelIndex index = m_view->currentIndex();
1837  return m_model->dateForCell(index.row(), index.column());
1838 }
1839 
1841 {
1842  QDate currentDate = getCurrentDate().addMonths(-1);
1843  updateCurrentPage(currentDate);
1844 }
1845 
1847 {
1848  QDate currentDate = getCurrentDate().addMonths(1);
1849  updateCurrentPage(currentDate);
1850 }
1851 
1853 {
1856  yearEdit->hide();
1857  q->setFocusPolicy(oldFocusPolicy);
1858  qApp->removeEventFilter(q);
1859  spaceHolder->changeSize(0, 0);
1860  yearButton->show();
1861  QDate currentDate = getCurrentDate();
1862  currentDate = currentDate.addYears(yearEdit->text().toInt() - currentDate.year());
1863  updateCurrentPage(currentDate);
1864 }
1865 
1867 {
1869  //show the spinbox on top of the button
1873  yearButton->hide();
1874  oldFocusPolicy = q->focusPolicy();
1875  q->setFocusPolicy(Qt::NoFocus);
1876  yearEdit->show();
1877  qApp->installEventFilter(q);
1878  yearEdit->raise();
1879  yearEdit->selectAll();
1881 }
1882 
1883 void QCalendarWidgetPrivate::showMonth(int year, int month)
1884 {
1885  if (m_model->m_shownYear == year && m_model->m_shownMonth == month)
1886  return;
1888  m_model->showMonth(year, month);
1890  emit q->currentPageChanged(year, month);
1892  cachedSizeHint = QSize();
1893  update();
1894  updateMonthMenu();
1895 }
1896 
1898 {
1900 
1901  QString monthName = q->locale().standaloneMonthName(m_model->m_shownMonth, QLocale::LongFormat);
1902 
1903  monthButton->setText(monthName);
1906 }
1907 
1909 {
1910  QDate currentDate = m_model->m_date;
1911  int row, column;
1912  m_model->cellForDate(currentDate, &row, &column);
1913  QModelIndex idx;
1914  m_selection->clear();
1915  if (row != -1 && column != -1) {
1916  idx = m_model->index(row, column);
1918  }
1919 }
1920 
1921 void QCalendarWidgetPrivate::paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
1922 {
1923  Q_Q(const QCalendarWidget);
1924  q->paintCell(painter, rect, date);
1925 }
1926 
1928 {
1929  updateCurrentPage(date);
1930 }
1931 
1933 {
1934  _q_slotChangeDate(date, true);
1935 }
1936 
1937 void QCalendarWidgetPrivate::_q_slotChangeDate(const QDate &date, bool changeMonth)
1938 {
1939  QDate oldDate = m_model->m_date;
1940  m_model->setDate(date);
1941  QDate newDate = m_model->m_date;
1942  if (changeMonth)
1943  showMonth(newDate.year(), newDate.month());
1944  if (oldDate != newDate) {
1945  update();
1947  m_navigator->setDate(newDate);
1948  emit q->selectionChanged();
1949  }
1950 }
1951 
1953 {
1955  emit q->activated(m_model->m_date);
1956 }
1957 
2053  : QWidget(*new QCalendarWidgetPrivate, parent, 0)
2054 {
2056 
2057  setAutoFillBackground(true);
2059 
2060  QVBoxLayout *layoutV = new QVBoxLayout(this);
2061  layoutV->setMargin(0);
2062  d->m_model = new QCalendarModel(this);
2063  QTextCharFormat fmt;
2065  d->m_model->m_dayFormats.insert(Qt::Saturday, fmt);
2066  d->m_model->m_dayFormats.insert(Qt::Sunday, fmt);
2067  d->m_view = new QCalendarView(this);
2068  d->m_view->setObjectName(QLatin1String("qt_calendar_calendarview"));
2069  d->m_view->setModel(d->m_model);
2070  d->m_model->setView(d->m_view);
2071  d->m_view->setSelectionBehavior(QAbstractItemView::SelectItems);
2072  d->m_view->setSelectionMode(QAbstractItemView::SingleSelection);
2073  d->m_view->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
2074  d->m_view->horizontalHeader()->setClickable(false);
2075  d->m_view->verticalHeader()->setResizeMode(QHeaderView::Stretch);
2076  d->m_view->verticalHeader()->setClickable(false);
2077  d->m_selection = d->m_view->selectionModel();
2078  d->createNavigationBar(this);
2079  d->m_view->setFrameStyle(QFrame::NoFrame);
2080  d->m_delegate = new QCalendarDelegate(d, this);
2081  d->m_view->setItemDelegate(d->m_delegate);
2082  d->update();
2083  d->updateNavigationBar();
2085  setFocusProxy(d->m_view);
2087 
2088  connect(d->m_view, SIGNAL(showDate(QDate)),
2089  this, SLOT(_q_slotShowDate(QDate)));
2090  connect(d->m_view, SIGNAL(changeDate(QDate,bool)),
2091  this, SLOT(_q_slotChangeDate(QDate,bool)));
2092  connect(d->m_view, SIGNAL(clicked(QDate)),
2093  this, SIGNAL(clicked(QDate)));
2094  connect(d->m_view, SIGNAL(editingFinished()),
2095  this, SLOT(_q_editingFinished()));
2096 
2097  connect(d->prevMonth, SIGNAL(clicked(bool)),
2098  this, SLOT(_q_prevMonthClicked()));
2099  connect(d->nextMonth, SIGNAL(clicked(bool)),
2100  this, SLOT(_q_nextMonthClicked()));
2101  connect(d->yearButton, SIGNAL(clicked(bool)),
2102  this, SLOT(_q_yearClicked()));
2103  connect(d->monthMenu, SIGNAL(triggered(QAction*)),
2104  this, SLOT(_q_monthChanged(QAction*)));
2105  connect(d->yearEdit, SIGNAL(editingFinished()),
2106  this, SLOT(_q_yearEditingFinished()));
2107 
2108  layoutV->setMargin(0);
2109  layoutV->setSpacing(0);
2110  layoutV->addWidget(d->navBarBackground);
2111  layoutV->addWidget(d->m_view);
2112 
2113  d->m_navigator = new QCalendarTextNavigator(this);
2114  setDateEditEnabled(true);
2115 }
2116 
2121 {
2122 }
2123 
2128 {
2129  return minimumSizeHint();
2130 }
2131 
2136 {
2137  Q_D(const QCalendarWidget);
2138  if (d->cachedSizeHint.isValid())
2139  return d->cachedSizeHint;
2140 
2141  ensurePolished();
2142 
2143  int w = 0;
2144  int h = 0;
2145 
2146  int end = 53;
2147  int rows = 7;
2148  int cols = 8;
2149 
2150  const int marginH = (style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1) * 2;
2151 
2153  rows = 6;
2154  } else {
2155  for (int i = 1; i <= 7; i++) {
2156  QFontMetrics fm(d->m_model->formatForCell(0, i).font());
2157  w = qMax(w, fm.width(d->m_model->dayName(d->m_model->dayOfWeekForColumn(i))) + marginH);
2158  h = qMax(h, fm.height());
2159  }
2160  }
2161 
2163  cols = 7;
2164  } else {
2165  for (int i = 1; i <= 6; i++) {
2166  QFontMetrics fm(d->m_model->formatForCell(i, 0).font());
2167  for (int j = 1; j < end; j++)
2168  w = qMax(w, fm.width(QString::number(j)) + marginH);
2169  h = qMax(h, fm.height());
2170  }
2171  }
2172 
2173  QFontMetrics fm(d->m_model->formatForCell(1, 1).font());
2174  for (int i = 1; i <= end; i++) {
2175  w = qMax(w, fm.width(QString::number(i)) + marginH);
2176  h = qMax(h, fm.height());
2177  }
2178 
2179  if (d->m_view->showGrid()) {
2180  // hardcoded in tableview
2181  w += 1;
2182  h += 1;
2183  }
2184 
2185  w += 1; // default column span
2186 
2187  h = qMax(h, d->m_view->verticalHeader()->minimumSectionSize());
2188  w = qMax(w, d->m_view->horizontalHeader()->minimumSectionSize());
2189 
2190  //add the size of the header.
2191  QSize headerSize(0, 0);
2192  if (d->navBarVisible) {
2193  int headerH = d->navBarBackground->sizeHint().height();
2194  int headerW = 0;
2195 
2196  headerW += d->prevMonth->sizeHint().width();
2197  headerW += d->nextMonth->sizeHint().width();
2198 
2199  QFontMetrics fm = d->monthButton->fontMetrics();
2200  int monthW = 0;
2201  for (int i = 1; i < 12; i++) {
2203  monthW = qMax(monthW, fm.boundingRect(monthName).width());
2204  }
2205  const int buttonDecoMargin = d->monthButton->sizeHint().width() - fm.boundingRect(d->monthButton->text()).width();
2206  headerW += monthW + buttonDecoMargin;
2207 
2208  fm = d->yearButton->fontMetrics();
2209  headerW += fm.boundingRect(QLatin1String("5555")).width() + buttonDecoMargin;
2210 
2211  headerSize = QSize(headerW, headerH);
2212  }
2213  w *= cols;
2214  w = qMax(headerSize.width(), w);
2215  h = (h * rows) + headerSize.height();
2216  d->cachedSizeHint = QSize(w, h);
2217  return d->cachedSizeHint;
2218 }
2219 
2224 void QCalendarWidget::paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
2225 {
2226  Q_D(const QCalendarWidget);
2227  d->m_delegate->paintCell(painter, rect, date);
2228 }
2229 
2245 {
2246  Q_D(const QCalendarWidget);
2247  return d->m_model->m_date;
2248 }
2249 
2251 {
2253  if (d->m_model->m_date == date && date == d->getCurrentDate())
2254  return;
2255 
2256  if (!date.isValid())
2257  return;
2258 
2259  d->m_model->setDate(date);
2260  d->update();
2261  QDate newDate = d->m_model->m_date;
2262  d->showMonth(newDate.year(), newDate.month());
2264 }
2265 
2274 {
2275  Q_D(const QCalendarWidget);
2276  return d->m_model->m_shownYear;
2277 }
2278 
2287 {
2288  Q_D(const QCalendarWidget);
2289  return d->m_model->m_shownMonth;
2290 }
2291 
2304 void QCalendarWidget::setCurrentPage(int year, int month)
2305 {
2307  QDate currentDate = d->getCurrentDate();
2308  int day = currentDate.day();
2309  int daysInMonths = QDate(year, month, 1).daysInMonth();
2310  if (day > daysInMonths)
2311  day = daysInMonths;
2312 
2313  d->showMonth(year, month);
2314 
2315  QDate newDate(year, month, day);
2316  int row = -1, col = -1;
2317  d->m_model->cellForDate(newDate, &row, &col);
2318  if (row != -1 && col != -1) {
2319  d->m_view->selectionModel()->setCurrentIndex(d->m_model->index(row, col),
2321  }
2322 }
2323 
2332 {
2333  int year = yearShown();
2334  int month = monthShown();
2335  if (month == 12) {
2336  ++year;
2337  month = 1;
2338  } else {
2339  ++month;
2340  }
2341  setCurrentPage(year, month);
2342 }
2343 
2352 {
2353  int year = yearShown();
2354  int month = monthShown();
2355  if (month == 1) {
2356  --year;
2357  month = 12;
2358  } else {
2359  --month;
2360  }
2361  setCurrentPage(year, month);
2362 }
2363 
2373 {
2374  int year = yearShown();
2375  int month = monthShown();
2376  ++year;
2377  setCurrentPage(year, month);
2378 }
2379 
2389 {
2390  int year = yearShown();
2391  int month = monthShown();
2392  --year;
2393  setCurrentPage(year, month);
2394 }
2395 
2402 {
2403  QDate currentDate = selectedDate();
2404  setCurrentPage(currentDate.year(), currentDate.month());
2405 }
2406 
2413 {
2414  QDate currentDate = QDate::currentDate();
2415  setCurrentPage(currentDate.year(), currentDate.month());
2416 }
2417 
2447 {
2448  Q_D(const QCalendarWidget);
2449  return d->m_model->m_minimumDate;
2450 }
2451 
2453 {
2455  if (!date.isValid() || d->m_model->m_minimumDate == date)
2456  return;
2457 
2458  QDate oldDate = d->m_model->m_date;
2459  d->m_model->setMinimumDate(date);
2460  d->yearEdit->setMinimum(d->m_model->m_minimumDate.year());
2461  d->updateMonthMenu();
2462  QDate newDate = d->m_model->m_date;
2463  if (oldDate != newDate) {
2464  d->update();
2465  d->showMonth(newDate.year(), newDate.month());
2466  d->m_navigator->setDate(newDate);
2468  }
2469 }
2470 
2500 {
2501  Q_D(const QCalendarWidget);
2502  return d->m_model->m_maximumDate;
2503 }
2504 
2506 {
2508  if (!date.isValid() || d->m_model->m_maximumDate == date)
2509  return;
2510 
2511  QDate oldDate = d->m_model->m_date;
2512  d->m_model->setMaximumDate(date);
2513  d->yearEdit->setMaximum(d->m_model->m_maximumDate.year());
2514  d->updateMonthMenu();
2515  QDate newDate = d->m_model->m_date;
2516  if (oldDate != newDate) {
2517  d->update();
2518  d->showMonth(newDate.year(), newDate.month());
2519  d->m_navigator->setDate(newDate);
2521  }
2522 }
2523 
2543 void QCalendarWidget::setDateRange(const QDate &min, const QDate &max)
2544 {
2546  if (d->m_model->m_minimumDate == min && d->m_model->m_maximumDate == max)
2547  return;
2548  if (!min.isValid() || !max.isValid())
2549  return;
2550 
2551  QDate oldDate = d->m_model->m_date;
2552  d->m_model->setRange(min, max);
2553  d->yearEdit->setMinimum(d->m_model->m_minimumDate.year());
2554  d->yearEdit->setMaximum(d->m_model->m_maximumDate.year());
2555  d->updateMonthMenu();
2556  QDate newDate = d->m_model->m_date;
2557  if (oldDate != newDate) {
2558  d->update();
2559  d->showMonth(newDate.year(), newDate.month());
2560  d->m_navigator->setDate(newDate);
2562  }
2563 }
2564 
2565 
2592 {
2594  if (d->m_model->m_horizontalHeaderFormat == format)
2595  return;
2596 
2597  d->m_model->setHorizontalHeaderFormat(format);
2598  d->cachedSizeHint = QSize();
2599  d->m_view->viewport()->update();
2600  d->m_view->updateGeometry();
2601 }
2602 
2604 {
2605  Q_D(const QCalendarWidget);
2606  return d->m_model->m_horizontalHeaderFormat;
2607 }
2608 
2609 
2635 {
2636  Q_D(const QCalendarWidget);
2637  bool shown = d->m_model->weekNumbersShown();
2638  if (shown)
2641 }
2642 
2644 {
2646  bool show = false;
2647  if (format == QCalendarWidget::ISOWeekNumbers)
2648  show = true;
2649  if (d->m_model->weekNumbersShown() == show)
2650  return;
2651  d->m_model->setWeekNumbersShown(show);
2652  d->cachedSizeHint = QSize();
2653  d->m_view->viewport()->update();
2654  d->m_view->updateGeometry();
2655 }
2656 
2675 {
2676  Q_D(const QCalendarWidget);
2677  return d->m_view->showGrid();
2678 }
2679 
2681 {
2683  d->m_view->setShowGrid(show);
2684  d->cachedSizeHint = QSize();
2685  d->m_view->viewport()->update();
2686  d->m_view->updateGeometry();
2687 }
2688 
2709 {
2710  Q_D(const QCalendarWidget);
2712 }
2713 
2715 {
2717  d->m_view->readOnly = (mode == QCalendarWidget::NoSelection);
2718  d->setNavigatorEnabled(isDateEditEnabled() && (selectionMode() != QCalendarWidget::NoSelection));
2719  d->update();
2720 }
2721 
2733 {
2735  if ((Qt::DayOfWeek)d->m_model->firstColumnDay() == dayOfWeek)
2736  return;
2737 
2738  d->m_model->setFirstColumnDay(dayOfWeek);
2739  d->update();
2740 }
2741 
2743 {
2744  Q_D(const QCalendarWidget);
2745  return (Qt::DayOfWeek)d->m_model->firstColumnDay();
2746 }
2747 
2752 {
2753  Q_D(const QCalendarWidget);
2754  return d->m_model->m_headerFormat;
2755 }
2756 
2765 {
2767  d->m_model->m_headerFormat = format;
2768  d->cachedSizeHint = QSize();
2769  d->m_view->viewport()->update();
2770  d->m_view->updateGeometry();
2771 }
2772 
2779 {
2780  Q_D(const QCalendarWidget);
2781  return d->m_model->m_dayFormats.value(dayOfWeek);
2782 }
2783 
2792 {
2794  d->m_model->m_dayFormats[dayOfWeek] = format;
2795  d->cachedSizeHint = QSize();
2796  d->m_view->viewport()->update();
2797  d->m_view->updateGeometry();
2798 }
2799 
2805 {
2806  Q_D(const QCalendarWidget);
2807  return d->m_model->m_dateFormats;
2808 }
2809 
2815 {
2816  Q_D(const QCalendarWidget);
2817  return d->m_model->m_dateFormats.value(date);
2818 }
2819 
2826 {
2828  if (date.isNull())
2829  d->m_model->m_dateFormats.clear();
2830  else
2831  d->m_model->m_dateFormats[date] = format;
2832  d->m_view->viewport()->update();
2833  d->m_view->updateGeometry();
2834 }
2835 
2858 {
2859  Q_D(const QCalendarWidget);
2860  return d->m_dateEditEnabled;
2861 }
2862 
2864 {
2866  if (isDateEditEnabled() == enable)
2867  return;
2868 
2869  d->m_dateEditEnabled = enable;
2870 
2871  d->setNavigatorEnabled(enable && (selectionMode() != QCalendarWidget::NoSelection));
2872 }
2873 
2890 {
2891  Q_D(const QCalendarWidget);
2892  return d->m_navigator->dateEditAcceptDelay();
2893 }
2894 
2896 {
2898  d->m_navigator->setDateEditAcceptDelay(delay);
2899 }
2900 
2913 {
2914  if (!date.isValid()) {
2915  qWarning("QCalendarWidget::updateCell: Invalid date");
2916  return;
2917  }
2918 
2919  if (!isVisible())
2920  return;
2921 
2923  int row, column;
2924  d->m_model->cellForDate(date, &row, &column);
2925  if (row == -1 || column == -1)
2926  return;
2927 
2928  QModelIndex modelIndex = d->m_model->index(row, column);
2929  if (!modelIndex.isValid())
2930  return;
2931 
2932  d->m_view->viewport()->update(d->m_view->visualRect(modelIndex));
2933 }
2934 
2946 {
2948  if (isVisible())
2949  d->m_view->viewport()->update();
2950 }
2951 
3027 {
3028  Q_D(const QCalendarWidget);
3029  return d->navBarVisible;
3030 }
3031 
3042 {
3043  setNavigationBarVisible(visible);
3044 }
3045 
3063 {
3065  d->navBarVisible = visible;
3066  d->cachedSizeHint = QSize();
3067  d->navBarBackground->setVisible(visible);
3068  updateGeometry();
3069 }
3070 
3075 {
3077  switch (event->type()) {
3079  d->updateButtonIcons();
3080  case QEvent::LocaleChange:
3081  d->cachedSizeHint = QSize();
3082  d->updateMonthMenuNames();
3083  d->updateNavigationBar();
3084  d->m_view->updateGeometry();
3085  break;
3086  case QEvent::FontChange:
3088  d->cachedSizeHint = QSize();
3089  d->m_view->updateGeometry();
3090  break;
3091  case QEvent::StyleChange:
3092  d->cachedSizeHint = QSize();
3093  d->m_view->updateGeometry();
3094  default:
3095  break;
3096  }
3097  return QWidget::event(event);
3098 }
3099 
3104 {
3106  if (event->type() == QEvent::MouseButtonPress && d->yearEdit->hasFocus()) {
3107  QWidget *tlw = window();
3108  QWidget *widget = static_cast<QWidget*>(watched);
3109  //as we have a event filter on the whole application we first make sure that the top level widget
3110  //of both this and the watched widget are the same to decide if we should finish the year edition.
3111  if (widget->window() == tlw) {
3112  QPoint mousePos = widget->mapTo(tlw, static_cast<QMouseEvent *>(event)->pos());
3113  QRect geom = QRect(d->yearEdit->mapTo(tlw, QPoint(0, 0)), d->yearEdit->size());
3114  if (!geom.contains(mousePos)) {
3115  event->accept();
3116  d->_q_yearEditingFinished();
3117  setFocus();
3118  return true;
3119  }
3120  }
3121  }
3122  return QWidget::eventFilter(watched, event);
3123 }
3124 
3129 {
3131  QWidget::mousePressEvent(event);
3132  setFocus();
3133 }
3134 
3139 {
3141 
3142  // XXX Should really use a QWidgetStack for yearEdit and yearButton,
3143  // XXX here we hide the year edit when the layout is likely to break
3144  // XXX the manual positioning of the yearEdit over the yearButton.
3145  if(d->yearEdit->isVisible() && event->size().width() != event->oldSize().width())
3146  d->_q_yearEditingFinished();
3147 
3148  QWidget::resizeEvent(event);
3149 }
3150 
3155 {
3157  if(d->yearEdit->isVisible()&& event->key() == Qt::Key_Escape)
3158  {
3159  d->yearEdit->setValue(yearShown());
3160  d->_q_yearEditingFinished();
3161  return;
3162  }
3163  QWidget::keyPressEvent(event);
3164 }
3165 
3167 
3168 #include "qcalendarwidget.moc"
3169 #include "moc_qcalendarwidget.cpp"
3170 
3171 #endif //QT_NO_CALENDARWIDGET
static QString number(int, int base=10)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: qstring.cpp:6448
void _q_slotShowDate(const QDate &date)
The QVariant class acts like a union for the most common Qt data types.
Definition: qvariant.h:92
SectionToken * m_currentToken
void setFirstDayOfWeek(Qt::DayOfWeek dayOfWeek)
QPoint pos() const
The QPainter class performs low-level painting on widgets and other paint devices.
Definition: qpainter.h:86
int dayOfWeek() const
Returns the weekday (1 = Monday to 7 = Sunday) for this date.
Definition: qdatetime.cpp:408
double d
Definition: qnumeric_p.h:62
virtual QDate applyToDate(const QDate &date) const
QFont font() const
Returns the font for this character format.
void _q_monthChanged(QAction *)
void setWidget(QWidget *widget)
void setFont(const QFont &)
Use the single-argument overload instead.
Definition: qwidget.cpp:4996
void _q_slotChangeDate(const QDate &date)
void mouseMoveEvent(QMouseEvent *event)
This function is called with the given event when a mouse move event is sent to the widget...
void setDateRange(const QDate &min, const QDate &max)
Defines a date range by setting the minimumDate and maximumDate properties.
QCalendarDelegate * m_delegate
QCalendarWidget::HorizontalHeaderFormat m_horizontalHeaderFormat
The QKeyEvent class describes a key event.
Definition: qevent.h:224
QVariant data(const QModelIndex &index, int role) const
Returns the data stored under the given role for the item referred to by the index.
void updateCells()
Updates all visible cells unless updates are disabled.
The QItemSelectionModel class keeps track of a view&#39;s selected items.
The QTextCharFormat class provides formatting information for characters in a QTextDocument.
Definition: qtextformat.h:372
int y() const
virtual void clear()
Clears the selection model.
bool removeRow(int row, const QModelIndex &parent=QModelIndex())
Removes the given row from the child items of the parent specified.
int daysTo(const QDate &) const
Returns the number of days from this date to d (which is negative if d is earlier than this date)...
Definition: qdatetime.cpp:1111
unsigned char c[8]
Definition: qnumeric_p.h:62
Q_DECL_CONSTEXPR const T & qMin(const T &a, const T &b)
Definition: qglobal.h:1215
The QFontMetrics class provides font metrics information.
Definition: qfontmetrics.h:65
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
void setText(const QString &text)
const QColor & color() const
Returns the brush color.
Definition: qbrush.h:183
bool isNull() const
Returns true if the date is null; otherwise returns false.
Definition: qdatetime.h:66
EventRef event
QPointer< QWidget > widget
void setMinimumDate(const QDate &date)
void selectionChanged()
This signal is emitted when the currently selected date is changed.
QLocale locale() const
void handleKeyEvent(QKeyEvent *keyEvent)
const QChar at(int i) const
Returns the character at the given index position in the string.
Definition: qstring.h:698
static void keyEvent(KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier=Qt::NoModifier, int delay=-1)
bool isValid() const
Returns true if this date is valid; otherwise returns false.
Definition: qdatetime.cpp:340
QModelIndex moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
Moves the cursor in accordance with the given cursorAction, using the information provided by the mod...
QPoint mapTo(QWidget *, const QPoint &) const
Translates the widget coordinate pos to the coordinate system of parent.
Definition: qwidget.cpp:4409
QCalToolButton * yearButton
int toInt(bool *ok=0, int base=10) const
Returns the string converted to an int using base base, which is 10 by default and must be between 2 ...
Definition: qstring.cpp:6090
virtual QString text() const
void ensurePolished() const
Ensures that the widget has been polished by QStyle (i.e., has a proper font and palette).
Definition: qwidget.cpp:10024
void mouseMoveEvent(QMouseEvent *event)
This function is called with the given event when a mouse move event is sent to the widget...
QStyle::State state
the style flags that are used when drawing the control
Definition: qstyleoption.h:88
#define it(className, varName)
void setDateEditAcceptDelay(int delay)
void mouseDoubleClickEvent(QMouseEvent *event)
This function is called with the given event when a mouse button is double clicked inside the widget...
The QWheelEvent class contains parameters that describe a wheel event.
Definition: qevent.h:139
void setLayout(QLayout *)
Sets the layout manager for this widget to layout.
Definition: qwidget.cpp:10104
void mouseDoubleClickEvent(QMouseEvent *event)
This function is called with the given event when a mouse button is double clicked inside the widget...
bool isVisible() const
Definition: qwidget.h:1005
virtual Section handleKey(int key)
virtual int pixelMetric(PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const =0
Returns the value of the given pixel metric.
The QCalendarWidget class provides a monthly based calendar widget allowing the user to select a date...
QMap< int, QAction * > monthToAction
void setHorizontalHeaderFormat(HorizontalHeaderFormat format)
bool isHeaderVisible() const
Use setNavigationBarVisible() instead.
int length() const
Returns the number of characters in this string.
Definition: qstring.h:696
void paintEvent(QPaintEvent *)
Paints the button in response to the paint event.
QString text
the action&#39;s descriptive text
Definition: qaction.h:76
#define SLOT(a)
Definition: qobjectdefs.h:226
int month() const
Returns the number corresponding to the month of this date, using the following convention: ...
Definition: qdatetime.cpp:382
virtual void mousePressEvent(QMouseEvent *)
This event handler, for event event, can be reimplemented in a subclass to receive mouse press events...
Definition: qwidget.cpp:9261
void removeEventFilter(QObject *)
Removes an event filter object obj from this object.
Definition: qobject.cpp:2099
QCalendarView * m_view
The QWidget class is the base class of all user interface objects.
Definition: qwidget.h:150
The QStyleOptionViewItemV4 class is used to describe the parameters necessary for drawing a frame in ...
Definition: qstyleoption.h:609
QModelIndex index(int row, int column, const QModelIndex &parent=QModelIndex()) const
Returns the index of the data in row and column with parent.
QHeaderView * horizontalHeader() const
Returns the table view&#39;s horizontal header.
static void clear(QVariant::Private *d)
Definition: qvariant.cpp:197
void setHorizontalScrollBarPolicy(Qt::ScrollBarPolicy)
void setFont(const QFont &font)
Sets the text format&#39;s font.
void insertStretch(int index, int stretch=0)
Inserts a stretchable space (a QSpacerItem) at position index, with zero minimum size and stretch fac...
Definition: qboxlayout.cpp:960
void showSelectedDate()
Shows the month of the selected date.
void mouseReleaseEvent(QMouseEvent *event)
This function is called with the given event when a mouse button is released, after a mouse press eve...
int width() const
Returns the width of the rectangle.
Definition: qrect.h:303
QTextCharFormat weekdayTextFormat(Qt::DayOfWeek dayOfWeek) const
Returns the text char format for rendering of day in the week dayOfWeek.
virtual QDate applyToDate(const QDate &date) const
int weekNumber(int *yearNum=0) const
Returns the week number (1 to 53), and stores the year in {yearNumber} unless yearNumber is null (the...
Definition: qdatetime.cpp:487
bool startsWith(const QString &s, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Returns true if the string starts with s; otherwise returns false.
Definition: qstring.cpp:3734
int day() const
Returns the day of the month (1 to 31) of this date.
Definition: qdatetime.cpp:395
virtual void resizeEvent(QResizeEvent *)
This event handler can be reimplemented in a subclass to receive widget resize events which are passe...
Definition: qwidget.cpp:9587
void setNavigationBarVisible(bool visible)
The QDate class provides date functions.
Definition: qdatetime.h:55
QDate minimumDate() const
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
void setValue(int val)
Definition: qspinbox.cpp:268
int countRepeat(const QString &str, int index) const
QDate handleMouseEvent(QMouseEvent *event)
void paintEvent(QPaintEvent *e)
Reimplemented Function
void setGeometry(int x, int y, int w, int h)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: qwidget.h:1017
void showMonth(int year, int month)
void setBackground(const QBrush &brush)
Sets the brush use to paint the document&#39;s background to the brush specified.
Definition: qtextformat.h:343
int height() const
Returns the height of the rectangle.
Definition: qrect.h:306
QString highlightString(const QString &str, int pos) const
bool isActiveWindow() const
void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
The QString class provides a Unicode character string.
Definition: qstring.h:83
static QDate fromJulianDay(int jd)
Converts the Julian day jd to a QDate.
Definition: qdatetime.h:133
T * qobject_cast(QObject *object)
Definition: qobject.h:375
DayOfWeek
Definition: qnamespace.h:1410
void setMaximumDate(const QDate &date)
int columnCount(const QModelIndex &) const
Returns the number of columns for the children of the given parent.
bool eventFilter(QObject *watched, QEvent *event)
Reimplemented Function
QAction * addAction(const QString &text)
This convenience function creates a new action with text.
Definition: qmenu.cpp:1453
QDate addYears(int years) const
Returns a QDate object containing a date nyears later than the date of this object (or earlier if nye...
Definition: qdatetime.cpp:1081
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
The QObject class is the base class of all Qt objects.
Definition: qobject.h:111
QDate addMonths(int months) const
Returns a QDate object containing a date nmonths later than the date of this object (or earlier if nm...
Definition: qdatetime.cpp:1016
void setNavigatorEnabled(bool enable)
bool insertRows(int row, int count, const QModelIndex &parent=QModelIndex())
On models that support this, inserts count rows into the model before the given row.
#define Q_D(Class)
Definition: qglobal.h:2482
const QColor & color(ColorGroup cg, ColorRole cr) const
Returns the color in the specified color group, used for the given color role.
Definition: qpalette.h:107
void addWidget(QWidget *, int stretch=0, Qt::Alignment alignment=0)
Adds widget to the end of this box layout, with a stretch factor of stretch and alignment alignment...
int height() const
SelectionMode
This enum describes the types of selection offered to the user for selecting dates in the calendar...
void showNextMonth()
Shows the next month relative to the currently displayed month.
The QChar class provides a 16-bit Unicode character.
Definition: qchar.h:72
bool eventFilter(QObject *o, QEvent *e)
Filters events if this object has been installed as an event filter for the watched object...
void changeDate(const QDate &date, bool changeMonth)
QMap< Qt::DayOfWeek, QTextCharFormat > m_dayFormats
The QStyleOptionToolButton class is used to describe the parameters for drawing a tool button...
Definition: qstyleoption.h:768
void setData(const QVariant &var)
Sets the action&#39;s internal data to the given userData.
Definition: qaction.cpp:1297
void showDate(const QDate &date)
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
void addItem(QLayoutItem *)
Reimplemented Function
Definition: qboxlayout.cpp:894
QCalendarDelegate(QCalendarWidgetPrivate *w, QObject *parent=0)
QStyle * style() const
Definition: qwidget.cpp:2742
void setMinimumDate(const QDate &date)
void setObjectName(const QString &name)
Definition: qobject.cpp:1112
#define Q_Q(Class)
Definition: qglobal.h:2483
void setAutoRepeat(bool)
ColorGroup
Definition: qpalette.h:92
QWidget * widget() const
int toInt(bool *ok=0) const
Returns the variant as an int if the variant has type() Int , Bool , ByteArray , Char ...
Definition: qvariant.cpp:2625
void keyPressEvent(QKeyEvent *event)
This function is called with the given event when a key event is sent to the widget.
static QCursor * moveCursor
Definition: qdnd_x11.cpp:254
void setTabKeyNavigation(bool enable)
void update()
Updates the widget unless updates are disabled or the widget is hidden.
Definition: qwidget.cpp:10883
void setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command)
Sets the model item index to be the current item, and emits currentChanged().
QRect boundingRect(QChar) const
Returns the rectangle that is covered by ink if character ch were to be drawn at the origin of the co...
virtual Qt::ItemFlags flags(const QModelIndex &index) const
Returns the item flags for the given index.
int key() const
Returns the code of the key that was pressed or released.
Definition: qevent.h:231
QCalendarDateSectionValidator * m_yearValidator
#define SIGNAL(a)
Definition: qobjectdefs.h:227
bool event(QEvent *event)
Reimplemented Function
int width() const
Returns the width.
Definition: qsize.h:126
QCalendarModel(QObject *parent=0)
void append(const T &t)
Inserts value at the end of the list.
Definition: qlist.h:507
void setBackgroundRole(QPalette::ColorRole)
Sets the background role of the widget to role.
Definition: qwidget.cpp:4708
void setView(QCalendarView *view)
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
void setWeekdayTextFormat(Qt::DayOfWeek dayOfWeek, const QTextCharFormat &format)
Sets the text char format for rendering of day in the week dayOfWeek to format.
void setBrush(ColorRole cr, const QBrush &brush)
Sets the brush for the given color role to the specified brush for all groups in the palette...
Definition: qpalette.h:206
bool weekNumbersShown() const
void setBold(bool)
If enable is true sets the font&#39;s weight to QFont::Bold ; otherwise sets the weight to QFont::Normal...
Definition: qfont.h:352
static int countRepeat(const QString &str, int index, int maxCount)
Parses the format newFormat.
Definition: qdatetime.cpp:4749
bool isGridVisible() const
void setHorizontalHeaderFormat(QCalendarWidget::HorizontalHeaderFormat format)
void mousePressEvent(QMouseEvent *event)
Reimplemented Function
bool visible
whether the widget is visible
Definition: qwidget.h:191
bool insertColumns(int column, int count, const QModelIndex &parent=QModelIndex())
On models that support this, inserts count new columns into the model before the given column...
QDate dateForCell(int row, int column) const
QString left(int n) const Q_REQUIRED_RESULT
Returns a substring that contains the n leftmost characters of the string.
Definition: qstring.cpp:3664
QCalendarDateSectionValidator * validator
virtual QSize minimumSizeHint() const
Reimplemented Function
The QSpacerItem class provides blank space in a layout.
Definition: qlayoutitem.h:96
int size() const
Returns the number of characters in this string.
Definition: qstring.h:102
static bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
Creates a connection of the given type from the signal in the sender object to the method in the rece...
Definition: qobject.cpp:2580
void raise()
Raises this widget to the top of the parent widget&#39;s stack.
Definition: qwidget.cpp:11901
int count() const
Reimplemented Function
Definition: qboxlayout.cpp:769
bool insertRow(int row, const QModelIndex &parent=QModelIndex())
Inserts a single row before the given row in the child items of the parent specified.
static QDate currentDate()
Returns the current date, as reported by the system clock.
Definition: qdatetime.cpp:3115
QItemSelectionModel * selectionModel() const
Returns the current selection model.
#define qApp
int width() const
virtual QDate applyToDate(const QDate &date) const
void wheelEvent(QWheelEvent *event)
This event handler can be reimplemented in a subclass to receive wheel events for the viewport() widg...
int row() const
Returns the row this model index refers to.
bool event(QEvent *event)
Reimplemented Function
virtual Section handleKey(int key)
QString currentText() const
void setHeaderTextFormat(const QTextCharFormat &format)
Sets the text char format for rendering the header to format.
const T value(const Key &key) const
Returns the value associated with the key key.
Definition: qmap.h:499
Qt::DayOfWeek dayOfWeekForColumn(int section) const
virtual void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
Paints the cell specified by the given date, using the given painter and rect.
#define emit
Definition: qobjectdefs.h:76
The QStringList class provides a list of strings.
Definition: qstringlist.h:66
const QPalette & palette() const
int monthShown() const
Returns the currently displayed month.
void selectAll()
Selects all the text in the spinbox except the prefix and suffix.
The QResizeEvent class contains event parameters for resize events.
Definition: qevent.h:349
const char * styleHint(const QFontDef &request)
virtual QSize sizeHint() const
Reimplemented Function
Qt::FocusPolicy oldFocusPolicy
void setWeekNumbersShown(bool show)
Q_CORE_EXPORT void qWarning(const char *,...)
int timerId() const
Returns the unique timer identifier, which is the same identifier as returned from QObject::startTime...
Definition: qcoreevent.h:346
QString toolTip() const
Returns the tool tip that is displayed for a fragment of text.
Definition: qtextformat.h:496
void paintEvent(QPaintEvent *)
Reimplemented Function
static const char * data(const QByteArray &arr)
QItemSelectionModel * m_selection
void setShowGrid(bool show)
QCalendarDateSectionValidator * m_monthValidator
QHeaderView * verticalHeader() const
Returns the table view&#39;s vertical header.
QModelIndex currentIndex() const
Returns the model index of the current item.
virtual void setDate(const QDate &date)
void keyPressEvent(QKeyEvent *event)
This function is called with the given event when a key event is sent to the widget.
QDate addDays(int days) const
Returns a QDate object containing a date ndays later than the date of this object (or earlier if nday...
Definition: qdatetime.cpp:989
void cellForDate(const QDate &date, int *row, int *column) const
void clear()
Removes all items from the list.
Definition: qlist.h:764
void setMaximumDate(const QDate &date)
QBrush background() const
Returns the brush used to paint the document&#39;s background.
Definition: qtextformat.h:345
QCalendarView(QWidget *parent=0)
void show()
Shows the widget and its child widgets.
Qt::DayOfWeek m_firstDay
virtual void keyPressEvent(QKeyEvent *)
This event handler, for event event, can be reimplemented in a subclass to receive key press events f...
Definition: qwidget.cpp:9375
bool removeRows(int row, int count, const QModelIndex &parent=QModelIndex())
On models that support this, removes count rows starting with the given row under parent parent from ...
QMap< QDate, QTextCharFormat > m_dateFormats
Qt::MouseButton button() const
Returns the button that caused the event.
Definition: qevent.h:101
The QTableView class provides a default model/view implementation of a table view.
Definition: qtableview.h:58
bool isValid() const
Returns true if this model index is valid; otherwise returns false.
void timerEvent(QTimerEvent *e)
This event handler can be reimplemented in a subclass to receive timer events for the object...
QRect rect() const
virtual void setDate(const QDate &date)=0
void setEnabled(bool)
Definition: qwidget.cpp:3447
#define Q_OBJECT
Definition: qobjectdefs.h:157
bool contains(const QPoint &p, bool proper=false) const
Returns true if the given point is inside or on the edge of the rectangle, otherwise returns false...
Definition: qrect.cpp:1101
bool isEnabled() const
Definition: qwidget.h:948
virtual void setVisible(bool visible)
Definition: qwidget.cpp:7991
void hide()
Hides the widget.
Definition: qwidget.h:501
void qSwap(T &value1, T &value2)
Definition: qglobal.h:2181
const QBrush & brush(ColorGroup cg, ColorRole cr) const
Returns the brush in the specified color group, used for the given color role.
Definition: qpalette.cpp:874
virtual bool eventFilter(QObject *, QEvent *)
Filters events if this object has been installed as an event filter for the watched object...
Definition: qobject.cpp:1375
QString text() const
bool removeColumn(int column, const QModelIndex &parent=QModelIndex())
Removes the given column from the child items of the parent specified.
The QMouseEvent class contains parameters that describe a mouse event.
Definition: qevent.h:85
QStyleOptionViewItemV4 storedOption
void setInitialDate(const QDate &date)
void setAutoFillBackground(bool enabled)
Definition: qwidget.cpp:631
int columnForDayOfWeek(Qt::DayOfWeek day) const
QList< SectionToken * > m_tokens
void showPreviousMonth()
Shows the previous month relative to the currently displayed month.
QString dayName(Qt::DayOfWeek day) const
The QBrush class defines the fill pattern of shapes drawn by QPainter.
Definition: qbrush.h:76
QDate selectedDate() const
QString mid(int position, int n=-1) const Q_REQUIRED_RESULT
Returns a string that contains n characters of this string, starting at the specified position index...
Definition: qstring.cpp:3706
int daysInMonth() const
Returns the number of days in the month (28 to 31) for this date.
Definition: qdatetime.cpp:431
void setVerticalScrollBarPolicy(Qt::ScrollBarPolicy)
bool insertColumn(int column, const QModelIndex &parent=QModelIndex())
Inserts a single column before the given column in the child items of the parent specified.
void updateCell(const QDate &date)
Updates the cell specified by the given date unless updates are disabled or the cell is hidden...
void setFocus()
Gives the keyboard input focus to this widget (or its focus proxy) if this widget or one of its paren...
Definition: qwidget.h:432
QCalendarTextNavigator * m_navigator
QCalendarWidget(QWidget *parent=0)
Constructs a calendar widget with the given parent.
void setFirstColumnDay(Qt::DayOfWeek dayOfWeek)
void setFocusProxy(QWidget *)
Sets the widget&#39;s focus proxy to widget w.
Definition: qwidget.cpp:6537
QSize sizeHint() const
Reimplemented Function
void createNavigationBar(QWidget *widget)
void setCurrentPage(int year, int month)
Displays the given month of the given year without changing the selected date.
#define Q_DECLARE_PUBLIC(Class)
Definition: qglobal.h:2477
The QMenu class provides a menu widget for use in menu bars, context menus, and other popup menus...
Definition: qmenu.h:72
QTextCharFormat formatForCell(int row, int col) const
int x() const
SelectionMode selectionMode() const
void setDateEditAcceptDelay(int delay)
void setDateEditEnabled(bool enable)
virtual QString text() const
The QTimerEvent class contains parameters that describe a timer event.
Definition: qcoreevent.h:341
bool removeColumns(int column, int count, const QModelIndex &parent=QModelIndex())
On models that support this, removes count columns starting with the given column under parent parent...
void resizeEvent(QResizeEvent *event)
Reimplemented Function
void merge(const QTextFormat &other)
Merges the other format with this format; where there are conflicts the other format takes precedence...
void headerDataChanged(Qt::Orientation orientation, int first, int last)
This signal is emitted whenever a header is changed.
void setDateTextFormat(const QDate &date, const QTextCharFormat &format)
Sets the format used to render the given date to that specified by format.
The QFont class specifies a font used for drawing text.
Definition: qfont.h:64
virtual Section handleKey(int key)=0
QCalendarDateSectionValidator::Section m_lastSectionMove
QString text() const
Returns the Unicode text that this key generated.
Definition: qevent.h:236
void setSelectedDate(const QDate &date)
virtual void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
Renders the delegate using the given painter and style option for the item specified by index...
void setMenu(QMenu *menu)
Associates the given menu with this tool button.
QCalToolButton(QWidget *parent)
virtual QString text() const =0
The QItemDelegate class provides display and editing facilities for data items from a model...
Definition: qitemdelegate.h:61
void setSpacing(int spacing)
Reimplements QLayout::setSpacing().
Definition: qboxlayout.cpp:667
Qt::DayOfWeek firstDayOfWeek() const
QObject * parent() const
Returns a pointer to the parent object.
Definition: qobject.h:273
void setFormat(const QString &format)
void showPreviousYear()
Shows the currently displayed month in the previous year relative to the currently displayed year...
int key
The QPoint class defines a point in the plane using integer precision.
Definition: qpoint.h:53
QVariant data() const
Returns the user data as set in QAction::setData.
Definition: qaction.cpp:1280
void setColor(ColorGroup cg, ColorRole cr, const QColor &color)
Sets the color in the specified color group, used for the given color role, to the specified solid co...
Definition: qpalette.h:201
void keyPressEvent(QKeyEvent *event)
Reimplemented Function
void setVerticalHeaderFormat(VerticalHeaderFormat format)
HorizontalHeaderFormat
This enum type defines the various formats the horizontal header can display.
void installEventFilter(QObject *)
Installs an event filter filterObj on this object.
Definition: qobject.cpp:2070
The QModelIndex class is used to locate data in a data model.
The QStyle class is an abstract base class that encapsulates the look and feel of a GUI...
Definition: qstyle.h:68
FocusPolicy
Definition: qnamespace.h:181
static qlonglong pow10(int exp)
Definition: qvalidator.cpp:392
void setAutoRaise(bool enable)
void paintCell(QPainter *painter, const QRect &rect, const QDate &date) const
QString standaloneMonthName(int, FormatType format=LongFormat) const
Returns the localized name of month that is used as a standalone text, in the format specified by typ...
Definition: qlocale.cpp:2056
QBrush foreground() const
Returns the brush used to render foreground details, such as text, frame outlines, and table borders.
Definition: qtextformat.h:352
void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
This signal is emitted whenever the data in an existing item changes.
int height() const
Returns the height.
Definition: qsize.h:129
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
SectionToken(QCalendarDateSectionValidator *val, int rep)
The QSpinBox class provides a spin box widget.
Definition: qspinbox.h:56
QListIterator< QString > QStringListIterator
Definition: qstringlist.h:61
The QLabel widget provides a text or image display.
Definition: qlabel.h:55
QCalToolButton * monthButton
void showToday()
Shows the month of the today&#39;s date.
bool contains(const Key &key) const
Returns true if the map contains an item with key key; otherwise returns false.
Definition: qmap.h:553
~QCalendarWidget()
Destroys the calendar widget.
QModelIndex moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
Moves the cursor in accordance with the given cursorAction, using the information provided by the mod...
void setSelectionMode(SelectionMode mode)
The QHBoxLayout class lines up widgets horizontally.
Definition: qboxlayout.h:129
void setPopupMode(ToolButtonPopupMode mode)
void setAttribute(Qt::WidgetAttribute, bool on=true)
Sets the attribute attribute on this widget if on is true; otherwise clears the attribute.
Definition: qwidget.cpp:11087
quint16 index
HorizontalHeaderFormat horizontalHeaderFormat() const
void mouseReleaseEvent(QMouseEvent *event)
This function is called with the given event when a mouse button is released, after a mouse press eve...
QMap< QDate, QTextCharFormat > dateTextFormat() const
Returns a QMap from QDate to QTextCharFormat showing all dates that use a special format that alters ...
QWidget * window() const
Returns the window for this widget, i.e.
Definition: qwidget.cpp:4492
void setDate(const QDate &d)
QObject * parent
Definition: qobject.h:92
void clicked(const QDate &date)
QCalendarDateSectionValidator * m_dayValidator
void editingFinished()
The QStylePainter class is a convenience class for drawing QStyle elements inside a widget...
Definition: qstylepainter.h:55
void setForeground(const QBrush &brush)
Sets the foreground brush to the specified brush.
Definition: qtextformat.h:350
void showMonth(int year, int month)
virtual void keyboardSearch(const QString &search)
Moves to and selects the item best matching the string search.
void accept()
Sets the accept flag of the event object, the equivalent of calling setAccepted(true).
Definition: qcoreevent.h:309
QPrevNextCalButton(QWidget *parent)
int year() const
Returns the year of this date.
Definition: qdatetime.cpp:353
const QFont & font() const
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
QTextCharFormat m_headerFormat
QString dayName(int, FormatType format=LongFormat) const
Returns the localized name of the day (where 1 represents Monday, 2 represents Tuesday and so on)...
Definition: qlocale.cpp:2106
void showNextYear()
Shows the currently displayed month in the next year relative to the currently displayed year...
bool isRightToLeft() const
Definition: qwidget.h:428
VerticalHeaderFormat verticalHeaderFormat() const
virtual QString text() const
CursorAction
This enum describes the different ways to navigate between items,.
void setLocale(const QLocale &locale)
The QVBoxLayout class lines up widgets vertically.
Definition: qboxlayout.h:149
The QStyleOptionViewItem class is used to describe the parameters used to draw an item in a view widg...
Definition: qstyleoption.h:539
void updateGeometry()
Notifies the layout system that this widget has changed and may need to change geometry.
Definition: qwidget.cpp:10372
bool event(QEvent *)
This is the main event handler; it handles event event.
Definition: qwidget.cpp:8636
The QToolButton class provides a quick-access button to commands or options, usually used inside a QT...
Definition: qtoolbutton.h:59
void drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex &opt)
Use the widget&#39;s style to draw a complex control cc specified by the QStyleOptionComplex option...
Definition: qstylepainter.h:92
void setGridVisible(bool show)
QDate maximumDate() const
#define signals
Definition: qobjectdefs.h:69
The QPaintEvent class contains event parameters for paint events.
Definition: qevent.h:298
void setSizePolicy(QSizePolicy)
Definition: qwidget.cpp:10198
QAbstractItemModel * model() const
Returns the model that this view is presenting.
static const KeyPair *const end
void setMinimum(int min)
Definition: qspinbox.cpp:425
int rowCount(const QModelIndex &) const
Returns the number of rows under the given parent.
void setMargin(int)
Definition: qlayout.cpp:464
void setIcon(const QIcon &icon)
QDate referenceDate() const
bool event(QEvent *event)
Reimplemented Function
The QEvent class is the base class of all event classes.
Definition: qcoreevent.h:56
void clicked(const QDate &date)
This signal is emitted when a mouse button is clicked.
virtual QDate applyToDate(const QDate &date) const =0
virtual void setDate(const QDate &date)
Type type() const
Returns the event type.
Definition: qcoreevent.h:303
int dateEditAcceptDelay() const
The QFrame class is the base class of widgets that can have a frame.
Definition: qframe.h:55
Qt::DayOfWeek firstColumnDay() const
void setRange(const QDate &min, const QDate &max)
#define Q_UNUSED(x)
Indicates to the compiler that the parameter with the specified name is not used in the body of a fun...
Definition: qglobal.h:1729
bool isDateEditEnabled() const
void changeSize(int w, int h, QSizePolicy::Policy hData=QSizePolicy::Minimum, QSizePolicy::Policy vData=QSizePolicy::Minimum)
Changes this spacer item to have preferred width w, preferred height h, horizontal size policy hPolic...
void mousePressEvent(QMouseEvent *event)
This function is called with the given event when a mouse button is pressed while the cursor is insid...
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
Renders the delegate using the given painter and style option for the item specified by index...
void mousePressEvent(QMouseEvent *event)
This function is called with the given event when a mouse button is pressed while the cursor is insid...
QModelIndex indexAt(const QPoint &p) const
Returns the index position of the model item corresponding to the table item at position pos in conte...
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:55
void updateCurrentPage(const QDate &newDate)
QRect rect
the area that should be used for various calculations and painting
Definition: qstyleoption.h:90
QTextCharFormat headerTextFormat() const
Returns the text char format for rendering the header.
virtual void setDate(const QDate &date)
void setMaximum(int max)
Definition: qspinbox.cpp:456
void setHeaderVisible(bool show)
Use setNavigationBarVisible() instead.
The QAction class provides an abstract user interface action that can be inserted into widgets...
Definition: qaction.h:64
void setPalette(const QPalette &)
Use the single-argument overload instead.
Definition: qwidget.cpp:4858
int columnForFirstOfMonth(const QDate &date) const
QCalendarWidgetPrivate * calendarWidgetPrivate
The QAbstractTableModel class provides an abstract model that can be subclassed to create table model...
virtual Section handleKey(int key)
int yearShown() const
Returns the year of the currently displayed month.
Qt::ItemFlags flags(const QModelIndex &index) const
Returns the item flags for the given index.
int column() const
Returns the column this model index refers to.
void setFocusPolicy(Qt::FocusPolicy policy)
Definition: qwidget.cpp:7631
The QList class is a template class that provides lists.
Definition: qdatastream.h:62
void setDate(const QDate &date)
VerticalHeaderFormat
This enum type defines the various formats the vertical header can display.
QString standaloneDayName(int, FormatType format=LongFormat) const
Returns the localized name of the day (where 1 represents Monday, 2 represents Tuesday and so on) tha...
Definition: qlocale.cpp:2158
The QPalette class contains color groups for each widget state.
Definition: qpalette.h:61