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

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the tools applications 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 "qtvariantproperty.h"

    43 #include "qtpropertymanager.h"

    44 #include "qteditorfactory.h"

    45 #include <QtCore/QVariant>

    46 #include <QtGui/QIcon>

    47 #include <QtCore/QDate>

    48 #include <QtCore/QLocale>

    49 

    50 #if defined(Q_CC_MSVC)

    51 #    pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */

    52 #endif

    53 

    54 QT_BEGIN_NAMESPACE

    55 

    56 class QtEnumPropertyType

    57 {

    58 };

    59 

    60 

    61 class QtFlagPropertyType

    62 {

    63 };

    64 

    65 

    66 class QtGroupPropertyType

    67 {

    68 };

    69 

    70 QT_END_NAMESPACE

    71 

    72 Q_DECLARE_METATYPE(QtEnumPropertyType)

    73 Q_DECLARE_METATYPE(QtFlagPropertyType)

    74 Q_DECLARE_METATYPE(QtGroupPropertyType)

    75 

    76 QT_BEGIN_NAMESPACE

    77 

    78 /*!

    79     Returns the type id for an enum property.

    80 

    81     Note that the property's value type can be retrieved using the

    82     valueType() function (which is QVariant::Int for the enum property

    83     type).

    84 

    85     \sa propertyType(), valueType()

    86 */

    87 int QtVariantPropertyManager::enumTypeId()

    88 {

    89     return qMetaTypeId<QtEnumPropertyType>();

    90 }

    91 

    92 /*!

    93     Returns the type id for a flag property.

    94 

    95     Note that the property's value type can be retrieved using the

    96     valueType() function (which is QVariant::Int for the flag property

    97     type).

    98 

    99     \sa propertyType(), valueType()

   100 */

   101 int QtVariantPropertyManager::flagTypeId()

   102 {

   103     return qMetaTypeId<QtFlagPropertyType>();

   104 }

   105 

   106 /*!

   107     Returns the type id for a group property.

   108 

   109     Note that the property's value type can be retrieved using the

   110     valueType() function (which is QVariant::Invalid for the group

   111     property type, since it doesn't provide any value).

   112 

   113     \sa propertyType(), valueType()

   114 */

   115 int QtVariantPropertyManager::groupTypeId()

   116 {

   117     return qMetaTypeId<QtGroupPropertyType>();

   118 }

   119 

   120 /*!

   121     Returns the type id for a icon map attribute.

   122 

   123     Note that the property's attribute type can be retrieved using the

   124     attributeType() function.

   125 

   126     \sa attributeType(), QtEnumPropertyManager::enumIcons()

   127 */

   128 int QtVariantPropertyManager::iconMapTypeId()

   129 {

   130     return qMetaTypeId<QtIconMap>();

   131 }

   132 

   133 typedef QMap<const QtProperty *, QtProperty *> PropertyMap;

   134 Q_GLOBAL_STATIC(PropertyMap, propertyToWrappedProperty)

   135 

   136 static QtProperty *wrappedProperty(QtProperty *property)

   137 {

   138     return propertyToWrappedProperty()->value(property, 0);

   139 }

   140 

   141 class QtVariantPropertyPrivate

   142 {

   143     QtVariantProperty *q_ptr;

   144 public:

   145     QtVariantPropertyPrivate(QtVariantPropertyManager *m) : manager(m) {}

   146 

   147     QtVariantPropertyManager *manager;

   148 };

   149 

   150 /*!

   151     \class QtVariantProperty

   152     \internal

   153     \inmodule QtDesigner

   154     \since 4.4

   155 

   156     \brief The QtVariantProperty class is a convenience class handling

   157     QVariant based properties.

   158 

   159     QtVariantProperty provides additional API: A property's type,

   160     value type, attribute values and current value can easily be

   161     retrieved using the propertyType(), valueType(), attributeValue()

   162     and value() functions respectively. In addition, the attribute

   163     values and the current value can be set using the corresponding

   164     setValue() and setAttribute() functions.

   165 

   166     For example, instead of writing:

   167 

   168     \snippet doc/src/snippets/code/tools_shared_qtpropertybrowser_qtvariantproperty.cpp 0

   169 

   170     you can write:

   171 

   172     \snippet doc/src/snippets/code/tools_shared_qtpropertybrowser_qtvariantproperty.cpp 1

   173 

   174     QtVariantProperty instances can only be created by the

   175     QtVariantPropertyManager class.

   176 

   177     \sa QtProperty, QtVariantPropertyManager, QtVariantEditorFactory

   178 */

   179 

   180 /*!

   181     Creates a variant property using the given \a manager.

   182 

   183     Do not use this constructor to create variant property instances;

   184     use the QtVariantPropertyManager::addProperty() function

   185     instead.  This constructor is used internally by the

   186     QtVariantPropertyManager::createProperty() function.

   187 

   188     \sa QtVariantPropertyManager

   189 */

   190 QtVariantProperty::QtVariantProperty(QtVariantPropertyManager *manager)

   191     : QtProperty(manager), d_ptr(new QtVariantPropertyPrivate(manager))

   192 {

   193 }

   194 

   195 /*!

   196     Destroys this property.

   197 

   198     \sa QtProperty::~QtProperty()

   199 */

   200 QtVariantProperty::~QtVariantProperty()

   201 {

   202 }

   203 

   204 /*!

   205     Returns the property's current value.

   206 

   207     \sa valueType(), setValue()

   208 */

   209 QVariant QtVariantProperty::value() const

   210 {

   211     return d_ptr->manager->value(this);

   212 }

   213 

   214 /*!

   215     Returns this property's value for the specified \a attribute.

   216 

   217     QtVariantPropertyManager provides a couple of related functions:

   218     \l{QtVariantPropertyManager::attributes()}{attributes()} and

   219     \l{QtVariantPropertyManager::attributeType()}{attributeType()}.

   220 

   221     \sa setAttribute()

   222 */

   223 QVariant QtVariantProperty::attributeValue(const QString &attribute) const

   224 {

   225     return d_ptr->manager->attributeValue(this, attribute);

   226 }

   227 

   228 /*!

   229     Returns the type of this property's value.

   230 

   231     \sa propertyType()

   232 */

   233 int QtVariantProperty::valueType() const

   234 {

   235     return d_ptr->manager->valueType(this);

   236 }

   237 

   238 /*!

   239     Returns this property's type.

   240 

   241     QtVariantPropertyManager provides several related functions:

   242     \l{QtVariantPropertyManager::enumTypeId()}{enumTypeId()},

   243     \l{QtVariantPropertyManager::flagTypeId()}{flagTypeId()} and

   244     \l{QtVariantPropertyManager::groupTypeId()}{groupTypeId()}.

   245 

   246     \sa valueType()

   247 */

   248 int QtVariantProperty::propertyType() const

   249 {

   250     return d_ptr->manager->propertyType(this);

   251 }

   252 

   253 /*!

   254     Sets the value of this property to \a value.

   255 

   256     The specified \a value must be of the type returned by

   257     valueType(), or of a type that can be converted to valueType()

   258     using the QVariant::canConvert() function; otherwise this function

   259     does nothing.

   260 

   261     \sa value()

   262 */

   263 void QtVariantProperty::setValue(const QVariant &value)

   264 {

   265     d_ptr->manager->setValue(this, value);

   266 }

   267 

   268 /*!

   269     Sets the \a attribute of property to \a value.

   270 

   271     QtVariantPropertyManager provides the related

   272     \l{QtVariantPropertyManager::setAttribute()}{setAttribute()}

   273     function.

   274 

   275     \sa attributeValue()

   276 */

   277 void QtVariantProperty::setAttribute(const QString &attribute, const QVariant &value)

   278 {

   279     d_ptr->manager->setAttribute(this, attribute, value);

   280 }

   281 

   282 class QtVariantPropertyManagerPrivate

   283 {

   284     QtVariantPropertyManager *q_ptr;

   285     Q_DECLARE_PUBLIC(QtVariantPropertyManager)

   286 public:

   287     QtVariantPropertyManagerPrivate();

   288 

   289     bool m_creatingProperty;

   290     bool m_creatingSubProperties;

   291     bool m_destroyingSubProperties;

   292     int m_propertyType;

   293 

   294     void slotValueChanged(QtProperty *property, int val);

   295     void slotRangeChanged(QtProperty *property, int min, int max);

   296     void slotSingleStepChanged(QtProperty *property, int step);

   297     void slotValueChanged(QtProperty *property, double val);

   298     void slotRangeChanged(QtProperty *property, double min, double max);

   299     void slotSingleStepChanged(QtProperty *property, double step);

   300     void slotDecimalsChanged(QtProperty *property, int prec);

   301     void slotValueChanged(QtProperty *property, bool val);

   302     void slotValueChanged(QtProperty *property, const QString &val);

   303     void slotRegExpChanged(QtProperty *property, const QRegExp &regExp);

   304     void slotValueChanged(QtProperty *property, const QDate &val);

   305     void slotRangeChanged(QtProperty *property, const QDate &min, const QDate &max);

   306     void slotValueChanged(QtProperty *property, const QTime &val);

   307     void slotValueChanged(QtProperty *property, const QDateTime &val);

   308     void slotValueChanged(QtProperty *property, const QKeySequence &val);

   309     void slotValueChanged(QtProperty *property, const QChar &val);

   310     void slotValueChanged(QtProperty *property, const QLocale &val);

   311     void slotValueChanged(QtProperty *property, const QPoint &val);

   312     void slotValueChanged(QtProperty *property, const QPointF &val);

   313     void slotValueChanged(QtProperty *property, const QSize &val);

   314     void slotRangeChanged(QtProperty *property, const QSize &min, const QSize &max);

   315     void slotValueChanged(QtProperty *property, const QSizeF &val);

   316     void slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max);

   317     void slotValueChanged(QtProperty *property, const QRect &val);

   318     void slotConstraintChanged(QtProperty *property, const QRect &val);

   319     void slotValueChanged(QtProperty *property, const QRectF &val);

   320     void slotConstraintChanged(QtProperty *property, const QRectF &val);

   321     void slotValueChanged(QtProperty *property, const QColor &val);

   322     void slotEnumChanged(QtProperty *property, int val);

   323     void slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames);

   324     void slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons);

   325     void slotValueChanged(QtProperty *property, const QSizePolicy &val);

   326     void slotValueChanged(QtProperty *property, const QFont &val);

   327     void slotValueChanged(QtProperty *property, const QCursor &val);

   328     void slotFlagChanged(QtProperty *property, int val);

   329     void slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames);

   330     void slotPropertyInserted(QtProperty *property, QtProperty *parent, QtProperty *after);

   331     void slotPropertyRemoved(QtProperty *property, QtProperty *parent);

   332 

   333     void valueChanged(QtProperty *property, const QVariant &val);

   334 

   335     int internalPropertyToType(QtProperty *property) const;

   336     QtVariantProperty *createSubProperty(QtVariantProperty *parent, QtVariantProperty *after,

   337             QtProperty *internal);

   338     void removeSubProperty(QtVariantProperty *property);

   339 

   340     QMap<int, QtAbstractPropertyManager *> m_typeToPropertyManager;

   341     QMap<int, QMap<QString, int> > m_typeToAttributeToAttributeType;

   342 

   343     QMap<const QtProperty *, QPair<QtVariantProperty *, int> > m_propertyToType;

   344 

   345     QMap<int, int> m_typeToValueType;

   346 

   347 

   348     QMap<QtProperty *, QtVariantProperty *> m_internalToProperty;

   349 

   350     const QString m_constraintAttribute;

   351     const QString m_singleStepAttribute;

   352     const QString m_decimalsAttribute;

   353     const QString m_enumIconsAttribute;

   354     const QString m_enumNamesAttribute;

   355     const QString m_flagNamesAttribute;

   356     const QString m_maximumAttribute;

   357     const QString m_minimumAttribute;

   358     const QString m_regExpAttribute;

   359 };

   360 

   361 QtVariantPropertyManagerPrivate::QtVariantPropertyManagerPrivate() :

   362     m_constraintAttribute(QLatin1String("constraint")),

   363     m_singleStepAttribute(QLatin1String("singleStep")),

   364     m_decimalsAttribute(QLatin1String("decimals")),

   365     m_enumIconsAttribute(QLatin1String("enumIcons")),

   366     m_enumNamesAttribute(QLatin1String("enumNames")),

   367     m_flagNamesAttribute(QLatin1String("flagNames")),

   368     m_maximumAttribute(QLatin1String("maximum")),

   369     m_minimumAttribute(QLatin1String("minimum")),

   370     m_regExpAttribute(QLatin1String("regExp"))

   371 {

   372 }

   373 

   374 int QtVariantPropertyManagerPrivate::internalPropertyToType(QtProperty *property) const

   375 {

   376     int type = 0;

   377     QtAbstractPropertyManager *internPropertyManager = property->propertyManager();

   378     if (qobject_cast<QtIntPropertyManager *>(internPropertyManager))

   379         type = QVariant::Int;

   380     else if (qobject_cast<QtEnumPropertyManager *>(internPropertyManager))

   381         type = QtVariantPropertyManager::enumTypeId();

   382     else if (qobject_cast<QtBoolPropertyManager *>(internPropertyManager))

   383         type = QVariant::Bool;

   384     else if (qobject_cast<QtDoublePropertyManager *>(internPropertyManager))

   385         type = QVariant::Double;

   386     return type;

   387 }

   388 

   389 QtVariantProperty *QtVariantPropertyManagerPrivate::createSubProperty(QtVariantProperty *parent,

   390             QtVariantProperty *after, QtProperty *internal)

   391 {

   392     int type = internalPropertyToType(internal);

   393     if (!type)

   394         return 0;

   395 

   396     bool wasCreatingSubProperties = m_creatingSubProperties;

   397     m_creatingSubProperties = true;

   398 

   399     QtVariantProperty *varChild = q_ptr->addProperty(type, internal->propertyName());

   400 

   401     m_creatingSubProperties = wasCreatingSubProperties;

   402 

   403     varChild->setPropertyName(internal->propertyName());

   404     varChild->setToolTip(internal->toolTip());

   405     varChild->setStatusTip(internal->statusTip());

   406     varChild->setWhatsThis(internal->whatsThis());

   407 

   408     parent->insertSubProperty(varChild, after);

   409 

   410     m_internalToProperty[internal] = varChild;

   411     propertyToWrappedProperty()->insert(varChild, internal);

   412     return varChild;

   413 }

   414 

   415 void QtVariantPropertyManagerPrivate::removeSubProperty(QtVariantProperty *property)

   416 {

   417     QtProperty *internChild = wrappedProperty(property);

   418     bool wasDestroyingSubProperties = m_destroyingSubProperties;

   419     m_destroyingSubProperties = true;

   420     delete property;

   421     m_destroyingSubProperties = wasDestroyingSubProperties;

   422     m_internalToProperty.remove(internChild);

   423     propertyToWrappedProperty()->remove(property);

   424 }

   425 

   426 void QtVariantPropertyManagerPrivate::slotPropertyInserted(QtProperty *property,

   427             QtProperty *parent, QtProperty *after)

   428 {

   429     if (m_creatingProperty)

   430         return;

   431 

   432     QtVariantProperty *varParent = m_internalToProperty.value(parent, 0);

   433     if (!varParent)

   434         return;

   435 

   436     QtVariantProperty *varAfter = 0;

   437     if (after) {

   438         varAfter = m_internalToProperty.value(after, 0);

   439         if (!varAfter)

   440             return;

   441     }

   442 

   443     createSubProperty(varParent, varAfter, property);

   444 }

   445 

   446 void QtVariantPropertyManagerPrivate::slotPropertyRemoved(QtProperty *property, QtProperty *parent)

   447 {

   448     Q_UNUSED(parent)

   449 

   450     QtVariantProperty *varProperty = m_internalToProperty.value(property, 0);

   451     if (!varProperty)

   452         return;

   453 

   454     removeSubProperty(varProperty);

   455 }

   456 

   457 void QtVariantPropertyManagerPrivate::valueChanged(QtProperty *property, const QVariant &val)

   458 {

   459     QtVariantProperty *varProp = m_internalToProperty.value(property, 0);

   460     if (!varProp)

   461         return;

   462     emit q_ptr->valueChanged(varProp, val);

   463     emit q_ptr->propertyChanged(varProp);

   464 }

   465 

   466 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, int val)

   467 {

   468     valueChanged(property, QVariant(val));

   469 }

   470 

   471 void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, int min, int max)

   472 {

   473     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

   474         emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

   475         emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

   476     }

   477 }

   478 

   479 void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, int step)

   480 {

   481     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   482         emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));

   483 }

   484 

   485 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, double val)

   486 {

   487     valueChanged(property, QVariant(val));

   488 }

   489 

   490 void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, double min, double max)

   491 {

   492     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

   493         emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

   494         emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

   495     }

   496 }

   497 

   498 void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, double step)

   499 {

   500     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   501         emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));

   502 }

   503 

   504 void QtVariantPropertyManagerPrivate::slotDecimalsChanged(QtProperty *property, int prec)

   505 {

   506     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   507         emit q_ptr->attributeChanged(varProp, m_decimalsAttribute, QVariant(prec));

   508 }

   509 

   510 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, bool val)

   511 {

   512     valueChanged(property, QVariant(val));

   513 }

   514 

   515 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QString &val)

   516 {

   517     valueChanged(property, QVariant(val));

   518 }

   519 

   520 void QtVariantPropertyManagerPrivate::slotRegExpChanged(QtProperty *property, const QRegExp &regExp)

   521 {

   522     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   523         emit q_ptr->attributeChanged(varProp, m_regExpAttribute, QVariant(regExp));

   524 }

   525 

   526 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QDate &val)

   527 {

   528     valueChanged(property, QVariant(val));

   529 }

   530 

   531 void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QDate &min, const QDate &max)

   532 {

   533     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

   534         emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

   535         emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

   536     }

   537 }

   538 

   539 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QTime &val)

   540 {

   541     valueChanged(property, QVariant(val));

   542 }

   543 

   544 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QDateTime &val)

   545 {

   546     valueChanged(property, QVariant(val));

   547 }

   548 

   549 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QKeySequence &val)

   550 {

   551     QVariant v;

   552     qVariantSetValue(v, val);

   553     valueChanged(property, v);

   554 }

   555 

   556 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QChar &val)

   557 {

   558     valueChanged(property, QVariant(val));

   559 }

   560 

   561 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QLocale &val)

   562 {

   563     valueChanged(property, QVariant(val));

   564 }

   565 

   566 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QPoint &val)

   567 {

   568     valueChanged(property, QVariant(val));

   569 }

   570 

   571 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QPointF &val)

   572 {

   573     valueChanged(property, QVariant(val));

   574 }

   575 

   576 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSize &val)

   577 {

   578     valueChanged(property, QVariant(val));

   579 }

   580 

   581 void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QSize &min, const QSize &max)

   582 {

   583     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

   584         emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

   585         emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

   586     }

   587 }

   588 

   589 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSizeF &val)

   590 {

   591     valueChanged(property, QVariant(val));

   592 }

   593 

   594 void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max)

   595 {

   596     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

   597         emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

   598         emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

   599     }

   600 }

   601 

   602 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QRect &val)

   603 {

   604     valueChanged(property, QVariant(val));

   605 }

   606 

   607 void QtVariantPropertyManagerPrivate::slotConstraintChanged(QtProperty *property, const QRect &constraint)

   608 {

   609     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   610         emit q_ptr->attributeChanged(varProp, m_constraintAttribute, QVariant(constraint));

   611 }

   612 

   613 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QRectF &val)

   614 {

   615     valueChanged(property, QVariant(val));

   616 }

   617 

   618 void QtVariantPropertyManagerPrivate::slotConstraintChanged(QtProperty *property, const QRectF &constraint)

   619 {

   620     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   621         emit q_ptr->attributeChanged(varProp, m_constraintAttribute, QVariant(constraint));

   622 }

   623 

   624 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QColor &val)

   625 {

   626     valueChanged(property, QVariant(val));

   627 }

   628 

   629 void QtVariantPropertyManagerPrivate::slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames)

   630 {

   631     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   632         emit q_ptr->attributeChanged(varProp, m_enumNamesAttribute, QVariant(enumNames));

   633 }

   634 

   635 void QtVariantPropertyManagerPrivate::slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons)

   636 {

   637     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

   638         QVariant v;

   639         qVariantSetValue(v, enumIcons);

   640         emit q_ptr->attributeChanged(varProp, m_enumIconsAttribute, v);

   641     }

   642 }

   643 

   644 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSizePolicy &val)

   645 {

   646     valueChanged(property, QVariant(val));

   647 }

   648 

   649 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QFont &val)

   650 {

   651     valueChanged(property, QVariant(val));

   652 }

   653 

   654 void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QCursor &val)

   655 {

   656 #ifndef QT_NO_CURSOR

   657     valueChanged(property, QVariant(val));

   658 #endif

   659 }

   660 

   661 void QtVariantPropertyManagerPrivate::slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames)

   662 {

   663     if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

   664         emit q_ptr->attributeChanged(varProp, m_flagNamesAttribute, QVariant(flagNames));

   665 }

   666 

   667 /*!

   668     \class QtVariantPropertyManager

   669     \internal

   670     \inmodule QtDesigner

   671     \since 4.4

   672 

   673     \brief The QtVariantPropertyManager class provides and manages QVariant based properties.

   674 

   675     QtVariantPropertyManager provides the addProperty() function which

   676     creates QtVariantProperty objects. The QtVariantProperty class is

   677     a convenience class handling QVariant based properties inheriting

   678     QtProperty. A QtProperty object created by a

   679     QtVariantPropertyManager instance can be converted into a

   680     QtVariantProperty object using the variantProperty() function.

   681 

   682     The property's value can be retrieved using the value(), and set

   683     using the setValue() slot. In addition the property's type, and

   684     the type of its value, can be retrieved using the propertyType()

   685     and valueType() functions respectively.

   686 

   687     A property's type is a QVariant::Type enumerator value, and

   688     usually a property's type is the same as its value type. But for

   689     some properties the types differ, for example for enums, flags and

   690     group types in which case QtVariantPropertyManager provides the

   691     enumTypeId(), flagTypeId() and groupTypeId() functions,

   692     respectively, to identify their property type (the value types are

   693     QVariant::Int for the enum and flag types, and QVariant::Invalid

   694     for the group type).

   695 

   696     Use the isPropertyTypeSupported() function to check if a particular

   697     property type is supported. The currently supported property types

   698     are:

   699 

   700     \table

   701     \header

   702         \o Property Type

   703         \o Property Type Id

   704     \row

   705         \o int

   706         \o QVariant::Int

   707     \row

   708         \o double

   709         \o QVariant::Double

   710     \row

   711         \o bool

   712         \o QVariant::Bool

   713     \row

   714         \o QString

   715         \o QVariant::String

   716     \row

   717         \o QDate

   718         \o QVariant::Date

   719     \row

   720         \o QTime

   721         \o QVariant::Time

   722     \row

   723         \o QDateTime

   724         \o QVariant::DateTime

   725     \row

   726         \o QKeySequence

   727         \o QVariant::KeySequence

   728     \row

   729         \o QChar

   730         \o QVariant::Char

   731     \row

   732         \o QLocale

   733         \o QVariant::Locale

   734     \row

   735         \o QPoint

   736         \o QVariant::Point

   737     \row

   738         \o QPointF

   739         \o QVariant::PointF

   740     \row

   741         \o QSize

   742         \o QVariant::Size

   743     \row

   744         \o QSizeF

   745         \o QVariant::SizeF

   746     \row

   747         \o QRect

   748         \o QVariant::Rect

   749     \row

   750         \o QRectF

   751         \o QVariant::RectF

   752     \row

   753         \o QColor

   754         \o QVariant::Color

   755     \row

   756         \o QSizePolicy

   757         \o QVariant::SizePolicy

   758     \row

   759         \o QFont

   760         \o QVariant::Font

   761     \row

   762         \o QCursor

   763         \o QVariant::Cursor

   764     \row

   765         \o enum

   766         \o enumTypeId()

   767     \row

   768         \o flag

   769         \o flagTypeId()

   770     \row

   771         \o group

   772         \o groupTypeId()

   773     \endtable

   774 

   775     Each property type can provide additional attributes,

   776     e.g. QVariant::Int and QVariant::Double provides minimum and

   777     maximum values. The currently supported attributes are:

   778 

   779     \table

   780     \header

   781         \o Property Type

   782         \o Attribute Name

   783         \o Attribute Type

   784     \row

   785         \o \c int

   786         \o minimum

   787         \o QVariant::Int

   788     \row

   789         \o

   790         \o maximum

   791         \o QVariant::Int

   792     \row

   793         \o

   794         \o singleStep

   795         \o QVariant::Int

   796     \row

   797         \o \c double

   798         \o minimum

   799         \o QVariant::Double

   800     \row

   801         \o

   802         \o maximum

   803         \o QVariant::Double

   804     \row

   805         \o

   806         \o singleStep

   807         \o QVariant::Double

   808     \row

   809         \o

   810         \o decimals

   811         \o QVariant::Int

   812     \row

   813         \o QString

   814         \o regExp

   815         \o QVariant::RegExp

   816     \row

   817         \o QDate

   818         \o minimum

   819         \o QVariant::Date

   820     \row

   821         \o

   822         \o maximum

   823         \o QVariant::Date

   824     \row

   825         \o QPointF

   826         \o decimals

   827         \o QVariant::Int

   828     \row

   829         \o QSize

   830         \o minimum

   831         \o QVariant::Size

   832     \row

   833         \o

   834         \o maximum

   835         \o QVariant::Size

   836     \row

   837         \o QSizeF

   838         \o minimum

   839         \o QVariant::SizeF

   840     \row

   841         \o

   842         \o maximum

   843         \o QVariant::SizeF

   844     \row

   845         \o

   846         \o decimals

   847         \o QVariant::Int

   848     \row

   849         \o QRect

   850         \o constraint

   851         \o QVariant::Rect

   852     \row

   853         \o QRectF

   854         \o constraint

   855         \o QVariant::RectF

   856     \row

   857         \o

   858         \o decimals

   859         \o QVariant::Int

   860     \row

   861         \o \c enum

   862         \o enumNames

   863         \o QVariant::StringList

   864     \row

   865         \o

   866         \o enumIcons

   867         \o iconMapTypeId()

   868     \row

   869         \o \c flag

   870         \o flagNames

   871         \o QVariant::StringList

   872     \endtable

   873 

   874     The attributes for a given property type can be retrieved using

   875     the attributes() function. Each attribute has a value type which

   876     can be retrieved using the attributeType() function, and a value

   877     accessible through the attributeValue() function. In addition, the

   878     value can be set using the setAttribute() slot.

   879 

   880     QtVariantManager also provides the valueChanged() signal which is

   881     emitted whenever a property created by this manager change, and

   882     the attributeChanged() signal which is emitted whenever an

   883     attribute of such a property changes.

   884 

   885     \sa QtVariantProperty, QtVariantEditorFactory

   886 */

   887 

   888 /*!

   889     \fn void QtVariantPropertyManager::valueChanged(QtProperty *property, const QVariant &value)

   890 

   891     This signal is emitted whenever a property created by this manager

   892     changes its value, passing a pointer to the \a property and the

   893     new \a value as parameters.

   894 

   895     \sa setValue()

   896 */

   897 

   898 /*!

   899     \fn void QtVariantPropertyManager::attributeChanged(QtProperty *property,

   900                 const QString &attribute, const QVariant &value)

   901 

   902     This signal is emitted whenever an attribute of a property created

   903     by this manager changes its value, passing a pointer to the \a

   904     property, the \a attribute and the new \a value as parameters.

   905 

   906     \sa setAttribute()

   907 */

   908 

   909 /*!

   910     Creates a manager with the given \a parent.

   911 */

   912 QtVariantPropertyManager::QtVariantPropertyManager(QObject *parent)

   913     : QtAbstractPropertyManager(parent), d_ptr(new QtVariantPropertyManagerPrivate)

   914 {

   915     d_ptr->q_ptr = this;

   916 

   917     d_ptr->m_creatingProperty = false;

   918     d_ptr->m_creatingSubProperties = false;

   919     d_ptr->m_destroyingSubProperties = false;

   920     d_ptr->m_propertyType = 0;

   921 

   922     // IntPropertyManager

   923     QtIntPropertyManager *intPropertyManager = new QtIntPropertyManager(this);

   924     d_ptr->m_typeToPropertyManager[QVariant::Int] = intPropertyManager;

   925     d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_minimumAttribute] = QVariant::Int;

   926     d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_maximumAttribute] = QVariant::Int;

   927     d_ptr->m_typeToAttributeToAttributeType[QVariant::Int][d_ptr->m_singleStepAttribute] = QVariant::Int;

   928     d_ptr->m_typeToValueType[QVariant::Int] = QVariant::Int;

   929     connect(intPropertyManager, SIGNAL(valueChanged(QtProperty *, int)),

   930                 this, SLOT(slotValueChanged(QtProperty *, int)));

   931     connect(intPropertyManager, SIGNAL(rangeChanged(QtProperty *, int, int)),

   932                 this, SLOT(slotRangeChanged(QtProperty *, int, int)));

   933     connect(intPropertyManager, SIGNAL(singleStepChanged(QtProperty *, int)),

   934                 this, SLOT(slotSingleStepChanged(QtProperty *, int)));

   935     // DoublePropertyManager

   936     QtDoublePropertyManager *doublePropertyManager = new QtDoublePropertyManager(this);

   937     d_ptr->m_typeToPropertyManager[QVariant::Double] = doublePropertyManager;

   938     d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_minimumAttribute] =

   939             QVariant::Double;

   940     d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_maximumAttribute] =

   941             QVariant::Double;

   942     d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_singleStepAttribute] =

   943             QVariant::Double;

   944     d_ptr->m_typeToAttributeToAttributeType[QVariant::Double][d_ptr->m_decimalsAttribute] =

   945             QVariant::Int;

   946     d_ptr->m_typeToValueType[QVariant::Double] = QVariant::Double;

   947     connect(doublePropertyManager, SIGNAL(valueChanged(QtProperty *, double)),

   948                 this, SLOT(slotValueChanged(QtProperty *, double)));

   949     connect(doublePropertyManager, SIGNAL(rangeChanged(QtProperty *, double, double)),

   950                 this, SLOT(slotRangeChanged(QtProperty *, double, double)));

   951     connect(doublePropertyManager, SIGNAL(singleStepChanged(QtProperty *, double)),

   952                 this, SLOT(slotSingleStepChanged(QtProperty *, double)));

   953     connect(doublePropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),

   954                 this, SLOT(slotDecimalsChanged(QtProperty *, int)));

   955     // BoolPropertyManager

   956     QtBoolPropertyManager *boolPropertyManager = new QtBoolPropertyManager(this);

   957     d_ptr->m_typeToPropertyManager[QVariant::Bool] = boolPropertyManager;

   958     d_ptr->m_typeToValueType[QVariant::Bool] = QVariant::Bool;

   959     connect(boolPropertyManager, SIGNAL(valueChanged(QtProperty *, bool)),

   960                 this, SLOT(slotValueChanged(QtProperty *, bool)));

   961     // StringPropertyManager

   962     QtStringPropertyManager *stringPropertyManager = new QtStringPropertyManager(this);

   963     d_ptr->m_typeToPropertyManager[QVariant::String] = stringPropertyManager;

   964     d_ptr->m_typeToValueType[QVariant::String] = QVariant::String;

   965     d_ptr->m_typeToAttributeToAttributeType[QVariant::String][d_ptr->m_regExpAttribute] =

   966             QVariant::RegExp;

   967     connect(stringPropertyManager, SIGNAL(valueChanged(QtProperty *, const QString &)),

   968                 this, SLOT(slotValueChanged(QtProperty *, const QString &)));

   969     connect(stringPropertyManager, SIGNAL(regExpChanged(QtProperty *, const QRegExp &)),

   970                 this, SLOT(slotRegExpChanged(QtProperty *, const QRegExp &)));

   971     // DatePropertyManager

   972     QtDatePropertyManager *datePropertyManager = new QtDatePropertyManager(this);

   973     d_ptr->m_typeToPropertyManager[QVariant::Date] = datePropertyManager;

   974     d_ptr->m_typeToValueType[QVariant::Date] = QVariant::Date;

   975     d_ptr->m_typeToAttributeToAttributeType[QVariant::Date][d_ptr->m_minimumAttribute] =

   976             QVariant::Date;

   977     d_ptr->m_typeToAttributeToAttributeType[QVariant::Date][d_ptr->m_maximumAttribute] =

   978             QVariant::Date;

   979     connect(datePropertyManager, SIGNAL(valueChanged(QtProperty *, const QDate &)),

   980                 this, SLOT(slotValueChanged(QtProperty *, const QDate &)));

   981     connect(datePropertyManager, SIGNAL(rangeChanged(QtProperty *, const QDate &, const QDate &)),

   982                 this, SLOT(slotRangeChanged(QtProperty *, const QDate &, const QDate &)));

   983     // TimePropertyManager

   984     QtTimePropertyManager *timePropertyManager = new QtTimePropertyManager(this);

   985     d_ptr->m_typeToPropertyManager[QVariant::Time] = timePropertyManager;

   986     d_ptr->m_typeToValueType[QVariant::Time] = QVariant::Time;

   987     connect(timePropertyManager, SIGNAL(valueChanged(QtProperty *, const QTime &)),

   988                 this, SLOT(slotValueChanged(QtProperty *, const QTime &)));

   989     // DateTimePropertyManager

   990     QtDateTimePropertyManager *dateTimePropertyManager = new QtDateTimePropertyManager(this);

   991     d_ptr->m_typeToPropertyManager[QVariant::DateTime] = dateTimePropertyManager;

   992     d_ptr->m_typeToValueType[QVariant::DateTime] = QVariant::DateTime;

   993     connect(dateTimePropertyManager, SIGNAL(valueChanged(QtProperty *, const QDateTime &)),

   994                 this, SLOT(slotValueChanged(QtProperty *, const QDateTime &)));

   995     // KeySequencePropertyManager

   996     QtKeySequencePropertyManager *keySequencePropertyManager = new QtKeySequencePropertyManager(this);

   997     d_ptr->m_typeToPropertyManager[QVariant::KeySequence] = keySequencePropertyManager;

   998     d_ptr->m_typeToValueType[QVariant::KeySequence] = QVariant::KeySequence;

   999     connect(keySequencePropertyManager, SIGNAL(valueChanged(QtProperty *, const QKeySequence &)),

  1000                 this, SLOT(slotValueChanged(QtProperty *, const QKeySequence &)));

  1001     // CharPropertyManager

  1002     QtCharPropertyManager *charPropertyManager = new QtCharPropertyManager(this);

  1003     d_ptr->m_typeToPropertyManager[QVariant::Char] = charPropertyManager;

  1004     d_ptr->m_typeToValueType[QVariant::Char] = QVariant::Char;

  1005     connect(charPropertyManager, SIGNAL(valueChanged(QtProperty *, const QChar &)),

  1006                 this, SLOT(slotValueChanged(QtProperty *, const QChar &)));

  1007     // LocalePropertyManager

  1008     QtLocalePropertyManager *localePropertyManager = new QtLocalePropertyManager(this);

  1009     d_ptr->m_typeToPropertyManager[QVariant::Locale] = localePropertyManager;

  1010     d_ptr->m_typeToValueType[QVariant::Locale] = QVariant::Locale;

  1011     connect(localePropertyManager, SIGNAL(valueChanged(QtProperty *, const QLocale &)),

  1012                 this, SLOT(slotValueChanged(QtProperty *, const QLocale &)));

  1013     connect(localePropertyManager->subEnumPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),

  1014                 this, SLOT(slotValueChanged(QtProperty *, int)));

  1015     connect(localePropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1016                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1017     connect(localePropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1018                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1019     // PointPropertyManager

  1020     QtPointPropertyManager *pointPropertyManager = new QtPointPropertyManager(this);

  1021     d_ptr->m_typeToPropertyManager[QVariant::Point] = pointPropertyManager;

  1022     d_ptr->m_typeToValueType[QVariant::Point] = QVariant::Point;

  1023     connect(pointPropertyManager, SIGNAL(valueChanged(QtProperty *, const QPoint &)),

  1024                 this, SLOT(slotValueChanged(QtProperty *, const QPoint &)));

  1025     connect(pointPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),

  1026                 this, SLOT(slotValueChanged(QtProperty *, int)));

  1027     connect(pointPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1028                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1029     connect(pointPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1030                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1031     // PointFPropertyManager

  1032     QtPointFPropertyManager *pointFPropertyManager = new QtPointFPropertyManager(this);

  1033     d_ptr->m_typeToPropertyManager[QVariant::PointF] = pointFPropertyManager;

  1034     d_ptr->m_typeToValueType[QVariant::PointF] = QVariant::PointF;

  1035     d_ptr->m_typeToAttributeToAttributeType[QVariant::PointF][d_ptr->m_decimalsAttribute] =

  1036             QVariant::Int;

  1037     connect(pointFPropertyManager, SIGNAL(valueChanged(QtProperty *, const QPointF &)),

  1038                 this, SLOT(slotValueChanged(QtProperty *, const QPointF &)));

  1039     connect(pointFPropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),

  1040                 this, SLOT(slotDecimalsChanged(QtProperty *, int)));

  1041     connect(pointFPropertyManager->subDoublePropertyManager(), SIGNAL(valueChanged(QtProperty *, double)),

  1042                 this, SLOT(slotValueChanged(QtProperty *, double)));

  1043     connect(pointFPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1044                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1045     connect(pointFPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1046                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1047     // SizePropertyManager

  1048     QtSizePropertyManager *sizePropertyManager = new QtSizePropertyManager(this);

  1049     d_ptr->m_typeToPropertyManager[QVariant::Size] = sizePropertyManager;

  1050     d_ptr->m_typeToValueType[QVariant::Size] = QVariant::Size;

  1051     d_ptr->m_typeToAttributeToAttributeType[QVariant::Size][d_ptr->m_minimumAttribute] =

  1052             QVariant::Size;

  1053     d_ptr->m_typeToAttributeToAttributeType[QVariant::Size][d_ptr->m_maximumAttribute] =

  1054             QVariant::Size;

  1055     connect(sizePropertyManager, SIGNAL(valueChanged(QtProperty *, const QSize &)),

  1056                 this, SLOT(slotValueChanged(QtProperty *, const QSize &)));

  1057     connect(sizePropertyManager, SIGNAL(rangeChanged(QtProperty *, const QSize &, const QSize &)),

  1058                 this, SLOT(slotRangeChanged(QtProperty *, const QSize &, const QSize &)));

  1059     connect(sizePropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),

  1060                 this, SLOT(slotValueChanged(QtProperty *, int)));

  1061     connect(sizePropertyManager->subIntPropertyManager(), SIGNAL(rangeChanged(QtProperty *, int, int)),

  1062                 this, SLOT(slotRangeChanged(QtProperty *, int, int)));

  1063     connect(sizePropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1064                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1065     connect(sizePropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1066                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1067     // SizeFPropertyManager

  1068     QtSizeFPropertyManager *sizeFPropertyManager = new QtSizeFPropertyManager(this);

  1069     d_ptr->m_typeToPropertyManager[QVariant::SizeF] = sizeFPropertyManager;

  1070     d_ptr->m_typeToValueType[QVariant::SizeF] = QVariant::SizeF;

  1071     d_ptr->m_typeToAttributeToAttributeType[QVariant::SizeF][d_ptr->m_minimumAttribute] =

  1072             QVariant::SizeF;

  1073     d_ptr->m_typeToAttributeToAttributeType[QVariant::SizeF][d_ptr->m_maximumAttribute] =

  1074             QVariant::SizeF;

  1075     d_ptr->m_typeToAttributeToAttributeType[QVariant::SizeF][d_ptr->m_decimalsAttribute] =

  1076             QVariant::Int;

  1077     connect(sizeFPropertyManager, SIGNAL(valueChanged(QtProperty *, const QSizeF &)),

  1078                 this, SLOT(slotValueChanged(QtProperty *, const QSizeF &)));

  1079     connect(sizeFPropertyManager, SIGNAL(rangeChanged(QtProperty *, const QSizeF &, const QSizeF &)),

  1080                 this, SLOT(slotRangeChanged(QtProperty *, const QSizeF &, const QSizeF &)));

  1081     connect(sizeFPropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),

  1082                 this, SLOT(slotDecimalsChanged(QtProperty *, int)));

  1083     connect(sizeFPropertyManager->subDoublePropertyManager(), SIGNAL(valueChanged(QtProperty *, double)),

  1084                 this, SLOT(slotValueChanged(QtProperty *, double)));

  1085     connect(sizeFPropertyManager->subDoublePropertyManager(), SIGNAL(rangeChanged(QtProperty *, double, double)),

  1086                 this, SLOT(slotRangeChanged(QtProperty *, double, double)));

  1087     connect(sizeFPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1088                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1089     connect(sizeFPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1090                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1091     // RectPropertyManager

  1092     QtRectPropertyManager *rectPropertyManager = new QtRectPropertyManager(this);

  1093     d_ptr->m_typeToPropertyManager[QVariant::Rect] = rectPropertyManager;

  1094     d_ptr->m_typeToValueType[QVariant::Rect] = QVariant::Rect;

  1095     d_ptr->m_typeToAttributeToAttributeType[QVariant::Rect][d_ptr->m_constraintAttribute] =

  1096             QVariant::Rect;

  1097     connect(rectPropertyManager, SIGNAL(valueChanged(QtProperty *, const QRect &)),

  1098                 this, SLOT(slotValueChanged(QtProperty *, const QRect &)));

  1099     connect(rectPropertyManager, SIGNAL(constraintChanged(QtProperty *, const QRect &)),

  1100                 this, SLOT(slotConstraintChanged(QtProperty *, const QRect &)));

  1101     connect(rectPropertyManager->subIntPropertyManager(), SIGNAL(valueChanged(QtProperty *, int)),

  1102                 this, SLOT(slotValueChanged(QtProperty *, int)));

  1103     connect(rectPropertyManager->subIntPropertyManager(), SIGNAL(rangeChanged(QtProperty *, int, int)),

  1104                 this, SLOT(slotRangeChanged(QtProperty *, int, int)));

  1105     connect(rectPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1106                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1107     connect(rectPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1108                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1109     // RectFPropertyManager

  1110     QtRectFPropertyManager *rectFPropertyManager = new QtRectFPropertyManager(this);

  1111     d_ptr->m_typeToPropertyManager[QVariant::RectF] = rectFPropertyManager;

  1112     d_ptr->m_typeToValueType[QVariant::RectF] = QVariant::RectF;

  1113     d_ptr->m_typeToAttributeToAttributeType[QVariant::RectF][d_ptr->m_constraintAttribute] =

  1114             QVariant::RectF;

  1115     d_ptr->m_typeToAttributeToAttributeType[QVariant::RectF][d_ptr->m_decimalsAttribute] =

  1116             QVariant::Int;

  1117     connect(rectFPropertyManager, SIGNAL(valueChanged(QtProperty *, const QRectF &)),

  1118                 this, SLOT(slotValueChanged(QtProperty *, const QRectF &)));

  1119     connect(rectFPropertyManager, SIGNAL(constraintChanged(QtProperty *, const QRectF &)),

  1120                 this, SLOT(slotConstraintChanged(QtProperty *, const QRectF &)));

  1121     connect(rectFPropertyManager, SIGNAL(decimalsChanged(QtProperty *, int)),

  1122                 this, SLOT(slotDecimalsChanged(QtProperty *, int)));

  1123     connect(rectFPropertyManager->subDoublePropertyManager(), SIGNAL(valueChanged(QtProperty *, double)),

  1124                 this, SLOT(slotValueChanged(QtProperty *, double)));

  1125     connect(rectFPropertyManager->subDoublePropertyManager(), SIGNAL(rangeChanged(QtProperty *, double, double)),

  1126                 this, SLOT(slotRangeChanged(QtProperty *, double, double)));

  1127     connect(rectFPropertyManager, SIGNAL(propertyInserted(QtProperty *, QtProperty *, QtProperty *)),

  1128                 this, SLOT(slotPropertyInserted(QtProperty *, QtProperty *, QtProperty *)));

  1129     connect(rectFPropertyManager, SIGNAL(propertyRemoved(QtProperty *, QtProperty *)),

  1130                 this, SLOT(slotPropertyRemoved(QtProperty *, QtProperty *)));

  1131     // ColorPropertyManager

  1132     QtColorPropertyManager *colorPropertyManager = new QtColorPropertyManager(this);

  1133     d_ptr->m_typeToPropertyManager[QVariant::Color] = colorPropertyManager;

  1134     d_ptr->m_typeToValueType[QVariant::Color] = QVariant::Color;