examples/tools/settingseditor/variantdelegate.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the examples of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtGui>
  43
  44 #include "variantdelegate.h"
  45
  46 VariantDelegate::VariantDelegate(QObject *parent)
  47     : QItemDelegate(parent)
  48 {
  49     boolExp.setPattern("true|false");
  50     boolExp.setCaseSensitivity(Qt::CaseInsensitive);
  51
  52     byteArrayExp.setPattern("[\\x00-\\xff]*");
  53     charExp.setPattern(".");
  54     colorExp.setPattern("\\(([0-9]*),([0-9]*),([0-9]*),([0-9]*)\\)");
  55     doubleExp.setPattern("");
  56     pointExp.setPattern("\\((-?[0-9]*),(-?[0-9]*)\\)");
  57     rectExp.setPattern("\\((-?[0-9]*),(-?[0-9]*),(-?[0-9]*),(-?[0-9]*)\\)");
  58     signedIntegerExp.setPattern("-?[0-9]*");
  59     sizeExp = pointExp;
  60     unsignedIntegerExp.setPattern("[0-9]*");
  61
  62     dateExp.setPattern("([0-9]{,4})-([0-9]{,2})-([0-9]{,2})");
  63     timeExp.setPattern("([0-9]{,2}):([0-9]{,2}):([0-9]{,2})");
  64     dateTimeExp.setPattern(dateExp.pattern() + "T" + timeExp.pattern());
  65 }
  66
  67 void VariantDelegate::paint(QPainter *painter,
  68                             const QStyleOptionViewItem &option,
  69                             const QModelIndex &index) const
  70 {
  71     if (index.column() == 2) {
  72         QVariant value = index.model()->data(index, Qt::UserRole);
  73         if (!isSupportedType(value.type())) {
  74             QStyleOptionViewItem myOption = option;
  75             myOption.state &= ~QStyle::State_Enabled;
  76             QItemDelegate::paint(painter, myOption, index);
  77             return;
  78         }
  79     }
  80
  81     QItemDelegate::paint(painter, option, index);
  82 }
  83
  84 QWidget *VariantDelegate::createEditor(QWidget *parent,
  85         const QStyleOptionViewItem & /* option */,
  86         const QModelIndex &index) const
  87 {
  88     if (index.column() != 2)
  89         return 0;
  90
  91     QVariant originalValue = index.model()->data(index, Qt::UserRole);
  92     if (!isSupportedType(originalValue.type()))
  93         return 0;
  94
  95     QLineEdit *lineEdit = new QLineEdit(parent);
  96     lineEdit->setFrame(false);
  97
  98     QRegExp regExp;
  99
 100     switch (originalValue.type()) {
 101     case QVariant::Bool:
 102         regExp = boolExp;
 103         break;
 104     case QVariant::ByteArray:
 105         regExp = byteArrayExp;
 106         break;
 107     case QVariant::Char:
 108         regExp = charExp;
 109         break;
 110     case QVariant::Color:
 111         regExp = colorExp;
 112         break;
 113     case QVariant::Date:
 114         regExp = dateExp;
 115         break;
 116     case QVariant::DateTime:
 117         regExp = dateTimeExp;
 118         break;
 119     case QVariant::Double:
 120         regExp = doubleExp;
 121         break;
 122     case QVariant::Int:
 123     case QVariant::LongLong:
 124         regExp = signedIntegerExp;
 125         break;
 126     case QVariant::Point:
 127         regExp = pointExp;
 128         break;
 129     case QVariant::Rect:
 130         regExp = rectExp;
 131         break;
 132     case QVariant::Size:
 133         regExp = sizeExp;
 134         break;
 135     case QVariant::Time:
 136         regExp = timeExp;
 137         break;
 138     case QVariant::UInt:
 139     case QVariant::ULongLong:
 140         regExp = unsignedIntegerExp;
 141         break;
 142     default:
 143         ;
 144     }
 145
 146     if (!regExp.isEmpty()) {
 147         QValidator *validator = new QRegExpValidator(regExp, lineEdit);
 148         lineEdit->setValidator(validator);
 149     }
 150
 151     return lineEdit;
 152 }
 153
 154 void VariantDelegate::setEditorData(QWidget *editor,
 155                                     const QModelIndex &index) const
 156 {
 157     QVariant value = index.model()->data(index, Qt::UserRole);
 158     if (QLineEdit *lineEdit = qobject_cast<QLineEdit *>(editor))
 159         lineEdit->setText(displayText(value));
 160 }
 161
 162 void VariantDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
 163                                    const QModelIndex &index) const
 164 {
 165     QLineEdit *lineEdit = qobject_cast<QLineEdit *>(editor);
 166     if (!lineEdit->isModified())
 167         return;
 168
 169     QString text = lineEdit->text();
 170     const QValidator *validator = lineEdit->validator();
 171     if (validator) {
 172         int pos;
 173         if (validator->validate(text, pos) != QValidator::Acceptable)
 174             return;
 175     }
 176
 177     QVariant originalValue = index.model()->data(index, Qt::UserRole);
 178     QVariant value;
 179
 180     switch (originalValue.type()) {
 181     case QVariant::Char:
 182         value = text.at(0);
 183         break;
 184     case QVariant::Color:
 185         colorExp.exactMatch(text);
 186         value = QColor(qMin(colorExp.cap(1).toInt(), 255),
 187                        qMin(colorExp.cap(2).toInt(), 255),
 188                        qMin(colorExp.cap(3).toInt(), 255),
 189                        qMin(colorExp.cap(4).toInt(), 255));
 190         break;
 191     case QVariant::Date:
 192         {
 193             QDate date = QDate::fromString(text, Qt::ISODate);
 194             if (!date.isValid())
 195                 return;
 196             value = date;
 197         }
 198         break;
 199     case QVariant::DateTime:
 200         {
 201             QDateTime dateTime = QDateTime::fromString(text, Qt::ISODate);
 202             if (!dateTime.isValid())
 203                 return;
 204             value = dateTime;
 205         }
 206         break;
 207     case QVariant::Point:
 208         pointExp.exactMatch(text);
 209         value = QPoint(pointExp.cap(1).toInt(), pointExp.cap(2).toInt());
 210         break;
 211     case QVariant::Rect:
 212         rectExp.exactMatch(text);
 213         value = QRect(rectExp.cap(1).toInt(), rectExp.cap(2).toInt(),
 214                       rectExp.cap(3).toInt(), rectExp.cap(4).toInt());
 215         break;
 216     case QVariant::Size:
 217         sizeExp.exactMatch(text);
 218         value = QSize(sizeExp.cap(1).toInt(), sizeExp.cap(2).toInt());
 219         break;
 220     case QVariant::StringList:
 221         value = text.split(",");
 222         break;
 223     case QVariant::Time:
 224         {
 225             QTime time = QTime::fromString(text, Qt::ISODate);
 226             if (!time.isValid())
 227                 return;
 228             value = time;
 229         }
 230         break;
 231     default:
 232         value = text;
 233         value.convert(originalValue.type());
 234     }
 235
 236     model->setData(index, displayText(value), Qt::DisplayRole);
 237     model->setData(index, value, Qt::UserRole);
 238 }
 239
 240 bool VariantDelegate::isSupportedType(QVariant::Type type)
 241 {
 242     switch (type) {
 243     case QVariant::Bool:
 244     case QVariant::ByteArray:
 245     case QVariant::Char:
 246     case QVariant::Color:
 247     case QVariant::Date:
 248     case QVariant::DateTime:
 249     case QVariant::Double:
 250     case QVariant::Int:
 251     case QVariant::LongLong:
 252     case QVariant::Point:
 253     case QVariant::Rect:
 254     case QVariant::Size:
 255     case QVariant::String:
 256     case QVariant::StringList:
 257     case QVariant::Time:
 258     case QVariant::UInt:
 259     case QVariant::ULongLong:
 260         return true;
 261     default:
 262         return false;
 263     }
 264 }
 265
 266 QString VariantDelegate::displayText(const QVariant &value)
 267 {
 268     switch (value.type()) {
 269     case QVariant::Bool:
 270     case QVariant::ByteArray:
 271     case QVariant::Char:
 272     case QVariant::Double:
 273     case QVariant::Int:
 274     case QVariant::LongLong:
 275     case QVariant::String:
 276     case QVariant::UInt:
 277     case QVariant::ULongLong:
 278         return value.toString();
 279     case QVariant::Color:
 280         {
 281             QColor color = qvariant_cast<QColor>(value);
 282             return QString("(%1,%2,%3,%4)")
 283                    .arg(color.red()).arg(color.green())
 284                    .arg(color.blue()).arg(color.alpha());
 285         }
 286     case QVariant::Date:
 287         return value.toDate().toString(Qt::ISODate);
 288     case QVariant::DateTime:
 289         return value.toDateTime().toString(Qt::ISODate);
 290     case QVariant::Invalid:
 291         return "<Invalid>";
 292     case QVariant::Point:
 293         {
 294             QPoint point = value.toPoint();
 295             return QString("(%1,%2)").arg(point.x()).arg(point.y());
 296         }
 297     case QVariant::Rect:
 298         {
 299             QRect rect = value.toRect();
 300             return QString("(%1,%2,%3,%4)")
 301                    .arg(rect.x()).arg(rect.y())
 302                    .arg(rect.width()).arg(rect.height());
 303         }
 304     case QVariant::Size:
 305         {
 306             QSize size = value.toSize();
 307             return QString("(%1,%2)").arg(size.width()).arg(size.height());
 308         }
 309     case QVariant::StringList:
 310         return value.toStringList().join(",");
 311     case QVariant::Time:
 312         return value.toTime().toString(Qt::ISODate);
 313     default:
 314         break;
 315     }
 316     return QString("<%1>").arg(value.typeName());
 317 }