--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbwidgets/editors/hbdatetimevalidator_p.cpp Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,407 @@
+/****************************************************************************
+**
+** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (developer.feedback@nokia.com)
+**
+** This file is part of the HbWidgets module of the UI Extensions for Mobile.
+**
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at developer.feedback@nokia.com.
+**
+****************************************************************************/
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Hb API. It exists purely as an
+// implementation detail. This file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QIntValidator>
+#include <QRegExpValidator>
+#include <QTextCursor>
+#include <QRegExp>
+#include <QtDebug>
+#include <QTextDocument>
+#include <QDate>
+
+#include "hbdatetimevalidator_p_p.h"
+#include "hbvalidator_p.h"
+
+#define DEFAULT_YEAR_VALUE "2009"
+
+const int KMinimumYear = -4713;
+const int KMaximumYear = 11000000; // see more in QDate documentation
+
+HbDateTimeValidatorPrivate::HbDateTimeValidatorPrivate() :
+ HbValidatorPrivate()
+{
+
+}
+
+HbDateTimeValidatorPrivate::~HbDateTimeValidatorPrivate()
+{
+
+}
+
+class HbFixableIntQValidator : public QIntValidator
+{
+public:
+ HbFixableIntQValidator( QObject * parent ) :
+ QIntValidator ( parent ),
+ mMaxLeght(10000)
+ {
+ }
+
+ HbFixableIntQValidator ( int minimum, int maximum, QObject * parent ) :
+ QIntValidator ( minimum, maximum, parent )
+ {
+ int topLenght = QString::number(top()).length();
+ int bottomLenght = QString::number(bottom()).length();
+ mMaxLeght = qMax(topLenght, bottomLenght);
+ }
+
+ void fixup ( QString & input ) const
+ {
+ QString newTextValue=input;
+ newTextValue.remove(QRegExp((bottom()>=0)?"[^0-9]":"[^\\-0-9]"));
+ bool ok;
+ int value = newTextValue.toInt(&ok);
+ if(ok) {
+ value = qBound(bottom(), value, top());
+ newTextValue.setNum(value);
+ if(newTextValue!=input) {
+ input = newTextValue;
+ }
+ }
+ }
+
+ State validate ( QString & input, int & pos ) const
+ {
+ if(input.length()>mMaxLeght) {
+ return Invalid;
+ }
+
+ return QIntValidator::validate(input, pos);
+ }
+
+private:
+ int mMaxLeght;
+};
+
+void HbDateTimeValidatorPrivate::addDateTimeField(const DataPositions& data)
+{
+ Q_Q(HbDateTimeValidator);
+ QValidator *fieldValidator = NULL;
+ QString defaultValue;
+
+ switch(data.type) {
+ case Year: {
+ if(data.lenght() == 4) {
+ fieldValidator = new HbFixableIntQValidator(KMinimumYear,
+ KMaximumYear,
+ q);
+ defaultValue = "2009";
+ } else {
+ fieldValidator = new HbFixableIntQValidator(0,99,q);
+ defaultValue = "09";
+ }
+ }
+ break;
+ case Month: {
+ fieldValidator = new HbFixableIntQValidator(1,12,q);
+ defaultValue = (data.lenght() == 1)?"1":"01";
+ }
+ break;
+ case Day: {
+ fieldValidator = new HbFixableIntQValidator(1,31,q);
+ defaultValue = (data.lenght() == 1)?"1":"01";
+ }
+ break;
+ case AmPm: {
+ QRegExp regUxp("AM|PM", Qt::CaseInsensitive);
+ fieldValidator = new QRegExpValidator(regUxp,q);
+ defaultValue = "AM";
+ }
+ break;
+ case Hour24: {
+ fieldValidator = new HbFixableIntQValidator(0,23,q);
+ defaultValue = (data.lenght() == 1)?"0":"00";
+ }
+ break;
+ case Hour12: {
+ fieldValidator = new HbFixableIntQValidator(1,12,q);
+ defaultValue = "12";
+ }
+ break;
+ case Minutes: {
+ fieldValidator = new HbFixableIntQValidator(0,59,q);
+ defaultValue = (data.lenght() == 1)?"0":"00";
+ }
+ break;
+ case Seconds: {
+ fieldValidator = new HbFixableIntQValidator(0,59,q);
+ defaultValue = (data.lenght() == 1)?"0":"00";
+ }
+ break;
+ case MilliSeconds: {
+ fieldValidator = new HbFixableIntQValidator(0,999,q);
+ defaultValue = (data.lenght() == 1)?"0":"000";
+ }
+ break;
+ default:
+ Q_ASSERT(false);
+ }
+ fieldTypes.append(data.type);
+ addField(separatorToAdd,fieldValidator,defaultValue);
+}
+
+bool HbDateTimeValidatorPrivate::fixDate(QTextCursor *cursor, bool updateCursor)
+{
+ Q_ASSERT(!fieldTypes.isEmpty());
+
+ QRegExp regExp = QRegExp(parseString,Qt::CaseInsensitive);
+
+ Q_ASSERT(regExp.isValid());
+
+ bool result = false;
+
+ if(regExp.exactMatch(cursor->document()->toPlainText())) {
+ QTextCursor fixingCursor(cursor->document());
+ fixingCursor.beginEditBlock();
+
+ // step one: fixing each field separately
+ for(int i = fieldTypes.count()-1; i>=0; --i ) {
+ int pos = regExp.pos(i+1);
+ QString fieldTxt = regExp.cap(i+1);
+ fixingCursor.setPosition(pos);
+ fixingCursor.setPosition(pos + fieldTxt.length());
+
+ int x = fieldTxt.length();
+ if( QValidator::Acceptable != fields.at(i)->mValidator->validate(fieldTxt, x) ) {
+ fields.at(i)->mValidator->fixup(fieldTxt);
+ if(QValidator::Acceptable == fields.at(i)->mValidator->validate(fieldTxt, x)) {
+ // successful fix
+ fixingCursor.insertText(fieldTxt);
+ result = true;
+ }
+ }
+ }
+
+ // step two: fixing correlations between fields
+ // Note: this functionality is specific for HbDateTimeValidator
+ int yearCapture = fieldTypes.indexOf(Year)+1;
+ int monthCapture = fieldTypes.indexOf(Month)+1;
+ int dayCapture = fieldTypes.indexOf(Day)+1;
+
+ if(dayCapture<=0 || monthCapture<=0) {
+ fixingCursor.endEditBlock();
+ return result; // nothing to fix no date
+ }
+
+ // match content again
+ if(regExp.exactMatch(cursor->document()->toPlainText())) {
+ int year=1900, month, day;
+
+ if(yearCapture>0) {
+ year = regExp.cap(yearCapture).toInt();
+ }
+ month = regExp.cap(monthCapture).toInt();
+
+ int daySize =0;
+ QString s = regExp.cap(dayCapture);
+ daySize = s.length();
+ day = s.toInt();
+
+ if( !QDate::isValid(year, month, day) ) {
+ QDate dateFoFix(year,month,1);
+ if(dateFoFix.daysInMonth()<day) {
+ dateFoFix.setDate(year,month,dateFoFix.daysInMonth());
+ int dayCapPos = regExp.pos(dayCapture);
+ fixingCursor.setPosition(dayCapPos);
+ fixingCursor.setPosition(dayCapPos+daySize, QTextCursor::KeepAnchor);
+
+ // updating date by changing document
+ // this will prevent some unexpected isues
+ fixingCursor.insertText(QString().setNum(dateFoFix.daysInMonth()));
+
+ if(updateCursor) {
+ fixingCursor.setPosition(dayCapPos);
+ fixingCursor.setPosition(dayCapPos+daySize, QTextCursor::KeepAnchor);
+ *cursor = fixingCursor;
+ }
+ result = true;
+ }
+ }
+ }
+ fixingCursor.endEditBlock();
+ }
+
+ return result;
+}
+
+/*!
+ \class HbDateTimeValidator
+ \brief HbDateTimeValidator provides validation services for QAbstractEdit derived editors.
+*/
+
+/*!
+ Constructs a HbDateTimeValidator object with a /a parent
+*/
+HbDateTimeValidator::HbDateTimeValidator(QObject *parent) :
+ HbValidator(*new HbDateTimeValidatorPrivate, parent)
+{
+ Q_D(HbDateTimeValidator);
+ d->q_ptr = this;
+}
+
+HbDateTimeValidator::HbDateTimeValidator(HbDateTimeValidatorPrivate &dd, QObject *parent) :
+ HbValidator(dd, parent)
+{
+ Q_D(HbDateTimeValidator);
+ d->q_ptr = this;
+}
+
+/*!
+ Destructor
+*/
+HbDateTimeValidator::~HbDateTimeValidator()
+{
+}
+
+inline void appendIfFound(DataType type, QList<DataPositions>* where, QRegExp& what, const QString& from)
+{
+ int pos = from.indexOf(what);
+ if(pos>=0) {
+ int matchLenght = what.cap(0).length();
+ Q_ASSERT( matchLenght>0 );
+ Q_ASSERT( from.indexOf(what, pos+matchLenght)==-1 );
+
+ where->append(
+ DataPositions(type, pos, matchLenght)
+ );
+ }
+}
+
+void HbDateTimeValidator::setDisplayFormat(const QString &format)
+{
+ QList<DataPositions> positions;
+
+ QRegExp regExp;
+ QString newParseString = QRegExp::escape(format);
+ const QString captureNumber = "([0-9]+)";
+
+ regExp.setPattern("yy(yy)?");
+ appendIfFound(Year, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ regExp.setPattern("M{1,3}");
+ appendIfFound(Month, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ regExp.setPattern("d{1,3}");
+ appendIfFound(Day, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ const QString captureAmPm("(AM|PM|am|pm)");
+ regExp.setPattern("ap");
+ appendIfFound(AmPm, &positions, regExp, format);
+ newParseString.replace(regExp, captureAmPm);
+
+ regExp.setPattern("AP");
+ appendIfFound(AmPm, &positions, regExp, format);
+ newParseString.replace(regExp, captureAmPm);
+
+ DataType hourType = Hour24;
+ if(!positions.isEmpty()) {
+ if(positions.last().type==AmPm) {
+ hourType = Hour12;
+ }
+ }
+
+ regExp.setPattern("hh?");
+ appendIfFound(hourType, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ regExp.setPattern("HH?");
+ appendIfFound(hourType, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ regExp.setPattern("mm?");
+ appendIfFound(Minutes, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ regExp.setPattern("ss?");
+ appendIfFound(Seconds, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ regExp.setPattern("z(zz)?");
+ appendIfFound(MilliSeconds, &positions, regExp, format);
+ newParseString.replace(regExp, captureNumber);
+
+ if(positions.size()==0) {
+ qWarning() << "HbDateTimeValidator::setDisplayFormat: format: \""
+ << format << "\" is invalid so it was ignored" ;
+ return;
+ }
+
+ qSort(positions);
+
+ Q_D(HbDateTimeValidator);
+ d->format = format;
+ // ignore trailing separators:
+ if(positions.back().stop < format.length()) {
+ newParseString.chop(QRegExp::escape(format.mid(positions.back().stop)).length());
+ d->format.resize(positions.back().stop);
+ }
+
+ // ignore front separators:
+ if(positions.front().start != 0) {
+ newParseString.remove(0,positions.front().start);
+ }
+
+ d->parseString = newParseString;
+ d->fieldTypes.clear();
+ d->deleteAllFields();
+
+ const int n=positions.size()-1;
+ for(int i=0; i<n; ++i) {
+ d->addDateTimeField(positions.at(i));
+ int separatorBegin = positions.at(i).stop;
+ int separatorLenght = positions.at(i+1).start - separatorBegin;
+ if(separatorLenght>0) {
+ setDefaultSeparator(format.mid(separatorBegin,separatorLenght));
+ } else {
+ setDefaultSeparator(" ");
+ }
+ }
+ d->addDateTimeField(positions.at(n));
+}
+
+const QString HbDateTimeValidator::displayFormat() const
+{
+ Q_D(const HbDateTimeValidator);
+ return d->format;
+}
+
+bool HbDateTimeValidator::fixDate(QTextCursor *cursor, bool updateCursor)
+{
+ return d_func()->fixDate(cursor, updateCursor);
+}