qt/qttools/src/shared/qtpropertybrowser/qtvariantproperty.cpp

Revision control

Copy as Markdown

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qtvariantproperty_p.h"
#include "qtpropertymanager_p.h"
#include "qteditorfactory_p.h"
#include <QtCore/qdatetime.h>
#include <QtCore/qhash.h>
#include <QtCore/qlocale.h>
#include <QtCore/qmap.h>
#include <QtCore/qregularexpression.h>
#include <QtCore/qvariant.h>
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
using QtIconMap = QMap<int, QIcon>;
class QtEnumPropertyType
{
};
class QtFlagPropertyType
{
};
class QtGroupPropertyType
{
};
QT_END_NAMESPACE
Q_DECLARE_METATYPE(QtEnumPropertyType)
Q_DECLARE_METATYPE(QtFlagPropertyType)
Q_DECLARE_METATYPE(QtGroupPropertyType)
QT_BEGIN_NAMESPACE
/*!
Returns the type id for an enum property.
Note that the property's value type can be retrieved using the
valueType() function (which is QMetaType::Int for the enum property
type).
\sa propertyType(), valueType()
*/
int QtVariantPropertyManager::enumTypeId()
{
return qMetaTypeId<QtEnumPropertyType>();
}
/*!
Returns the type id for a flag property.
Note that the property's value type can be retrieved using the
valueType() function (which is QMetaType::Int for the flag property
type).
\sa propertyType(), valueType()
*/
int QtVariantPropertyManager::flagTypeId()
{
return qMetaTypeId<QtFlagPropertyType>();
}
/*!
Returns the type id for a group property.
Note that the property's value type can be retrieved using the
valueType() function (which is QMetaType::UnknownType for the group
property type, since it doesn't provide any value).
\sa propertyType(), valueType()
*/
int QtVariantPropertyManager::groupTypeId()
{
return qMetaTypeId<QtGroupPropertyType>();
}
/*!
Returns the type id for a icon map attribute.
Note that the property's attribute type can be retrieved using the
attributeType() function.
\sa attributeType(), QtEnumPropertyManager::enumIcons()
*/
int QtVariantPropertyManager::iconMapTypeId()
{
return qMetaTypeId<QtIconMap>();
}
using PropertyPropertyMap = QHash<const QtProperty *, QtProperty *>;
Q_GLOBAL_STATIC(PropertyPropertyMap, propertyToWrappedProperty)
static QtProperty *wrappedProperty(QtProperty *property)
{
return propertyToWrappedProperty()->value(property, nullptr);
}
class QtVariantPropertyPrivate
{
public:
QtVariantPropertyPrivate(QtVariantPropertyManager *m) : manager(m) {}
QtVariantPropertyManager *manager;
};
/*!
\class QtVariantProperty
\internal
\inmodule QtDesigner
\since 4.4
\brief The QtVariantProperty class is a convenience class handling
QVariant based properties.
QtVariantProperty provides additional API: A property's type,
value type, attribute values and current value can easily be
retrieved using the propertyType(), valueType(), attributeValue()
and value() functions respectively. In addition, the attribute
values and the current value can be set using the corresponding
setValue() and setAttribute() functions.
For example, instead of writing:
\snippet doc/src/snippets/code/tools_shared_qtpropertybrowser_qtvariantproperty.cpp 0
you can write:
\snippet doc/src/snippets/code/tools_shared_qtpropertybrowser_qtvariantproperty.cpp 1
QtVariantProperty instances can only be created by the
QtVariantPropertyManager class.
\sa QtProperty, QtVariantPropertyManager, QtVariantEditorFactory
*/
/*!
Creates a variant property using the given \a manager.
Do not use this constructor to create variant property instances;
use the QtVariantPropertyManager::addProperty() function
instead. This constructor is used internally by the
QtVariantPropertyManager::createProperty() function.
\sa QtVariantPropertyManager
*/
QtVariantProperty::QtVariantProperty(QtVariantPropertyManager *manager)
: QtProperty(manager), d_ptr(new QtVariantPropertyPrivate(manager))
{
}
/*!
Destroys this property.
\sa QtProperty::~QtProperty()
*/
QtVariantProperty::~QtVariantProperty() = default;
/*!
Returns the property's current value.
\sa valueType(), setValue()
*/
QVariant QtVariantProperty::value() const
{
return d_ptr->manager->value(this);
}
/*!
Returns this property's value for the specified \a attribute.
QtVariantPropertyManager provides a couple of related functions:
\l{QtVariantPropertyManager::attributes()}{attributes()} and
\l{QtVariantPropertyManager::attributeType()}{attributeType()}.
\sa setAttribute()
*/
QVariant QtVariantProperty::attributeValue(const QString &attribute) const
{
return d_ptr->manager->attributeValue(this, attribute);
}
/*!
Returns the type of this property's value.
\sa propertyType()
*/
int QtVariantProperty::valueType() const
{
return d_ptr->manager->valueType(this);
}
/*!
Returns this property's type.
QtVariantPropertyManager provides several related functions:
\l{QtVariantPropertyManager::enumTypeId()}{enumTypeId()},
\l{QtVariantPropertyManager::flagTypeId()}{flagTypeId()} and
\l{QtVariantPropertyManager::groupTypeId()}{groupTypeId()}.
\sa valueType()
*/
int QtVariantProperty::propertyType() const
{
return d_ptr->manager->propertyType(this);
}
/*!
Sets the value of this property to \a value.
The specified \a value must be of the type returned by
valueType(), or of a type that can be converted to valueType()
using the QVariant::canConvert() function; otherwise this function
does nothing.
\sa value()
*/
void QtVariantProperty::setValue(const QVariant &value)
{
d_ptr->manager->setValue(this, value);
}
/*!
Sets the \a attribute of property to \a value.
QtVariantPropertyManager provides the related
\l{QtVariantPropertyManager::setAttribute()}{setAttribute()}
function.
\sa attributeValue()
*/
void QtVariantProperty::setAttribute(const QString &attribute, const QVariant &value)
{
d_ptr->manager->setAttribute(this, attribute, value);
}
class QtVariantPropertyManagerPrivate
{
QtVariantPropertyManager *q_ptr;
Q_DECLARE_PUBLIC(QtVariantPropertyManager)
public:
QtVariantPropertyManagerPrivate();
bool m_creatingProperty;
bool m_creatingSubProperties;
bool m_destroyingSubProperties;
int m_propertyType;
void slotValueChanged(QtProperty *property, int val);
void slotRangeChanged(QtProperty *property, int min, int max);
void slotSingleStepChanged(QtProperty *property, int step);
void slotValueChanged(QtProperty *property, double val);
void slotRangeChanged(QtProperty *property, double min, double max);
void slotSingleStepChanged(QtProperty *property, double step);
void slotDecimalsChanged(QtProperty *property, int prec);
void slotValueChanged(QtProperty *property, bool val);
void slotValueChanged(QtProperty *property, const QString &val);
void slotRegExpChanged(QtProperty *property, const QRegularExpression &regExp);
void slotValueChanged(QtProperty *property, QDate val);
void slotRangeChanged(QtProperty *property, QDate min, QDate max);
void slotValueChanged(QtProperty *property, QTime val);
void slotValueChanged(QtProperty *property, const QDateTime &val);
void slotValueChanged(QtProperty *property, const QKeySequence &val);
void slotValueChanged(QtProperty *property, const QChar &val);
void slotValueChanged(QtProperty *property, const QLocale &val);
void slotValueChanged(QtProperty *property, QPoint val);
void slotValueChanged(QtProperty *property, QPointF val);
void slotValueChanged(QtProperty *property, QSize val);
void slotRangeChanged(QtProperty *property, QSize min, QSize max);
void slotValueChanged(QtProperty *property, const QSizeF &val);
void slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max);
void slotValueChanged(QtProperty *property, QRect val);
void slotConstraintChanged(QtProperty *property, QRect val);
void slotValueChanged(QtProperty *property, const QRectF &val);
void slotConstraintChanged(QtProperty *property, const QRectF &val);
void slotValueChanged(QtProperty *property, const QColor &val);
void slotEnumChanged(QtProperty *property, int val);
void slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames);
void slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons);
void slotValueChanged(QtProperty *property, QSizePolicy val);
void slotValueChanged(QtProperty *property, const QFont &val);
void slotValueChanged(QtProperty *property, const QCursor &val);
void slotFlagChanged(QtProperty *property, int val);
void slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames);
void slotPropertyInserted(QtProperty *property, QtProperty *parent, QtProperty *after);
void slotPropertyRemoved(QtProperty *property, QtProperty *parent);
void valueChanged(QtProperty *property, const QVariant &val);
static int internalPropertyToType(QtProperty *property);
QtVariantProperty *createSubProperty(QtVariantProperty *parent, QtVariantProperty *after,
QtProperty *internal);
void removeSubProperty(QtVariantProperty *property);
QMap<int, QtAbstractPropertyManager *> m_typeToPropertyManager;
QMap<int, QMap<QString, int> > m_typeToAttributeToAttributeType;
QHash<const QtProperty *, std::pair<QtVariantProperty *, int>> m_propertyToType;
QMap<int, int> m_typeToValueType;
QHash<QtProperty *, QtVariantProperty *> m_internalToProperty;
const QString m_constraintAttribute;
const QString m_singleStepAttribute;
const QString m_decimalsAttribute;
const QString m_enumIconsAttribute;
const QString m_enumNamesAttribute;
const QString m_flagNamesAttribute;
const QString m_maximumAttribute;
const QString m_minimumAttribute;
const QString m_regExpAttribute;
};
QtVariantPropertyManagerPrivate::QtVariantPropertyManagerPrivate() :
m_constraintAttribute("constraint"_L1),
m_singleStepAttribute("singleStep"_L1),
m_decimalsAttribute("decimals"_L1),
m_enumIconsAttribute("enumIcons"_L1),
m_enumNamesAttribute("enumNames"_L1),
m_flagNamesAttribute("flagNames"_L1),
m_maximumAttribute("maximum"_L1),
m_minimumAttribute("minimum"_L1),
m_regExpAttribute("regExp"_L1)
{
}
int QtVariantPropertyManagerPrivate::internalPropertyToType(QtProperty *property)
{
int type = 0;
QtAbstractPropertyManager *internPropertyManager = property->propertyManager();
if (qobject_cast<QtIntPropertyManager *>(internPropertyManager))
type = QMetaType::Int;
else if (qobject_cast<QtEnumPropertyManager *>(internPropertyManager))
type = QtVariantPropertyManager::enumTypeId();
else if (qobject_cast<QtBoolPropertyManager *>(internPropertyManager))
type = QMetaType::Bool;
else if (qobject_cast<QtDoublePropertyManager *>(internPropertyManager))
type = QMetaType::Double;
return type;
}
QtVariantProperty *QtVariantPropertyManagerPrivate::createSubProperty(QtVariantProperty *parent,
QtVariantProperty *after, QtProperty *internal)
{
int type = internalPropertyToType(internal);
if (!type)
return nullptr;
bool wasCreatingSubProperties = m_creatingSubProperties;
m_creatingSubProperties = true;
QtVariantProperty *varChild = q_ptr->addProperty(type, internal->propertyName());
m_creatingSubProperties = wasCreatingSubProperties;
varChild->setPropertyName(internal->propertyName());
varChild->setToolTip(internal->toolTip());
varChild->setStatusTip(internal->statusTip());
varChild->setWhatsThis(internal->whatsThis());
parent->insertSubProperty(varChild, after);
m_internalToProperty[internal] = varChild;
propertyToWrappedProperty()->insert(varChild, internal);
return varChild;
}
void QtVariantPropertyManagerPrivate::removeSubProperty(QtVariantProperty *property)
{
QtProperty *internChild = wrappedProperty(property);
bool wasDestroyingSubProperties = m_destroyingSubProperties;
m_destroyingSubProperties = true;
delete property;
m_destroyingSubProperties = wasDestroyingSubProperties;
m_internalToProperty.remove(internChild);
propertyToWrappedProperty()->remove(property);
}
void QtVariantPropertyManagerPrivate::slotPropertyInserted(QtProperty *property,
QtProperty *parent, QtProperty *after)
{
if (m_creatingProperty)
return;
QtVariantProperty *varParent = m_internalToProperty.value(parent, nullptr);
if (!varParent)
return;
QtVariantProperty *varAfter = nullptr;
if (after) {
varAfter = m_internalToProperty.value(after, nullptr);
if (!varAfter)
return;
}
createSubProperty(varParent, varAfter, property);
}
void QtVariantPropertyManagerPrivate::slotPropertyRemoved(QtProperty *property, QtProperty *parent)
{
Q_UNUSED(parent);
QtVariantProperty *varProperty = m_internalToProperty.value(property, nullptr);
if (!varProperty)
return;
removeSubProperty(varProperty);
}
void QtVariantPropertyManagerPrivate::valueChanged(QtProperty *property, const QVariant &val)
{
QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr);
if (!varProp)
return;
emit q_ptr->valueChanged(varProp, val);
emit q_ptr->propertyChanged(varProp);
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, int val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, int min, int max)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr)) {
emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
}
}
void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, int step)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, double val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, double min, double max)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr)) {
emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
}
}
void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, double step)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));
}
void QtVariantPropertyManagerPrivate::slotDecimalsChanged(QtProperty *property, int prec)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_decimalsAttribute, QVariant(prec));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, bool val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QString &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotRegExpChanged(QtProperty *property, const QRegularExpression &regExp)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_regExpAttribute, QVariant(regExp));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QDate val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, QDate min, QDate max)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr)) {
emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
}
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QTime val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QDateTime &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QKeySequence &val)
{
QVariant v;
v.setValue(val);
valueChanged(property, v);
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QChar &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QLocale &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QPoint val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QPointF val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QSize val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, QSize min, QSize max)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr)) {
emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
}
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QSizeF &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr)) {
emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));
emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));
}
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QRect val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotConstraintChanged(QtProperty *property, QRect constraint)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_constraintAttribute, QVariant(constraint));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QRectF &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotConstraintChanged(QtProperty *property, const QRectF &constraint)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_constraintAttribute, QVariant(constraint));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QColor &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_enumNamesAttribute, QVariant(enumNames));
}
void QtVariantPropertyManagerPrivate::slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr)) {
QVariant v;
v.setValue(enumIcons);
emit q_ptr->attributeChanged(varProp, m_enumIconsAttribute, v);
}
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, QSizePolicy val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QFont &val)
{
valueChanged(property, QVariant(val));
}
void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QCursor &val)
{
#ifndef QT_NO_CURSOR
valueChanged(property, QVariant(val));
#endif
}
void QtVariantPropertyManagerPrivate::slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames)
{
if (QtVariantProperty *varProp = m_internalToProperty.value(property, nullptr))
emit q_ptr->attributeChanged(varProp, m_flagNamesAttribute, QVariant(flagNames));
}
/*!
\class QtVariantPropertyManager
\internal
\inmodule QtDesigner
\since 4.4
\brief The QtVariantPropertyManager class provides and manages QVariant based properties.
QtVariantPropertyManager provides the addProperty() function which
creates QtVariantProperty objects. The QtVariantProperty class is
a convenience class handling QVariant based properties inheriting
QtProperty. A QtProperty object created by a
QtVariantPropertyManager instance can be converted into a
QtVariantProperty object using the variantProperty() function.
The property's value can be retrieved using the value(), and set
using the setValue() slot. In addition the property's type, and
the type of its value, can be retrieved using the propertyType()
and valueType() functions respectively.
A property's type is a QMetaType::QType enumerator value, and
usually a property's type is the same as its value type. But for
some properties the types differ, for example for enums, flags and
group types in which case QtVariantPropertyManager provides the
enumTypeId(), flagTypeId() and groupTypeId() functions,
respectively, to identify their property type (the value types are
QMetaType::Int for the enum and flag types, and QMetaType::UnknownType
for the group type).
Use the isPropertyTypeSupported() function to check if a particular
property type is supported. The currently supported property types
are:
\table
\header
\li Property Type
\li Property Type Id
\row
\li int
\li QMetaType::Int
\row
\li double
\li QMetaType::Double
\row
\li bool
\li QMetaType::Bool
\row
\li QString
\li QMetaType::QString
\row
\li QDate
\li QMetaType::QDate
\row
\li QTime
\li QMetaType::QTime
\row
\li QDateTime
\li QMetaType::QDateTime
\row
\li QKeySequence
\li QMetaType::QKeySequence
\row
\li QChar
\li QMetaType::QChar
\row
\li QLocale
\li QMetaType::QLocale
\row
\li QPoint
\li QMetaType::QPoint
\row
\li QPointF
\li QMetaType::QPointF
\row
\li QSize
\li QMetaType::QSize
\row
\li QSizeF
\li QMetaType::QSizeF
\row
\li QRect
\li QMetaType::QRect
\row
\li QRectF
\li QMetaType::QRectF
\row
\li QColor
\li QMetaType::QColor
\row
\li QSizePolicy
\li QMetaType::QSizePolicy
\row
\li QFont
\li QMetaType::QFont
\row
\li QCursor
\li QMetaType::QCursor
\row
\li enum
\li enumTypeId()
\row
\li flag
\li flagTypeId()
\row
\li group
\li groupTypeId()
\endtable
Each property type can provide additional attributes,
e.g. QMetaType::Int and QMetaType::Double provides minimum and
maximum values. The currently supported attributes are:
\table
\header
\li Property Type
\li Attribute Name
\li Attribute Type
\row
\li \c int
\li minimum
\li QMetaType::Int
\row
\li
\li maximum
\li QMetaType::Int
\row
\li
\li singleStep
\li QMetaType::Int
\row
\li \c double
\li minimum
\li QMetaType::Double
\row
\li
\li maximum
\li QMetaType::Double
\row
\li
\li singleStep
\li QMetaType::Double
\row
\li
\li decimals
\li QMetaType::Int
\row
\li QString
\li regExp
\li QMetaType::QRegExp
\row
\li QDate
\li minimum
\li QMetaType::QDate
\row
\li
\li maximum
\li QMetaType::QDate
\row
\li QPointF
\li decimals
\li QMetaType::Int
\row
\li QSize
\li minimum
\li QMetaType::QSize
\row
\li
\li maximum
\li QMetaType::QSize
\row
\li QSizeF
\li minimum
\li QMetaType::QSizeF
\row
\li
\li maximum
\li QMetaType::QSizeF
\row
\li
\li decimals
\li QMetaType::Int
\row
\li QRect
\li constraint
\li QMetaType::QRect
\row
\li QRectF
\li constraint
\li QMetaType::QRectF
\row
\li
\li decimals
\li QMetaType::Int
\row
\li \c enum
\li enumNames
\li QMetaType::QStringList
\row
\li
\li enumIcons
\li iconMapTypeId()
\row
\li \c flag
\li flagNames
\li QMetaType::QStringList
\endtable
The attributes for a given property type can be retrieved using
the attributes() function. Each attribute has a value type which
can be retrieved using the attributeType() function, and a value
accessible through the attributeValue() function. In addition, the
value can be set using the setAttribute() slot.
QtVariantManager also provides the valueChanged() signal which is
emitted whenever a property created by this manager change, and
the attributeChanged() signal which is emitted whenever an
attribute of such a property changes.
\sa QtVariantProperty, QtVariantEditorFactory
*/
/*!
\fn void QtVariantPropertyManager::valueChanged(QtProperty *property, const QVariant &value)
This signal is emitted whenever a property created by this manager
changes its value, passing a pointer to the \a property and the
new \a value as parameters.
\sa setValue()
*/
/*!
\fn void QtVariantPropertyManager::attributeChanged(QtProperty *property,
const QString &attribute, const QVariant &value)
This signal is emitted whenever an attribute of a property created
by this manager changes its value, passing a pointer to the \a
property, the \a attribute and the new \a value as parameters.
\sa setAttribute()
*/
/*!
Creates a manager with the given \a parent.
*/
QtVariantPropertyManager::QtVariantPropertyManager(QObject *parent)
: QtAbstractPropertyManager(parent), d_ptr(new QtVariantPropertyManagerPrivate)
{
d_ptr->q_ptr = this;
d_ptr->m_creatingProperty = false;
d_ptr->m_creatingSubProperties = false;
d_ptr->m_destroyingSubProperties = false;
d_ptr->m_propertyType = 0;
// IntPropertyManager
auto *intPropertyManager = new QtIntPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::Int] = intPropertyManager;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Int][d_ptr->m_minimumAttribute] = QMetaType::Int;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Int][d_ptr->m_maximumAttribute] = QMetaType::Int;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Int][d_ptr->m_singleStepAttribute] = QMetaType::Int;
d_ptr->m_typeToValueType[QMetaType::Int] = QMetaType::Int;
connect(intPropertyManager, &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(intPropertyManager, &QtIntPropertyManager::rangeChanged,
this, [this](QtProperty *property, int min, int max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(intPropertyManager, &QtIntPropertyManager::singleStepChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotSingleStepChanged(property, value); });
// DoublePropertyManager
auto *doublePropertyManager = new QtDoublePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::Double] = doublePropertyManager;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Double][d_ptr->m_minimumAttribute] =
QMetaType::Double;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Double][d_ptr->m_maximumAttribute] =
QMetaType::Double;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Double][d_ptr->m_singleStepAttribute] =
QMetaType::Double;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::Double][d_ptr->m_decimalsAttribute] =
QMetaType::Int;
d_ptr->m_typeToValueType[QMetaType::Double] = QMetaType::Double;
connect(doublePropertyManager, &QtDoublePropertyManager::valueChanged,
this, [this](QtProperty *property, double value)
{ d_ptr->slotValueChanged(property, value); });
connect(doublePropertyManager, &QtDoublePropertyManager::rangeChanged,
this, [this](QtProperty *property, double min, double max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(doublePropertyManager, &QtDoublePropertyManager::singleStepChanged,
this, [this](QtProperty *property, double value)
{ d_ptr->slotSingleStepChanged(property, value); });
connect(doublePropertyManager, &QtDoublePropertyManager::decimalsChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotDecimalsChanged(property, value); });
// BoolPropertyManager
auto *boolPropertyManager = new QtBoolPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::Bool] = boolPropertyManager;
d_ptr->m_typeToValueType[QMetaType::Bool] = QMetaType::Bool;
connect(boolPropertyManager, &QtBoolPropertyManager::valueChanged,
this, [this](QtProperty *property, bool value)
{ d_ptr->slotValueChanged(property, value); });
// StringPropertyManager
auto *stringPropertyManager = new QtStringPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QString] = stringPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QString] = QMetaType::QString;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QString][d_ptr->m_regExpAttribute] =
QMetaType::QRegularExpression;
connect(stringPropertyManager, &QtStringPropertyManager::valueChanged,
this, [this](QtProperty *property, const QString &value)
{ d_ptr->slotValueChanged(property, value); });
connect(stringPropertyManager, &QtStringPropertyManager::regExpChanged,
this, [this](QtProperty *property, const QRegularExpression &value)
{ d_ptr->slotRegExpChanged(property, value); });
// DatePropertyManager
auto *datePropertyManager = new QtDatePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QDate] = datePropertyManager;
d_ptr->m_typeToValueType[QMetaType::QDate] = QMetaType::QDate;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QDate][d_ptr->m_minimumAttribute] =
QMetaType::QDate;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QDate][d_ptr->m_maximumAttribute] =
QMetaType::QDate;
connect(datePropertyManager, &QtDatePropertyManager::valueChanged,
this, [this](QtProperty *property, const QDate &value)
{ d_ptr->slotValueChanged(property, value); });
connect(datePropertyManager, &QtDatePropertyManager::rangeChanged,
this, [this](QtProperty *property, const QDate &min, const QDate &max)
{ d_ptr->slotRangeChanged(property, min, max); });
// TimePropertyManager
auto *timePropertyManager = new QtTimePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QTime] = timePropertyManager;
d_ptr->m_typeToValueType[QMetaType::QTime] = QMetaType::QTime;
connect(timePropertyManager, &QtTimePropertyManager::valueChanged,
this, [this](QtProperty *property, const QTime &value)
{ d_ptr->slotValueChanged(property, value); });
// DateTimePropertyManager
auto *dateTimePropertyManager = new QtDateTimePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QDateTime] = dateTimePropertyManager;
d_ptr->m_typeToValueType[QMetaType::QDateTime] = QMetaType::QDateTime;
connect(dateTimePropertyManager, &QtDateTimePropertyManager::valueChanged,
this, [this](QtProperty *property, const QDateTime &value)
{ d_ptr->slotValueChanged(property, value); });
// KeySequencePropertyManager
auto *keySequencePropertyManager = new QtKeySequencePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QKeySequence] = keySequencePropertyManager;
d_ptr->m_typeToValueType[QMetaType::QKeySequence] = QMetaType::QKeySequence;
connect(keySequencePropertyManager, &QtKeySequencePropertyManager::valueChanged,
this, [this](QtProperty *property, const QKeySequence &value)
{ d_ptr->slotValueChanged(property, value); });
// CharPropertyManager
auto *charPropertyManager = new QtCharPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QChar] = charPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QChar] = QMetaType::QChar;
connect(charPropertyManager, &QtCharPropertyManager::valueChanged,
this, [this](QtProperty *property, const QChar &value)
{ d_ptr->slotValueChanged(property, value); });
// LocalePropertyManager
auto *localePropertyManager = new QtLocalePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QLocale] = localePropertyManager;
d_ptr->m_typeToValueType[QMetaType::QLocale] = QMetaType::QLocale;
connect(localePropertyManager, &QtLocalePropertyManager::valueChanged,
this, [this](QtProperty *property, const QLocale &value)
{ d_ptr->slotValueChanged(property, value); });
connect(localePropertyManager->subEnumPropertyManager(), &QtEnumPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(localePropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(localePropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// PointPropertyManager
auto *pointPropertyManager = new QtPointPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QPoint] = pointPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QPoint] = QMetaType::QPoint;
connect(pointPropertyManager, &QtPointPropertyManager::valueChanged,
this, [this](QtProperty *property, QPoint value)
{ d_ptr->slotValueChanged(property, value); });
connect(pointPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(pointPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(pointPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// PointFPropertyManager
auto *pointFPropertyManager = new QtPointFPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QPointF] = pointFPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QPointF] = QMetaType::QPointF;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QPointF][d_ptr->m_decimalsAttribute] =
QMetaType::Int;
connect(pointFPropertyManager, &QtPointFPropertyManager::valueChanged,
this, [this](QtProperty *property, QPointF value)
{ d_ptr->slotValueChanged(property, value); });
connect(pointFPropertyManager, &QtPointFPropertyManager::decimalsChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotDecimalsChanged(property, value); });
connect(pointFPropertyManager->subDoublePropertyManager(), &QtDoublePropertyManager::valueChanged,
this, [this](QtProperty *property, double value)
{ d_ptr->slotValueChanged(property, value); });
connect(pointFPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(pointFPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// SizePropertyManager
auto *sizePropertyManager = new QtSizePropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QSize] = sizePropertyManager;
d_ptr->m_typeToValueType[QMetaType::QSize] = QMetaType::QSize;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QSize][d_ptr->m_minimumAttribute] =
QMetaType::QSize;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QSize][d_ptr->m_maximumAttribute] =
QMetaType::QSize;
connect(sizePropertyManager, &QtSizePropertyManager::valueChanged,
this, [this](QtProperty *property, QSize value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizePropertyManager, &QtSizePropertyManager::rangeChanged,
this, [this](QtProperty *property, QSize min, QSize max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(sizePropertyManager->subIntPropertyManager(), &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizePropertyManager->subIntPropertyManager(), &QtIntPropertyManager::rangeChanged,
this, [this](QtProperty *property, int min, int max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(sizePropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(sizePropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// SizeFPropertyManager
auto *sizeFPropertyManager = new QtSizeFPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QSizeF] = sizeFPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QSizeF] = QMetaType::QSizeF;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QSizeF][d_ptr->m_minimumAttribute] =
QMetaType::QSizeF;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QSizeF][d_ptr->m_maximumAttribute] =
QMetaType::QSizeF;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QSizeF][d_ptr->m_decimalsAttribute] =
QMetaType::Int;
connect(sizeFPropertyManager, &QtSizeFPropertyManager::valueChanged,
this, [this](QtProperty *property, const QSizeF &value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizeFPropertyManager, &QtSizeFPropertyManager::rangeChanged,
this, [this](QtProperty *property, const QSizeF &min, const QSizeF &max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(sizeFPropertyManager->subDoublePropertyManager(), &QtDoublePropertyManager::valueChanged,
this, [this](QtProperty *property, double value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizeFPropertyManager->subDoublePropertyManager(), &QtDoublePropertyManager::rangeChanged,
this, [this](QtProperty *property, double min, double max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(sizeFPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(sizeFPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// RectPropertyManager
auto *rectPropertyManager = new QtRectPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QRect] = rectPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QRect] = QMetaType::QRect;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QRect][d_ptr->m_constraintAttribute] =
QMetaType::QRect;
connect(rectPropertyManager, &QtRectPropertyManager::valueChanged,
this, [this](QtProperty *property, QRect value)
{ d_ptr->slotValueChanged(property, value); });
connect(rectPropertyManager, &QtRectPropertyManager::constraintChanged,
this, [this](QtProperty *property, QRect value)
{ d_ptr->slotConstraintChanged(property, value); });
connect(rectPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(rectPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::rangeChanged,
this, [this](QtProperty *property, int min, int max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(rectPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(rectPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// RectFPropertyManager
auto *rectFPropertyManager = new QtRectFPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QRectF] = rectFPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QRectF] = QMetaType::QRectF;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QRectF][d_ptr->m_constraintAttribute] =
QMetaType::QRectF;
d_ptr->m_typeToAttributeToAttributeType[QMetaType::QRectF][d_ptr->m_decimalsAttribute] =
QMetaType::Int;
connect(rectFPropertyManager, &QtRectFPropertyManager::valueChanged,
this, [this](QtProperty *property, const QRectF &value)
{ d_ptr->slotValueChanged(property, value); });
connect(rectFPropertyManager, &QtRectFPropertyManager::constraintChanged,
this, [this](QtProperty *property, const QRectF &value)
{ d_ptr->slotConstraintChanged(property, value); });
connect(rectFPropertyManager->subDoublePropertyManager(), &QtDoublePropertyManager::valueChanged,
this, [this](QtProperty *property, double value)
{ d_ptr->slotValueChanged(property, value); });
connect(rectFPropertyManager->subDoublePropertyManager(), &QtDoublePropertyManager::rangeChanged,
this, [this](QtProperty *property, double min, double max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(rectFPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(rectFPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// ColorPropertyManager
auto *colorPropertyManager = new QtColorPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QColor] = colorPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QColor] = QMetaType::QColor;
connect(colorPropertyManager, &QtColorPropertyManager::valueChanged,
this, [this](QtProperty *property, const QColor &value)
{ d_ptr->slotValueChanged(property, value); });
connect(colorPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(colorPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(colorPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// EnumPropertyManager
int enumId = enumTypeId();
auto *enumPropertyManager = new QtEnumPropertyManager(this);
d_ptr->m_typeToPropertyManager[enumId] = enumPropertyManager;
d_ptr->m_typeToValueType[enumId] = QMetaType::Int;
d_ptr->m_typeToAttributeToAttributeType[enumId][d_ptr->m_enumNamesAttribute] =
QMetaType::QStringList;
d_ptr->m_typeToAttributeToAttributeType[enumId][d_ptr->m_enumIconsAttribute] =
iconMapTypeId();
connect(enumPropertyManager, &QtEnumPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(enumPropertyManager, &QtEnumPropertyManager::enumNamesChanged,
this, [this](QtProperty *property, const QStringList &value)
{ d_ptr->slotEnumNamesChanged(property, value); });
connect(enumPropertyManager, &QtEnumPropertyManager::enumIconsChanged,
this, [this](QtProperty *property, const QMap<int,QIcon> &value)
{ d_ptr->slotEnumIconsChanged(property, value); });
// SizePolicyPropertyManager
auto *sizePolicyPropertyManager = new QtSizePolicyPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QSizePolicy] = sizePolicyPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QSizePolicy] = QMetaType::QSizePolicy;
connect(sizePolicyPropertyManager, &QtSizePolicyPropertyManager::valueChanged,
this, [this](QtProperty *property, QSizePolicy value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizePolicyPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizePolicyPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::rangeChanged,
this, [this](QtProperty *property, int min, int max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(sizePolicyPropertyManager->subEnumPropertyManager(), &QtEnumPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(sizePolicyPropertyManager->subEnumPropertyManager(), &QtEnumPropertyManager::enumNamesChanged,
this, [this](QtProperty *property, const QStringList &value)
{ d_ptr->slotEnumNamesChanged(property, value); });
connect(sizePolicyPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(sizePolicyPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// FontPropertyManager
auto *fontPropertyManager = new QtFontPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QFont] = fontPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QFont] = QMetaType::QFont;
connect(fontPropertyManager, &QtFontPropertyManager::valueChanged,
this, [this](QtProperty *property, const QFont &value)
{ d_ptr->slotValueChanged(property, value); });
connect(fontPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(fontPropertyManager->subIntPropertyManager(), &QtIntPropertyManager::rangeChanged,
this, [this](QtProperty *property, int min, int max)
{ d_ptr->slotRangeChanged(property, min, max); });
connect(fontPropertyManager->subEnumPropertyManager(), &QtEnumPropertyManager::valueChanged,
this, [this](QtProperty *property, int value)
{ d_ptr->slotValueChanged(property, value); });
connect(fontPropertyManager->subEnumPropertyManager(), &QtEnumPropertyManager::enumNamesChanged,
this, [this](QtProperty *property, const QStringList &value)
{ d_ptr->slotEnumNamesChanged(property, value); });
connect(fontPropertyManager->subBoolPropertyManager(), &QtBoolPropertyManager::valueChanged,
this, [this](QtProperty *property, bool value)
{ d_ptr->slotValueChanged(property, value); });
connect(fontPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(fontPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// CursorPropertyManager
auto *cursorPropertyManager = new QtCursorPropertyManager(this);
d_ptr->m_typeToPropertyManager[QMetaType::QCursor] = cursorPropertyManager;
d_ptr->m_typeToValueType[QMetaType::QCursor] = QMetaType::QCursor;
connect(cursorPropertyManager, &QtCursorPropertyManager::valueChanged,
this, [this](QtProperty *property, const QCursor &value)
{ d_ptr->slotValueChanged(property, value); });
// FlagPropertyManager
int flagId = flagTypeId();
auto *flagPropertyManager = new QtFlagPropertyManager(this);
d_ptr->m_typeToPropertyManager[flagId] = flagPropertyManager;
d_ptr->m_typeToValueType[flagId] = QMetaType::Int;
d_ptr->m_typeToAttributeToAttributeType[flagId][d_ptr->m_flagNamesAttribute] =
QMetaType::QStringList;
connect(flagPropertyManager, &QtFlagPropertyManager::valueChanged,
this, [this](QtProperty *property, const QColor &value)
{ d_ptr->slotValueChanged(property, value); });
connect(flagPropertyManager, &QtFlagPropertyManager::flagNamesChanged,
this, [this](QtProperty *property, const QStringList &value)
{ d_ptr->slotFlagNamesChanged(property, value); });
connect(flagPropertyManager->subBoolPropertyManager(), &QtBoolPropertyManager::valueChanged,
this, [this](QtProperty *property, bool value)
{ d_ptr->slotValueChanged(property, value); });
connect(flagPropertyManager, &QtAbstractPropertyManager::propertyInserted,
this, [this](QtProperty *property, QtProperty *parent, QtProperty *after)
{ d_ptr->slotPropertyInserted(property, parent, after); });
connect(flagPropertyManager, &QtAbstractPropertyManager::propertyRemoved,
this, [this](QtProperty *property, QtProperty *parent)
{ d_ptr->slotPropertyRemoved(property, parent); });
// FlagPropertyManager
int groupId = groupTypeId();
auto *groupPropertyManager = new QtGroupPropertyManager(this);
d_ptr->m_typeToPropertyManager[groupId] = groupPropertyManager;
d_ptr->m_typeToValueType[groupId] = QMetaType::UnknownType;
}
/*!
Destroys this manager, and all the properties it has created.
*/
QtVariantPropertyManager::~QtVariantPropertyManager()
{
clear();
}
/*!
Returns the given \a property converted into a QtVariantProperty.
If the \a property was not created by this variant manager, the
function returns 0.
\sa createProperty()
*/
QtVariantProperty *QtVariantPropertyManager::variantProperty(const QtProperty *property) const
{
const auto it = d_ptr->m_propertyToType.constFind(property);
if (it == d_ptr->m_propertyToType.constEnd())
return nullptr;
return it.value().first;
}
/*!
Returns true if the given \a propertyType is supported by this
variant manager; otherwise false.
\sa propertyType()
*/
bool QtVariantPropertyManager::isPropertyTypeSupported(int propertyType) const
{
return d_ptr->m_typeToValueType.contains(propertyType);
}
/*!
Creates and returns a variant property of the given \a propertyType
with the given \a name.
If the specified \a propertyType is not supported by this variant
manager, this function returns 0.
Do not use the inherited
QtAbstractPropertyManager::addProperty() function to create a
variant property (that function will always return 0 since it will
not be clear what type the property should have).
\sa isPropertyTypeSupported()
*/
QtVariantProperty *QtVariantPropertyManager::addProperty(int propertyType, const QString &name)
{
if (!isPropertyTypeSupported(propertyType))
return nullptr;
bool wasCreating = d_ptr->m_creatingProperty;
d_ptr->m_creatingProperty = true;
d_ptr->m_propertyType = propertyType;
QtProperty *property = QtAbstractPropertyManager::addProperty(name);
d_ptr->m_creatingProperty = wasCreating;
d_ptr->m_propertyType = 0;
if (!property)
return nullptr;
return variantProperty(property);
}
/*!
Returns the given \a property's value.
If the given \a property is not managed by this manager, this
function returns an invalid variant.
\sa setValue()
*/
QVariant QtVariantPropertyManager::value(const QtProperty *property) const
{
QtProperty *internProp = propertyToWrappedProperty()->value(property, nullptr);
if (internProp == nullptr)
return {};
QtAbstractPropertyManager *manager = internProp->propertyManager();
if (auto *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
return intManager->value(internProp);
} else if (auto *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
return doubleManager->value(internProp);
} else if (auto *boolManager = qobject_cast<QtBoolPropertyManager *>(manager)) {
return boolManager->value(internProp);
} else if (auto *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
return stringManager->value(internProp);
} else if (auto *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
return dateManager->value(internProp);
} else if (auto *timeManager = qobject_cast<QtTimePropertyManager *>(manager)) {
return timeManager->value(internProp);
} else if (auto *dateTimeManager = qobject_cast<QtDateTimePropertyManager *>(manager)) {
return dateTimeManager->value(internProp);
} else if (auto *keySequenceManager = qobject_cast<QtKeySequencePropertyManager *>(manager)) {
return QVariant::fromValue(keySequenceManager->value(internProp));
} else if (auto *charManager = qobject_cast<QtCharPropertyManager *>(manager)) {
return charManager->value(internProp);
} else if (auto *localeManager = qobject_cast<QtLocalePropertyManager *>(manager)) {
return localeManager->value(internProp);
} else if (auto *pointManager = qobject_cast<QtPointPropertyManager *>(manager)) {
return pointManager->value(internProp);
} else if (auto *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
return pointFManager->value(internProp);
} else if (auto *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
return sizeManager->value(internProp);
} else if (auto *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
return sizeFManager->value(internProp);
} else if (auto *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
return rectManager->value(internProp);
} else if (auto *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
return rectFManager->value(internProp);
} else if (auto *colorManager = qobject_cast<QtColorPropertyManager *>(manager)) {
return colorManager->value(internProp);
} else if (auto *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
return enumManager->value(internProp);
} else if (QtSizePolicyPropertyManager *sizePolicyManager =
qobject_cast<QtSizePolicyPropertyManager *>(manager)) {
return sizePolicyManager->value(internProp);
} else if (auto *fontManager = qobject_cast<QtFontPropertyManager *>(manager)) {
return fontManager->value(internProp);
#ifndef QT_NO_CURSOR
} else if (auto *cursorManager = qobject_cast<QtCursorPropertyManager *>(manager)) {
return cursorManager->value(internProp);
#endif
} else if (auto *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
return flagManager->value(internProp);
}
return {};
}
/*!
Returns the given \a property's value type.
\sa propertyType()
*/
int QtVariantPropertyManager::valueType(const QtProperty *property) const
{
int propType = propertyType(property);
return valueType(propType);
}
/*!
\overload
Returns the value type associated with the given \a propertyType.
*/
int QtVariantPropertyManager::valueType(int propertyType) const
{
return d_ptr->m_typeToValueType.value(propertyType, 0);
}
/*!
Returns the given \a property's type.
\sa valueType()
*/
int QtVariantPropertyManager::propertyType(const QtProperty *property) const
{
const auto it = d_ptr->m_propertyToType.constFind(property);
if (it == d_ptr->m_propertyToType.constEnd())
return 0;
return it.value().second;
}
/*!
Returns the given \a property's value for the specified \a
attribute
If the given \a property was not created by \e this manager, or if
the specified \a attribute does not exist, this function returns
an invalid variant.
\sa attributes(), attributeType(), setAttribute()
*/
QVariant QtVariantPropertyManager::attributeValue(const QtProperty *property, const QString &attribute) const
{
int propType = propertyType(property);
if (!propType)
return {};
const auto it = d_ptr->m_typeToAttributeToAttributeType.constFind(propType);
if (it == d_ptr->m_typeToAttributeToAttributeType.constEnd())
return {};
const QMap<QString, int> &attributes = it.value();
const auto itAttr = attributes.constFind(attribute);
if (itAttr == attributes.constEnd())
return {};
QtProperty *internProp = propertyToWrappedProperty()->value(property, nullptr);
if (internProp == nullptr)
return {};
QtAbstractPropertyManager *manager = internProp->propertyManager();
if (auto *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
return intManager->maximum(internProp);
if (attribute == d_ptr->m_minimumAttribute)
return intManager->minimum(internProp);
if (attribute == d_ptr->m_singleStepAttribute)
return intManager->singleStep(internProp);
return {};
} else if (auto *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
return doubleManager->maximum(internProp);
if (attribute == d_ptr->m_minimumAttribute)
return doubleManager->minimum(internProp);
if (attribute == d_ptr->m_singleStepAttribute)
return doubleManager->singleStep(internProp);
if (attribute == d_ptr->m_decimalsAttribute)
return doubleManager->decimals(internProp);
return {};
} else if (auto *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
if (attribute == d_ptr->m_regExpAttribute)
return stringManager->regExp(internProp);
return {};
} else if (auto *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
return dateManager->maximum(internProp);
if (attribute == d_ptr->m_minimumAttribute)
return dateManager->minimum(internProp);
return {};
} else if (auto *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
if (attribute == d_ptr->m_decimalsAttribute)
return pointFManager->decimals(internProp);
return {};
} else if (auto *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
return sizeManager->maximum(internProp);
if (attribute == d_ptr->m_minimumAttribute)
return sizeManager->minimum(internProp);
return {};
} else if (auto *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
return sizeFManager->maximum(internProp);
if (attribute == d_ptr->m_minimumAttribute)
return sizeFManager->minimum(internProp);
if (attribute == d_ptr->m_decimalsAttribute)
return sizeFManager->decimals(internProp);
return {};
} else if (auto *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
if (attribute == d_ptr->m_constraintAttribute)
return rectManager->constraint(internProp);
return {};
} else if (auto *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
if (attribute == d_ptr->m_constraintAttribute)
return rectFManager->constraint(internProp);
if (attribute == d_ptr->m_decimalsAttribute)
return rectFManager->decimals(internProp);
return {};
} else if (auto *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
if (attribute == d_ptr->m_enumNamesAttribute)
return enumManager->enumNames(internProp);
if (attribute == d_ptr->m_enumIconsAttribute) {
QVariant v;
v.setValue(enumManager->enumIcons(internProp));
return v;
}
return {};
} else if (auto *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
if (attribute == d_ptr->m_flagNamesAttribute)
return flagManager->flagNames(internProp);
return {};
}
return {};
}
/*!
Returns a list of the given \a propertyType 's attributes.
\sa attributeValue(), attributeType()
*/
QStringList QtVariantPropertyManager::attributes(int propertyType) const
{
const auto it = d_ptr->m_typeToAttributeToAttributeType.constFind(propertyType);
if (it == d_ptr->m_typeToAttributeToAttributeType.constEnd())
return {};
return it.value().keys();
}
/*!
Returns the type of the specified \a attribute of the given \a
propertyType.
If the given \a propertyType is not supported by \e this manager,
or if the given \a propertyType does not possess the specified \a
attribute, this function returns QMetaType::UnknownType.
\sa attributes(), valueType()
*/
int QtVariantPropertyManager::attributeType(int propertyType, const QString &attribute) const
{
const auto it = d_ptr->m_typeToAttributeToAttributeType.constFind(propertyType);
if (it == d_ptr->m_typeToAttributeToAttributeType.constEnd())
return 0;
const QMap<QString, int> &attributes = it.value();
const auto itAttr = attributes.constFind(attribute);
if (itAttr == attributes.constEnd())
return 0;
return itAttr.value();
}
/*!
\fn void QtVariantPropertyManager::setValue(QtProperty *property, const QVariant &value)
Sets the value of the given \a property to \a value.
The specified \a value must be of a type returned by valueType(),
or of type that can be converted to valueType() using the
QVariant::canConvert() function, otherwise this function does
nothing.
\sa value(), QtVariantProperty::setValue(), valueChanged()
*/
void QtVariantPropertyManager::setValue(QtProperty *property, const QVariant &val)
{
int propType = val.userType();
if (!propType)
return;
int valType = valueType(property);
if (propType != valType && !val.canConvert(QMetaType(valType)))
return;
QtProperty *internProp = propertyToWrappedProperty()->value(property, nullptr);
if (internProp == nullptr)
return;
QtAbstractPropertyManager *manager = internProp->propertyManager();
if (auto *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
intManager->setValue(internProp, qvariant_cast<int>(val));
return;
} else if (auto *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
doubleManager->setValue(internProp, qvariant_cast<double>(val));
return;
} else if (auto *boolManager = qobject_cast<QtBoolPropertyManager *>(manager)) {
boolManager->setValue(internProp, qvariant_cast<bool>(val));
return;
} else if (auto *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
stringManager->setValue(internProp, qvariant_cast<QString>(val));
return;
} else if (auto *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
dateManager->setValue(internProp, qvariant_cast<QDate>(val));
return;
} else if (auto *timeManager = qobject_cast<QtTimePropertyManager *>(manager)) {
timeManager->setValue(internProp, qvariant_cast<QTime>(val));
return;
} else if (auto *dateTimeManager = qobject_cast<QtDateTimePropertyManager *>(manager)) {
dateTimeManager->setValue(internProp, qvariant_cast<QDateTime>(val));
return;
} else if (auto *keySequenceManager = qobject_cast<QtKeySequencePropertyManager *>(manager)) {
keySequenceManager->setValue(internProp, qvariant_cast<QKeySequence>(val));
return;
} else if (auto *charManager = qobject_cast<QtCharPropertyManager *>(manager)) {
charManager->setValue(internProp, qvariant_cast<QChar>(val));
return;
} else if (auto *localeManager = qobject_cast<QtLocalePropertyManager *>(manager)) {
localeManager->setValue(internProp, qvariant_cast<QLocale>(val));
return;
} else if (auto *pointManager = qobject_cast<QtPointPropertyManager *>(manager)) {
pointManager->setValue(internProp, qvariant_cast<QPoint>(val));
return;
} else if (auto *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
pointFManager->setValue(internProp, qvariant_cast<QPointF>(val));
return;
} else if (auto *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
sizeManager->setValue(internProp, qvariant_cast<QSize>(val));
return;
} else if (auto *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
sizeFManager->setValue(internProp, qvariant_cast<QSizeF>(val));
return;
} else if (auto *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
rectManager->setValue(internProp, qvariant_cast<QRect>(val));
return;
} else if (auto *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
rectFManager->setValue(internProp, qvariant_cast<QRectF>(val));
return;
} else if (auto *colorManager = qobject_cast<QtColorPropertyManager *>(manager)) {
colorManager->setValue(internProp, qvariant_cast<QColor>(val));
return;
} else if (auto *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
enumManager->setValue(internProp, qvariant_cast<int>(val));
return;
} else if (QtSizePolicyPropertyManager *sizePolicyManager =
qobject_cast<QtSizePolicyPropertyManager *>(manager)) {
sizePolicyManager->setValue(internProp, qvariant_cast<QSizePolicy>(val));
return;
} else if (auto *fontManager = qobject_cast<QtFontPropertyManager *>(manager)) {
fontManager->setValue(internProp, qvariant_cast<QFont>(val));
return;
#ifndef QT_NO_CURSOR
} else if (auto *cursorManager = qobject_cast<QtCursorPropertyManager *>(manager)) {
cursorManager->setValue(internProp, qvariant_cast<QCursor>(val));
return;
#endif
} else if (auto *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
flagManager->setValue(internProp, qvariant_cast<int>(val));
return;
}
}
/*!
Sets the value of the specified \a attribute of the given \a
property, to \a value.
The new \a value's type must be of the type returned by
attributeType(), or of a type that can be converted to
attributeType() using the QVariant::canConvert() function,
otherwise this function does nothing.
\sa attributeValue(), QtVariantProperty::setAttribute(), attributeChanged()
*/
void QtVariantPropertyManager::setAttribute(QtProperty *property,
const QString &attribute, const QVariant &value)
{
QVariant oldAttr = attributeValue(property, attribute);
if (!oldAttr.isValid())
return;
int attrType = value.userType();
if (!attrType)
return;
if (attrType != attributeType(propertyType(property), attribute) &&
!value.canConvert(QMetaType(attrType)))
return;
QtProperty *internProp = propertyToWrappedProperty()->value(property, nullptr);
if (internProp == nullptr)
return;
QtAbstractPropertyManager *manager = internProp->propertyManager();
if (auto *intManager = qobject_cast<QtIntPropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
intManager->setMaximum(internProp, qvariant_cast<int>(value));
else if (attribute == d_ptr->m_minimumAttribute)
intManager->setMinimum(internProp, qvariant_cast<int>(value));
else if (attribute == d_ptr->m_singleStepAttribute)
intManager->setSingleStep(internProp, qvariant_cast<int>(value));
return;
} else if (auto *doubleManager = qobject_cast<QtDoublePropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
doubleManager->setMaximum(internProp, qvariant_cast<double>(value));
if (attribute == d_ptr->m_minimumAttribute)
doubleManager->setMinimum(internProp, qvariant_cast<double>(value));
if (attribute == d_ptr->m_singleStepAttribute)
doubleManager->setSingleStep(internProp, qvariant_cast<double>(value));
if (attribute == d_ptr->m_decimalsAttribute)
doubleManager->setDecimals(internProp, qvariant_cast<int>(value));
return;
} else if (auto *stringManager = qobject_cast<QtStringPropertyManager *>(manager)) {
if (attribute == d_ptr->m_regExpAttribute)
stringManager->setRegExp(internProp, qvariant_cast<QRegularExpression>(value));
return;
} else if (auto *dateManager = qobject_cast<QtDatePropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
dateManager->setMaximum(internProp, qvariant_cast<QDate>(value));
if (attribute == d_ptr->m_minimumAttribute)
dateManager->setMinimum(internProp, qvariant_cast<QDate>(value));
return;
} else if (auto *pointFManager = qobject_cast<QtPointFPropertyManager *>(manager)) {
if (attribute == d_ptr->m_decimalsAttribute)
pointFManager->setDecimals(internProp, qvariant_cast<int>(value));
return;
} else if (auto *sizeManager = qobject_cast<QtSizePropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
sizeManager->setMaximum(internProp, qvariant_cast<QSize>(value));
if (attribute == d_ptr->m_minimumAttribute)
sizeManager->setMinimum(internProp, qvariant_cast<QSize>(value));
return;
} else if (auto *sizeFManager = qobject_cast<QtSizeFPropertyManager *>(manager)) {
if (attribute == d_ptr->m_maximumAttribute)
sizeFManager->setMaximum(internProp, qvariant_cast<QSizeF>(value));
if (attribute == d_ptr->m_minimumAttribute)
sizeFManager->setMinimum(internProp, qvariant_cast<QSizeF>(value));
if (attribute == d_ptr->m_decimalsAttribute)
sizeFManager->setDecimals(internProp, qvariant_cast<int>(value));
return;
} else if (auto *rectManager = qobject_cast<QtRectPropertyManager *>(manager)) {
if (attribute == d_ptr->m_constraintAttribute)
rectManager->setConstraint(internProp, qvariant_cast<QRect>(value));
return;
} else if (auto *rectFManager = qobject_cast<QtRectFPropertyManager *>(manager)) {
if (attribute == d_ptr->m_constraintAttribute)
rectFManager->setConstraint(internProp, qvariant_cast<QRectF>(value));
if (attribute == d_ptr->m_decimalsAttribute)
rectFManager->setDecimals(internProp, qvariant_cast<int>(value));
return;
} else if (auto *enumManager = qobject_cast<QtEnumPropertyManager *>(manager)) {
if (attribute == d_ptr->m_enumNamesAttribute)
enumManager->setEnumNames(internProp, qvariant_cast<QStringList>(value));
if (attribute == d_ptr->m_enumIconsAttribute)
enumManager->setEnumIcons(internProp, qvariant_cast<QtIconMap>(value));
return;
} else if (auto *flagManager = qobject_cast<QtFlagPropertyManager *>(manager)) {
if (attribute == d_ptr->m_flagNamesAttribute)
flagManager->setFlagNames(internProp, qvariant_cast<QStringList>(value));
return;
}
}
/*!
\internal
*/
bool QtVariantPropertyManager::hasValue(const QtProperty *property) const
{
if (propertyType(property) == groupTypeId())
return false;
return true;
}
/*!
\internal
*/
QString QtVariantPropertyManager::valueText(const QtProperty *property) const
{
const QtProperty *internProp = propertyToWrappedProperty()->value(property, nullptr);
return internProp ? internProp->valueText() : QString();
}
/*!
\internal
*/
QIcon QtVariantPropertyManager::valueIcon(const QtProperty *property) const
{
const QtProperty *internProp = propertyToWrappedProperty()->value(property, nullptr);
return internProp ? internProp->valueIcon() : QIcon();
}
/*!
\internal
*/
void QtVariantPropertyManager::initializeProperty(QtProperty *property)
{
QtVariantProperty *varProp = variantProperty(property);
if (!varProp)
return;
const auto it = d_ptr->m_typeToPropertyManager.constFind(d_ptr->m_propertyType);
if (it != d_ptr->m_typeToPropertyManager.constEnd()) {
QtProperty *internProp = nullptr;
if (!d_ptr->m_creatingSubProperties) {
QtAbstractPropertyManager *manager = it.value();
internProp = manager->addProperty();
d_ptr->m_internalToProperty[internProp] = varProp;
}
propertyToWrappedProperty()->insert(varProp, internProp);
if (internProp) {
const auto children = internProp->subProperties();
QtVariantProperty *lastProperty = nullptr;
for (QtProperty *child : children) {
QtVariantProperty *prop = d_ptr->createSubProperty(varProp, lastProperty, child);
lastProperty = prop ? prop : lastProperty;
}
}
}
}
/*!
\internal
*/
void QtVariantPropertyManager::uninitializeProperty(QtProperty *property)
{
const auto type_it = d_ptr->m_propertyToType.find(property);
if (type_it == d_ptr->m_propertyToType.end())
return;
const auto it = propertyToWrappedProperty()->find(property);
if (it != propertyToWrappedProperty()->end()) {
QtProperty *internProp = it.value();
if (internProp) {
d_ptr->m_internalToProperty.remove(internProp);
if (!d_ptr->m_destroyingSubProperties) {
delete internProp;
}
}
propertyToWrappedProperty()->erase(it);
}
d_ptr->m_propertyToType.erase(type_it);
}
/*!
\internal
*/
QtProperty *QtVariantPropertyManager::createProperty()
{
if (!d_ptr->m_creatingProperty)
return nullptr;
auto *property = new QtVariantProperty(this);
d_ptr->m_propertyToType.insert(property, {property, d_ptr->m_propertyType});
return property;
}
/////////////////////////////
class QtVariantEditorFactoryPrivate
{
QtVariantEditorFactory *q_ptr;
Q_DECLARE_PUBLIC(QtVariantEditorFactory)
public:
QtSpinBoxFactory *m_spinBoxFactory;
QtDoubleSpinBoxFactory *m_doubleSpinBoxFactory;
QtCheckBoxFactory *m_checkBoxFactory;
QtLineEditFactory *m_lineEditFactory;
QtDateEditFactory *m_dateEditFactory;
QtTimeEditFactory *m_timeEditFactory;
QtDateTimeEditFactory *m_dateTimeEditFactory;
QtKeySequenceEditorFactory *m_keySequenceEditorFactory;
QtCharEditorFactory *m_charEditorFactory;
QtEnumEditorFactory *m_comboBoxFactory;
QtCursorEditorFactory *m_cursorEditorFactory;
QtColorEditorFactory *m_colorEditorFactory;
QtFontEditorFactory *m_fontEditorFactory;
QHash<QtAbstractEditorFactoryBase *, int> m_factoryToType;
QMap<int, QtAbstractEditorFactoryBase *> m_typeToFactory;
};
/*!
\class QtVariantEditorFactory
\internal
\inmodule QtDesigner
\since 4.4
\brief The QtVariantEditorFactory class provides widgets for properties
created by QtVariantPropertyManager objects.
The variant factory provides the following widgets for the
specified property types:
\table
\header
\li Property Type
\li Widget
\row
\li \c int
\li QSpinBox
\row
\li \c double
\li QDoubleSpinBox
\row
\li \c bool
\li QCheckBox
\row
\li QString
\li QLineEdit
\row
\li QDate
\li QDateEdit
\row
\li QTime
\li QTimeEdit
\row
\li QDateTime
\li QDateTimeEdit
\row
\li QKeySequence
\li customized editor
\row
\li QChar
\li customized editor
\row
\li \c enum
\li QComboBox
\row
\li QCursor
\li QComboBox
\endtable
Note that QtVariantPropertyManager supports several additional property
types for which the QtVariantEditorFactory class does not provide
editing widgets, e.g. QPoint and QSize. To provide widgets for other
types using the variant approach, derive from the QtVariantEditorFactory
class.
\sa QtAbstractEditorFactory, QtVariantPropertyManager
*/
/*!
Creates a factory with the given \a parent.
*/
QtVariantEditorFactory::QtVariantEditorFactory(QObject *parent)
: QtAbstractEditorFactory<QtVariantPropertyManager>(parent), d_ptr(new QtVariantEditorFactoryPrivate())
{
d_ptr->q_ptr = this;
d_ptr->m_spinBoxFactory = new QtSpinBoxFactory(this);
d_ptr->m_factoryToType[d_ptr->m_spinBoxFactory] = QMetaType::Int;
d_ptr->m_typeToFactory[QMetaType::Int] = d_ptr->m_spinBoxFactory;
d_ptr->m_doubleSpinBoxFactory = new QtDoubleSpinBoxFactory(this);
d_ptr->m_factoryToType[d_ptr->m_doubleSpinBoxFactory] = QMetaType::Double;
d_ptr->m_typeToFactory[QMetaType::Double] = d_ptr->m_doubleSpinBoxFactory;
d_ptr->m_checkBoxFactory = new QtCheckBoxFactory(this);
d_ptr->m_factoryToType[d_ptr->m_checkBoxFactory] = QMetaType::Bool;
d_ptr->m_typeToFactory[QMetaType::Bool] = d_ptr->m_checkBoxFactory;
d_ptr->m_lineEditFactory = new QtLineEditFactory(this);
d_ptr->m_factoryToType[d_ptr->m_lineEditFactory] = QMetaType::QString;
d_ptr->m_typeToFactory[QMetaType::QString] = d_ptr->m_lineEditFactory;
d_ptr->m_dateEditFactory = new QtDateEditFactory(this);
d_ptr->m_factoryToType[d_ptr->m_dateEditFactory] = QMetaType::QDate;
d_ptr->m_typeToFactory[QMetaType::QDate] = d_ptr->m_dateEditFactory;
d_ptr->m_timeEditFactory = new QtTimeEditFactory(this);
d_ptr->m_factoryToType[d_ptr->m_timeEditFactory] = QMetaType::QTime;
d_ptr->m_typeToFactory[QMetaType::QTime] = d_ptr->m_timeEditFactory;
d_ptr->m_dateTimeEditFactory = new QtDateTimeEditFactory(this);
d_ptr->m_factoryToType[d_ptr->m_dateTimeEditFactory] = QMetaType::QDateTime;
d_ptr->m_typeToFactory[QMetaType::QDateTime] = d_ptr->m_dateTimeEditFactory;
d_ptr->m_keySequenceEditorFactory = new QtKeySequenceEditorFactory(this);
d_ptr->m_factoryToType[d_ptr->m_keySequenceEditorFactory] = QMetaType::QKeySequence;
d_ptr->m_typeToFactory[QMetaType::QKeySequence] = d_ptr->m_keySequenceEditorFactory;
d_ptr->m_charEditorFactory = new QtCharEditorFactory(this);
d_ptr->m_factoryToType[d_ptr->m_charEditorFactory] = QMetaType::QChar;
d_ptr->m_typeToFactory[QMetaType::QChar] = d_ptr->m_charEditorFactory;
d_ptr->m_cursorEditorFactory = new QtCursorEditorFactory(this);
d_ptr->m_factoryToType[d_ptr->m_cursorEditorFactory] = QMetaType::QCursor;
d_ptr->m_typeToFactory[QMetaType::QCursor] = d_ptr->m_cursorEditorFactory;
d_ptr->m_colorEditorFactory = new QtColorEditorFactory(this);
d_ptr->m_factoryToType[d_ptr->m_colorEditorFactory] = QMetaType::QColor;
d_ptr->m_typeToFactory[QMetaType::QColor] = d_ptr->m_colorEditorFactory;
d_ptr->m_fontEditorFactory = new QtFontEditorFactory(this);
d_ptr->m_factoryToType[d_ptr->m_fontEditorFactory] = QMetaType::QFont;
d_ptr->m_typeToFactory[QMetaType::QFont] = d_ptr->m_fontEditorFactory;
d_ptr->m_comboBoxFactory = new QtEnumEditorFactory(this);
const int enumId = QtVariantPropertyManager::enumTypeId();
d_ptr->m_factoryToType[d_ptr->m_comboBoxFactory] = enumId;
d_ptr->m_typeToFactory[enumId] = d_ptr->m_comboBoxFactory;
}
/*!
Destroys this factory, and all the widgets it has created.
*/
QtVariantEditorFactory::~QtVariantEditorFactory() = default;
/*!
\internal
Reimplemented from the QtAbstractEditorFactory class.
*/
void QtVariantEditorFactory::connectPropertyManager(QtVariantPropertyManager *manager)
{
const auto intPropertyManagers = manager->findChildren<QtIntPropertyManager *>();
for (QtIntPropertyManager *manager : intPropertyManagers)
d_ptr->m_spinBoxFactory->addPropertyManager(manager);
const auto doublePropertyManagers = manager->findChildren<QtDoublePropertyManager *>();
for (QtDoublePropertyManager *manager : doublePropertyManagers)
d_ptr->m_doubleSpinBoxFactory->addPropertyManager(manager);
const auto boolPropertyManagers = manager->findChildren<QtBoolPropertyManager *>();
for (QtBoolPropertyManager *manager : boolPropertyManagers)
d_ptr->m_checkBoxFactory->addPropertyManager(manager);
const auto stringPropertyManagers = manager->findChildren<QtStringPropertyManager *>();
for (QtStringPropertyManager *manager : stringPropertyManagers)
d_ptr->m_lineEditFactory->addPropertyManager(manager);
const auto datePropertyManagers = manager->findChildren<QtDatePropertyManager *>();
for (QtDatePropertyManager *manager : datePropertyManagers)
d_ptr->m_dateEditFactory->addPropertyManager(manager);
const auto timePropertyManagers = manager->findChildren<QtTimePropertyManager *>();
for (QtTimePropertyManager *manager : timePropertyManagers)
d_ptr->m_timeEditFactory->addPropertyManager(manager);
const auto dateTimePropertyManagers = manager->findChildren<QtDateTimePropertyManager *>();
for (QtDateTimePropertyManager *manager : dateTimePropertyManagers)
d_ptr->m_dateTimeEditFactory->addPropertyManager(manager);
const auto keySequencePropertyManagers = manager->findChildren<QtKeySequencePropertyManager *>();
for (QtKeySequencePropertyManager *manager : keySequencePropertyManagers)
d_ptr->m_keySequenceEditorFactory->addPropertyManager(manager);
const auto charPropertyManagers = manager->findChildren<QtCharPropertyManager *>();
for (QtCharPropertyManager *manager : charPropertyManagers)
d_ptr->m_charEditorFactory->addPropertyManager(manager);
const auto localePropertyManagers = manager->findChildren<QtLocalePropertyManager *>();
for (QtLocalePropertyManager *manager : localePropertyManagers)
d_ptr->m_comboBoxFactory->addPropertyManager(manager->subEnumPropertyManager());
const auto pointPropertyManagers = manager->findChildren<QtPointPropertyManager *>();
for (QtPointPropertyManager *manager : pointPropertyManagers)
d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
const auto pointFPropertyManagers = manager->findChildren<QtPointFPropertyManager *>();
for (QtPointFPropertyManager *manager : pointFPropertyManagers)
d_ptr->m_doubleSpinBoxFactory->addPropertyManager(manager->subDoublePropertyManager());
const auto sizePropertyManagers = manager->findChildren<QtSizePropertyManager *>();
for (QtSizePropertyManager *manager : sizePropertyManagers)
d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
const auto sizeFPropertyManagers = manager->findChildren<QtSizeFPropertyManager *>();
for (QtSizeFPropertyManager *manager : sizeFPropertyManagers)
d_ptr->m_doubleSpinBoxFactory->addPropertyManager(manager->subDoublePropertyManager());
const auto rectPropertyManagers = manager->findChildren<QtRectPropertyManager *>();
for (QtRectPropertyManager *manager : rectPropertyManagers)
d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
const auto rectFPropertyManagers = manager->findChildren<QtRectFPropertyManager *>();
for (QtRectFPropertyManager *manager : rectFPropertyManagers)
d_ptr->m_doubleSpinBoxFactory->addPropertyManager(manager->subDoublePropertyManager());
const auto colorPropertyManagers = manager->findChildren<QtColorPropertyManager *>();
for (QtColorPropertyManager *manager : colorPropertyManagers) {
d_ptr->m_colorEditorFactory->addPropertyManager(manager);
d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
}
const auto enumPropertyManagers = manager->findChildren<QtEnumPropertyManager *>();
for (QtEnumPropertyManager *manager : enumPropertyManagers)
d_ptr->m_comboBoxFactory->addPropertyManager(manager);
const auto sizePolicyPropertyManagers = manager->findChildren<QtSizePolicyPropertyManager *>();
for (QtSizePolicyPropertyManager *manager : sizePolicyPropertyManagers) {
d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
d_ptr->m_comboBoxFactory->addPropertyManager(manager->subEnumPropertyManager());
}
const auto fontPropertyManagers = manager->findChildren<QtFontPropertyManager *>();
for (QtFontPropertyManager *manager : fontPropertyManagers) {
d_ptr->m_fontEditorFactory->addPropertyManager(manager);
d_ptr->m_spinBoxFactory->addPropertyManager(manager->subIntPropertyManager());
d_ptr->m_comboBoxFactory->addPropertyManager(manager->subEnumPropertyManager());
d_ptr->m_checkBoxFactory->addPropertyManager(manager->subBoolPropertyManager());
}
const auto cursorPropertyManagers = manager->findChildren<QtCursorPropertyManager *>();
for (QtCursorPropertyManager *manager : cursorPropertyManagers)
d_ptr->m_cursorEditorFactory->addPropertyManager(manager);
const auto flagPropertyManagers = manager->findChildren<QtFlagPropertyManager *>();
for (QtFlagPropertyManager *manager : flagPropertyManagers)
d_ptr->m_checkBoxFactory->addPropertyManager(manager->subBoolPropertyManager());
}
/*!
\internal
Reimplemented from the QtAbstractEditorFactory class.
*/
QWidget *QtVariantEditorFactory::createEditor(QtVariantPropertyManager *manager, QtProperty *property,
QWidget *parent)
{
const int propType = manager->propertyType(property);
QtAbstractEditorFactoryBase *factory = d_ptr->m_typeToFactory.value(propType, nullptr);
if (!factory)
return nullptr;
return factory->createEditor(wrappedProperty(property), parent);
}
/*!
\internal
Reimplemented from the QtAbstractEditorFactory class.
*/
void QtVariantEditorFactory::disconnectPropertyManager(QtVariantPropertyManager *manager)
{
const auto intPropertyManagers = manager->findChildren<QtIntPropertyManager *>();
for (QtIntPropertyManager *manager : intPropertyManagers)
d_ptr->m_spinBoxFactory->removePropertyManager(manager);
const auto doublePropertyManagers = manager->findChildren<QtDoublePropertyManager *>();
for (QtDoublePropertyManager *manager : doublePropertyManagers)
d_ptr->m_doubleSpinBoxFactory->removePropertyManager(manager);
const auto boolPropertyManagers = manager->findChildren<QtBoolPropertyManager *>();
for (QtBoolPropertyManager *manager : boolPropertyManagers)
d_ptr->m_checkBoxFactory->removePropertyManager(manager);
const auto stringPropertyManagers = manager->findChildren<QtStringPropertyManager *>();
for (QtStringPropertyManager *manager : stringPropertyManagers)
d_ptr->m_lineEditFactory->removePropertyManager(manager);
const auto datePropertyManagers = manager->findChildren<QtDatePropertyManager *>();
for (QtDatePropertyManager *manager : datePropertyManagers)
d_ptr->m_dateEditFactory->removePropertyManager(manager);
const auto timePropertyManagers = manager->findChildren<QtTimePropertyManager *>();
for (QtTimePropertyManager *manager : timePropertyManagers)
d_ptr->m_timeEditFactory->removePropertyManager(manager);
const auto dateTimePropertyManagers = manager->findChildren<QtDateTimePropertyManager *>();
for (QtDateTimePropertyManager *manager : dateTimePropertyManagers)
d_ptr->m_dateTimeEditFactory->removePropertyManager(manager);
const auto keySequencePropertyManagers = manager->findChildren<QtKeySequencePropertyManager *>();
for (QtKeySequencePropertyManager *manager : keySequencePropertyManagers)
d_ptr->m_keySequenceEditorFactory->removePropertyManager(manager);
const auto charPropertyManagers = manager->findChildren<QtCharPropertyManager *>();
for (QtCharPropertyManager *manager : charPropertyManagers)
d_ptr->m_charEditorFactory->removePropertyManager(manager);
const auto localePropertyManagers = manager->findChildren<QtLocalePropertyManager *>();
for (QtLocalePropertyManager *manager : localePropertyManagers)
d_ptr->m_comboBoxFactory->removePropertyManager(manager->subEnumPropertyManager());
const auto pointPropertyManagers = manager->findChildren<QtPointPropertyManager *>();
for (QtPointPropertyManager *manager : pointPropertyManagers)
d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
const auto pointFPropertyManagers = manager->findChildren<QtPointFPropertyManager *>();
for (QtPointFPropertyManager *manager : pointFPropertyManagers)
d_ptr->m_doubleSpinBoxFactory->removePropertyManager(manager->subDoublePropertyManager());
const auto sizePropertyManagers = manager->findChildren<QtSizePropertyManager *>();
for (QtSizePropertyManager *manager : sizePropertyManagers)
d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
const auto sizeFPropertyManagers = manager->findChildren<QtSizeFPropertyManager *>();
for (QtSizeFPropertyManager *manager : sizeFPropertyManagers)
d_ptr->m_doubleSpinBoxFactory->removePropertyManager(manager->subDoublePropertyManager());
const auto rectPropertyManagers = manager->findChildren<QtRectPropertyManager *>();
for (QtRectPropertyManager *manager : rectPropertyManagers)
d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
const auto rectFPropertyManagers = manager->findChildren<QtRectFPropertyManager *>();
for (QtRectFPropertyManager *manager : rectFPropertyManagers)
d_ptr->m_doubleSpinBoxFactory->removePropertyManager(manager->subDoublePropertyManager());
const auto colorPropertyManagers = manager->findChildren<QtColorPropertyManager *>();
for (QtColorPropertyManager *manager : colorPropertyManagers) {
d_ptr->m_colorEditorFactory->removePropertyManager(manager);
d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
}
const auto enumPropertyManagers = manager->findChildren<QtEnumPropertyManager *>();
for (QtEnumPropertyManager *manager : enumPropertyManagers)
d_ptr->m_comboBoxFactory->removePropertyManager(manager);
const auto sizePolicyPropertyManagers = manager->findChildren<QtSizePolicyPropertyManager *>();
for (QtSizePolicyPropertyManager *manager : sizePolicyPropertyManagers) {
d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
d_ptr->m_comboBoxFactory->removePropertyManager(manager->subEnumPropertyManager());
}
const auto fontPropertyManagers = manager->findChildren<QtFontPropertyManager *>();
for (QtFontPropertyManager *manager : fontPropertyManagers) {
d_ptr->m_fontEditorFactory->removePropertyManager(manager);
d_ptr->m_spinBoxFactory->removePropertyManager(manager->subIntPropertyManager());
d_ptr->m_comboBoxFactory->removePropertyManager(manager->subEnumPropertyManager());
d_ptr->m_checkBoxFactory->removePropertyManager(manager->subBoolPropertyManager());
}
const auto cursorPropertyManagers = manager->findChildren<QtCursorPropertyManager *>();
for (QtCursorPropertyManager *manager : cursorPropertyManagers)
d_ptr->m_cursorEditorFactory->removePropertyManager(manager);
const auto flagPropertyManagers = manager->findChildren<QtFlagPropertyManager *>();
for (QtFlagPropertyManager *manager : flagPropertyManagers)
d_ptr->m_checkBoxFactory->removePropertyManager(manager->subBoolPropertyManager());
}
QT_END_NAMESPACE
#include "moc_qtvariantproperty_p.cpp"