Revision control
++ // 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 "qtpropertymanager_p.h"
++ #include "qtpropertybrowserutils_p.h"
++
++ #include <QtWidgets/qapplication.h>
++ #include <QtWidgets/qlabel.h>
++ #include <QtWidgets/qstyle.h>
++ #include <QtWidgets/qstyleoption.h>
++
++ #include <QtGui/qfontdatabase.h>
++ #include <QtGui/qicon.h>
++ #include <QtGui/qpainter.h>
++
++ #include <QtCore/qdatetime.h>
++ #include <QtCore/qhash.h>
++ #include <QtCore/qlocale.h>
++ #include <QtCore/qmap.h>
++ #include <QtCore/qmetaobject.h>
++ #include <QtCore/qregularexpression.h>
++ #include <QtCore/qtimer.h>
++
++ #include <limits>
++
++ #include <algorithm>
++ #include <utility>
++
++ QT_BEGIN_NAMESPACE
++
++ using DisambiguatedTranslation = std::pair<const char *, const char *>;
++
++ static const QFont::Weight weightValues[] = {
++ QFont::Thin, QFont::ExtraLight, QFont::Light, QFont::Normal, QFont::Medium, QFont::DemiBold,
++ QFont::Bold, QFont::ExtraBold, QFont::Black
++ };
++
++ static int indexOfFontWeight(QFont::Weight w)
++ {
++ auto it = std::find(std::begin(weightValues), std::end(weightValues), w);
++ return int(it - std::begin(weightValues));
++ }
++
++ static inline QFont::Weight weightFromIndex(int i)
++ {
++ return weightValues[i];
++ }
++
++ template <class PrivateData, class Value>
++ static void setSimpleMinimumData(PrivateData *data, const Value &minVal)
++ {
++ data->minVal = minVal;
++ if (data->maxVal < data->minVal)
++ data->maxVal = data->minVal;
++
++ if (data->val < data->minVal)
++ data->val = data->minVal;
++ }
++
++ template <class PrivateData, class Value>
++ static void setSimpleMaximumData(PrivateData *data, const Value &maxVal)
++ {
++ data->maxVal = maxVal;
++ if (data->minVal > data->maxVal)
++ data->minVal = data->maxVal;
++
++ if (data->val > data->maxVal)
++ data->val = data->maxVal;
++ }
++
++ template <class PrivateData, class Value>
++ static void setSizeMinimumData(PrivateData *data, const Value &newMinVal)
++ {
++ data->minVal = newMinVal;
++ if (data->maxVal.width() < data->minVal.width())
++ data->maxVal.setWidth(data->minVal.width());
++ if (data->maxVal.height() < data->minVal.height())
++ data->maxVal.setHeight(data->minVal.height());
++
++ if (data->val.width() < data->minVal.width())
++ data->val.setWidth(data->minVal.width());
++ if (data->val.height() < data->minVal.height())
++ data->val.setHeight(data->minVal.height());
++ }
++
++ template <class PrivateData, class Value>
++ static void setSizeMaximumData(PrivateData *data, const Value &newMaxVal)
++ {
++ data->maxVal = newMaxVal;
++ if (data->minVal.width() > data->maxVal.width())
++ data->minVal.setWidth(data->maxVal.width());
++ if (data->minVal.height() > data->maxVal.height())
++ data->minVal.setHeight(data->maxVal.height());
++
++ if (data->val.width() > data->maxVal.width())
++ data->val.setWidth(data->maxVal.width());
++ if (data->val.height() > data->maxVal.height())
++ data->val.setHeight(data->maxVal.height());
++ }
++
++ template <class SizeValue>
++ static SizeValue qBoundSize(const SizeValue &minVal, const SizeValue &val, const SizeValue &maxVal)
++ {
++ SizeValue croppedVal = val;
++ if (minVal.width() > val.width())
++ croppedVal.setWidth(minVal.width());
++ else if (maxVal.width() < val.width())
++ croppedVal.setWidth(maxVal.width());
++
++ if (minVal.height() > val.height())
++ croppedVal.setHeight(minVal.height());
++ else if (maxVal.height() < val.height())
++ croppedVal.setHeight(maxVal.height());
++
++ return croppedVal;
++ }
++
++ // Match the exact signature of qBound for VS 6.
++ QSize qBound(QSize minVal, QSize val, QSize maxVal)
++ {
++ return qBoundSize(minVal, val, maxVal);
++ }
++
++ QSizeF qBound(QSizeF minVal, QSizeF val, QSizeF maxVal)
++ {
++ return qBoundSize(minVal, val, maxVal);
++ }
++
++ namespace {
++
++ namespace {
++ template <class Value>
++ void orderBorders(Value &minVal, Value &maxVal)
++ {
++ if (minVal > maxVal)
++ qSwap(minVal, maxVal);
++ }
++
++ template <class Value>
++ static void orderSizeBorders(Value &minVal, Value &maxVal)
++ {
++ Value fromSize = minVal;
++ Value toSize = maxVal;
++ if (fromSize.width() > toSize.width()) {
++ fromSize.setWidth(maxVal.width());
++ toSize.setWidth(minVal.width());
++ }
++ if (fromSize.height() > toSize.height()) {
++ fromSize.setHeight(maxVal.height());
++ toSize.setHeight(minVal.height());
++ }
++ minVal = fromSize;
++ maxVal = toSize;
++ }
++
++ void orderBorders(QSize &minVal, QSize &maxVal)
++ {
++ orderSizeBorders(minVal, maxVal);
++ }
++
++ void orderBorders(QSizeF &minVal, QSizeF &maxVal)
++ {
++ orderSizeBorders(minVal, maxVal);
++ }
++
++ }
++ }
++ ////////
++
++ template <class Value, class PrivateData>
++ static Value getData(const QHash<const QtProperty *, PrivateData> &propertyMap,
++ Value PrivateData::*data,
++ const QtProperty *property, const Value &defaultValue = Value())
++ {
++ const auto it = propertyMap.constFind(property);
++ if (it == propertyMap.constEnd())
++ return defaultValue;
++ return it.value().*data;
++ }
++
++ template <class Value, class PrivateData>
++ static Value getValue(const QHash<const QtProperty *, PrivateData> &propertyMap,
++ const QtProperty *property, const Value &defaultValue = Value())
++ {
++ return getData<Value>(propertyMap, &PrivateData::val, property, defaultValue);
++ }
++
++ template <class Value, class PrivateData>
++ static Value getMinimum(const QHash<const QtProperty *, PrivateData> &propertyMap,
++ const QtProperty *property, const Value &defaultValue = Value())
++ {
++ return getData<Value>(propertyMap, &PrivateData::minVal, property, defaultValue);
++ }
++
++ template <class Value, class PrivateData>
++ static Value getMaximum(const QHash<const QtProperty *, PrivateData> &propertyMap,
++ const QtProperty *property, const Value &defaultValue = Value())
++ {
++ return getData<Value>(propertyMap, &PrivateData::maxVal, property, defaultValue);
++ }
++
++ template <class ValueChangeParameter, class Value, class PropertyManager>
++ static void setSimpleValue(QHash<const QtProperty *, Value> &propertyMap,
++ PropertyManager *manager,
++ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
++ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
++ QtProperty *property, const Value &val)
++ {
++ const auto it = propertyMap.find(property);
++ if (it == propertyMap.end())
++ return;
++
++ if (it.value() == val)
++ return;
++
++ it.value() = val;
++
++ emit (manager->*propertyChangedSignal)(property);
++ emit (manager->*valueChangedSignal)(property, val);
++ }
++
++ template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value>
++ static void setValueInRange(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
++ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
++ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
++ QtProperty *property, const Value &val,
++ void (PropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, ValueChangeParameter))
++ {
++ const auto it = managerPrivate->m_values.find(property);
++ if (it == managerPrivate->m_values.end())
++ return;
++
++ auto &data = it.value();
++
++ if (data.val == val)
++ return;
++
++ const Value oldVal = data.val;
++
++ data.val = qBound(data.minVal, val, data.maxVal);
++
++ if (data.val == oldVal)
++ return;
++
++ if (setSubPropertyValue)
++ (managerPrivate->*setSubPropertyValue)(property, data.val);
++
++ emit (manager->*propertyChangedSignal)(property);
++ emit (manager->*valueChangedSignal)(property, data.val);
++ }
++
++ template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value>
++ static void setBorderValues(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
++ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
++ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
++ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
++ QtProperty *property, ValueChangeParameter minVal, ValueChangeParameter maxVal,
++ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
++ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))
++ {
++ const auto it = managerPrivate->m_values.find(property);
++ if (it == managerPrivate->m_values.end())
++ return;
++
++ Value fromVal = minVal;
++ Value toVal = maxVal;
++ orderBorders(fromVal, toVal);
++
++ auto &data = it.value();
++
++ if (data.minVal == fromVal && data.maxVal == toVal)
++ return;
++
++ const Value oldVal = data.val;
++
++ data.setMinimumValue(fromVal);
++ data.setMaximumValue(toVal);
++
++ emit (manager->*rangeChangedSignal)(property, data.minVal, data.maxVal);
++
++ if (setSubPropertyRange)
++ (managerPrivate->*setSubPropertyRange)(property, data.minVal, data.maxVal, data.val);
++
++ if (data.val == oldVal)
++ return;
++
++ emit (manager->*propertyChangedSignal)(property);
++ emit (manager->*valueChangedSignal)(property, data.val);
++ }
++
++ template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>
++ static void setBorderValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
++ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
++ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
++ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
++ QtProperty *property,
++ Value (PrivateData::*getRangeVal)() const,
++ void (PrivateData::*setRangeVal)(ValueChangeParameter), const Value &borderVal,
++ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
++ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))
++ {
++ const auto it = managerPrivate->m_values.find(property);
++ if (it == managerPrivate->m_values.end())
++ return;
++
++ PrivateData &data = it.value();
++
++ if ((data.*getRangeVal)() == borderVal)
++ return;
++
++ const Value oldVal = data.val;
++
++ (data.*setRangeVal)(borderVal);
++
++ emit (manager->*rangeChangedSignal)(property, data.minVal, data.maxVal);
++
++ if (setSubPropertyRange)
++ (managerPrivate->*setSubPropertyRange)(property, data.minVal, data.maxVal, data.val);
++
++ if (data.val == oldVal)
++ return;
++
++ emit (manager->*propertyChangedSignal)(property);
++ emit (manager->*valueChangedSignal)(property, data.val);
++ }
++
++ template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>
++ static void setMinimumValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
++ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
++ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
++ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
++ QtProperty *property, const Value &minVal)
++ {
++ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
++ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter) = nullptr;
++ setBorderValue<ValueChangeParameter, PropertyManagerPrivate, PropertyManager, Value, PrivateData>(manager, managerPrivate,
++ propertyChangedSignal, valueChangedSignal, rangeChangedSignal,
++ property, &PropertyManagerPrivate::Data::minimumValue, &PropertyManagerPrivate::Data::setMinimumValue, minVal, setSubPropertyRange);
++ }
++
++ template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>
++ static void setMaximumValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,
++ void (PropertyManager::*propertyChangedSignal)(QtProperty *),
++ void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
++ void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),
++ QtProperty *property, const Value &maxVal)
++ {
++ void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
++ ValueChangeParameter, ValueChangeParameter, ValueChangeParameter) = nullptr;
++ setBorderValue<ValueChangeParameter, PropertyManagerPrivate, PropertyManager, Value, PrivateData>(manager, managerPrivate,
++ propertyChangedSignal, valueChangedSignal, rangeChangedSignal,
++ property, &PropertyManagerPrivate::Data::maximumValue, &PropertyManagerPrivate::Data::setMaximumValue, maxVal, setSubPropertyRange);
++ }
++
++ class QtMetaEnumWrapper : public QObject
++ {
++ Q_OBJECT
++ Q_PROPERTY(QSizePolicy::Policy policy READ policy)
++ public:
++ QSizePolicy::Policy policy() const { return QSizePolicy::Ignored; }
++ private:
++ QtMetaEnumWrapper(QObject *parent) : QObject(parent) {}
++ };
++
++ class QtMetaEnumProvider
++ {
++ public:
++ QtMetaEnumProvider();
++
++ QStringList policyEnumNames() const { return m_policyEnumNames; }
++ QStringList languageEnumNames() const { return m_languageEnumNames; }
++ QStringList territoryEnumNames(QLocale::Language language) const { return m_territoryEnumNames.value(language); }
++
++ QSizePolicy::Policy indexToSizePolicy(int index) const;
++ int sizePolicyToIndex(QSizePolicy::Policy policy) const;
++
++ void indexToLocale(int languageIndex, int territoryIndex, QLocale::Language *language, QLocale::Territory *territory) const;
++ void localeToIndex(QLocale::Language language, QLocale::Territory territory, int *languageIndex, int *territoryIndex) const;
++
++ private:
++ void initLocale();
++
++ QStringList m_policyEnumNames;
++ QStringList m_languageEnumNames;
++ QMap<QLocale::Language, QStringList> m_territoryEnumNames;
++ QMap<int, QLocale::Language> m_indexToLanguage;
++ QMap<QLocale::Language, int> m_languageToIndex;
++ QMap<int, QMap<int, QLocale::Territory> > m_indexToTerritory;
++ QMap<QLocale::Language, QMap<QLocale::Territory, int> > m_territoryToIndex;
++ QMetaEnum m_policyEnum;
++ };
++
++ static QList<QLocale::Territory> sortedTerritories(const QList<QLocale> &locales)
++ {
++ QMultiMap<QString, QLocale::Territory> nameToTerritory;
++ for (const QLocale &locale : locales) {
++ const auto territory = locale.territory();
++ nameToTerritory.insert(QLocale::territoryToString(territory), territory);
++ }
++ return nameToTerritory.values();
++ }
++
++ void QtMetaEnumProvider::initLocale()
++ {
++ QMultiMap<QString, QLocale::Language> nameToLanguage;
++ for (int l = QLocale::C, last = QLocale::LastLanguage; l <= last; ++l) {
++ const QLocale::Language language = static_cast<QLocale::Language>(l);
++ QLocale locale(language);
++ if (locale.language() == language)
++ nameToLanguage.insert(QLocale::languageToString(language), language);
++ }
++
++ const QLocale system = QLocale::system();
++ if (!nameToLanguage.contains(QLocale::languageToString(system.language())))
++ nameToLanguage.insert(QLocale::languageToString(system.language()), system.language());
++
++ const auto languages = nameToLanguage.values();
++ for (QLocale::Language language : languages) {
++ auto locales = QLocale::matchingLocales(language, QLocale::AnyScript,
++ QLocale::AnyTerritory);
++
++ if (!locales.isEmpty() && !m_languageToIndex.contains(language)) {
++ const auto territories = sortedTerritories(locales);
++ qsizetype langIdx = m_languageEnumNames.size();
++ m_indexToLanguage[langIdx] = language;
++ m_languageToIndex[language] = langIdx;
++ QStringList territoryNames;
++ int territoryIdx = 0;
++ for (QLocale::Territory territory : territories) {
++ territoryNames << QLocale::territoryToString(territory);
++ m_indexToTerritory[langIdx][territoryIdx] = territory;
++ m_territoryToIndex[language][territory] = territoryIdx;
++ ++territoryIdx;
++ }
++ m_languageEnumNames << QLocale::languageToString(language);
++ m_territoryEnumNames[language] = territoryNames;
++ }
++ }
++ }
++
++ QtMetaEnumProvider::QtMetaEnumProvider()
++ {
++ QMetaProperty p;
++
++ p = QtMetaEnumWrapper::staticMetaObject.property(
++ QtMetaEnumWrapper::staticMetaObject.propertyOffset() + 0);
++ m_policyEnum = p.enumerator();
++ const int keyCount = m_policyEnum.keyCount();
++ for (int i = 0; i < keyCount; i++)
++ m_policyEnumNames << QLatin1StringView(m_policyEnum.key(i));
++
++ initLocale();
++ }
++
++ QSizePolicy::Policy QtMetaEnumProvider::indexToSizePolicy(int index) const
++ {
++ return static_cast<QSizePolicy::Policy>(m_policyEnum.value(index));
++ }
++
++ int QtMetaEnumProvider::sizePolicyToIndex(QSizePolicy::Policy policy) const
++ {
++ const int keyCount = m_policyEnum.keyCount();
++ for (int i = 0; i < keyCount; i++)
++ if (indexToSizePolicy(i) == policy)
++ return i;
++ return -1;
++ }
++
++ void QtMetaEnumProvider::indexToLocale(int languageIndex, int territoryIndex, QLocale::Language *language, QLocale::Territory *territory) const
++ {
++ QLocale::Language l = QLocale::C;
++ QLocale::Territory c = QLocale::AnyTerritory;
++ const auto lit = m_indexToLanguage.constFind(languageIndex);
++ if (lit != m_indexToLanguage.cend()) {
++ l = lit.value();
++ const auto tit = m_indexToTerritory.constFind(languageIndex);
++ if (tit != m_indexToTerritory.end()) {
++ const auto tit2 = tit.value().constFind(territoryIndex);
++ if (tit2 != tit.value().cend())
++ c = tit2.value();
++ }
++ }
++ if (language)
++ *language = l;
++ if (territory)
++ *territory = c;
++ }
++
++ void QtMetaEnumProvider::localeToIndex(QLocale::Language language, QLocale::Territory territory, int *languageIndex, int *territoryIndex) const
++ {
++ int l = -1;
++ int c = -1;
++ const auto lit = m_languageToIndex.constFind(language);
++ if (lit != m_languageToIndex.cend()) {
++ l = lit.value();
++ const auto tit = m_territoryToIndex.constFind(language);
++ if (tit != m_territoryToIndex.cend()) {
++ const auto tit2 = tit.value().constFind(territory);
++ if (tit2 != tit.value().cend())
++ c = tit2.value();
++ }
++ }
++
++ if (languageIndex)
++ *languageIndex = l;
++ if (territoryIndex)
++ *territoryIndex = c;
++ }
++
++ Q_GLOBAL_STATIC(QtMetaEnumProvider, metaEnumProvider)
++
++ // QtGroupPropertyManager
++
++ /*!
++ \class QtGroupPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtGroupPropertyManager provides and manages group properties.
++
++ This class is intended to provide a grouping element without any value.
++
++ \sa QtAbstractPropertyManager
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtGroupPropertyManager::QtGroupPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent)
++ {
++
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtGroupPropertyManager::~QtGroupPropertyManager() = default;
++
++ /*!
++ \reimp
++ */
++ bool QtGroupPropertyManager::hasValue(const QtProperty *property) const
++ {
++ Q_UNUSED(property);
++ return false;
++ }
++
++ /*!
++ \reimp
++ */
++ void QtGroupPropertyManager::initializeProperty(QtProperty *property)
++ {
++ Q_UNUSED(property);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtGroupPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ Q_UNUSED(property);
++ }
++
++ // QtIntPropertyManager
++
++ class QtIntPropertyManagerPrivate
++ {
++ QtIntPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtIntPropertyManager)
++ public:
++
++ struct Data
++ {
++ int val{0};
++ int minVal{std::numeric_limits<int>::min()};
++ int maxVal{std::numeric_limits<int>::max()};
++ int singleStep{1};
++ int minimumValue() const { return minVal; }
++ int maximumValue() const { return maxVal; }
++ void setMinimumValue(int newMinVal) { setSimpleMinimumData(this, newMinVal); }
++ void setMaximumValue(int newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++ };
++
++ /*!
++ \class QtIntPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtIntPropertyManager provides and manages int properties.
++
++ An int property has a current value, and a range specifying the
++ valid values. The range is defined by a minimum and a maximum
++ value.
++
++ The property's value and range can be retrieved using the value(),
++ minimum() and maximum() functions, and can be set using the
++ setValue(), setMinimum() and setMaximum() slots. Alternatively,
++ the range can be defined in one go using the setRange() slot.
++
++ In addition, QtIntPropertyManager provides the valueChanged() signal which
++ is emitted whenever a property created by this manager changes,
++ and the rangeChanged() signal which is emitted whenever such a
++ property changes its range of valid values.
++
++ \sa QtAbstractPropertyManager, QtSpinBoxFactory, QtSliderFactory, QtScrollBarFactory
++ */
++
++ /*!
++ \fn void QtIntPropertyManager::valueChanged(QtProperty *property, int 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 QtIntPropertyManager::rangeChanged(QtProperty *property, int minimum, int maximum)
++
++ This signal is emitted whenever a property created by this manager
++ changes its range of valid values, passing a pointer to the
++ \a property and the new \a minimum and \a maximum values.
++
++ \sa setRange()
++ */
++
++ /*!
++ \fn void QtIntPropertyManager::singleStepChanged(QtProperty *property, int step)
++
++ This signal is emitted whenever a property created by this manager
++ changes its single step property, passing a pointer to the
++ \a property and the new \a step value
++
++ \sa setSingleStep()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtIntPropertyManager::QtIntPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtIntPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtIntPropertyManager::~QtIntPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns 0.
++
++ \sa setValue()
++ */
++ int QtIntPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<int>(d_ptr->m_values, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's minimum value.
++
++ \sa setMinimum(), maximum(), setRange()
++ */
++ int QtIntPropertyManager::minimum(const QtProperty *property) const
++ {
++ return getMinimum<int>(d_ptr->m_values, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's maximum value.
++
++ \sa setMaximum(), minimum(), setRange()
++ */
++ int QtIntPropertyManager::maximum(const QtProperty *property) const
++ {
++ return getMaximum<int>(d_ptr->m_values, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's step value.
++
++ The step is typically used to increment or decrement a property value while pressing an arrow key.
++
++ \sa setSingleStep()
++ */
++ int QtIntPropertyManager::singleStep(const QtProperty *property) const
++ {
++ return getData<int>(d_ptr->m_values, &QtIntPropertyManagerPrivate::Data::singleStep, property, 0);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtIntPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return QString::number(it.value().val);
++ }
++
++ /*!
++ \fn void QtIntPropertyManager::setValue(QtProperty *property, int value)
++
++ Sets the value of the given \a property to \a value.
++
++ If the specified \a value is not valid according to the given \a
++ property's range, the \a value is adjusted to the nearest valid
++ value within the range.
++
++ \sa value(), setRange(), valueChanged()
++ */
++ void QtIntPropertyManager::setValue(QtProperty *property, int val)
++ {
++ void (QtIntPropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, int) = nullptr;
++ setValueInRange<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int>(this, d_ptr.data(),
++ &QtIntPropertyManager::propertyChanged,
++ &QtIntPropertyManager::valueChanged,
++ property, val, setSubPropertyValue);
++ }
++
++ /*!
++ Sets the minimum value for the given \a property to \a minVal.
++
++ When setting the minimum value, the maximum and current values are
++ adjusted if necessary (ensuring that the range remains valid and
++ that the current value is within the range).
++
++ \sa minimum(), setRange(), rangeChanged()
++ */
++ void QtIntPropertyManager::setMinimum(QtProperty *property, int minVal)
++ {
++ setMinimumValue<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int, QtIntPropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtIntPropertyManager::propertyChanged,
++ &QtIntPropertyManager::valueChanged,
++ &QtIntPropertyManager::rangeChanged,
++ property, minVal);
++ }
++
++ /*!
++ Sets the maximum value for the given \a property to \a maxVal.
++
++ When setting maximum value, the minimum and current values are
++ adjusted if necessary (ensuring that the range remains valid and
++ that the current value is within the range).
++
++ \sa maximum(), setRange(), rangeChanged()
++ */
++ void QtIntPropertyManager::setMaximum(QtProperty *property, int maxVal)
++ {
++ setMaximumValue<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int, QtIntPropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtIntPropertyManager::propertyChanged,
++ &QtIntPropertyManager::valueChanged,
++ &QtIntPropertyManager::rangeChanged,
++ property, maxVal);
++ }
++
++ /*!
++ \fn void QtIntPropertyManager::setRange(QtProperty *property, int minimum, int maximum)
++
++ Sets the range of valid values.
++
++ This is a convenience function defining the range of valid values
++ in one go; setting the \a minimum and \a maximum values for the
++ given \a property with a single function call.
++
++ When setting a new range, the current value is adjusted if
++ necessary (ensuring that the value remains within range).
++
++ \sa setMinimum(), setMaximum(), rangeChanged()
++ */
++ void QtIntPropertyManager::setRange(QtProperty *property, int minVal, int maxVal)
++ {
++ void (QtIntPropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, int, int, int) = nullptr;
++ setBorderValues<int, QtIntPropertyManagerPrivate, QtIntPropertyManager, int>(this, d_ptr.data(),
++ &QtIntPropertyManager::propertyChanged,
++ &QtIntPropertyManager::valueChanged,
++ &QtIntPropertyManager::rangeChanged,
++ property, minVal, maxVal, setSubPropertyRange);
++ }
++
++ /*!
++ Sets the step value for the given \a property to \a step.
++
++ The step is typically used to increment or decrement a property value while pressing an arrow key.
++
++ \sa singleStep()
++ */
++ void QtIntPropertyManager::setSingleStep(QtProperty *property, int step)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtIntPropertyManagerPrivate::Data data = it.value();
++
++ if (step < 0)
++ step = 0;
++
++ if (data.singleStep == step)
++ return;
++
++ data.singleStep = step;
++
++ it.value() = data;
++
++ emit singleStepChanged(property, data.singleStep);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtIntPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtIntPropertyManagerPrivate::Data();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtIntPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtDoublePropertyManager
++
++ class QtDoublePropertyManagerPrivate
++ {
++ QtDoublePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtDoublePropertyManager)
++ public:
++
++ struct Data
++ {
++ double val{0};
++ double minVal{std::numeric_limits<double>::lowest()};
++ double maxVal{std::numeric_limits<double>::max()};
++ double singleStep{1};
++ int decimals{2};
++ double minimumValue() const { return minVal; }
++ double maximumValue() const { return maxVal; }
++ void setMinimumValue(double newMinVal) { setSimpleMinimumData(this, newMinVal); }
++ void setMaximumValue(double newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++ };
++
++ /*!
++ \class QtDoublePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtDoublePropertyManager provides and manages double properties.
++
++ A double property has a current value, and a range specifying the
++ valid values. The range is defined by a minimum and a maximum
++ value.
++
++ The property's value and range can be retrieved using the value(),
++ minimum() and maximum() functions, and can be set using the
++ setValue(), setMinimum() and setMaximum() slots.
++ Alternatively, the range can be defined in one go using the
++ setRange() slot.
++
++ In addition, QtDoublePropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the rangeChanged() signal which is emitted whenever
++ such a property changes its range of valid values.
++
++ \sa QtAbstractPropertyManager, QtDoubleSpinBoxFactory
++ */
++
++ /*!
++ \fn void QtDoublePropertyManager::valueChanged(QtProperty *property, double 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 QtDoublePropertyManager::rangeChanged(QtProperty *property, double minimum, double maximum)
++
++ This signal is emitted whenever a property created by this manager
++ changes its range of valid values, passing a pointer to the
++ \a property and the new \a minimum and \a maximum values
++
++ \sa setRange()
++ */
++
++ /*!
++ \fn void QtDoublePropertyManager::decimalsChanged(QtProperty *property, int prec)
++
++ This signal is emitted whenever a property created by this manager
++ changes its precision of value, passing a pointer to the
++ \a property and the new \a prec value
++
++ \sa setDecimals()
++ */
++
++ /*!
++ \fn void QtDoublePropertyManager::singleStepChanged(QtProperty *property, double step)
++
++ This signal is emitted whenever a property created by this manager
++ changes its single step property, passing a pointer to the
++ \a property and the new \a step value
++
++ \sa setSingleStep()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtDoublePropertyManager::QtDoublePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtDoublePropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtDoublePropertyManager::~QtDoublePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns 0.
++
++ \sa setValue()
++ */
++ double QtDoublePropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<double>(d_ptr->m_values, property, 0.0);
++ }
++
++ /*!
++ Returns the given \a property's minimum value.
++
++ \sa maximum(), setRange()
++ */
++ double QtDoublePropertyManager::minimum(const QtProperty *property) const
++ {
++ return getMinimum<double>(d_ptr->m_values, property, 0.0);
++ }
++
++ /*!
++ Returns the given \a property's maximum value.
++
++ \sa minimum(), setRange()
++ */
++ double QtDoublePropertyManager::maximum(const QtProperty *property) const
++ {
++ return getMaximum<double>(d_ptr->m_values, property, 0.0);
++ }
++
++ /*!
++ Returns the given \a property's step value.
++
++ The step is typically used to increment or decrement a property value while pressing an arrow key.
++
++ \sa setSingleStep()
++ */
++ double QtDoublePropertyManager::singleStep(const QtProperty *property) const
++ {
++ return getData<double>(d_ptr->m_values, &QtDoublePropertyManagerPrivate::Data::singleStep, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's precision, in decimals.
++
++ \sa setDecimals()
++ */
++ int QtDoublePropertyManager::decimals(const QtProperty *property) const
++ {
++ return getData<int>(d_ptr->m_values, &QtDoublePropertyManagerPrivate::Data::decimals, property, 0);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtDoublePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return QString::number(it.value().val, 'f', it.value().decimals);
++ }
++
++ /*!
++ \fn void QtDoublePropertyManager::setValue(QtProperty *property, double value)
++
++ Sets the value of the given \a property to \a value.
++
++ If the specified \a value is not valid according to the given
++ \a property's range, the \a value is adjusted to the nearest valid value
++ within the range.
++
++ \sa value(), setRange(), valueChanged()
++ */
++ void QtDoublePropertyManager::setValue(QtProperty *property, double val)
++ {
++ void (QtDoublePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, double) = nullptr;
++ setValueInRange<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double>(this, d_ptr.data(),
++ &QtDoublePropertyManager::propertyChanged,
++ &QtDoublePropertyManager::valueChanged,
++ property, val, setSubPropertyValue);
++ }
++
++ /*!
++ Sets the step value for the given \a property to \a step.
++
++ The step is typically used to increment or decrement a property value while pressing an arrow key.
++
++ \sa singleStep()
++ */
++ void QtDoublePropertyManager::setSingleStep(QtProperty *property, double step)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtDoublePropertyManagerPrivate::Data data = it.value();
++
++ if (step < 0)
++ step = 0;
++
++ if (data.singleStep == step)
++ return;
++
++ data.singleStep = step;
++
++ it.value() = data;
++
++ emit singleStepChanged(property, data.singleStep);
++ }
++
++ /*!
++ \fn void QtDoublePropertyManager::setDecimals(QtProperty *property, int prec)
++
++ Sets the precision of the given \a property to \a prec.
++
++ The valid decimal range is 0-13. The default is 2.
++
++ \sa decimals()
++ */
++ void QtDoublePropertyManager::setDecimals(QtProperty *property, int prec)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtDoublePropertyManagerPrivate::Data data = it.value();
++
++ if (prec > 13)
++ prec = 13;
++ else if (prec < 0)
++ prec = 0;
++
++ if (data.decimals == prec)
++ return;
++
++ data.decimals = prec;
++
++ it.value() = data;
++
++ emit decimalsChanged(property, data.decimals);
++ }
++
++ /*!
++ Sets the minimum value for the given \a property to \a minVal.
++
++ When setting the minimum value, the maximum and current values are
++ adjusted if necessary (ensuring that the range remains valid and
++ that the current value is within in the range).
++
++ \sa minimum(), setRange(), rangeChanged()
++ */
++ void QtDoublePropertyManager::setMinimum(QtProperty *property, double minVal)
++ {
++ setMinimumValue<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double, QtDoublePropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtDoublePropertyManager::propertyChanged,
++ &QtDoublePropertyManager::valueChanged,
++ &QtDoublePropertyManager::rangeChanged,
++ property, minVal);
++ }
++
++ /*!
++ Sets the maximum value for the given \a property to \a maxVal.
++
++ When setting the maximum value, the minimum and current values are
++ adjusted if necessary (ensuring that the range remains valid and
++ that the current value is within in the range).
++
++ \sa maximum(), setRange(), rangeChanged()
++ */
++ void QtDoublePropertyManager::setMaximum(QtProperty *property, double maxVal)
++ {
++ setMaximumValue<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double, QtDoublePropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtDoublePropertyManager::propertyChanged,
++ &QtDoublePropertyManager::valueChanged,
++ &QtDoublePropertyManager::rangeChanged,
++ property, maxVal);
++ }
++
++ /*!
++ \fn void QtDoublePropertyManager::setRange(QtProperty *property, double minimum, double maximum)
++
++ Sets the range of valid values.
++
++ This is a convenience function defining the range of valid values
++ in one go; setting the \a minimum and \a maximum values for the
++ given \a property with a single function call.
++
++ When setting a new range, the current value is adjusted if
++ necessary (ensuring that the value remains within range).
++
++ \sa setMinimum(), setMaximum(), rangeChanged()
++ */
++ void QtDoublePropertyManager::setRange(QtProperty *property, double minVal, double maxVal)
++ {
++ void (QtDoublePropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, double, double, double) = nullptr;
++ setBorderValues<double, QtDoublePropertyManagerPrivate, QtDoublePropertyManager, double>(this, d_ptr.data(),
++ &QtDoublePropertyManager::propertyChanged,
++ &QtDoublePropertyManager::valueChanged,
++ &QtDoublePropertyManager::rangeChanged,
++ property, minVal, maxVal, setSubPropertyRange);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtDoublePropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtDoublePropertyManagerPrivate::Data();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtDoublePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtStringPropertyManager
++
++ class QtStringPropertyManagerPrivate
++ {
++ QtStringPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtStringPropertyManager)
++ public:
++
++ struct Data
++ {
++ QString val;
++ QRegularExpression regExp;
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++ };
++
++ /*!
++ \class QtStringPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtStringPropertyManager provides and manages QString properties.
++
++ A string property's value can be retrieved using the value()
++ function, and set using the setValue() slot.
++
++ The current value can be checked against a regular expression. To
++ set the regular expression use the setRegExp() slot, use the
++ regExp() function to retrieve the currently set expression.
++
++ In addition, QtStringPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the regExpChanged() signal which is emitted whenever
++ such a property changes its currently set regular expression.
++
++ \sa QtAbstractPropertyManager, QtLineEditFactory
++ */
++
++ /*!
++ \fn void QtStringPropertyManager::valueChanged(QtProperty *property, const QString &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 QtStringPropertyManager::regExpChanged(QtProperty *property, const QRegularExpression ®Exp)
++
++ This signal is emitted whenever a property created by this manager
++ changes its currenlty set regular expression, passing a pointer to
++ the \a property and the new \a regExp as parameters.
++
++ \sa setRegExp()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtStringPropertyManager::QtStringPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtStringPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtStringPropertyManager::~QtStringPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns an empty string.
++
++ \sa setValue()
++ */
++ QString QtStringPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QString>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's currently set regular expression.
++
++ If the given \a property is not managed by this manager, this
++ function returns an empty expression.
++
++ \sa setRegExp()
++ */
++ QRegularExpression QtStringPropertyManager::regExp(const QtProperty *property) const
++ {
++ return getData<QRegularExpression>(d_ptr->m_values, &QtStringPropertyManagerPrivate::Data::regExp, property, QRegularExpression());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtStringPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return it.value().val;
++ }
++
++ /*!
++ \fn void QtStringPropertyManager::setValue(QtProperty *property, const QString &value)
++
++ Sets the value of the given \a property to \a value.
++
++ If the specified \a value doesn't match the given \a property's
++ regular expression, this function does nothing.
++
++ \sa value(), setRegExp(), valueChanged()
++ */
++ void QtStringPropertyManager::setValue(QtProperty *property, const QString &val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtStringPropertyManagerPrivate::Data data = it.value();
++
++ if (data.val == val)
++ return;
++
++ if (data.regExp.isValid() && !data.regExp.pattern().isEmpty()
++ && !data.regExp.match(val).hasMatch()) {
++ return;
++ }
++
++ data.val = val;
++
++ it.value() = data;
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ Sets the regular expression of the given \a property to \a regExp.
++
++ \sa regExp(), setValue(), regExpChanged()
++ */
++ void QtStringPropertyManager::setRegExp(QtProperty *property, const QRegularExpression ®Exp)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtStringPropertyManagerPrivate::Data data = it.value() ;
++
++ if (data.regExp == regExp)
++ return;
++
++ data.regExp = regExp;
++
++ it.value() = data;
++
++ emit regExpChanged(property, data.regExp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtStringPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtStringPropertyManagerPrivate::Data();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtStringPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtBoolPropertyManager
++ // Return an icon containing a check box indicator
++ class QCheckBoxIconEngine : public QtPropertyIconEngine
++ {
++ public:
++ Q_DISABLE_COPY_MOVE(QCheckBoxIconEngine)
++
++ explicit QCheckBoxIconEngine(bool checked) : m_checked(checked) { }
++
++ QIconEngine *clone() const override { return new QCheckBoxIconEngine(m_checked); }
++
++ void paint(QPainter *painter, const QRect &rect, QIcon::Mode, QIcon::State) override
++ {
++ QStyleOptionButton opt;
++ opt.state.setFlag(m_checked ? QStyle::State_On : QStyle::State_Off);
++ opt.state.setFlag(QStyle::State_Enabled);
++
++ // Figure out size of an indicator and make sure it is not scaled down in a list view item
++ // by making the pixmap as big as a list view icon and centering the indicator in it.
++ // (if it is smaller, it can't be helped)
++ const QStyle *style = QApplication::style();
++ const int indicatorWidth = style->pixelMetric(QStyle::PM_IndicatorWidth, &opt);
++ const int indicatorHeight = style->pixelMetric(QStyle::PM_IndicatorHeight, &opt);
++ opt.rect = rect;
++ if (opt.rect.width() > indicatorWidth) {
++ const int xOff = opt.rect.width() - indicatorWidth;
++ opt.rect.setX(opt.rect.x() + xOff / 2);
++ opt.rect.setWidth(indicatorWidth);
++ }
++ if (opt.rect.height() > indicatorHeight) {
++ const int yOff = opt.rect.height() - indicatorHeight;
++ opt.rect.setY(opt.rect.y() + yOff / 2);
++ opt.rect.setHeight(indicatorHeight);
++ }
++
++ style->drawPrimitive(QStyle::PE_IndicatorCheckBox, &opt, painter);
++ }
++
++ private:
++ bool m_checked;
++ };
++
++ class QtBoolPropertyManagerPrivate
++ {
++ QtBoolPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtBoolPropertyManager)
++ public:
++ QtBoolPropertyManagerPrivate();
++
++ QHash<const QtProperty *, bool> m_values;
++ const QIcon m_checkedIcon;
++ const QIcon m_uncheckedIcon;
++ };
++
++ QtBoolPropertyManagerPrivate::QtBoolPropertyManagerPrivate() :
++ m_checkedIcon(new QCheckBoxIconEngine(true)),
++ m_uncheckedIcon(new QCheckBoxIconEngine(false))
++ {
++ }
++
++ /*!
++ \class QtBoolPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtBoolPropertyManager class provides and manages boolean properties.
++
++ The property's value can be retrieved using the value() function,
++ and set using the setValue() slot.
++
++ In addition, QtBoolPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes.
++
++ \sa QtAbstractPropertyManager, QtCheckBoxFactory
++ */
++
++ /*!
++ \fn void QtBoolPropertyManager::valueChanged(QtProperty *property, bool 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.
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtBoolPropertyManager::QtBoolPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtBoolPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtBoolPropertyManager::~QtBoolPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by \e this manager, this
++ function returns false.
++
++ \sa setValue()
++ */
++ bool QtBoolPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, false);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtBoolPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ static const QString trueText = tr("True");
++ static const QString falseText = tr("False");
++ return it.value() ? trueText : falseText;
++ }
++
++ /*!
++ \reimp
++ */
++ QIcon QtBoolPropertyManager::valueIcon(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ return it.value() ? d_ptr->m_checkedIcon : d_ptr->m_uncheckedIcon;
++ }
++
++ /*!
++ \fn void QtBoolPropertyManager::setValue(QtProperty *property, bool value)
++
++ Sets the value of the given \a property to \a value.
++
++ \sa value()
++ */
++ void QtBoolPropertyManager::setValue(QtProperty *property, bool val)
++ {
++ setSimpleValue<bool, bool, QtBoolPropertyManager>(d_ptr->m_values, this,
++ &QtBoolPropertyManager::propertyChanged,
++ &QtBoolPropertyManager::valueChanged,
++ property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtBoolPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = false;
++ }
++
++ /*!
++ \reimp
++ */
++ void QtBoolPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtDatePropertyManager
++
++ class QtDatePropertyManagerPrivate
++ {
++ QtDatePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtDatePropertyManager)
++ public:
++ explicit QtDatePropertyManagerPrivate(QtDatePropertyManager *q);
++
++ struct Data
++ {
++ QDate val{QDate::currentDate()};
++ QDate minVal{QDate(1752, 9, 14)};
++ QDate maxVal{QDate(9999, 12, 31)};
++ QDate minimumValue() const { return minVal; }
++ QDate maximumValue() const { return maxVal; }
++ void setMinimumValue(QDate newMinVal) { setSimpleMinimumData(this, newMinVal); }
++ void setMaximumValue(QDate newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
++ };
++
++ QString m_format;
++
++ QHash<const QtProperty *, Data> m_values;
++ };
++
++ QtDatePropertyManagerPrivate::QtDatePropertyManagerPrivate(QtDatePropertyManager *q) :
++ q_ptr(q),
++ m_format(QtPropertyBrowserUtils::dateFormat())
++ {
++ }
++
++ /*!
++ \class QtDatePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtDatePropertyManager provides and manages QDate properties.
++
++ A date property has a current value, and a range specifying the
++ valid dates. The range is defined by a minimum and a maximum
++ value.
++
++ The property's values can be retrieved using the minimum(),
++ maximum() and value() functions, and can be set using the
++ setMinimum(), setMaximum() and setValue() slots. Alternatively,
++ the range can be defined in one go using the setRange() slot.
++
++ In addition, QtDatePropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the rangeChanged() signal which is emitted whenever
++ such a property changes its range of valid dates.
++
++ \sa QtAbstractPropertyManager, QtDateEditFactory, QtDateTimePropertyManager
++ */
++
++ /*!
++ \fn void QtDatePropertyManager::valueChanged(QtProperty *property, QDate 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 QtDatePropertyManager::rangeChanged(QtProperty *property, QDate minimum, QDate maximum)
++
++ This signal is emitted whenever a property created by this manager
++ changes its range of valid dates, passing a pointer to the \a
++ property and the new \a minimum and \a maximum dates.
++
++ \sa setRange()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtDatePropertyManager::QtDatePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtDatePropertyManagerPrivate(this))
++ {
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtDatePropertyManager::~QtDatePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by \e this manager, this
++ function returns an invalid date.
++
++ \sa setValue()
++ */
++ QDate QtDatePropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QDate>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's minimum date.
++
++ \sa maximum(), setRange()
++ */
++ QDate QtDatePropertyManager::minimum(const QtProperty *property) const
++ {
++ return getMinimum<QDate>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's maximum date.
++
++ \sa minimum(), setRange()
++ */
++ QDate QtDatePropertyManager::maximum(const QtProperty *property) const
++ {
++ return getMaximum<QDate>(d_ptr->m_values, property);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtDatePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return it.value().val.toString(d_ptr->m_format);
++ }
++
++ /*!
++ \fn void QtDatePropertyManager::setValue(QtProperty *property, QDate value)
++
++ Sets the value of the given \a property to \a value.
++
++ If the specified \a value is not a valid date according to the
++ given \a property's range, the value is adjusted to the nearest
++ valid value within the range.
++
++ \sa value(), setRange(), valueChanged()
++ */
++ void QtDatePropertyManager::setValue(QtProperty *property, QDate val)
++ {
++ void (QtDatePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, QDate) = nullptr;
++ setValueInRange<QDate, QtDatePropertyManagerPrivate, QtDatePropertyManager, const QDate>(this, d_ptr.data(),
++ &QtDatePropertyManager::propertyChanged,
++ &QtDatePropertyManager::valueChanged,
++ property, val, setSubPropertyValue);
++ }
++
++ /*!
++ Sets the minimum value for the given \a property to \a minVal.
++
++ When setting the minimum value, the maximum and current values are
++ adjusted if necessary (ensuring that the range remains valid and
++ that the current value is within in the range).
++
++ \sa minimum(), setRange()
++ */
++ void QtDatePropertyManager::setMinimum(QtProperty *property, QDate minVal)
++ {
++ setMinimumValue<QDate, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate, QtDatePropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtDatePropertyManager::propertyChanged,
++ &QtDatePropertyManager::valueChanged,
++ &QtDatePropertyManager::rangeChanged,
++ property, minVal);
++ }
++
++ /*!
++ Sets the maximum value for the given \a property to \a maxVal.
++
++ When setting the maximum value, the minimum and current
++ values are adjusted if necessary (ensuring that the range remains
++ valid and that the current value is within in the range).
++
++ \sa maximum(), setRange()
++ */
++ void QtDatePropertyManager::setMaximum(QtProperty *property, QDate maxVal)
++ {
++ setMaximumValue<QDate, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate, QtDatePropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtDatePropertyManager::propertyChanged,
++ &QtDatePropertyManager::valueChanged,
++ &QtDatePropertyManager::rangeChanged,
++ property, maxVal);
++ }
++
++ /*!
++ \fn void QtDatePropertyManager::setRange(QtProperty *property, QDate minimum, QDate maximum)
++
++ Sets the range of valid dates.
++
++ This is a convenience function defining the range of valid dates
++ in one go; setting the \a minimum and \a maximum values for the
++ given \a property with a single function call.
++
++ When setting a new date range, the current value is adjusted if
++ necessary (ensuring that the value remains in date range).
++
++ \sa setMinimum(), setMaximum(), rangeChanged()
++ */
++ void QtDatePropertyManager::setRange(QtProperty *property, QDate minVal, QDate maxVal)
++ {
++ void (QtDatePropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, QDate, QDate, QDate) = nullptr;
++ setBorderValues<QDate, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate>(this, d_ptr.data(),
++ &QtDatePropertyManager::propertyChanged,
++ &QtDatePropertyManager::valueChanged,
++ &QtDatePropertyManager::rangeChanged,
++ property, minVal, maxVal, setSubPropertyRange);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtDatePropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtDatePropertyManagerPrivate::Data();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtDatePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtTimePropertyManager
++
++ class QtTimePropertyManagerPrivate
++ {
++ QtTimePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtTimePropertyManager)
++ public:
++ explicit QtTimePropertyManagerPrivate(QtTimePropertyManager *q);
++
++ const QString m_format;
++
++ QHash<const QtProperty *, QTime> m_values;
++ };
++
++ QtTimePropertyManagerPrivate::QtTimePropertyManagerPrivate(QtTimePropertyManager *q) :
++ q_ptr(q),
++ m_format(QtPropertyBrowserUtils::timeFormat())
++ {
++ }
++
++ /*!
++ \class QtTimePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtTimePropertyManager provides and manages QTime properties.
++
++ A time property's value can be retrieved using the value()
++ function, and set using the setValue() slot.
++
++ In addition, QtTimePropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes.
++
++ \sa QtAbstractPropertyManager, QtTimeEditFactory
++ */
++
++ /*!
++ \fn void QtTimePropertyManager::valueChanged(QtProperty *property, QTime 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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtTimePropertyManager::QtTimePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtTimePropertyManagerPrivate(this))
++ {
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtTimePropertyManager::~QtTimePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns an invalid time object.
++
++ \sa setValue()
++ */
++ QTime QtTimePropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QTime());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtTimePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return it.value().toString(d_ptr->m_format);
++ }
++
++ /*!
++ \fn void QtTimePropertyManager::setValue(QtProperty *property, QTime value)
++
++ Sets the value of the given \a property to \a value.
++
++ \sa value(), valueChanged()
++ */
++ void QtTimePropertyManager::setValue(QtProperty *property, QTime val)
++ {
++ setSimpleValue<QTime, QTime, QtTimePropertyManager>(d_ptr->m_values, this,
++ &QtTimePropertyManager::propertyChanged,
++ &QtTimePropertyManager::valueChanged,
++ property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtTimePropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QTime::currentTime();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtTimePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtDateTimePropertyManager
++
++ class QtDateTimePropertyManagerPrivate
++ {
++ QtDateTimePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtDateTimePropertyManager)
++ public:
++ explicit QtDateTimePropertyManagerPrivate(QtDateTimePropertyManager *q);
++
++ const QString m_format;
++
++ QHash<const QtProperty *, QDateTime> m_values;
++ };
++
++ QtDateTimePropertyManagerPrivate::QtDateTimePropertyManagerPrivate(QtDateTimePropertyManager *q) :
++ q_ptr(q),
++ m_format(QtPropertyBrowserUtils::dateTimeFormat())
++ {
++ }
++
++ /*! \class QtDateTimePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtDateTimePropertyManager provides and manages QDateTime properties.
++
++ A date and time property has a current value which can be
++ retrieved using the value() function, and set using the setValue()
++ slot. In addition, QtDateTimePropertyManager provides the
++ valueChanged() signal which is emitted whenever a property created
++ by this manager changes.
++
++ \sa QtAbstractPropertyManager, QtDateTimeEditFactory, QtDatePropertyManager
++ */
++
++ /*!
++ \fn void QtDateTimePropertyManager::valueChanged(QtProperty *property, const QDateTime &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.
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtDateTimePropertyManager::QtDateTimePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtDateTimePropertyManagerPrivate(this))
++ {
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtDateTimePropertyManager::~QtDateTimePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an invalid QDateTime object.
++
++ \sa setValue()
++ */
++ QDateTime QtDateTimePropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QDateTime());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtDateTimePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return it.value().toString(d_ptr->m_format);
++ }
++
++ /*!
++ \fn void QtDateTimePropertyManager::setValue(QtProperty *property, const QDateTime &value)
++
++ Sets the value of the given \a property to \a value.
++
++ \sa value(), valueChanged()
++ */
++ void QtDateTimePropertyManager::setValue(QtProperty *property, const QDateTime &val)
++ {
++ setSimpleValue<const QDateTime &, QDateTime, QtDateTimePropertyManager>(d_ptr->m_values, this,
++ &QtDateTimePropertyManager::propertyChanged,
++ &QtDateTimePropertyManager::valueChanged,
++ property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtDateTimePropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QDateTime::currentDateTime();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtDateTimePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtKeySequencePropertyManager
++
++ class QtKeySequencePropertyManagerPrivate
++ {
++ QtKeySequencePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtKeySequencePropertyManager)
++ public:
++
++ QString m_format;
++
++ QHash<const QtProperty *, QKeySequence> m_values;
++ };
++
++ /*! \class QtKeySequencePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtKeySequencePropertyManager provides and manages QKeySequence properties.
++
++ A key sequence's value can be retrieved using the value()
++ function, and set using the setValue() slot.
++
++ In addition, QtKeySequencePropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes.
++
++ \sa QtAbstractPropertyManager
++ */
++
++ /*!
++ \fn void QtKeySequencePropertyManager::valueChanged(QtProperty *property, const QKeySequence &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.
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtKeySequencePropertyManager::QtKeySequencePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtKeySequencePropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtKeySequencePropertyManager::~QtKeySequencePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an empty QKeySequence object.
++
++ \sa setValue()
++ */
++ QKeySequence QtKeySequencePropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QKeySequence());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtKeySequencePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return it.value().toString(QKeySequence::NativeText);
++ }
++
++ /*!
++ \fn void QtKeySequencePropertyManager::setValue(QtProperty *property, const QKeySequence &value)
++
++ Sets the value of the given \a property to \a value.
++
++ \sa value(), valueChanged()
++ */
++ void QtKeySequencePropertyManager::setValue(QtProperty *property, const QKeySequence &val)
++ {
++ setSimpleValue<const QKeySequence &, QKeySequence, QtKeySequencePropertyManager>(d_ptr->m_values, this,
++ &QtKeySequencePropertyManager::propertyChanged,
++ &QtKeySequencePropertyManager::valueChanged,
++ property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtKeySequencePropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QKeySequence();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtKeySequencePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtCharPropertyManager
++
++ class QtCharPropertyManagerPrivate
++ {
++ QtCharPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtCharPropertyManager)
++ public:
++
++ QHash<const QtProperty *, QChar> m_values;
++ };
++
++ /*! \class QtCharPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtCharPropertyManager provides and manages QChar properties.
++
++ A char's value can be retrieved using the value()
++ function, and set using the setValue() slot.
++
++ In addition, QtCharPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes.
++
++ \sa QtAbstractPropertyManager
++ */
++
++ /*!
++ \fn void QtCharPropertyManager::valueChanged(QtProperty *property, const QChar &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.
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtCharPropertyManager::QtCharPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtCharPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtCharPropertyManager::~QtCharPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an null QChar object.
++
++ \sa setValue()
++ */
++ QChar QtCharPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QChar());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtCharPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QChar c = it.value();
++ return c.isNull() ? QString() : QString(c);
++ }
++
++ /*!
++ \fn void QtCharPropertyManager::setValue(QtProperty *property, const QChar &value)
++
++ Sets the value of the given \a property to \a value.
++
++ \sa value(), valueChanged()
++ */
++ void QtCharPropertyManager::setValue(QtProperty *property, const QChar &val)
++ {
++ setSimpleValue<const QChar &, QChar, QtCharPropertyManager>(d_ptr->m_values, this,
++ &QtCharPropertyManager::propertyChanged,
++ &QtCharPropertyManager::valueChanged,
++ property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtCharPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QChar();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtCharPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtLocalePropertyManager
++
++ class QtLocalePropertyManagerPrivate
++ {
++ QtLocalePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtLocalePropertyManager)
++ public:
++
++ void slotEnumChanged(QtProperty *property, int value);
++ void slotPropertyDestroyed(QtProperty *property);
++
++ QHash<const QtProperty *, QLocale> m_values;
++
++ QtEnumPropertyManager *m_enumPropertyManager = nullptr;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToLanguage;
++ QHash<const QtProperty *, QtProperty *> m_propertyToTerritory;
++
++ QHash<const QtProperty *, QtProperty *> m_languageToProperty;
++ QHash<const QtProperty *, QtProperty *> m_territoryToProperty;
++ };
++
++ void QtLocalePropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *prop = m_languageToProperty.value(property, nullptr)) {
++ const QLocale loc = m_values[prop];
++ QLocale::Language newLanguage = loc.language();
++ QLocale::Territory newTerritory = loc.territory();
++ metaEnumProvider()->indexToLocale(value, 0, &newLanguage, nullptr);
++ QLocale newLoc(newLanguage, newTerritory);
++ q_ptr->setValue(prop, newLoc);
++ } else if (QtProperty *prop = m_territoryToProperty.value(property, nullptr)) {
++ const QLocale loc = m_values[prop];
++ QLocale::Language newLanguage = loc.language();
++ QLocale::Territory newTerritory = loc.territory();
++ metaEnumProvider()->indexToLocale(m_enumPropertyManager->value(m_propertyToLanguage.value(prop)), value, &newLanguage, &newTerritory);
++ QLocale newLoc(newLanguage, newTerritory);
++ q_ptr->setValue(prop, newLoc);
++ }
++ }
++
++ void QtLocalePropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *subProp = m_languageToProperty.value(property, nullptr)) {
++ m_propertyToLanguage[subProp] = nullptr;
++ m_languageToProperty.remove(property);
++ } else if (QtProperty *subProp = m_territoryToProperty.value(property, nullptr)) {
++ m_propertyToTerritory[subProp] = nullptr;
++ m_territoryToProperty.remove(property);
++ }
++ }
++
++ /*!
++ \class QtLocalePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtLocalePropertyManager provides and manages QLocale properties.
++
++ A locale property has nested \e language and \e territory
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by QtEnumPropertyManager object.
++ These submanager can be retrieved using the subEnumPropertyManager()
++ function. In order to provide editing widgets for the subproperties
++ in a property browser widget, this manager must be associated with editor factory.
++
++ In addition, QtLocalePropertyManager provides the valueChanged()
++ signal which is emitted whenever a property created by this
++ manager changes.
++
++ \sa QtAbstractPropertyManager, QtEnumPropertyManager
++ */
++
++ /*!
++ \fn void QtLocalePropertyManager::valueChanged(QtProperty *property, const QLocale &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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtLocalePropertyManager::QtLocalePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtLocalePropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
++ connect(d_ptr->m_enumPropertyManager, &QtEnumPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotEnumChanged(property, value); });
++ connect(d_ptr->m_enumPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtLocalePropertyManager::~QtLocalePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e language
++ and \e territory subproperties.
++
++ In order to provide editing widgets for the mentioned subproperties
++ in a property browser widget, this manager must be associated with
++ an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtEnumPropertyManager *QtLocalePropertyManager::subEnumPropertyManager() const
++ {
++ return d_ptr->m_enumPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns the default locale.
++
++ \sa setValue()
++ */
++ QLocale QtLocalePropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QLocale());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtLocalePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ const QLocale &loc = it.value();
++
++ int langIdx = 0;
++ int territoryIdx = 0;
++ const QtMetaEnumProvider *me = metaEnumProvider();
++ me->localeToIndex(loc.language(), loc.territory(), &langIdx, &territoryIdx);
++ if (langIdx < 0) {
++ qWarning("QtLocalePropertyManager::valueText: Unknown language %d", loc.language());
++ return tr("<Invalid>");
++ }
++ QString languageName = me->languageEnumNames().at(langIdx); // enable move
++ if (territoryIdx < 0) {
++ qWarning("QtLocalePropertyManager::valueText: Unknown territory %d for %s", loc.territory(), qPrintable(languageName));
++ return languageName;
++ }
++ const QString territoryName = me->territoryEnumNames(loc.language()).at(territoryIdx);
++ return tr("%1, %2").arg(languageName, territoryName);
++ }
++
++ /*!
++ \fn void QtLocalePropertyManager::setValue(QtProperty *property, const QLocale &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ \sa value(), valueChanged()
++ */
++ void QtLocalePropertyManager::setValue(QtProperty *property, const QLocale &val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ const QLocale &loc = it.value();
++ if (loc == val)
++ return;
++
++ it.value() = val;
++
++ int langIdx = 0;
++ int territoryIdx = 0;
++ metaEnumProvider()->localeToIndex(val.language(), val.territory(), &langIdx, &territoryIdx);
++ if (loc.language() != val.language()) {
++ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToLanguage.value(property), langIdx);
++ d_ptr->m_enumPropertyManager->setEnumNames(d_ptr->m_propertyToTerritory.value(property),
++ metaEnumProvider()->territoryEnumNames(val.language()));
++ }
++ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToTerritory.value(property), territoryIdx);
++
++ emit propertyChanged(property);
++ emit valueChanged(property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtLocalePropertyManager::initializeProperty(QtProperty *property)
++ {
++ QLocale val;
++ d_ptr->m_values[property] = val;
++
++ int langIdx = 0;
++ int territoryIdx = 0;
++ metaEnumProvider()->localeToIndex(val.language(), val.territory(), &langIdx, &territoryIdx);
++
++ QtProperty *languageProp = d_ptr->m_enumPropertyManager->addProperty();
++ languageProp->setPropertyName(tr("Language"));
++ d_ptr->m_enumPropertyManager->setEnumNames(languageProp, metaEnumProvider()->languageEnumNames());
++ d_ptr->m_enumPropertyManager->setValue(languageProp, langIdx);
++ d_ptr->m_propertyToLanguage[property] = languageProp;
++ d_ptr->m_languageToProperty[languageProp] = property;
++ property->addSubProperty(languageProp);
++
++ QtProperty *territoryProp = d_ptr->m_enumPropertyManager->addProperty();
++ territoryProp->setPropertyName(tr("Territory"));
++ d_ptr->m_enumPropertyManager->setEnumNames(territoryProp, metaEnumProvider()->territoryEnumNames(val.language()));
++ d_ptr->m_enumPropertyManager->setValue(territoryProp, territoryIdx);
++ d_ptr->m_propertyToTerritory[property] = territoryProp;
++ d_ptr->m_territoryToProperty[territoryProp] = property;
++ property->addSubProperty(territoryProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtLocalePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *languageProp = d_ptr->m_propertyToLanguage[property];
++ if (languageProp) {
++ d_ptr->m_languageToProperty.remove(languageProp);
++ delete languageProp;
++ }
++ d_ptr->m_propertyToLanguage.remove(property);
++
++ QtProperty *territoryProp = d_ptr->m_propertyToTerritory[property];
++ if (territoryProp) {
++ d_ptr->m_territoryToProperty.remove(territoryProp);
++ delete territoryProp;
++ }
++ d_ptr->m_propertyToTerritory.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtPointPropertyManager
++
++ class QtPointPropertyManagerPrivate
++ {
++ QtPointPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtPointPropertyManager)
++ public:
++
++ void slotIntChanged(QtProperty *property, int value);
++ void slotPropertyDestroyed(QtProperty *property);
++
++ QHash<const QtProperty *, QPoint> m_values;
++
++ QtIntPropertyManager *m_intPropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToX;
++ QHash<const QtProperty *, QtProperty *> m_propertyToY;
++
++ QHash<const QtProperty *, QtProperty *> m_xToProperty;
++ QHash<const QtProperty *, QtProperty *> m_yToProperty;
++ };
++
++ void QtPointPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *xprop = m_xToProperty.value(property, nullptr)) {
++ QPoint p = m_values[xprop];
++ p.setX(value);
++ q_ptr->setValue(xprop, p);
++ } else if (QtProperty *yprop = m_yToProperty.value(property, nullptr)) {
++ QPoint p = m_values[yprop];
++ p.setY(value);
++ q_ptr->setValue(yprop, p);
++ }
++ }
++
++ void QtPointPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_xToProperty.value(property, nullptr)) {
++ m_propertyToX[pointProp] = nullptr;
++ m_xToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_yToProperty.value(property, nullptr)) {
++ m_propertyToY[pointProp] = nullptr;
++ m_yToProperty.remove(property);
++ }
++ }
++
++ /*! \class QtPointPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtPointPropertyManager provides and manages QPoint properties.
++
++ A point property has nested \e x and \e y subproperties. The
++ top-level property's value can be retrieved using the value()
++ function, and set using the setValue() slot.
++
++ The subproperties are created by a QtIntPropertyManager object. This
++ manager can be retrieved using the subIntPropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ In addition, QtPointPropertyManager provides the valueChanged() signal which
++ is emitted whenever a property created by this manager changes.
++
++ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtPointFPropertyManager
++ */
++
++ /*!
++ \fn void QtPointPropertyManager::valueChanged(QtProperty *property, const QPoint &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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtPointPropertyManager::QtPointPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtPointPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
++ connect(d_ptr->m_intPropertyManager, &QtIntPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotIntChanged(property, value); });
++ connect(d_ptr->m_intPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtPointPropertyManager::~QtPointPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e x and \e y
++ subproperties.
++
++ In order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtIntPropertyManager *QtPointPropertyManager::subIntPropertyManager() const
++ {
++ return d_ptr->m_intPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns a point with coordinates (0, 0).
++
++ \sa setValue()
++ */
++ QPoint QtPointPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QPoint());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtPointPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QPoint v = it.value();
++ return tr("(%1, %2)").arg(v.x()).arg(v.y());
++ }
++
++ /*!
++ \fn void QtPointPropertyManager::setValue(QtProperty *property, const QPoint &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ \sa value(), valueChanged()
++ */
++ void QtPointPropertyManager::setValue(QtProperty *property, QPoint val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ if (it.value() == val)
++ return;
++
++ it.value() = val;
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToX[property], val.x());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToY[property], val.y());
++
++ emit propertyChanged(property);
++ emit valueChanged(property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtPointPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QPoint(0, 0);
++
++ QtProperty *xProp = d_ptr->m_intPropertyManager->addProperty();
++ xProp->setPropertyName(tr("X"));
++ d_ptr->m_intPropertyManager->setValue(xProp, 0);
++ d_ptr->m_propertyToX[property] = xProp;
++ d_ptr->m_xToProperty[xProp] = property;
++ property->addSubProperty(xProp);
++
++ QtProperty *yProp = d_ptr->m_intPropertyManager->addProperty();
++ yProp->setPropertyName(tr("Y"));
++ d_ptr->m_intPropertyManager->setValue(yProp, 0);
++ d_ptr->m_propertyToY[property] = yProp;
++ d_ptr->m_yToProperty[yProp] = property;
++ property->addSubProperty(yProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtPointPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *xProp = d_ptr->m_propertyToX[property];
++ if (xProp) {
++ d_ptr->m_xToProperty.remove(xProp);
++ delete xProp;
++ }
++ d_ptr->m_propertyToX.remove(property);
++
++ QtProperty *yProp = d_ptr->m_propertyToY[property];
++ if (yProp) {
++ d_ptr->m_yToProperty.remove(yProp);
++ delete yProp;
++ }
++ d_ptr->m_propertyToY.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtPointFPropertyManager
++
++ class QtPointFPropertyManagerPrivate
++ {
++ QtPointFPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtPointFPropertyManager)
++ public:
++
++ struct Data
++ {
++ QPointF val;
++ int decimals{2};
++ };
++
++ void slotDoubleChanged(QtProperty *property, double value);
++ void slotPropertyDestroyed(QtProperty *property);
++
++ QHash<const QtProperty *, Data> m_values;
++
++ QtDoublePropertyManager *m_doublePropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToX;
++ QHash<const QtProperty *, QtProperty *> m_propertyToY;
++
++ QHash<const QtProperty *, QtProperty *> m_xToProperty;
++ QHash<const QtProperty *, QtProperty *> m_yToProperty;
++ };
++
++ void QtPointFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
++ {
++ if (QtProperty *prop = m_xToProperty.value(property, nullptr)) {
++ QPointF p = m_values[prop].val;
++ p.setX(value);
++ q_ptr->setValue(prop, p);
++ } else if (QtProperty *prop = m_yToProperty.value(property, nullptr)) {
++ QPointF p = m_values[prop].val;
++ p.setY(value);
++ q_ptr->setValue(prop, p);
++ }
++ }
++
++ void QtPointFPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_xToProperty.value(property, nullptr)) {
++ m_propertyToX[pointProp] = nullptr;
++ m_xToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_yToProperty.value(property, nullptr)) {
++ m_propertyToY[pointProp] = nullptr;
++ m_yToProperty.remove(property);
++ }
++ }
++
++ /*! \class QtPointFPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtPointFPropertyManager provides and manages QPointF properties.
++
++ A point property has nested \e x and \e y subproperties. The
++ top-level property's value can be retrieved using the value()
++ function, and set using the setValue() slot.
++
++ The subproperties are created by a QtDoublePropertyManager object. This
++ manager can be retrieved using the subDoublePropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ In addition, QtPointFPropertyManager provides the valueChanged() signal which
++ is emitted whenever a property created by this manager changes.
++
++ \sa QtAbstractPropertyManager, QtDoublePropertyManager, QtPointPropertyManager
++ */
++
++ /*!
++ \fn void QtPointFPropertyManager::valueChanged(QtProperty *property, const QPointF &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 QtPointFPropertyManager::decimalsChanged(QtProperty *property, int prec)
++
++ This signal is emitted whenever a property created by this manager
++ changes its precision of value, passing a pointer to the
++ \a property and the new \a prec value
++
++ \sa setDecimals()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtPointFPropertyManager::QtPointFPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtPointFPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_doublePropertyManager = new QtDoublePropertyManager(this);
++ connect(d_ptr->m_doublePropertyManager, &QtDoublePropertyManager::valueChanged, this,
++ [this](QtProperty *property, double value) { d_ptr->slotDoubleChanged(property, value); });
++ connect(d_ptr->m_doublePropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtPointFPropertyManager::~QtPointFPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e x and \e y
++ subproperties.
++
++ In order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtDoublePropertyManager *QtPointFPropertyManager::subDoublePropertyManager() const
++ {
++ return d_ptr->m_doublePropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns a point with coordinates (0, 0).
++
++ \sa setValue()
++ */
++ QPointF QtPointFPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QPointF>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's precision, in decimals.
++
++ \sa setDecimals()
++ */
++ int QtPointFPropertyManager::decimals(const QtProperty *property) const
++ {
++ return getData<int>(d_ptr->m_values, &QtPointFPropertyManagerPrivate::Data::decimals, property, 0);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtPointFPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QPointF v = it.value().val;
++ const int dec = it.value().decimals;
++ return tr("(%1, %2)").arg(QString::number(v.x(), 'f', dec),
++ QString::number(v.y(), 'f', dec));
++ }
++
++ /*!
++ \fn void QtPointFPropertyManager::setValue(QtProperty *property, const QPointF &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ \sa value(), valueChanged()
++ */
++ void QtPointFPropertyManager::setValue(QtProperty *property, QPointF val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ if (it.value().val == val)
++ return;
++
++ it.value().val = val;
++ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToX[property], val.x());
++ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToY[property], val.y());
++
++ emit propertyChanged(property);
++ emit valueChanged(property, val);
++ }
++
++ /*!
++ \fn void QtPointFPropertyManager::setDecimals(QtProperty *property, int prec)
++
++ Sets the precision of the given \a property to \a prec.
++
++ The valid decimal range is 0-13. The default is 2.
++
++ \sa decimals()
++ */
++ void QtPointFPropertyManager::setDecimals(QtProperty *property, int prec)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtPointFPropertyManagerPrivate::Data data = it.value();
++
++ if (prec > 13)
++ prec = 13;
++ else if (prec < 0)
++ prec = 0;
++
++ if (data.decimals == prec)
++ return;
++
++ data.decimals = prec;
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToX[property], prec);
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToY[property], prec);
++
++ it.value() = data;
++
++ emit decimalsChanged(property, data.decimals);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtPointFPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtPointFPropertyManagerPrivate::Data();
++
++ QtProperty *xProp = d_ptr->m_doublePropertyManager->addProperty();
++ xProp->setPropertyName(tr("X"));
++ d_ptr->m_doublePropertyManager->setDecimals(xProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(xProp, 0);
++ d_ptr->m_propertyToX[property] = xProp;
++ d_ptr->m_xToProperty[xProp] = property;
++ property->addSubProperty(xProp);
++
++ QtProperty *yProp = d_ptr->m_doublePropertyManager->addProperty();
++ yProp->setPropertyName(tr("Y"));
++ d_ptr->m_doublePropertyManager->setDecimals(yProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(yProp, 0);
++ d_ptr->m_propertyToY[property] = yProp;
++ d_ptr->m_yToProperty[yProp] = property;
++ property->addSubProperty(yProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtPointFPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *xProp = d_ptr->m_propertyToX[property];
++ if (xProp) {
++ d_ptr->m_xToProperty.remove(xProp);
++ delete xProp;
++ }
++ d_ptr->m_propertyToX.remove(property);
++
++ QtProperty *yProp = d_ptr->m_propertyToY[property];
++ if (yProp) {
++ d_ptr->m_yToProperty.remove(yProp);
++ delete yProp;
++ }
++ d_ptr->m_propertyToY.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtSizePropertyManager
++
++ class QtSizePropertyManagerPrivate
++ {
++ QtSizePropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtSizePropertyManager)
++ public:
++
++ void slotIntChanged(QtProperty *property, int value);
++ void slotPropertyDestroyed(QtProperty *property);
++ void setValue(QtProperty *property, QSize val);
++ void setRange(QtProperty *property,
++ QSize minVal, QSize maxVal, QSize val);
++
++ struct Data
++ {
++ QSize val{0, 0};
++ QSize minVal{0, 0};
++ QSize maxVal{std::numeric_limits<int>::max(), std::numeric_limits<int>::max()};
++ QSize minimumValue() const { return minVal; }
++ QSize maximumValue() const { return maxVal; }
++ void setMinimumValue(QSize newMinVal) { setSizeMinimumData(this, newMinVal); }
++ void setMaximumValue(QSize newMaxVal) { setSizeMaximumData(this, newMaxVal); }
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++
++ QtIntPropertyManager *m_intPropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToW;
++ QHash<const QtProperty *, QtProperty *> m_propertyToH;
++
++ QHash<const QtProperty *, QtProperty *> m_wToProperty;
++ QHash<const QtProperty *, QtProperty *> m_hToProperty;
++ };
++
++ void QtSizePropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *prop = m_wToProperty.value(property, nullptr)) {
++ QSize s = m_values[prop].val;
++ s.setWidth(value);
++ q_ptr->setValue(prop, s);
++ } else if (QtProperty *prop = m_hToProperty.value(property, nullptr)) {
++ QSize s = m_values[prop].val;
++ s.setHeight(value);
++ q_ptr->setValue(prop, s);
++ }
++ }
++
++ void QtSizePropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_wToProperty.value(property, nullptr)) {
++ m_propertyToW[pointProp] = nullptr;
++ m_wToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_hToProperty.value(property, nullptr)) {
++ m_propertyToH[pointProp] = nullptr;
++ m_hToProperty.remove(property);
++ }
++ }
++
++ void QtSizePropertyManagerPrivate::setValue(QtProperty *property, QSize val)
++ {
++ m_intPropertyManager->setValue(m_propertyToW.value(property), val.width());
++ m_intPropertyManager->setValue(m_propertyToH.value(property), val.height());
++ }
++
++ void QtSizePropertyManagerPrivate::setRange(QtProperty *property,
++ QSize minVal, QSize maxVal, QSize val)
++ {
++ QtProperty *wProperty = m_propertyToW.value(property);
++ QtProperty *hProperty = m_propertyToH.value(property);
++ m_intPropertyManager->setRange(wProperty, minVal.width(), maxVal.width());
++ m_intPropertyManager->setValue(wProperty, val.width());
++ m_intPropertyManager->setRange(hProperty, minVal.height(), maxVal.height());
++ m_intPropertyManager->setValue(hProperty, val.height());
++ }
++
++ /*!
++ \class QtSizePropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtSizePropertyManager provides and manages QSize properties.
++
++ A size property has nested \e width and \e height
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by a QtIntPropertyManager object. This
++ manager can be retrieved using the subIntPropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ A size property also has a range of valid values defined by a
++ minimum size and a maximum size. These sizes can be retrieved
++ using the minimum() and the maximum() functions, and set using the
++ setMinimum() and setMaximum() slots. Alternatively, the range can
++ be defined in one go using the setRange() slot.
++
++ In addition, QtSizePropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the rangeChanged() signal which is emitted whenever
++ such a property changes its range of valid sizes.
++
++ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtSizeFPropertyManager
++ */
++
++ /*!
++ \fn void QtSizePropertyManager::valueChanged(QtProperty *property, const QSize &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 QtSizePropertyManager::rangeChanged(QtProperty *property, const QSize &minimum, const QSize &maximum)
++
++ This signal is emitted whenever a property created by this manager
++ changes its range of valid sizes, passing a pointer to the \a
++ property and the new \a minimum and \a maximum sizes.
++
++ \sa setRange()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtSizePropertyManager::QtSizePropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtSizePropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
++ connect(d_ptr->m_intPropertyManager, &QtIntPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotIntChanged(property, value); });
++ connect(d_ptr->m_intPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtSizePropertyManager::~QtSizePropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e width and \e height
++ subproperties.
++
++ In order to provide editing widgets for the \e width and \e height
++ properties in a property browser widget, this manager must be
++ associated with an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtIntPropertyManager *QtSizePropertyManager::subIntPropertyManager() const
++ {
++ return d_ptr->m_intPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an invalid size
++
++ \sa setValue()
++ */
++ QSize QtSizePropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QSize>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's minimum size value.
++
++ \sa setMinimum(), maximum(), setRange()
++ */
++ QSize QtSizePropertyManager::minimum(const QtProperty *property) const
++ {
++ return getMinimum<QSize>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's maximum size value.
++
++ \sa setMaximum(), minimum(), setRange()
++ */
++ QSize QtSizePropertyManager::maximum(const QtProperty *property) const
++ {
++ return getMaximum<QSize>(d_ptr->m_values, property);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtSizePropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QSize v = it.value().val;
++ return tr("%1 x %2").arg(v.width()).arg(v.height());
++ }
++
++ /*!
++ \fn void QtSizePropertyManager::setValue(QtProperty *property, const QSize &value)
++
++ Sets the value of the given \a property to \a value.
++
++ If the specified \a value is not valid according to the given \a
++ property's size range, the \a value is adjusted to the nearest
++ valid value within the size range.
++
++ \sa value(), setRange(), valueChanged()
++ */
++ void QtSizePropertyManager::setValue(QtProperty *property, QSize val)
++ {
++ setValueInRange<QSize, QtSizePropertyManagerPrivate, QtSizePropertyManager, const QSize>(this, d_ptr.data(),
++ &QtSizePropertyManager::propertyChanged,
++ &QtSizePropertyManager::valueChanged,
++ property, val, &QtSizePropertyManagerPrivate::setValue);
++ }
++
++ /*!
++ Sets the minimum size value for the given \a property to \a minVal.
++
++ When setting the minimum size value, the maximum and current
++ values are adjusted if necessary (ensuring that the size range
++ remains valid and that the current value is within the range).
++
++ \sa minimum(), setRange(), rangeChanged()
++ */
++ void QtSizePropertyManager::setMinimum(QtProperty *property, QSize minVal)
++ {
++ setBorderValue<QSize, QtSizePropertyManagerPrivate, QtSizePropertyManager, QSize, QtSizePropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtSizePropertyManager::propertyChanged,
++ &QtSizePropertyManager::valueChanged,
++ &QtSizePropertyManager::rangeChanged,
++ property,
++ &QtSizePropertyManagerPrivate::Data::minimumValue,
++ &QtSizePropertyManagerPrivate::Data::setMinimumValue,
++ minVal, &QtSizePropertyManagerPrivate::setRange);
++ }
++
++ /*!
++ Sets the maximum size value for the given \a property to \a maxVal.
++
++ When setting the maximum size value, the minimum and current
++ values are adjusted if necessary (ensuring that the size range
++ remains valid and that the current value is within the range).
++
++ \sa maximum(), setRange(), rangeChanged()
++ */
++ void QtSizePropertyManager::setMaximum(QtProperty *property, QSize maxVal)
++ {
++ setBorderValue<QSize, QtSizePropertyManagerPrivate, QtSizePropertyManager, QSize, QtSizePropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtSizePropertyManager::propertyChanged,
++ &QtSizePropertyManager::valueChanged,
++ &QtSizePropertyManager::rangeChanged,
++ property,
++ &QtSizePropertyManagerPrivate::Data::maximumValue,
++ &QtSizePropertyManagerPrivate::Data::setMaximumValue,
++ maxVal, &QtSizePropertyManagerPrivate::setRange);
++ }
++
++ /*!
++ \fn void QtSizePropertyManager::setRange(QtProperty *property, const QSize &minimum, const QSize &maximum)
++
++ Sets the range of valid values.
++
++ This is a convenience function defining the range of valid values
++ in one go; setting the \a minimum and \a maximum values for the
++ given \a property with a single function call.
++
++ When setting a new range, the current value is adjusted if
++ necessary (ensuring that the value remains within the range).
++
++ \sa setMinimum(), setMaximum(), rangeChanged()
++ */
++ void QtSizePropertyManager::setRange(QtProperty *property, QSize minVal, QSize maxVal)
++ {
++ setBorderValues<QSize, QtSizePropertyManagerPrivate, QtSizePropertyManager, QSize>(this, d_ptr.data(),
++ &QtSizePropertyManager::propertyChanged,
++ &QtSizePropertyManager::valueChanged,
++ &QtSizePropertyManager::rangeChanged,
++ property, minVal, maxVal, &QtSizePropertyManagerPrivate::setRange);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtSizePropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtSizePropertyManagerPrivate::Data();
++
++ QtProperty *wProp = d_ptr->m_intPropertyManager->addProperty();
++ wProp->setPropertyName(tr("Width"));
++ d_ptr->m_intPropertyManager->setValue(wProp, 0);
++ d_ptr->m_intPropertyManager->setMinimum(wProp, 0);
++ d_ptr->m_propertyToW[property] = wProp;
++ d_ptr->m_wToProperty[wProp] = property;
++ property->addSubProperty(wProp);
++
++ QtProperty *hProp = d_ptr->m_intPropertyManager->addProperty();
++ hProp->setPropertyName(tr("Height"));
++ d_ptr->m_intPropertyManager->setValue(hProp, 0);
++ d_ptr->m_intPropertyManager->setMinimum(hProp, 0);
++ d_ptr->m_propertyToH[property] = hProp;
++ d_ptr->m_hToProperty[hProp] = property;
++ property->addSubProperty(hProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtSizePropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *wProp = d_ptr->m_propertyToW[property];
++ if (wProp) {
++ d_ptr->m_wToProperty.remove(wProp);
++ delete wProp;
++ }
++ d_ptr->m_propertyToW.remove(property);
++
++ QtProperty *hProp = d_ptr->m_propertyToH[property];
++ if (hProp) {
++ d_ptr->m_hToProperty.remove(hProp);
++ delete hProp;
++ }
++ d_ptr->m_propertyToH.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtSizeFPropertyManager
++
++ class QtSizeFPropertyManagerPrivate
++ {
++ QtSizeFPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtSizeFPropertyManager)
++ public:
++
++ void slotDoubleChanged(QtProperty *property, double value);
++ void slotPropertyDestroyed(QtProperty *property);
++ void setValue(QtProperty *property, QSizeF val);
++ void setRange(QtProperty *property,
++ QSizeF minVal, QSizeF maxVal, QSizeF val);
++
++ struct Data
++ {
++ QSizeF val{0, 0};
++ QSizeF minVal{0, 0};
++ QSizeF maxVal{std::numeric_limits<qreal>::max(), std::numeric_limits<qreal>::max()};
++ int decimals{2};
++ QSizeF minimumValue() const { return minVal; }
++ QSizeF maximumValue() const { return maxVal; }
++ void setMinimumValue(QSizeF newMinVal) { setSizeMinimumData(this, newMinVal); }
++ void setMaximumValue(QSizeF newMaxVal) { setSizeMaximumData(this, newMaxVal); }
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++
++ QtDoublePropertyManager *m_doublePropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToW;
++ QHash<const QtProperty *, QtProperty *> m_propertyToH;
++
++ QHash<const QtProperty *, QtProperty *> m_wToProperty;
++ QHash<const QtProperty *, QtProperty *> m_hToProperty;
++ };
++
++ void QtSizeFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
++ {
++ if (QtProperty *prop = m_wToProperty.value(property, nullptr)) {
++ QSizeF s = m_values[prop].val;
++ s.setWidth(value);
++ q_ptr->setValue(prop, s);
++ } else if (QtProperty *prop = m_hToProperty.value(property, nullptr)) {
++ QSizeF s = m_values[prop].val;
++ s.setHeight(value);
++ q_ptr->setValue(prop, s);
++ }
++ }
++
++ void QtSizeFPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_wToProperty.value(property, nullptr)) {
++ m_propertyToW[pointProp] = nullptr;
++ m_wToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_hToProperty.value(property, nullptr)) {
++ m_propertyToH[pointProp] = nullptr;
++ m_hToProperty.remove(property);
++ }
++ }
++
++ void QtSizeFPropertyManagerPrivate::setValue(QtProperty *property, QSizeF val)
++ {
++ m_doublePropertyManager->setValue(m_propertyToW.value(property), val.width());
++ m_doublePropertyManager->setValue(m_propertyToH.value(property), val.height());
++ }
++
++ void QtSizeFPropertyManagerPrivate::setRange(QtProperty *property,
++ QSizeF minVal, QSizeF maxVal, QSizeF val)
++ {
++ m_doublePropertyManager->setRange(m_propertyToW[property], minVal.width(), maxVal.width());
++ m_doublePropertyManager->setValue(m_propertyToW[property], val.width());
++ m_doublePropertyManager->setRange(m_propertyToH[property], minVal.height(), maxVal.height());
++ m_doublePropertyManager->setValue(m_propertyToH[property], val.height());
++ }
++
++ /*!
++ \class QtSizeFPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtSizeFPropertyManager provides and manages QSizeF properties.
++
++ A size property has nested \e width and \e height
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by a QtDoublePropertyManager object. This
++ manager can be retrieved using the subDoublePropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ A size property also has a range of valid values defined by a
++ minimum size and a maximum size. These sizes can be retrieved
++ using the minimum() and the maximum() functions, and set using the
++ setMinimum() and setMaximum() slots. Alternatively, the range can
++ be defined in one go using the setRange() slot.
++
++ In addition, QtSizeFPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the rangeChanged() signal which is emitted whenever
++ such a property changes its range of valid sizes.
++
++ \sa QtAbstractPropertyManager, QtDoublePropertyManager, QtSizePropertyManager
++ */
++
++ /*!
++ \fn void QtSizeFPropertyManager::valueChanged(QtProperty *property, const QSizeF &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 QtSizeFPropertyManager::rangeChanged(QtProperty *property, const QSizeF &minimum, const QSizeF &maximum)
++
++ This signal is emitted whenever a property created by this manager
++ changes its range of valid sizes, passing a pointer to the \a
++ property and the new \a minimum and \a maximum sizes.
++
++ \sa setRange()
++ */
++
++ /*!
++ \fn void QtSizeFPropertyManager::decimalsChanged(QtProperty *property, int prec)
++
++ This signal is emitted whenever a property created by this manager
++ changes its precision of value, passing a pointer to the
++ \a property and the new \a prec value
++
++ \sa setDecimals()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtSizeFPropertyManager::QtSizeFPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtSizeFPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_doublePropertyManager = new QtDoublePropertyManager(this);
++ connect(d_ptr->m_doublePropertyManager, &QtDoublePropertyManager::valueChanged, this,
++ [this](QtProperty *property, double value) { d_ptr->slotDoubleChanged(property, value); });
++ connect(d_ptr->m_doublePropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtSizeFPropertyManager::~QtSizeFPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e width and \e height
++ subproperties.
++
++ In order to provide editing widgets for the \e width and \e height
++ properties in a property browser widget, this manager must be
++ associated with an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtDoublePropertyManager *QtSizeFPropertyManager::subDoublePropertyManager() const
++ {
++ return d_ptr->m_doublePropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an invalid size
++
++ \sa setValue()
++ */
++ QSizeF QtSizeFPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QSizeF>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's precision, in decimals.
++
++ \sa setDecimals()
++ */
++ int QtSizeFPropertyManager::decimals(const QtProperty *property) const
++ {
++ return getData<int>(d_ptr->m_values, &QtSizeFPropertyManagerPrivate::Data::decimals, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's minimum size value.
++
++ \sa setMinimum(), maximum(), setRange()
++ */
++ QSizeF QtSizeFPropertyManager::minimum(const QtProperty *property) const
++ {
++ return getMinimum<QSizeF>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's maximum size value.
++
++ \sa setMaximum(), minimum(), setRange()
++ */
++ QSizeF QtSizeFPropertyManager::maximum(const QtProperty *property) const
++ {
++ return getMaximum<QSizeF>(d_ptr->m_values, property);
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtSizeFPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QSizeF v = it.value().val;
++ const int dec = it.value().decimals;
++ return tr("%1 x %2").arg(QString::number(v.width(), 'f', dec),
++ QString::number(v.height(), 'f', dec));
++ }
++
++ /*!
++ \fn void QtSizeFPropertyManager::setValue(QtProperty *property, const QSizeF &value)
++
++ Sets the value of the given \a property to \a value.
++
++ If the specified \a value is not valid according to the given \a
++ property's size range, the \a value is adjusted to the nearest
++ valid value within the size range.
++
++ \sa value(), setRange(), valueChanged()
++ */
++ void QtSizeFPropertyManager::setValue(QtProperty *property, QSizeF val)
++ {
++ setValueInRange<QSizeF, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF>(this, d_ptr.data(),
++ &QtSizeFPropertyManager::propertyChanged,
++ &QtSizeFPropertyManager::valueChanged,
++ property, val, &QtSizeFPropertyManagerPrivate::setValue);
++ }
++
++ /*!
++ \fn void QtSizeFPropertyManager::setDecimals(QtProperty *property, int prec)
++
++ Sets the precision of the given \a property to \a prec.
++
++ The valid decimal range is 0-13. The default is 2.
++
++ \sa decimals()
++ */
++ void QtSizeFPropertyManager::setDecimals(QtProperty *property, int prec)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtSizeFPropertyManagerPrivate::Data data = it.value();
++
++ if (prec > 13)
++ prec = 13;
++ else if (prec < 0)
++ prec = 0;
++
++ if (data.decimals == prec)
++ return;
++
++ data.decimals = prec;
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToW[property], prec);
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToH[property], prec);
++
++ it.value() = data;
++
++ emit decimalsChanged(property, data.decimals);
++ }
++
++ /*!
++ Sets the minimum size value for the given \a property to \a minVal.
++
++ When setting the minimum size value, the maximum and current
++ values are adjusted if necessary (ensuring that the size range
++ remains valid and that the current value is within the range).
++
++ \sa minimum(), setRange(), rangeChanged()
++ */
++ void QtSizeFPropertyManager::setMinimum(QtProperty *property, QSizeF minVal)
++ {
++ setBorderValue<QSizeF, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF, QtSizeFPropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtSizeFPropertyManager::propertyChanged,
++ &QtSizeFPropertyManager::valueChanged,
++ &QtSizeFPropertyManager::rangeChanged,
++ property,
++ &QtSizeFPropertyManagerPrivate::Data::minimumValue,
++ &QtSizeFPropertyManagerPrivate::Data::setMinimumValue,
++ minVal, &QtSizeFPropertyManagerPrivate::setRange);
++ }
++
++ /*!
++ Sets the maximum size value for the given \a property to \a maxVal.
++
++ When setting the maximum size value, the minimum and current
++ values are adjusted if necessary (ensuring that the size range
++ remains valid and that the current value is within the range).
++
++ \sa maximum(), setRange(), rangeChanged()
++ */
++ void QtSizeFPropertyManager::setMaximum(QtProperty *property, QSizeF maxVal)
++ {
++ setBorderValue<QSizeF, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF, QtSizeFPropertyManagerPrivate::Data>(this, d_ptr.data(),
++ &QtSizeFPropertyManager::propertyChanged,
++ &QtSizeFPropertyManager::valueChanged,
++ &QtSizeFPropertyManager::rangeChanged,
++ property,
++ &QtSizeFPropertyManagerPrivate::Data::maximumValue,
++ &QtSizeFPropertyManagerPrivate::Data::setMaximumValue,
++ maxVal, &QtSizeFPropertyManagerPrivate::setRange);
++ }
++
++ /*!
++ \fn void QtSizeFPropertyManager::setRange(QtProperty *property, const QSizeF &minimum, const QSizeF &maximum)
++
++ Sets the range of valid values.
++
++ This is a convenience function defining the range of valid values
++ in one go; setting the \a minimum and \a maximum values for the
++ given \a property with a single function call.
++
++ When setting a new range, the current value is adjusted if
++ necessary (ensuring that the value remains within the range).
++
++ \sa setMinimum(), setMaximum(), rangeChanged()
++ */
++ void QtSizeFPropertyManager::setRange(QtProperty *property, QSizeF minVal, QSizeF maxVal)
++ {
++ setBorderValues<QSizeF, QtSizeFPropertyManagerPrivate, QtSizeFPropertyManager, QSizeF>(this, d_ptr.data(),
++ &QtSizeFPropertyManager::propertyChanged,
++ &QtSizeFPropertyManager::valueChanged,
++ &QtSizeFPropertyManager::rangeChanged,
++ property, minVal, maxVal, &QtSizeFPropertyManagerPrivate::setRange);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtSizeFPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtSizeFPropertyManagerPrivate::Data();
++
++ QtProperty *wProp = d_ptr->m_doublePropertyManager->addProperty();
++ wProp->setPropertyName(tr("Width"));
++ d_ptr->m_doublePropertyManager->setDecimals(wProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(wProp, 0);
++ d_ptr->m_doublePropertyManager->setMinimum(wProp, 0);
++ d_ptr->m_propertyToW[property] = wProp;
++ d_ptr->m_wToProperty[wProp] = property;
++ property->addSubProperty(wProp);
++
++ QtProperty *hProp = d_ptr->m_doublePropertyManager->addProperty();
++ hProp->setPropertyName(tr("Height"));
++ d_ptr->m_doublePropertyManager->setDecimals(hProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(hProp, 0);
++ d_ptr->m_doublePropertyManager->setMinimum(hProp, 0);
++ d_ptr->m_propertyToH[property] = hProp;
++ d_ptr->m_hToProperty[hProp] = property;
++ property->addSubProperty(hProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtSizeFPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *wProp = d_ptr->m_propertyToW[property];
++ if (wProp) {
++ d_ptr->m_wToProperty.remove(wProp);
++ delete wProp;
++ }
++ d_ptr->m_propertyToW.remove(property);
++
++ QtProperty *hProp = d_ptr->m_propertyToH[property];
++ if (hProp) {
++ d_ptr->m_hToProperty.remove(hProp);
++ delete hProp;
++ }
++ d_ptr->m_propertyToH.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtRectPropertyManager
++
++ class QtRectPropertyManagerPrivate
++ {
++ QtRectPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtRectPropertyManager)
++ public:
++
++ void slotIntChanged(QtProperty *property, int value);
++ void slotPropertyDestroyed(QtProperty *property);
++ void setConstraint(QtProperty *property, QRect constraint, QRect val);
++
++ struct Data
++ {
++ QRect val{0, 0, 0, 0};
++ QRect constraint;
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++
++ QtIntPropertyManager *m_intPropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToX;
++ QHash<const QtProperty *, QtProperty *> m_propertyToY;
++ QHash<const QtProperty *, QtProperty *> m_propertyToW;
++ QHash<const QtProperty *, QtProperty *> m_propertyToH;
++
++ QHash<const QtProperty *, QtProperty *> m_xToProperty;
++ QHash<const QtProperty *, QtProperty *> m_yToProperty;
++ QHash<const QtProperty *, QtProperty *> m_wToProperty;
++ QHash<const QtProperty *, QtProperty *> m_hToProperty;
++ };
++
++ void QtRectPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *prop = m_xToProperty.value(property, nullptr)) {
++ QRect r = m_values[prop].val;
++ r.moveLeft(value);
++ q_ptr->setValue(prop, r);
++ } else if (QtProperty *prop = m_yToProperty.value(property)) {
++ QRect r = m_values[prop].val;
++ r.moveTop(value);
++ q_ptr->setValue(prop, r);
++ } else if (QtProperty *prop = m_wToProperty.value(property, nullptr)) {
++ Data data = m_values[prop];
++ QRect r = data.val;
++ r.setWidth(value);
++ if (!data.constraint.isNull() && data.constraint.x() + data.constraint.width() < r.x() + r.width()) {
++ r.moveLeft(data.constraint.left() + data.constraint.width() - r.width());
++ }
++ q_ptr->setValue(prop, r);
++ } else if (QtProperty *prop = m_hToProperty.value(property, nullptr)) {
++ Data data = m_values[prop];
++ QRect r = data.val;
++ r.setHeight(value);
++ if (!data.constraint.isNull() && data.constraint.y() + data.constraint.height() < r.y() + r.height()) {
++ r.moveTop(data.constraint.top() + data.constraint.height() - r.height());
++ }
++ q_ptr->setValue(prop, r);
++ }
++ }
++
++ void QtRectPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_xToProperty.value(property, nullptr)) {
++ m_propertyToX[pointProp] = nullptr;
++ m_xToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_yToProperty.value(property, nullptr)) {
++ m_propertyToY[pointProp] = nullptr;
++ m_yToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_wToProperty.value(property, nullptr)) {
++ m_propertyToW[pointProp] = nullptr;
++ m_wToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_hToProperty.value(property, nullptr)) {
++ m_propertyToH[pointProp] = nullptr;
++ m_hToProperty.remove(property);
++ }
++ }
++
++ void QtRectPropertyManagerPrivate::setConstraint(QtProperty *property,
++ QRect constraint, QRect val)
++ {
++ const bool isNull = constraint.isNull();
++ const int left = isNull ? std::numeric_limits<int>::min() : constraint.left();
++ const int right = isNull
++ ? std::numeric_limits<int>::max() : constraint.left() + constraint.width();
++ const int top = isNull ? std::numeric_limits<int>::min() : constraint.top();
++ const int bottom = isNull
++ ? std::numeric_limits<int>::max() : constraint.top() + constraint.height();
++ const int width = isNull ? std::numeric_limits<int>::max() : constraint.width();
++ const int height = isNull ? std::numeric_limits<int>::max() : constraint.height();
++
++ m_intPropertyManager->setRange(m_propertyToX[property], left, right);
++ m_intPropertyManager->setRange(m_propertyToY[property], top, bottom);
++ m_intPropertyManager->setRange(m_propertyToW[property], 0, width);
++ m_intPropertyManager->setRange(m_propertyToH[property], 0, height);
++
++ m_intPropertyManager->setValue(m_propertyToX[property], val.x());
++ m_intPropertyManager->setValue(m_propertyToY[property], val.y());
++ m_intPropertyManager->setValue(m_propertyToW[property], val.width());
++ m_intPropertyManager->setValue(m_propertyToH[property], val.height());
++ }
++
++ /*!
++ \class QtRectPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtRectPropertyManager provides and manages QRect properties.
++
++ A rectangle property has nested \e x, \e y, \e width and \e height
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by a QtIntPropertyManager object. This
++ manager can be retrieved using the subIntPropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ A rectangle property also has a constraint rectangle which can be
++ retrieved using the constraint() function, and set using the
++ setConstraint() slot.
++
++ In addition, QtRectPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the constraintChanged() signal which is emitted
++ whenever such a property changes its constraint rectangle.
++
++ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtRectFPropertyManager
++ */
++
++ /*!
++ \fn void QtRectPropertyManager::valueChanged(QtProperty *property, const QRect &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 QtRectPropertyManager::constraintChanged(QtProperty *property, const QRect &constraint)
++
++ This signal is emitted whenever property changes its constraint
++ rectangle, passing a pointer to the \a property and the new \a
++ constraint rectangle as parameters.
++
++ \sa setConstraint()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtRectPropertyManager::QtRectPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtRectPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
++ connect(d_ptr->m_intPropertyManager, &QtIntPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotIntChanged(property, value); });
++ connect(d_ptr->m_intPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtRectPropertyManager::~QtRectPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e x, \e y, \e width
++ and \e height subproperties.
++
++ In order to provide editing widgets for the mentioned
++ subproperties in a property browser widget, this manager must be
++ associated with an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtIntPropertyManager *QtRectPropertyManager::subIntPropertyManager() const
++ {
++ return d_ptr->m_intPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an invalid rectangle.
++
++ \sa setValue(), constraint()
++ */
++ QRect QtRectPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QRect>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's constraining rectangle. If returned value is null QRect it means there is no constraint applied.
++
++ \sa value(), setConstraint()
++ */
++ QRect QtRectPropertyManager::constraint(const QtProperty *property) const
++ {
++ return getData<QRect>(d_ptr->m_values, &QtRectPropertyManagerPrivate::Data::constraint, property, QRect());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtRectPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QRect v = it.value().val;
++ return tr("[(%1, %2), %3 x %4]").arg(v.x()) .arg(v.y())
++ .arg(v.width()).arg(v.height());
++ }
++
++ /*!
++ \fn void QtRectPropertyManager::setValue(QtProperty *property, const QRect &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ If the specified \a value is not inside the given \a property's
++ constraining rectangle, the value is adjusted accordingly to fit
++ within the constraint.
++
++ \sa value(), setConstraint(), valueChanged()
++ */
++ void QtRectPropertyManager::setValue(QtProperty *property, QRect val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtRectPropertyManagerPrivate::Data data = it.value();
++
++ QRect newRect = val.normalized();
++ if (!data.constraint.isNull() && !data.constraint.contains(newRect)) {
++ const QRect r1 = data.constraint;
++ const QRect r2 = newRect;
++ newRect.setLeft(qMax(r1.left(), r2.left()));
++ newRect.setRight(qMin(r1.right(), r2.right()));
++ newRect.setTop(qMax(r1.top(), r2.top()));
++ newRect.setBottom(qMin(r1.bottom(), r2.bottom()));
++ if (newRect.width() < 0 || newRect.height() < 0)
++ return;
++ }
++
++ if (data.val == newRect)
++ return;
++
++ data.val = newRect;
++
++ it.value() = data;
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToX[property], newRect.x());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToY[property], newRect.y());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToW[property], newRect.width());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToH[property], newRect.height());
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ Sets the given \a property's constraining rectangle to \a
++ constraint.
++
++ When setting the constraint, the current value is adjusted if
++ necessary (ensuring that the current rectangle value is inside the
++ constraint). In order to reset the constraint pass a null QRect value.
++
++ \sa setValue(), constraint(), constraintChanged()
++ */
++ void QtRectPropertyManager::setConstraint(QtProperty *property, QRect constraint)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtRectPropertyManagerPrivate::Data data = it.value();
++
++ QRect newConstraint = constraint.normalized();
++ if (data.constraint == newConstraint)
++ return;
++
++ const QRect oldVal = data.val;
++
++ data.constraint = newConstraint;
++
++ if (!data.constraint.isNull() && !data.constraint.contains(oldVal)) {
++ QRect r1 = data.constraint;
++ QRect r2 = data.val;
++
++ if (r2.width() > r1.width())
++ r2.setWidth(r1.width());
++ if (r2.height() > r1.height())
++ r2.setHeight(r1.height());
++ if (r2.left() < r1.left())
++ r2.moveLeft(r1.left());
++ else if (r2.right() > r1.right())
++ r2.moveRight(r1.right());
++ if (r2.top() < r1.top())
++ r2.moveTop(r1.top());
++ else if (r2.bottom() > r1.bottom())
++ r2.moveBottom(r1.bottom());
++
++ data.val = r2;
++ }
++
++ it.value() = data;
++
++ emit constraintChanged(property, data.constraint);
++
++ d_ptr->setConstraint(property, data.constraint, data.val);
++
++ if (data.val == oldVal)
++ return;
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtRectPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtRectPropertyManagerPrivate::Data();
++
++ QtProperty *xProp = d_ptr->m_intPropertyManager->addProperty();
++ xProp->setPropertyName(tr("X"));
++ d_ptr->m_intPropertyManager->setValue(xProp, 0);
++ d_ptr->m_propertyToX[property] = xProp;
++ d_ptr->m_xToProperty[xProp] = property;
++ property->addSubProperty(xProp);
++
++ QtProperty *yProp = d_ptr->m_intPropertyManager->addProperty();
++ yProp->setPropertyName(tr("Y"));
++ d_ptr->m_intPropertyManager->setValue(yProp, 0);
++ d_ptr->m_propertyToY[property] = yProp;
++ d_ptr->m_yToProperty[yProp] = property;
++ property->addSubProperty(yProp);
++
++ QtProperty *wProp = d_ptr->m_intPropertyManager->addProperty();
++ wProp->setPropertyName(tr("Width"));
++ d_ptr->m_intPropertyManager->setValue(wProp, 0);
++ d_ptr->m_intPropertyManager->setMinimum(wProp, 0);
++ d_ptr->m_propertyToW[property] = wProp;
++ d_ptr->m_wToProperty[wProp] = property;
++ property->addSubProperty(wProp);
++
++ QtProperty *hProp = d_ptr->m_intPropertyManager->addProperty();
++ hProp->setPropertyName(tr("Height"));
++ d_ptr->m_intPropertyManager->setValue(hProp, 0);
++ d_ptr->m_intPropertyManager->setMinimum(hProp, 0);
++ d_ptr->m_propertyToH[property] = hProp;
++ d_ptr->m_hToProperty[hProp] = property;
++ property->addSubProperty(hProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtRectPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *xProp = d_ptr->m_propertyToX[property];
++ if (xProp) {
++ d_ptr->m_xToProperty.remove(xProp);
++ delete xProp;
++ }
++ d_ptr->m_propertyToX.remove(property);
++
++ QtProperty *yProp = d_ptr->m_propertyToY[property];
++ if (yProp) {
++ d_ptr->m_yToProperty.remove(yProp);
++ delete yProp;
++ }
++ d_ptr->m_propertyToY.remove(property);
++
++ QtProperty *wProp = d_ptr->m_propertyToW[property];
++ if (wProp) {
++ d_ptr->m_wToProperty.remove(wProp);
++ delete wProp;
++ }
++ d_ptr->m_propertyToW.remove(property);
++
++ QtProperty *hProp = d_ptr->m_propertyToH[property];
++ if (hProp) {
++ d_ptr->m_hToProperty.remove(hProp);
++ delete hProp;
++ }
++ d_ptr->m_propertyToH.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtRectFPropertyManager
++
++ class QtRectFPropertyManagerPrivate
++ {
++ QtRectFPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtRectFPropertyManager)
++ public:
++
++ void slotDoubleChanged(QtProperty *property, double value);
++ void slotPropertyDestroyed(QtProperty *property);
++ void setConstraint(QtProperty *property, const QRectF &constraint, const QRectF &val);
++
++ struct Data
++ {
++ QRectF val{0, 0, 0, 0};
++ QRectF constraint;
++ int decimals{2};
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++
++ QtDoublePropertyManager *m_doublePropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToX;
++ QHash<const QtProperty *, QtProperty *> m_propertyToY;
++ QHash<const QtProperty *, QtProperty *> m_propertyToW;
++ QHash<const QtProperty *, QtProperty *> m_propertyToH;
++
++ QHash<const QtProperty *, QtProperty *> m_xToProperty;
++ QHash<const QtProperty *, QtProperty *> m_yToProperty;
++ QHash<const QtProperty *, QtProperty *> m_wToProperty;
++ QHash<const QtProperty *, QtProperty *> m_hToProperty;
++ };
++
++ void QtRectFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
++ {
++ if (QtProperty *prop = m_xToProperty.value(property, nullptr)) {
++ QRectF r = m_values[prop].val;
++ r.moveLeft(value);
++ q_ptr->setValue(prop, r);
++ } else if (QtProperty *prop = m_yToProperty.value(property, nullptr)) {
++ QRectF r = m_values[prop].val;
++ r.moveTop(value);
++ q_ptr->setValue(prop, r);
++ } else if (QtProperty *prop = m_wToProperty.value(property, nullptr)) {
++ Data data = m_values[prop];
++ QRectF r = data.val;
++ r.setWidth(value);
++ if (!data.constraint.isNull() && data.constraint.x() + data.constraint.width() < r.x() + r.width()) {
++ r.moveLeft(data.constraint.left() + data.constraint.width() - r.width());
++ }
++ q_ptr->setValue(prop, r);
++ } else if (QtProperty *prop = m_hToProperty.value(property, nullptr)) {
++ Data data = m_values[prop];
++ QRectF r = data.val;
++ r.setHeight(value);
++ if (!data.constraint.isNull() && data.constraint.y() + data.constraint.height() < r.y() + r.height()) {
++ r.moveTop(data.constraint.top() + data.constraint.height() - r.height());
++ }
++ q_ptr->setValue(prop, r);
++ }
++ }
++
++ void QtRectFPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_xToProperty.value(property, nullptr)) {
++ m_propertyToX[pointProp] = nullptr;
++ m_xToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_yToProperty.value(property, nullptr)) {
++ m_propertyToY[pointProp] = nullptr;
++ m_yToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_wToProperty.value(property, nullptr)) {
++ m_propertyToW[pointProp] = nullptr;
++ m_wToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_hToProperty.value(property, nullptr)) {
++ m_propertyToH[pointProp] = nullptr;
++ m_hToProperty.remove(property);
++ }
++ }
++
++ void QtRectFPropertyManagerPrivate::setConstraint(QtProperty *property,
++ const QRectF &constraint, const QRectF &val)
++ {
++ const bool isNull = constraint.isNull();
++ const float left = isNull ? std::numeric_limits<float>::lowest() : constraint.left();
++ const float right = isNull
++ ? std::numeric_limits<float>::max() : constraint.left() + constraint.width();
++ const float top = isNull ? std::numeric_limits<float>::lowest() : constraint.top();
++ const float bottom = isNull
++ ? std::numeric_limits<float>::max() : constraint.top() + constraint.height();
++ const float width = isNull ? std::numeric_limits<float>::max() : constraint.width();
++ const float height = isNull ? std::numeric_limits<float>::max() : constraint.height();
++
++ m_doublePropertyManager->setRange(m_propertyToX[property], left, right);
++ m_doublePropertyManager->setRange(m_propertyToY[property], top, bottom);
++ m_doublePropertyManager->setRange(m_propertyToW[property], 0, width);
++ m_doublePropertyManager->setRange(m_propertyToH[property], 0, height);
++
++ m_doublePropertyManager->setValue(m_propertyToX[property], val.x());
++ m_doublePropertyManager->setValue(m_propertyToY[property], val.y());
++ m_doublePropertyManager->setValue(m_propertyToW[property], val.width());
++ m_doublePropertyManager->setValue(m_propertyToH[property], val.height());
++ }
++
++ /*!
++ \class QtRectFPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtRectFPropertyManager provides and manages QRectF properties.
++
++ A rectangle property has nested \e x, \e y, \e width and \e height
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by a QtDoublePropertyManager object. This
++ manager can be retrieved using the subDoublePropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ A rectangle property also has a constraint rectangle which can be
++ retrieved using the constraint() function, and set using the
++ setConstraint() slot.
++
++ In addition, QtRectFPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the constraintChanged() signal which is emitted
++ whenever such a property changes its constraint rectangle.
++
++ \sa QtAbstractPropertyManager, QtDoublePropertyManager, QtRectPropertyManager
++ */
++
++ /*!
++ \fn void QtRectFPropertyManager::valueChanged(QtProperty *property, const QRectF &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 QtRectFPropertyManager::constraintChanged(QtProperty *property, const QRectF &constraint)
++
++ This signal is emitted whenever property changes its constraint
++ rectangle, passing a pointer to the \a property and the new \a
++ constraint rectangle as parameters.
++
++ \sa setConstraint()
++ */
++
++ /*!
++ \fn void QtRectFPropertyManager::decimalsChanged(QtProperty *property, int prec)
++
++ This signal is emitted whenever a property created by this manager
++ changes its precision of value, passing a pointer to the
++ \a property and the new \a prec value
++
++ \sa setDecimals()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtRectFPropertyManager::QtRectFPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtRectFPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_doublePropertyManager = new QtDoublePropertyManager(this);
++ connect(d_ptr->m_doublePropertyManager, &QtDoublePropertyManager::valueChanged, this,
++ [this](QtProperty *property, double value) { d_ptr->slotDoubleChanged(property, value); });
++ connect(d_ptr->m_doublePropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtRectFPropertyManager::~QtRectFPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e x, \e y, \e width
++ and \e height subproperties.
++
++ In order to provide editing widgets for the mentioned
++ subproperties in a property browser widget, this manager must be
++ associated with an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtDoublePropertyManager *QtRectFPropertyManager::subDoublePropertyManager() const
++ {
++ return d_ptr->m_doublePropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns an invalid rectangle.
++
++ \sa setValue(), constraint()
++ */
++ QRectF QtRectFPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<QRectF>(d_ptr->m_values, property);
++ }
++
++ /*!
++ Returns the given \a property's precision, in decimals.
++
++ \sa setDecimals()
++ */
++ int QtRectFPropertyManager::decimals(const QtProperty *property) const
++ {
++ return getData<int>(d_ptr->m_values, &QtRectFPropertyManagerPrivate::Data::decimals, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's constraining rectangle. If returned value is null QRectF it means there is no constraint applied.
++
++ \sa value(), setConstraint()
++ */
++ QRectF QtRectFPropertyManager::constraint(const QtProperty *property) const
++ {
++ return getData<QRectF>(d_ptr->m_values, &QtRectFPropertyManagerPrivate::Data::constraint, property, QRect());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtRectFPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ const QRectF v = it.value().val;
++ const int dec = it.value().decimals;
++ return QString(tr("[(%1, %2), %3 x %4]").arg(QString::number(v.x(), 'f', dec),
++ QString::number(v.y(), 'f', dec),
++ QString::number(v.width(), 'f', dec),
++ QString::number(v.height(), 'f', dec)));
++ }
++
++ /*!
++ \fn void QtRectFPropertyManager::setValue(QtProperty *property, const QRectF &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ If the specified \a value is not inside the given \a property's
++ constraining rectangle, the value is adjusted accordingly to fit
++ within the constraint.
++
++ \sa value(), setConstraint(), valueChanged()
++ */
++ void QtRectFPropertyManager::setValue(QtProperty *property, const QRectF &val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtRectFPropertyManagerPrivate::Data data = it.value();
++
++ QRectF newRect = val.normalized();
++ if (!data.constraint.isNull() && !data.constraint.contains(newRect)) {
++ const QRectF r1 = data.constraint;
++ const QRectF r2 = newRect;
++ newRect.setLeft(qMax(r1.left(), r2.left()));
++ newRect.setRight(qMin(r1.right(), r2.right()));
++ newRect.setTop(qMax(r1.top(), r2.top()));
++ newRect.setBottom(qMin(r1.bottom(), r2.bottom()));
++ if (newRect.width() < 0 || newRect.height() < 0)
++ return;
++ }
++
++ if (data.val == newRect)
++ return;
++
++ data.val = newRect;
++
++ it.value() = data;
++ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToX[property], newRect.x());
++ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToY[property], newRect.y());
++ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToW[property], newRect.width());
++ d_ptr->m_doublePropertyManager->setValue(d_ptr->m_propertyToH[property], newRect.height());
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ Sets the given \a property's constraining rectangle to \a
++ constraint.
++
++ When setting the constraint, the current value is adjusted if
++ necessary (ensuring that the current rectangle value is inside the
++ constraint). In order to reset the constraint pass a null QRectF value.
++
++ \sa setValue(), constraint(), constraintChanged()
++ */
++ void QtRectFPropertyManager::setConstraint(QtProperty *property, const QRectF &constraint)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtRectFPropertyManagerPrivate::Data data = it.value();
++
++ QRectF newConstraint = constraint.normalized();
++ if (data.constraint == newConstraint)
++ return;
++
++ const QRectF oldVal = data.val;
++
++ data.constraint = newConstraint;
++
++ if (!data.constraint.isNull() && !data.constraint.contains(oldVal)) {
++ QRectF r1 = data.constraint;
++ QRectF r2 = data.val;
++
++ if (r2.width() > r1.width())
++ r2.setWidth(r1.width());
++ if (r2.height() > r1.height())
++ r2.setHeight(r1.height());
++ if (r2.left() < r1.left())
++ r2.moveLeft(r1.left());
++ else if (r2.right() > r1.right())
++ r2.moveRight(r1.right());
++ if (r2.top() < r1.top())
++ r2.moveTop(r1.top());
++ else if (r2.bottom() > r1.bottom())
++ r2.moveBottom(r1.bottom());
++
++ data.val = r2;
++ }
++
++ it.value() = data;
++
++ emit constraintChanged(property, data.constraint);
++
++ d_ptr->setConstraint(property, data.constraint, data.val);
++
++ if (data.val == oldVal)
++ return;
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ \fn void QtRectFPropertyManager::setDecimals(QtProperty *property, int prec)
++
++ Sets the precision of the given \a property to \a prec.
++
++ The valid decimal range is 0-13. The default is 2.
++
++ \sa decimals()
++ */
++ void QtRectFPropertyManager::setDecimals(QtProperty *property, int prec)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtRectFPropertyManagerPrivate::Data data = it.value();
++
++ if (prec > 13)
++ prec = 13;
++ else if (prec < 0)
++ prec = 0;
++
++ if (data.decimals == prec)
++ return;
++
++ data.decimals = prec;
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToX[property], prec);
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToY[property], prec);
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToW[property], prec);
++ d_ptr->m_doublePropertyManager->setDecimals(d_ptr->m_propertyToH[property], prec);
++
++ it.value() = data;
++
++ emit decimalsChanged(property, data.decimals);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtRectFPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtRectFPropertyManagerPrivate::Data();
++
++ QtProperty *xProp = d_ptr->m_doublePropertyManager->addProperty();
++ xProp->setPropertyName(tr("X"));
++ d_ptr->m_doublePropertyManager->setDecimals(xProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(xProp, 0);
++ d_ptr->m_propertyToX[property] = xProp;
++ d_ptr->m_xToProperty[xProp] = property;
++ property->addSubProperty(xProp);
++
++ QtProperty *yProp = d_ptr->m_doublePropertyManager->addProperty();
++ yProp->setPropertyName(tr("Y"));
++ d_ptr->m_doublePropertyManager->setDecimals(yProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(yProp, 0);
++ d_ptr->m_propertyToY[property] = yProp;
++ d_ptr->m_yToProperty[yProp] = property;
++ property->addSubProperty(yProp);
++
++ QtProperty *wProp = d_ptr->m_doublePropertyManager->addProperty();
++ wProp->setPropertyName(tr("Width"));
++ d_ptr->m_doublePropertyManager->setDecimals(wProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(wProp, 0);
++ d_ptr->m_doublePropertyManager->setMinimum(wProp, 0);
++ d_ptr->m_propertyToW[property] = wProp;
++ d_ptr->m_wToProperty[wProp] = property;
++ property->addSubProperty(wProp);
++
++ QtProperty *hProp = d_ptr->m_doublePropertyManager->addProperty();
++ hProp->setPropertyName(tr("Height"));
++ d_ptr->m_doublePropertyManager->setDecimals(hProp, decimals(property));
++ d_ptr->m_doublePropertyManager->setValue(hProp, 0);
++ d_ptr->m_doublePropertyManager->setMinimum(hProp, 0);
++ d_ptr->m_propertyToH[property] = hProp;
++ d_ptr->m_hToProperty[hProp] = property;
++ property->addSubProperty(hProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtRectFPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *xProp = d_ptr->m_propertyToX[property];
++ if (xProp) {
++ d_ptr->m_xToProperty.remove(xProp);
++ delete xProp;
++ }
++ d_ptr->m_propertyToX.remove(property);
++
++ QtProperty *yProp = d_ptr->m_propertyToY[property];
++ if (yProp) {
++ d_ptr->m_yToProperty.remove(yProp);
++ delete yProp;
++ }
++ d_ptr->m_propertyToY.remove(property);
++
++ QtProperty *wProp = d_ptr->m_propertyToW[property];
++ if (wProp) {
++ d_ptr->m_wToProperty.remove(wProp);
++ delete wProp;
++ }
++ d_ptr->m_propertyToW.remove(property);
++
++ QtProperty *hProp = d_ptr->m_propertyToH[property];
++ if (hProp) {
++ d_ptr->m_hToProperty.remove(hProp);
++ delete hProp;
++ }
++ d_ptr->m_propertyToH.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtEnumPropertyManager
++
++ class QtEnumPropertyManagerPrivate
++ {
++ QtEnumPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtEnumPropertyManager)
++ public:
++
++ struct Data
++ {
++ int val{-1};
++ QStringList enumNames;
++ QMap<int, QIcon> enumIcons;
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++ };
++
++ /*!
++ \class QtEnumPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtEnumPropertyManager provides and manages enum properties.
++
++ Each enum property has an associated list of enum names which can
++ be retrieved using the enumNames() function, and set using the
++ corresponding setEnumNames() function. An enum property's value is
++ represented by an index in this list, and can be retrieved and set
++ using the value() and setValue() slots respectively.
++
++ Each enum value can also have an associated icon. The mapping from
++ values to icons can be set using the setEnumIcons() function and
++ queried with the enumIcons() function.
++
++ In addition, QtEnumPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes. The enumNamesChanged() or enumIconsChanged() signal is emitted
++ whenever the list of enum names or icons is altered.
++
++ \sa QtAbstractPropertyManager, QtEnumEditorFactory
++ */
++
++ /*!
++ \fn void QtEnumPropertyManager::valueChanged(QtProperty *property, int 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 QtEnumPropertyManager::enumNamesChanged(QtProperty *property, const QStringList &names)
++
++ This signal is emitted whenever a property created by this manager
++ changes its enum names, passing a pointer to the \a property and
++ the new \a names as parameters.
++
++ \sa setEnumNames()
++ */
++
++ /*!
++ \fn void QtEnumPropertyManager::enumIconsChanged(QtProperty *property, const QMap<int, QIcon> &icons)
++
++ This signal is emitted whenever a property created by this manager
++ changes its enum icons, passing a pointer to the \a property and
++ the new mapping of values to \a icons as parameters.
++
++ \sa setEnumIcons()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtEnumPropertyManager::QtEnumPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtEnumPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtEnumPropertyManager::~QtEnumPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value which is an index in the
++ list returned by enumNames()
++
++ If the given property is not managed by this manager, this
++ function returns -1.
++
++ \sa enumNames(), setValue()
++ */
++ int QtEnumPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<int>(d_ptr->m_values, property, -1);
++ }
++
++ /*!
++ Returns the given \a property's list of enum names.
++
++ \sa value(), setEnumNames()
++ */
++ QStringList QtEnumPropertyManager::enumNames(const QtProperty *property) const
++ {
++ return getData<QStringList>(d_ptr->m_values, &QtEnumPropertyManagerPrivate::Data::enumNames, property, QStringList());
++ }
++
++ /*!
++ Returns the given \a property's map of enum values to their icons.
++
++ \sa value(), setEnumIcons()
++ */
++ QMap<int, QIcon> QtEnumPropertyManager::enumIcons(const QtProperty *property) const
++ {
++ return getData<QMap<int, QIcon> >(d_ptr->m_values, &QtEnumPropertyManagerPrivate::Data::enumIcons, property, QMap<int, QIcon>());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtEnumPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ const QtEnumPropertyManagerPrivate::Data &data = it.value();
++
++ const int v = data.val;
++ if (v >= 0 && v < data.enumNames.size())
++ return data.enumNames.at(v);
++ return {};
++ }
++
++ /*!
++ \reimp
++ */
++ QIcon QtEnumPropertyManager::valueIcon(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ const QtEnumPropertyManagerPrivate::Data &data = it.value();
++
++ const int v = data.val;
++ return data.enumIcons.value(v);
++ }
++
++ /*!
++ \fn void QtEnumPropertyManager::setValue(QtProperty *property, int value)
++
++ Sets the value of the given \a property to \a value.
++
++ The specified \a value must be less than the size of the given \a
++ property's enumNames() list, and larger than (or equal to) 0.
++
++ \sa value(), valueChanged()
++ */
++ void QtEnumPropertyManager::setValue(QtProperty *property, int val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtEnumPropertyManagerPrivate::Data data = it.value();
++
++ if (val >= data.enumNames.size())
++ return;
++
++ if (val < 0 && !data.enumNames.empty())
++ return;
++
++ if (val < 0)
++ val = -1;
++
++ if (data.val == val)
++ return;
++
++ data.val = val;
++
++ it.value() = data;
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ Sets the given \a property's list of enum names to \a
++ enumNames. The \a property's current value is reset to 0
++ indicating the first item of the list.
++
++ If the specified \a enumNames list is empty, the \a property's
++ current value is set to -1.
++
++ \sa enumNames(), enumNamesChanged()
++ */
++ void QtEnumPropertyManager::setEnumNames(QtProperty *property, const QStringList &enumNames)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtEnumPropertyManagerPrivate::Data data = it.value();
++
++ if (data.enumNames == enumNames)
++ return;
++
++ data.enumNames = enumNames;
++
++ data.val = -1;
++
++ if (!enumNames.empty())
++ data.val = 0;
++
++ it.value() = data;
++
++ emit enumNamesChanged(property, data.enumNames);
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ Sets the given \a property's map of enum values to their icons to \a
++ enumIcons.
++
++ Each enum value can have associated icon. This association is represented with passed \a enumIcons map.
++
++ \sa enumNames(), enumNamesChanged()
++ */
++ void QtEnumPropertyManager::setEnumIcons(QtProperty *property, const QMap<int, QIcon> &enumIcons)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ it.value().enumIcons = enumIcons;
++
++ emit enumIconsChanged(property, it.value().enumIcons);
++
++ emit propertyChanged(property);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtEnumPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtEnumPropertyManagerPrivate::Data();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtEnumPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtFlagPropertyManager
++
++ class QtFlagPropertyManagerPrivate
++ {
++ QtFlagPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtFlagPropertyManager)
++ public:
++
++ void slotBoolChanged(QtProperty *property, bool value);
++ void slotPropertyDestroyed(QtProperty *property);
++
++ struct Data
++ {
++ int val{-1};
++ QStringList flagNames;
++ };
++
++ QHash<const QtProperty *, Data> m_values;
++
++ QtBoolPropertyManager *m_boolPropertyManager;
++
++ QHash<const QtProperty *, QList<QtProperty *>> m_propertyToFlags;
++
++ QHash<const QtProperty *, QtProperty *> m_flagToProperty;
++ };
++
++ void QtFlagPropertyManagerPrivate::slotBoolChanged(QtProperty *property, bool value)
++ {
++ QtProperty *prop = m_flagToProperty.value(property, nullptr);
++ if (prop == nullptr)
++ return;
++
++ const auto pfit = m_propertyToFlags.constFind(prop);
++ if (pfit == m_propertyToFlags.constEnd())
++ return;
++ int level = 0;
++ for (QtProperty *p : pfit.value()) {
++ if (p == property) {
++ int v = m_values[prop].val;
++ if (value) {
++ v |= (1 << level);
++ } else {
++ v &= ~(1 << level);
++ }
++ q_ptr->setValue(prop, v);
++ return;
++ }
++ level++;
++ }
++ }
++
++ void QtFlagPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ QtProperty *flagProperty = m_flagToProperty.value(property, nullptr);
++ if (flagProperty == nullptr)
++ return;
++
++ m_propertyToFlags[flagProperty].replace(m_propertyToFlags[flagProperty].indexOf(property), nullptr);
++ m_flagToProperty.remove(property);
++ }
++
++ /*!
++ \class QtFlagPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtFlagPropertyManager provides and manages flag properties.
++
++ Each flag property has an associated list of flag names which can
++ be retrieved using the flagNames() function, and set using the
++ corresponding setFlagNames() function.
++
++ The flag manager provides properties with nested boolean
++ subproperties representing each flag, i.e. a flag property's value
++ is the binary combination of the subproperties' values. A
++ property's value can be retrieved and set using the value() and
++ setValue() slots respectively. The combination of flags is represented
++ by single int value - that's why it's possible to store up to
++ 32 independent flags in one flag property.
++
++ The subproperties are created by a QtBoolPropertyManager object. This
++ manager can be retrieved using the subBoolPropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ In addition, QtFlagPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes, and the flagNamesChanged() signal which is emitted
++ whenever the list of flag names is altered.
++
++ \sa QtAbstractPropertyManager, QtBoolPropertyManager
++ */
++
++ /*!
++ \fn void QtFlagPropertyManager::valueChanged(QtProperty *property, int 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 QtFlagPropertyManager::flagNamesChanged(QtProperty *property, const QStringList &names)
++
++ This signal is emitted whenever a property created by this manager
++ changes its flag names, passing a pointer to the \a property and the
++ new \a names as parameters.
++
++ \sa setFlagNames()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtFlagPropertyManager::QtFlagPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtFlagPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
++ connect(d_ptr->m_boolPropertyManager, &QtBoolPropertyManager::valueChanged, this,
++ [this](QtProperty *property, bool value) { d_ptr->slotBoolChanged(property, value); });
++ connect(d_ptr->m_boolPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtFlagPropertyManager::~QtFlagPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that produces the nested boolean subproperties
++ representing each flag.
++
++ In order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtBoolPropertyManager *QtFlagPropertyManager::subBoolPropertyManager() const
++ {
++ return d_ptr->m_boolPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns 0.
++
++ \sa flagNames(), setValue()
++ */
++ int QtFlagPropertyManager::value(const QtProperty *property) const
++ {
++ return getValue<int>(d_ptr->m_values, property, 0);
++ }
++
++ /*!
++ Returns the given \a property's list of flag names.
++
++ \sa value(), setFlagNames()
++ */
++ QStringList QtFlagPropertyManager::flagNames(const QtProperty *property) const
++ {
++ return getData<QStringList>(d_ptr->m_values, &QtFlagPropertyManagerPrivate::Data::flagNames, property, QStringList());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtFlagPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ const QtFlagPropertyManagerPrivate::Data &data = it.value();
++
++ QString str;
++ int level = 0;
++ const QChar bar = QLatin1Char('|');
++ for (const auto &name : data.flagNames) {
++ if (data.val & (1 << level)) {
++ if (!str.isEmpty())
++ str += bar;
++ str += name;
++ }
++
++ level++;
++ }
++ return str;
++ }
++
++ /*!
++ \fn void QtFlagPropertyManager::setValue(QtProperty *property, int value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ The specified \a value must be less than the binary combination of
++ the property's flagNames() list size (i.e. less than 2\sup n,
++ where \c n is the size of the list) and larger than (or equal to)
++ 0.
++
++ \sa value(), valueChanged()
++ */
++ void QtFlagPropertyManager::setValue(QtProperty *property, int val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtFlagPropertyManagerPrivate::Data data = it.value();
++
++ if (data.val == val)
++ return;
++
++ if (val > (1 << data.flagNames.size()) - 1)
++ return;
++
++ if (val < 0)
++ return;
++
++ data.val = val;
++
++ it.value() = data;
++
++ const auto pfit = d_ptr->m_propertyToFlags.constFind(property);
++ int level = 0;
++ if (pfit != d_ptr->m_propertyToFlags.constEnd()) {
++ for (QtProperty *prop : pfit.value()) {
++ if (prop)
++ d_ptr->m_boolPropertyManager->setValue(prop, val & (1 << level));
++ level++;
++ }
++ }
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ Sets the given \a property's list of flag names to \a flagNames. The
++ property's current value is reset to 0 indicating the first item
++ of the list.
++
++ \sa flagNames(), flagNamesChanged()
++ */
++ void QtFlagPropertyManager::setFlagNames(QtProperty *property, const QStringList &flagNames)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ QtFlagPropertyManagerPrivate::Data data = it.value();
++
++ if (data.flagNames == flagNames)
++ return;
++
++ data.flagNames = flagNames;
++ data.val = 0;
++
++ it.value() = data;
++
++ const auto pfit = d_ptr->m_propertyToFlags.find(property);
++ if (pfit != d_ptr->m_propertyToFlags.end()) {
++ for (QtProperty *prop : std::as_const(pfit.value())) {
++ if (prop) {
++ delete prop;
++ d_ptr->m_flagToProperty.remove(prop);
++ }
++ }
++ pfit.value().clear();
++ }
++
++ for (const QString &flagName : flagNames) {
++ QtProperty *prop = d_ptr->m_boolPropertyManager->addProperty();
++ prop->setPropertyName(flagName);
++ property->addSubProperty(prop);
++ d_ptr->m_propertyToFlags[property].append(prop);
++ d_ptr->m_flagToProperty[prop] = property;
++ }
++
++ emit flagNamesChanged(property, data.flagNames);
++
++ emit propertyChanged(property);
++ emit valueChanged(property, data.val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtFlagPropertyManager::initializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values[property] = QtFlagPropertyManagerPrivate::Data();
++
++ d_ptr->m_propertyToFlags[property] = QList<QtProperty *>();
++ }
++
++ /*!
++ \reimp
++ */
++ void QtFlagPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ const auto it = d_ptr->m_propertyToFlags.find(property);
++ if (it != d_ptr->m_propertyToFlags.end()) {
++ for (QtProperty *prop : std::as_const(it.value())) {
++ if (prop) {
++ d_ptr->m_flagToProperty.remove(prop);
++ delete prop;
++ }
++ }
++ }
++ d_ptr->m_propertyToFlags.erase(it);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtSizePolicyPropertyManager
++
++ class QtSizePolicyPropertyManagerPrivate
++ {
++ QtSizePolicyPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtSizePolicyPropertyManager)
++ public:
++
++ void slotIntChanged(QtProperty *property, int value);
++ void slotEnumChanged(QtProperty *property, int value);
++ void slotPropertyDestroyed(QtProperty *property);
++
++ QHash<const QtProperty *, QSizePolicy> m_values;
++
++ QtIntPropertyManager *m_intPropertyManager = nullptr;
++ QtEnumPropertyManager *m_enumPropertyManager = nullptr;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToHPolicy;
++ QHash<const QtProperty *, QtProperty *> m_propertyToVPolicy;
++ QHash<const QtProperty *, QtProperty *> m_propertyToHStretch;
++ QHash<const QtProperty *, QtProperty *> m_propertyToVStretch;
++
++ QHash<const QtProperty *, QtProperty *> m_hPolicyToProperty;
++ QHash<const QtProperty *, QtProperty *> m_vPolicyToProperty;
++ QHash<const QtProperty *, QtProperty *> m_hStretchToProperty;
++ QHash<const QtProperty *, QtProperty *> m_vStretchToProperty;
++ };
++
++ void QtSizePolicyPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *prop = m_hStretchToProperty.value(property, nullptr)) {
++ QSizePolicy sp = m_values[prop];
++ sp.setHorizontalStretch(value);
++ q_ptr->setValue(prop, sp);
++ } else if (QtProperty *prop = m_vStretchToProperty.value(property, nullptr)) {
++ QSizePolicy sp = m_values[prop];
++ sp.setVerticalStretch(value);
++ q_ptr->setValue(prop, sp);
++ }
++ }
++
++ void QtSizePolicyPropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *prop = m_hPolicyToProperty.value(property, nullptr)) {
++ QSizePolicy sp = m_values[prop];
++ sp.setHorizontalPolicy(metaEnumProvider()->indexToSizePolicy(value));
++ q_ptr->setValue(prop, sp);
++ } else if (QtProperty *prop = m_vPolicyToProperty.value(property, nullptr)) {
++ QSizePolicy sp = m_values[prop];
++ sp.setVerticalPolicy(metaEnumProvider()->indexToSizePolicy(value));
++ q_ptr->setValue(prop, sp);
++ }
++ }
++
++ void QtSizePolicyPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_hStretchToProperty.value(property, nullptr)) {
++ m_propertyToHStretch[pointProp] = nullptr;
++ m_hStretchToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_vStretchToProperty.value(property, nullptr)) {
++ m_propertyToVStretch[pointProp] = nullptr;
++ m_vStretchToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_hPolicyToProperty.value(property, nullptr)) {
++ m_propertyToHPolicy[pointProp] = nullptr;
++ m_hPolicyToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_vPolicyToProperty.value(property, nullptr)) {
++ m_propertyToVPolicy[pointProp] = nullptr;
++ m_vPolicyToProperty.remove(property);
++ }
++ }
++
++ /*!
++ \class QtSizePolicyPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtSizePolicyPropertyManager provides and manages QSizePolicy properties.
++
++ A size policy property has nested \e horizontalPolicy, \e
++ verticalPolicy, \e horizontalStretch and \e verticalStretch
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by QtIntPropertyManager and QtEnumPropertyManager
++ objects. These managers can be retrieved using the subIntPropertyManager()
++ and subEnumPropertyManager() functions respectively. In order to provide
++ editing widgets for the subproperties in a property browser widget,
++ these managers must be associated with editor factories.
++
++ In addition, QtSizePolicyPropertyManager provides the valueChanged()
++ signal which is emitted whenever a property created by this
++ manager changes.
++
++ \sa QtAbstractPropertyManager, QtIntPropertyManager, QtEnumPropertyManager
++ */
++
++ /*!
++ \fn void QtSizePolicyPropertyManager::valueChanged(QtProperty *property, const QSizePolicy &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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtSizePolicyPropertyManager::QtSizePolicyPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtSizePolicyPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
++ connect(d_ptr->m_intPropertyManager, &QtIntPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotIntChanged(property, value); });
++ connect(d_ptr->m_intPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++
++ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
++ connect(d_ptr->m_enumPropertyManager, &QtEnumPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotEnumChanged(property, value); });
++ connect(d_ptr->m_enumPropertyManager, &QtEnumPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtSizePolicyPropertyManager::~QtSizePolicyPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the nested \e horizontalStretch
++ and \e verticalStretch subproperties.
++
++ In order to provide editing widgets for the mentioned subproperties
++ in a property browser widget, this manager must be associated with
++ an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtIntPropertyManager *QtSizePolicyPropertyManager::subIntPropertyManager() const
++ {
++ return d_ptr->m_intPropertyManager;
++ }
++
++ /*!
++ Returns the manager that creates the nested \e horizontalPolicy
++ and \e verticalPolicy subproperties.
++
++ In order to provide editing widgets for the mentioned subproperties
++ in a property browser widget, this manager must be associated with
++ an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtEnumPropertyManager *QtSizePolicyPropertyManager::subEnumPropertyManager() const
++ {
++ return d_ptr->m_enumPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns the default size policy.
++
++ \sa setValue()
++ */
++ QSizePolicy QtSizePolicyPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QSizePolicy());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtSizePolicyPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ const QSizePolicy sp = it.value();
++ const QtMetaEnumProvider *mep = metaEnumProvider();
++ const int hIndex = mep->sizePolicyToIndex(sp.horizontalPolicy());
++ const int vIndex = mep->sizePolicyToIndex(sp.verticalPolicy());
++ //! Unknown size policy on reading invalid uic3 files
++ const QString hPolicy = hIndex != -1 ? mep->policyEnumNames().at(hIndex) : tr("<Invalid>");
++ const QString vPolicy = vIndex != -1 ? mep->policyEnumNames().at(vIndex) : tr("<Invalid>");
++ const QString str = tr("[%1, %2, %3, %4]").arg(hPolicy, vPolicy).arg(sp.horizontalStretch()).arg(sp.verticalStretch());
++ return str;
++ }
++
++ /*!
++ \fn void QtSizePolicyPropertyManager::setValue(QtProperty *property, const QSizePolicy &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ \sa value(), valueChanged()
++ */
++ void QtSizePolicyPropertyManager::setValue(QtProperty *property, QSizePolicy val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ if (it.value() == val)
++ return;
++
++ it.value() = val;
++
++ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToHPolicy[property],
++ metaEnumProvider()->sizePolicyToIndex(val.horizontalPolicy()));
++ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToVPolicy[property],
++ metaEnumProvider()->sizePolicyToIndex(val.verticalPolicy()));
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToHStretch[property],
++ val.horizontalStretch());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToVStretch[property],
++ val.verticalStretch());
++
++ emit propertyChanged(property);
++ emit valueChanged(property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtSizePolicyPropertyManager::initializeProperty(QtProperty *property)
++ {
++ QSizePolicy val;
++ d_ptr->m_values[property] = val;
++
++ QtProperty *hPolicyProp = d_ptr->m_enumPropertyManager->addProperty();
++ hPolicyProp->setPropertyName(tr("Horizontal Policy"));
++ d_ptr->m_enumPropertyManager->setEnumNames(hPolicyProp, metaEnumProvider()->policyEnumNames());
++ d_ptr->m_enumPropertyManager->setValue(hPolicyProp,
++ metaEnumProvider()->sizePolicyToIndex(val.horizontalPolicy()));
++ d_ptr->m_propertyToHPolicy[property] = hPolicyProp;
++ d_ptr->m_hPolicyToProperty[hPolicyProp] = property;
++ property->addSubProperty(hPolicyProp);
++
++ QtProperty *vPolicyProp = d_ptr->m_enumPropertyManager->addProperty();
++ vPolicyProp->setPropertyName(tr("Vertical Policy"));
++ d_ptr->m_enumPropertyManager->setEnumNames(vPolicyProp, metaEnumProvider()->policyEnumNames());
++ d_ptr->m_enumPropertyManager->setValue(vPolicyProp,
++ metaEnumProvider()->sizePolicyToIndex(val.verticalPolicy()));
++ d_ptr->m_propertyToVPolicy[property] = vPolicyProp;
++ d_ptr->m_vPolicyToProperty[vPolicyProp] = property;
++ property->addSubProperty(vPolicyProp);
++
++ QtProperty *hStretchProp = d_ptr->m_intPropertyManager->addProperty();
++ hStretchProp->setPropertyName(tr("Horizontal Stretch"));
++ d_ptr->m_intPropertyManager->setValue(hStretchProp, val.horizontalStretch());
++ d_ptr->m_intPropertyManager->setRange(hStretchProp, 0, 0xff);
++ d_ptr->m_propertyToHStretch[property] = hStretchProp;
++ d_ptr->m_hStretchToProperty[hStretchProp] = property;
++ property->addSubProperty(hStretchProp);
++
++ QtProperty *vStretchProp = d_ptr->m_intPropertyManager->addProperty();
++ vStretchProp->setPropertyName(tr("Vertical Stretch"));
++ d_ptr->m_intPropertyManager->setValue(vStretchProp, val.verticalStretch());
++ d_ptr->m_intPropertyManager->setRange(vStretchProp, 0, 0xff);
++ d_ptr->m_propertyToVStretch[property] = vStretchProp;
++ d_ptr->m_vStretchToProperty[vStretchProp] = property;
++ property->addSubProperty(vStretchProp);
++
++ }
++
++ /*!
++ \reimp
++ */
++ void QtSizePolicyPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *hPolicyProp = d_ptr->m_propertyToHPolicy[property];
++ if (hPolicyProp) {
++ d_ptr->m_hPolicyToProperty.remove(hPolicyProp);
++ delete hPolicyProp;
++ }
++ d_ptr->m_propertyToHPolicy.remove(property);
++
++ QtProperty *vPolicyProp = d_ptr->m_propertyToVPolicy[property];
++ if (vPolicyProp) {
++ d_ptr->m_vPolicyToProperty.remove(vPolicyProp);
++ delete vPolicyProp;
++ }
++ d_ptr->m_propertyToVPolicy.remove(property);
++
++ QtProperty *hStretchProp = d_ptr->m_propertyToHStretch[property];
++ if (hStretchProp) {
++ d_ptr->m_hStretchToProperty.remove(hStretchProp);
++ delete hStretchProp;
++ }
++ d_ptr->m_propertyToHStretch.remove(property);
++
++ QtProperty *vStretchProp = d_ptr->m_propertyToVStretch[property];
++ if (vStretchProp) {
++ d_ptr->m_vStretchToProperty.remove(vStretchProp);
++ delete vStretchProp;
++ }
++ d_ptr->m_propertyToVStretch.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtFontPropertyManager:
++ // QtFontPropertyManagerPrivate has a mechanism for reacting
++ // to QApplication::fontDatabaseChanged() [4.5], which is emitted
++ // when someone loads an application font. The signals are compressed
++ // using a timer with interval 0, which then causes the family
++ // enumeration manager to re-set its strings and index values
++ // for each property.
++
++ class QtFontPropertyManagerPrivate
++ {
++ QtFontPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtFontPropertyManager)
++ public:
++
++ void slotIntChanged(QtProperty *property, int value);
++ void slotEnumChanged(QtProperty *property, int value);
++ void slotBoolChanged(QtProperty *property, bool value);
++ void slotPropertyDestroyed(QtProperty *property);
++ void slotFontDatabaseChanged();
++ void slotFontDatabaseDelayedChange();
++
++ QStringList m_familyNames;
++
++ QHash<const QtProperty *, QFont> m_values;
++
++ QtIntPropertyManager *m_intPropertyManager;
++ QtEnumPropertyManager *m_enumPropertyManager;
++ QtBoolPropertyManager *m_boolPropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToFamily;
++ QHash<const QtProperty *, QtProperty *> m_propertyToPointSize;
++ QHash<const QtProperty *, QtProperty *> m_propertyToBold;
++ QHash<const QtProperty *, QtProperty *> m_propertyToItalic;
++ QHash<const QtProperty *, QtProperty *> m_propertyToUnderline;
++ QHash<const QtProperty *, QtProperty *> m_propertyToStrikeOut;
++ QHash<const QtProperty *, QtProperty *> m_propertyToKerning;
++ QHash<const QtProperty *, QtProperty *> m_propertyToWeight;
++
++ QHash<const QtProperty *, QtProperty *> m_familyToProperty;
++ QHash<const QtProperty *, QtProperty *> m_pointSizeToProperty;
++ QHash<const QtProperty *, QtProperty *> m_boldToProperty;
++ QHash<const QtProperty *, QtProperty *> m_italicToProperty;
++ QHash<const QtProperty *, QtProperty *> m_underlineToProperty;
++ QHash<const QtProperty *, QtProperty *> m_strikeOutToProperty;
++ QHash<const QtProperty *, QtProperty *> m_kerningToProperty;
++ QHash<const QtProperty *, QtProperty *> m_weightToProperty;
++
++ bool m_settingValue = false;
++ QTimer *m_fontDatabaseChangeTimer = nullptr;
++ };
++
++ void QtFontPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
++ {
++ if (m_settingValue)
++ return;
++ if (QtProperty *prop = m_pointSizeToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setPointSize(value);
++ q_ptr->setValue(prop, f);
++ }
++ }
++
++ void QtFontPropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
++ {
++ if (m_settingValue)
++ return;
++ if (QtProperty *prop = m_familyToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setFamily(m_familyNames.at(value));
++ q_ptr->setValue(prop, f);
++ } else if (auto *prop = m_weightToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setWeight(weightFromIndex(value));
++ q_ptr->setValue(prop, f);
++ }
++ }
++
++ void QtFontPropertyManagerPrivate::slotBoolChanged(QtProperty *property, bool value)
++ {
++ if (m_settingValue)
++ return;
++ if (QtProperty *prop = m_boldToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setBold(value);
++ q_ptr->setValue(prop, f);
++ } else if (QtProperty *prop = m_italicToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setItalic(value);
++ q_ptr->setValue(prop, f);
++ } else if (QtProperty *prop = m_underlineToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setUnderline(value);
++ q_ptr->setValue(prop, f);
++ } else if (QtProperty *prop = m_strikeOutToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setStrikeOut(value);
++ q_ptr->setValue(prop, f);
++ } else if (QtProperty *prop = m_kerningToProperty.value(property, nullptr)) {
++ QFont f = m_values[prop];
++ f.setKerning(value);
++ q_ptr->setValue(prop, f);
++ }
++ }
++
++ void QtFontPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_pointSizeToProperty.value(property, nullptr)) {
++ m_propertyToPointSize[pointProp] = nullptr;
++ m_pointSizeToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_familyToProperty.value(property, nullptr)) {
++ m_propertyToFamily[pointProp] = nullptr;
++ m_familyToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_boldToProperty.value(property, nullptr)) {
++ m_propertyToBold[pointProp] = nullptr;
++ m_boldToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_italicToProperty.value(property, nullptr)) {
++ m_propertyToItalic[pointProp] = nullptr;
++ m_italicToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_underlineToProperty.value(property, nullptr)) {
++ m_propertyToUnderline[pointProp] = nullptr;
++ m_underlineToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_strikeOutToProperty.value(property, nullptr)) {
++ m_propertyToStrikeOut[pointProp] = nullptr;
++ m_strikeOutToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_kerningToProperty.value(property, nullptr)) {
++ m_propertyToKerning[pointProp] = nullptr;
++ m_kerningToProperty.remove(property);
++ } else if (QtProperty *weightProp = m_weightToProperty.value(property, nullptr)) {
++ m_propertyToWeight[weightProp] = nullptr;
++ m_weightToProperty.remove(property);
++ }
++ }
++
++ void QtFontPropertyManagerPrivate::slotFontDatabaseChanged()
++ {
++ if (!m_fontDatabaseChangeTimer) {
++ m_fontDatabaseChangeTimer = new QTimer(q_ptr);
++ m_fontDatabaseChangeTimer->setInterval(0);
++ m_fontDatabaseChangeTimer->setSingleShot(true);
++ QObject::connect(m_fontDatabaseChangeTimer, &QTimer::timeout, q_ptr,
++ [this] { slotFontDatabaseDelayedChange(); });
++ }
++ if (!m_fontDatabaseChangeTimer->isActive())
++ m_fontDatabaseChangeTimer->start();
++ }
++
++ void QtFontPropertyManagerPrivate::slotFontDatabaseDelayedChange()
++ {
++ // rescan available font names
++ const QStringList oldFamilies = m_familyNames;
++ m_familyNames = QFontDatabase::families();
++
++ // Adapt all existing properties
++ if (!m_propertyToFamily.isEmpty()) {
++ for (QtProperty *familyProp : std::as_const(m_propertyToFamily)) {
++ const int oldIdx = m_enumPropertyManager->value(familyProp);
++ qsizetype newIdx = m_familyNames.indexOf(oldFamilies.at(oldIdx));
++ if (newIdx < 0)
++ newIdx = 0;
++ m_enumPropertyManager->setEnumNames(familyProp, m_familyNames);
++ m_enumPropertyManager->setValue(familyProp, newIdx);
++ }
++ }
++ }
++
++ /*!
++ \class QtFontPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtFontPropertyManager provides and manages QFont properties.
++
++ A font property has nested \e family, \e pointSize, \e bold, \e
++ italic, \e underline, \e strikeOut and \e kerning subproperties. The top-level
++ property's value can be retrieved using the value() function, and
++ set using the setValue() slot.
++
++ The subproperties are created by QtIntPropertyManager, QtEnumPropertyManager and
++ QtBoolPropertyManager objects. These managers can be retrieved using the
++ corresponding subIntPropertyManager(), subEnumPropertyManager() and
++ subBoolPropertyManager() functions. In order to provide editing widgets
++ for the subproperties in a property browser widget, these managers
++ must be associated with editor factories.
++
++ In addition, QtFontPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes.
++
++ \sa QtAbstractPropertyManager, QtEnumPropertyManager, QtIntPropertyManager, QtBoolPropertyManager
++ */
++
++ /*!
++ \fn void QtFontPropertyManager::valueChanged(QtProperty *property, const QFont &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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtFontPropertyManager::QtFontPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtFontPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ QObject::connect(qApp, &QGuiApplication::fontDatabaseChanged, this,
++ [this] { d_ptr->slotFontDatabaseChanged(); });
++
++ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
++ connect(d_ptr->m_intPropertyManager, &QtIntPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotIntChanged(property, value); });
++ connect(d_ptr->m_intPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++
++ d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
++ connect(d_ptr->m_enumPropertyManager, &QtEnumPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotEnumChanged(property, value); });
++ connect(d_ptr->m_enumPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++
++ d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
++ connect(d_ptr->m_boolPropertyManager, &QtBoolPropertyManager::valueChanged, this,
++ [this](QtProperty *property, bool value) { d_ptr->slotBoolChanged(property, value); });
++ connect(d_ptr->m_boolPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtFontPropertyManager::~QtFontPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that creates the \e pointSize subproperty.
++
++ In order to provide editing widgets for the \e pointSize property
++ in a property browser widget, this manager must be associated
++ with an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtIntPropertyManager *QtFontPropertyManager::subIntPropertyManager() const
++ {
++ return d_ptr->m_intPropertyManager;
++ }
++
++ /*!
++ Returns the manager that create the \e family subproperty.
++
++ In order to provide editing widgets for the \e family property
++ in a property browser widget, this manager must be associated
++ with an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtEnumPropertyManager *QtFontPropertyManager::subEnumPropertyManager() const
++ {
++ return d_ptr->m_enumPropertyManager;
++ }
++
++ /*!
++ Returns the manager that creates the \e bold, \e italic, \e underline,
++ \e strikeOut and \e kerning subproperties.
++
++ In order to provide editing widgets for the mentioned properties
++ in a property browser widget, this manager must be associated with
++ an editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtBoolPropertyManager *QtFontPropertyManager::subBoolPropertyManager() const
++ {
++ return d_ptr->m_boolPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given property is not managed by this manager, this
++ function returns a font object that uses the application's default
++ font.
++
++ \sa setValue()
++ */
++ QFont QtFontPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QFont());
++ }
++
++ /*!
++ \reimp
++ */
++ QString QtFontPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ return QtPropertyBrowserUtils::fontValueText(it.value());
++ }
++
++ /*!
++ \reimp
++ */
++ QIcon QtFontPropertyManager::valueIcon(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ return QtPropertyBrowserUtils::fontValueIcon(it.value());
++ }
++
++ /*!
++ \fn void QtFontPropertyManager::setValue(QtProperty *property, const QFont &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ \sa value(), valueChanged()
++ */
++ void QtFontPropertyManager::setValue(QtProperty *property, const QFont &val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ const QFont &oldVal = it.value();
++ if (oldVal == val && oldVal.resolveMask() == val.resolveMask())
++ return;
++
++ it.value() = val;
++
++ qsizetype idx = d_ptr->m_familyNames.indexOf(val.family());
++ if (idx == -1)
++ idx = 0;
++ bool settingValue = d_ptr->m_settingValue;
++ d_ptr->m_settingValue = true;
++ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToFamily[property], idx);
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToPointSize[property], val.pointSize());
++ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToBold[property], val.bold());
++ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToItalic[property], val.italic());
++ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToUnderline[property], val.underline());
++ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToStrikeOut[property], val.strikeOut());
++ d_ptr->m_boolPropertyManager->setValue(d_ptr->m_propertyToKerning[property], val.kerning());
++ d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToWeight[property],
++ indexOfFontWeight(val.weight()));
++ d_ptr->m_settingValue = settingValue;
++
++ emit propertyChanged(property);
++ emit valueChanged(property, val);
++ }
++
++ static QStringList fontWeightNames()
++ {
++ static const DisambiguatedTranslation weightsC[] = {
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "Thin", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "ExtraLight", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "Light", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "Normal", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "Medium", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "DemiBold", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "Bold", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "ExtraBold", "QFont::Weight combo"),
++ QT_TRANSLATE_NOOP3("FontPropertyManager", "Black", "QFont::Weight combo")
++ };
++
++ QStringList result;
++ for (const auto &w : weightsC)
++ result.append(QCoreApplication::translate("FontPropertyManager", w.first, w.second));
++ return result;
++ }
++
++ /*!
++ \reimp
++ */
++ void QtFontPropertyManager::initializeProperty(QtProperty *property)
++ {
++ QFont val;
++ d_ptr->m_values[property] = val;
++
++ QtProperty *familyProp = d_ptr->m_enumPropertyManager->addProperty();
++ familyProp->setPropertyName(tr("Family"));
++ if (d_ptr->m_familyNames.isEmpty())
++ d_ptr->m_familyNames = QFontDatabase::families();
++ d_ptr->m_enumPropertyManager->setEnumNames(familyProp, d_ptr->m_familyNames);
++ qsizetype idx = d_ptr->m_familyNames.indexOf(val.family());
++ if (idx == -1)
++ idx = 0;
++ d_ptr->m_enumPropertyManager->setValue(familyProp, idx);
++ d_ptr->m_propertyToFamily[property] = familyProp;
++ d_ptr->m_familyToProperty[familyProp] = property;
++ property->addSubProperty(familyProp);
++
++ QtProperty *pointSizeProp = d_ptr->m_intPropertyManager->addProperty();
++ pointSizeProp->setPropertyName(tr("Point Size"));
++ d_ptr->m_intPropertyManager->setValue(pointSizeProp, val.pointSize());
++ d_ptr->m_intPropertyManager->setMinimum(pointSizeProp, 1);
++ d_ptr->m_propertyToPointSize[property] = pointSizeProp;
++ d_ptr->m_pointSizeToProperty[pointSizeProp] = property;
++ property->addSubProperty(pointSizeProp);
++
++ QtProperty *boldProp = d_ptr->m_boolPropertyManager->addProperty();
++ boldProp->setPropertyName(tr("Bold", "Bold toggle"));
++ d_ptr->m_boolPropertyManager->setValue(boldProp, val.bold());
++ d_ptr->m_propertyToBold[property] = boldProp;
++ d_ptr->m_boldToProperty[boldProp] = property;
++ property->addSubProperty(boldProp);
++
++ QtProperty *italicProp = d_ptr->m_boolPropertyManager->addProperty();
++ italicProp->setPropertyName(tr("Italic"));
++ d_ptr->m_boolPropertyManager->setValue(italicProp, val.italic());
++ d_ptr->m_propertyToItalic[property] = italicProp;
++ d_ptr->m_italicToProperty[italicProp] = property;
++ property->addSubProperty(italicProp);
++
++ QtProperty *underlineProp = d_ptr->m_boolPropertyManager->addProperty();
++ underlineProp->setPropertyName(tr("Underline"));
++ d_ptr->m_boolPropertyManager->setValue(underlineProp, val.underline());
++ d_ptr->m_propertyToUnderline[property] = underlineProp;
++ d_ptr->m_underlineToProperty[underlineProp] = property;
++ property->addSubProperty(underlineProp);
++
++ QtProperty *strikeOutProp = d_ptr->m_boolPropertyManager->addProperty();
++ strikeOutProp->setPropertyName(tr("Strikeout"));
++ d_ptr->m_boolPropertyManager->setValue(strikeOutProp, val.strikeOut());
++ d_ptr->m_propertyToStrikeOut[property] = strikeOutProp;
++ d_ptr->m_strikeOutToProperty[strikeOutProp] = property;
++ property->addSubProperty(strikeOutProp);
++
++ QtProperty *kerningProp = d_ptr->m_boolPropertyManager->addProperty();
++ kerningProp->setPropertyName(tr("Kerning"));
++ d_ptr->m_boolPropertyManager->setValue(kerningProp, val.kerning());
++ d_ptr->m_propertyToKerning[property] = kerningProp;
++ d_ptr->m_kerningToProperty[kerningProp] = property;
++ property->addSubProperty(kerningProp);
++
++ auto *weightProp = d_ptr->m_enumPropertyManager->addProperty();
++ weightProp->setPropertyName(tr("Weight"));
++ static const QStringList weightNames = fontWeightNames();
++ d_ptr->m_enumPropertyManager->setEnumNames(weightProp, weightNames);
++ d_ptr->m_enumPropertyManager->setValue(weightProp, indexOfFontWeight(val.weight()));
++ d_ptr->m_propertyToWeight[property] = weightProp;
++ d_ptr->m_weightToProperty[weightProp] = property;
++ property->addSubProperty(weightProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtFontPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *familyProp = d_ptr->m_propertyToFamily[property];
++ if (familyProp) {
++ d_ptr->m_familyToProperty.remove(familyProp);
++ delete familyProp;
++ }
++ d_ptr->m_propertyToFamily.remove(property);
++
++ QtProperty *pointSizeProp = d_ptr->m_propertyToPointSize[property];
++ if (pointSizeProp) {
++ d_ptr->m_pointSizeToProperty.remove(pointSizeProp);
++ delete pointSizeProp;
++ }
++ d_ptr->m_propertyToPointSize.remove(property);
++
++ QtProperty *boldProp = d_ptr->m_propertyToBold[property];
++ if (boldProp) {
++ d_ptr->m_boldToProperty.remove(boldProp);
++ delete boldProp;
++ }
++ d_ptr->m_propertyToBold.remove(property);
++
++ QtProperty *italicProp = d_ptr->m_propertyToItalic[property];
++ if (italicProp) {
++ d_ptr->m_italicToProperty.remove(italicProp);
++ delete italicProp;
++ }
++ d_ptr->m_propertyToItalic.remove(property);
++
++ QtProperty *underlineProp = d_ptr->m_propertyToUnderline[property];
++ if (underlineProp) {
++ d_ptr->m_underlineToProperty.remove(underlineProp);
++ delete underlineProp;
++ }
++ d_ptr->m_propertyToUnderline.remove(property);
++
++ QtProperty *strikeOutProp = d_ptr->m_propertyToStrikeOut[property];
++ if (strikeOutProp) {
++ d_ptr->m_strikeOutToProperty.remove(strikeOutProp);
++ delete strikeOutProp;
++ }
++ d_ptr->m_propertyToStrikeOut.remove(property);
++
++ QtProperty *kerningProp = d_ptr->m_propertyToKerning[property];
++ if (kerningProp) {
++ d_ptr->m_kerningToProperty.remove(kerningProp);
++ delete kerningProp;
++ }
++ d_ptr->m_propertyToKerning.remove(property);
++
++ if (auto weightProp = d_ptr->m_propertyToWeight[property]) {
++ d_ptr->m_weightToProperty.remove(weightProp);
++ delete weightProp;
++ }
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtColorPropertyManager
++
++ class QtColorPropertyManagerPrivate
++ {
++ QtColorPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtColorPropertyManager)
++ public:
++
++ void slotIntChanged(QtProperty *property, int value);
++ void slotPropertyDestroyed(QtProperty *property);
++
++ QHash<const QtProperty *, QColor> m_values;
++
++ QtIntPropertyManager *m_intPropertyManager;
++
++ QHash<const QtProperty *, QtProperty *> m_propertyToR;
++ QHash<const QtProperty *, QtProperty *> m_propertyToG;
++ QHash<const QtProperty *, QtProperty *> m_propertyToB;
++ QHash<const QtProperty *, QtProperty *> m_propertyToA;
++
++ QHash<const QtProperty *, QtProperty *> m_rToProperty;
++ QHash<const QtProperty *, QtProperty *> m_gToProperty;
++ QHash<const QtProperty *, QtProperty *> m_bToProperty;
++ QHash<const QtProperty *, QtProperty *> m_aToProperty;
++ };
++
++ void QtColorPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
++ {
++ if (QtProperty *prop = m_rToProperty.value(property, nullptr)) {
++ QColor c = m_values[prop];
++ c.setRed(value);
++ q_ptr->setValue(prop, c);
++ } else if (QtProperty *prop = m_gToProperty.value(property, nullptr)) {
++ QColor c = m_values[prop];
++ c.setGreen(value);
++ q_ptr->setValue(prop, c);
++ } else if (QtProperty *prop = m_bToProperty.value(property, nullptr)) {
++ QColor c = m_values[prop];
++ c.setBlue(value);
++ q_ptr->setValue(prop, c);
++ } else if (QtProperty *prop = m_aToProperty.value(property, nullptr)) {
++ QColor c = m_values[prop];
++ c.setAlpha(value);
++ q_ptr->setValue(prop, c);
++ }
++ }
++
++ void QtColorPropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
++ {
++ if (QtProperty *pointProp = m_rToProperty.value(property, nullptr)) {
++ m_propertyToR[pointProp] = nullptr;
++ m_rToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_gToProperty.value(property, nullptr)) {
++ m_propertyToG[pointProp] = nullptr;
++ m_gToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_bToProperty.value(property, nullptr)) {
++ m_propertyToB[pointProp] = nullptr;
++ m_bToProperty.remove(property);
++ } else if (QtProperty *pointProp = m_aToProperty.value(property, nullptr)) {
++ m_propertyToA[pointProp] = nullptr;
++ m_aToProperty.remove(property);
++ }
++ }
++
++ /*!
++ \class QtColorPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtColorPropertyManager provides and manages QColor properties.
++
++ A color property has nested \e red, \e green and \e blue
++ subproperties. The top-level property's value can be retrieved
++ using the value() function, and set using the setValue() slot.
++
++ The subproperties are created by a QtIntPropertyManager object. This
++ manager can be retrieved using the subIntPropertyManager() function. In
++ order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ In addition, QtColorPropertyManager provides the valueChanged() signal
++ which is emitted whenever a property created by this manager
++ changes.
++
++ \sa QtAbstractPropertyManager, QtAbstractPropertyBrowser, QtIntPropertyManager
++ */
++
++ /*!
++ \fn void QtColorPropertyManager::valueChanged(QtProperty *property, const QColor &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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtColorPropertyManager::QtColorPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtColorPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++
++ d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
++ connect(d_ptr->m_intPropertyManager, &QtIntPropertyManager::valueChanged, this,
++ [this](QtProperty *property, int value) { d_ptr->slotIntChanged(property, value); });
++ connect(d_ptr->m_intPropertyManager, &QtAbstractPropertyManager::propertyDestroyed, this,
++ [this](QtProperty *property) { d_ptr->slotPropertyDestroyed(property); });
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtColorPropertyManager::~QtColorPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the manager that produces the nested \e red, \e green and
++ \e blue subproperties.
++
++ In order to provide editing widgets for the subproperties in a
++ property browser widget, this manager must be associated with an
++ editor factory.
++
++ \sa QtAbstractPropertyBrowser::setFactoryForManager()
++ */
++ QtIntPropertyManager *QtColorPropertyManager::subIntPropertyManager() const
++ {
++ return d_ptr->m_intPropertyManager;
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by \e this manager, this
++ function returns an invalid color.
++
++ \sa setValue()
++ */
++ QColor QtColorPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QColor());
++ }
++
++ /*!
++ \reimp
++ */
++
++ QString QtColorPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ return QtPropertyBrowserUtils::colorValueText(it.value());
++ }
++
++ /*!
++ \reimp
++ */
++
++ QIcon QtColorPropertyManager::valueIcon(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++ return QtPropertyBrowserUtils::brushValueIcon(QBrush(it.value()));
++ }
++
++ /*!
++ \fn void QtColorPropertyManager::setValue(QtProperty *property, const QColor &value)
++
++ Sets the value of the given \a property to \a value. Nested
++ properties are updated automatically.
++
++ \sa value(), valueChanged()
++ */
++ void QtColorPropertyManager::setValue(QtProperty *property, QColor val)
++ {
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ if (it.value() == val)
++ return;
++
++ it.value() = val;
++
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToR[property], val.red());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToG[property], val.green());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToB[property], val.blue());
++ d_ptr->m_intPropertyManager->setValue(d_ptr->m_propertyToA[property], val.alpha());
++
++ emit propertyChanged(property);
++ emit valueChanged(property, val);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtColorPropertyManager::initializeProperty(QtProperty *property)
++ {
++ QColor val;
++ d_ptr->m_values[property] = val;
++
++ QtProperty *rProp = d_ptr->m_intPropertyManager->addProperty();
++ rProp->setPropertyName(tr("Red"));
++ d_ptr->m_intPropertyManager->setValue(rProp, val.red());
++ d_ptr->m_intPropertyManager->setRange(rProp, 0, 0xFF);
++ d_ptr->m_propertyToR[property] = rProp;
++ d_ptr->m_rToProperty[rProp] = property;
++ property->addSubProperty(rProp);
++
++ QtProperty *gProp = d_ptr->m_intPropertyManager->addProperty();
++ gProp->setPropertyName(tr("Green"));
++ d_ptr->m_intPropertyManager->setValue(gProp, val.green());
++ d_ptr->m_intPropertyManager->setRange(gProp, 0, 0xFF);
++ d_ptr->m_propertyToG[property] = gProp;
++ d_ptr->m_gToProperty[gProp] = property;
++ property->addSubProperty(gProp);
++
++ QtProperty *bProp = d_ptr->m_intPropertyManager->addProperty();
++ bProp->setPropertyName(tr("Blue"));
++ d_ptr->m_intPropertyManager->setValue(bProp, val.blue());
++ d_ptr->m_intPropertyManager->setRange(bProp, 0, 0xFF);
++ d_ptr->m_propertyToB[property] = bProp;
++ d_ptr->m_bToProperty[bProp] = property;
++ property->addSubProperty(bProp);
++
++ QtProperty *aProp = d_ptr->m_intPropertyManager->addProperty();
++ aProp->setPropertyName(tr("Alpha"));
++ d_ptr->m_intPropertyManager->setValue(aProp, val.alpha());
++ d_ptr->m_intPropertyManager->setRange(aProp, 0, 0xFF);
++ d_ptr->m_propertyToA[property] = aProp;
++ d_ptr->m_aToProperty[aProp] = property;
++ property->addSubProperty(aProp);
++ }
++
++ /*!
++ \reimp
++ */
++ void QtColorPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ QtProperty *rProp = d_ptr->m_propertyToR[property];
++ if (rProp) {
++ d_ptr->m_rToProperty.remove(rProp);
++ delete rProp;
++ }
++ d_ptr->m_propertyToR.remove(property);
++
++ QtProperty *gProp = d_ptr->m_propertyToG[property];
++ if (gProp) {
++ d_ptr->m_gToProperty.remove(gProp);
++ delete gProp;
++ }
++ d_ptr->m_propertyToG.remove(property);
++
++ QtProperty *bProp = d_ptr->m_propertyToB[property];
++ if (bProp) {
++ d_ptr->m_bToProperty.remove(bProp);
++ delete bProp;
++ }
++ d_ptr->m_propertyToB.remove(property);
++
++ QtProperty *aProp = d_ptr->m_propertyToA[property];
++ if (aProp) {
++ d_ptr->m_aToProperty.remove(aProp);
++ delete aProp;
++ }
++ d_ptr->m_propertyToA.remove(property);
++
++ d_ptr->m_values.remove(property);
++ }
++
++ // QtCursorPropertyManager
++
++ class QtCursorPropertyManagerPrivate
++ {
++ QtCursorPropertyManager *q_ptr = nullptr;
++ Q_DECLARE_PUBLIC(QtCursorPropertyManager)
++ public:
++ QHash<const QtProperty *, QCursor> m_values;
++ };
++
++ /*!
++ \class QtCursorPropertyManager
++ \internal
++ \inmodule QtDesigner
++ \since 4.4
++
++ \brief The QtCursorPropertyManager provides and manages QCursor properties.
++
++ A cursor property has a current value which can be
++ retrieved using the value() function, and set using the setValue()
++ slot. In addition, QtCursorPropertyManager provides the
++ valueChanged() signal which is emitted whenever a property created
++ by this manager changes.
++
++ \sa QtAbstractPropertyManager
++ */
++
++ /*!
++ \fn void QtCursorPropertyManager::valueChanged(QtProperty *property, const QCursor &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()
++ */
++
++ /*!
++ Creates a manager with the given \a parent.
++ */
++ QtCursorPropertyManager::QtCursorPropertyManager(QObject *parent)
++ : QtAbstractPropertyManager(parent), d_ptr(new QtCursorPropertyManagerPrivate)
++ {
++ d_ptr->q_ptr = this;
++ }
++
++ /*!
++ Destroys this manager, and all the properties it has created.
++ */
++ QtCursorPropertyManager::~QtCursorPropertyManager()
++ {
++ clear();
++ }
++
++ /*!
++ Returns the given \a property's value.
++
++ If the given \a property is not managed by this manager, this
++ function returns a default QCursor object.
++
++ \sa setValue()
++ */
++ #ifndef QT_NO_CURSOR
++ QCursor QtCursorPropertyManager::value(const QtProperty *property) const
++ {
++ return d_ptr->m_values.value(property, QCursor());
++ }
++ #endif
++
++ /*!
++ \reimp
++ */
++ QString QtCursorPropertyManager::valueText(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ return QtCursorDatabase::instance()->cursorToShapeName(it.value());
++ }
++
++ /*!
++ \reimp
++ */
++ QIcon QtCursorPropertyManager::valueIcon(const QtProperty *property) const
++ {
++ const auto it = d_ptr->m_values.constFind(property);
++ if (it == d_ptr->m_values.constEnd())
++ return {};
++
++ return QtCursorDatabase::instance()->cursorToShapeIcon(it.value());
++ }
++
++ /*!
++ \fn void QtCursorPropertyManager::setValue(QtProperty *property, const QCursor &value)
++
++ Sets the value of the given \a property to \a value.
++
++ \sa value(), valueChanged()
++ */
++ void QtCursorPropertyManager::setValue(QtProperty *property, const QCursor &value)
++ {
++ #ifndef QT_NO_CURSOR
++ const auto it = d_ptr->m_values.find(property);
++ if (it == d_ptr->m_values.end())
++ return;
++
++ if (it.value().shape() == value.shape() && value.shape() != Qt::BitmapCursor)
++ return;
++
++ it.value() = value;
++
++ emit propertyChanged(property);
++ emit valueChanged(property, value);
++ #endif
++ }
++
++ /*!
++ \reimp
++ */
++ void QtCursorPropertyManager::initializeProperty(QtProperty *property)
++ {
++ #ifndef QT_NO_CURSOR
++ d_ptr->m_values[property] = QCursor();
++ #endif
++ }
++
++ /*!
++ \reimp
++ */
++ void QtCursorPropertyManager::uninitializeProperty(QtProperty *property)
++ {
++ d_ptr->m_values.remove(property);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qtpropertymanager_p.cpp"
++ #include "qtpropertymanager.moc"