FCL/sf/mw/qt: comparison util/tools/shared/qtpropertybrowser/qtpropertymanager.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qtpropertymanager.h"
+#include "qtpropertybrowserutils_p.h"
+#include <QtCore/QDateTime>
+#include <QtCore/QLocale>
+#include <QtCore/QMap>
+#include <QtCore/QTimer>
+#include <QtGui/QIcon>
+#include <QtCore/QMetaEnum>
+#include <QtGui/QFontDatabase>
+#include <QtGui/QStyleOption>
+#include <QtGui/QStyle>
+#include <QtGui/QApplication>
+#include <QtGui/QPainter>
+#include <QtGui/QLabel>
+#include <limits.h>
+#include <float.h>
+#if defined(Q_CC_MSVC)
+#    pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */
+#endif
+QT_BEGIN_NAMESPACE
+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 QMap<const QtProperty *, PrivateData> &propertyMap,
+Value PrivateData::*data,
+const QtProperty *property, const Value &defaultValue = Value())
+{
+typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+typedef Q_TYPENAME PropertyToData::const_iterator PropertyToDataConstIterator;
+const PropertyToDataConstIterator it = propertyMap.constFind(property);
+if (it == propertyMap.constEnd())
+return defaultValue;
+return it.value().*data;
+}
+template <class Value, class PrivateData>
+static Value getValue(const QMap<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 QMap<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 QMap<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(QMap<const QtProperty *, Value> &propertyMap,
+PropertyManager *manager,
+void (PropertyManager::*propertyChangedSignal)(QtProperty *),
+void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),
+QtProperty *property, const Value &val)
+{
+typedef QMap<const QtProperty *, Value> PropertyToData;
+typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;
+const PropertyToDataIterator 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))
+{
+typedef Q_TYPENAME PropertyManagerPrivate::Data PrivateData;
+typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;
+const PropertyToDataIterator it = managerPrivate->m_values.find(property);
+if (it == managerPrivate->m_values.end())
+return;
+PrivateData &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, const Value &minVal, const Value &maxVal,
+void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,
+ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))
+{
+typedef Q_TYPENAME PropertyManagerPrivate::Data PrivateData;
+typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;
+const PropertyToDataIterator it = managerPrivate->m_values.find(property);
+if (it == managerPrivate->m_values.end())
+return;
+Value fromVal = minVal;
+Value toVal = maxVal;
+orderBorders(fromVal, toVal);
+PrivateData &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))
+{
+typedef QMap<const QtProperty *, PrivateData> PropertyToData;
+typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;
+const PropertyToDataIterator 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) = 0;
+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) = 0;
+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 countryEnumNames(QLocale::Language language) const { return m_countryEnumNames.value(language); }
+QSizePolicy::Policy indexToSizePolicy(int index) const;
+int sizePolicyToIndex(QSizePolicy::Policy policy) const;
+void indexToLocale(int languageIndex, int countryIndex, QLocale::Language *language, QLocale::Country *country) const;
+void localeToIndex(QLocale::Language language, QLocale::Country country, int *languageIndex, int *countryIndex) const;
+private:
+void initLocale();
+QStringList m_policyEnumNames;
+QStringList m_languageEnumNames;
+QMap<QLocale::Language, QStringList> m_countryEnumNames;
+QMap<int, QLocale::Language> m_indexToLanguage;
+QMap<QLocale::Language, int> m_languageToIndex;
+QMap<int, QMap<int, QLocale::Country> > m_indexToCountry;
+QMap<QLocale::Language, QMap<QLocale::Country, int> > m_countryToIndex;
+QMetaEnum m_policyEnum;
+};
+static QList<QLocale::Country> sortCountries(const QList<QLocale::Country> &countries)
+{
+QMultiMap<QString, QLocale::Country> nameToCountry;
+QListIterator<QLocale::Country> itCountry(countries);
+while (itCountry.hasNext()) {
+QLocale::Country country = itCountry.next();
+nameToCountry.insert(QLocale::countryToString(country), country);
+}
+return nameToCountry.values();
+}
+void QtMetaEnumProvider::initLocale()
+{
+QMultiMap<QString, QLocale::Language> nameToLanguage;
+QLocale::Language language = QLocale::C;
+while (language <= QLocale::LastLanguage) {
+QLocale locale(language);
+if (locale.language() == language)
+nameToLanguage.insert(QLocale::languageToString(language), language);
+language = (QLocale::Language)((uint)language + 1); // ++language
+}
+const QLocale system = QLocale::system();
+if (!nameToLanguage.contains(QLocale::languageToString(system.language())))
+nameToLanguage.insert(QLocale::languageToString(system.language()), system.language());
+QList<QLocale::Language> languages = nameToLanguage.values();
+QListIterator<QLocale::Language> itLang(languages);
+while (itLang.hasNext()) {
+QLocale::Language language = itLang.next();
+QList<QLocale::Country> countries;
+countries = QLocale::countriesForLanguage(language);
+if (countries.isEmpty() && language == system.language())
+countries << system.country();
+if (!countries.isEmpty() && !m_languageToIndex.contains(language)) {
+countries = sortCountries(countries);
+int langIdx = m_languageEnumNames.count();
+m_indexToLanguage[langIdx] = language;
+m_languageToIndex[language] = langIdx;
+QStringList countryNames;
+QListIterator<QLocale::Country> it(countries);
+int countryIdx = 0;
+while (it.hasNext()) {
+QLocale::Country country = it.next();
+countryNames << QLocale::countryToString(country);
+m_indexToCountry[langIdx][countryIdx] = country;
+m_countryToIndex[language][country] = countryIdx;
+++countryIdx;
+}
+m_languageEnumNames << QLocale::languageToString(language);
+m_countryEnumNames[language] = countryNames;
+}
+}
+}
+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 << QLatin1String(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 countryIndex, QLocale::Language *language, QLocale::Country *country) const
+{
+QLocale::Language l = QLocale::C;
+QLocale::Country c = QLocale::AnyCountry;
+if (m_indexToLanguage.contains(languageIndex)) {
+l = m_indexToLanguage[languageIndex];
+if (m_indexToCountry.contains(languageIndex) && m_indexToCountry[languageIndex].contains(countryIndex))
+c = m_indexToCountry[languageIndex][countryIndex];
+}
+if (language)
+*language = l;
+if (country)
+*country = c;
+}
+void QtMetaEnumProvider::localeToIndex(QLocale::Language language, QLocale::Country country, int *languageIndex, int *countryIndex) const
+{
+int l = -1;
+int c = -1;
+if (m_languageToIndex.contains(language)) {
+l = m_languageToIndex[language];
+if (m_countryToIndex.contains(language) && m_countryToIndex[language].contains(country))
+c = m_countryToIndex[language][country];
+}
+if (languageIndex)
+*languageIndex = l;
+if (countryIndex)
+*countryIndex = 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()
+{
+}
+/*!
+\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;
+Q_DECLARE_PUBLIC(QtIntPropertyManager)
+public:
+struct Data
+{
+Data() : val(0), minVal(-INT_MAX), maxVal(INT_MAX), singleStep(1) {}
+int val;
+int minVal;
+int maxVal;
+int singleStep;
+int minimumValue() const { return minVal; }
+int maximumValue() const { return maxVal; }
+void setMinimumValue(int newMinVal) { setSimpleMinimumData(this, newMinVal); }
+void setMaximumValue(int newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap 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 QtIntPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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) = 0;
+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) = 0;
+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 QtIntPropertyManagerPrivate::PropertyValueMap::iterator 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;
+Q_DECLARE_PUBLIC(QtDoublePropertyManager)
+public:
+struct Data
+{
+Data() : val(0), minVal(-INT_MAX), maxVal(INT_MAX), singleStep(1), decimals(2) {}
+double val;
+double minVal;
+double maxVal;
+double singleStep;
+int decimals;
+double minimumValue() const { return minVal; }
+double maximumValue() const { return maxVal; }
+void setMinimumValue(double newMinVal) { setSimpleMinimumData(this, newMinVal); }
+void setMaximumValue(double newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap 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 QtDoublePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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) = 0;
+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 QtDoublePropertyManagerPrivate::PropertyValueMap::iterator 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 QtDoublePropertyManagerPrivate::PropertyValueMap::iterator 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) = 0;
+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;
+Q_DECLARE_PUBLIC(QtStringPropertyManager)
+public:
+struct Data
+{
+Data() : regExp(QString(QLatin1Char('*')),  Qt::CaseSensitive, QRegExp::Wildcard)
+{
+}
+QString val;
+QRegExp regExp;
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+QMap<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 QRegExp &regExp)
+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()
+*/
+QRegExp QtStringPropertyManager::regExp(const QtProperty *property) const
+{
+return getData<QRegExp>(d_ptr->m_values, &QtStringPropertyManagerPrivate::Data::regExp, property, QRegExp());
+}
+/*!
+\reimp
+*/
+QString QtStringPropertyManager::valueText(const QtProperty *property) const
+{
+const QtStringPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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 QtStringPropertyManagerPrivate::PropertyValueMap::iterator 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.exactMatch(val))
+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 QRegExp &regExp)
+{
+const QtStringPropertyManagerPrivate::PropertyValueMap::iterator 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
+static QIcon drawCheckBox(bool value)
+{
+QStyleOptionButton opt;
+opt.state |= value ? QStyle::State_On : QStyle::State_Off;
+opt.state |= QStyle::State_Enabled;
+const QStyle *style = QApplication::style();
+// 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 int indicatorWidth = style->pixelMetric(QStyle::PM_IndicatorWidth, &opt);
+const int indicatorHeight = style->pixelMetric(QStyle::PM_IndicatorHeight, &opt);
+const int listViewIconSize = indicatorWidth;
+const int pixmapWidth = indicatorWidth;
+const int pixmapHeight = qMax(indicatorHeight, listViewIconSize);
+opt.rect = QRect(0, 0, indicatorWidth, indicatorHeight);
+QPixmap pixmap = QPixmap(pixmapWidth, pixmapHeight);
+pixmap.fill(Qt::transparent);
+{
+// Center?
+const int xoff = (pixmapWidth  > indicatorWidth)  ? (pixmapWidth  - indicatorWidth)  / 2 : 0;
+const int yoff = (pixmapHeight > indicatorHeight) ? (pixmapHeight - indicatorHeight) / 2 : 0;
+QPainter painter(&pixmap);
+painter.translate(xoff, yoff);
+style->drawPrimitive(QStyle::PE_IndicatorCheckBox, &opt, &painter);
+}
+return QIcon(pixmap);
+}
+class QtBoolPropertyManagerPrivate
+{
+QtBoolPropertyManager *q_ptr;
+Q_DECLARE_PUBLIC(QtBoolPropertyManager)
+public:
+QtBoolPropertyManagerPrivate();
+QMap<const QtProperty *, bool> m_values;
+const QIcon m_checkedIcon;
+const QIcon m_uncheckedIcon;
+};
+QtBoolPropertyManagerPrivate::QtBoolPropertyManagerPrivate() :
+m_checkedIcon(drawCheckBox(true)),
+m_uncheckedIcon(drawCheckBox(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 QMap<const QtProperty *, bool>::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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 QMap<const QtProperty *, bool>::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QIcon();
+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;
+Q_DECLARE_PUBLIC(QtDatePropertyManager)
+public:
+explicit QtDatePropertyManagerPrivate(QtDatePropertyManager *q);
+struct Data
+{
+Data() : val(QDate::currentDate()), minVal(QDate(1752, 9, 14)),
+maxVal(QDate(7999, 12, 31)) {}
+QDate val;
+QDate minVal;
+QDate maxVal;
+QDate minimumValue() const { return minVal; }
+QDate maximumValue() const { return maxVal; }
+void setMinimumValue(const QDate &newMinVal) { setSimpleMinimumData(this, newMinVal); }
+void setMaximumValue(const QDate &newMaxVal) { setSimpleMaximumData(this, newMaxVal); }
+};
+QString m_format;
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+QMap<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, const 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, const QDate &minimum, const 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 QtDatePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+return it.value().val.toString(d_ptr->m_format);
+}
+/*!
+\fn void QtDatePropertyManager::setValue(QtProperty *property, const 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, const QDate &val)
+{
+void (QtDatePropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, const QDate &) = 0;
+setValueInRange<const 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, const QDate &minVal)
+{
+setMinimumValue<const 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, const QDate &maxVal)
+{
+setMaximumValue<const QDate &, QtDatePropertyManagerPrivate, QtDatePropertyManager, QDate, QtDatePropertyManagerPrivate::Data>(this, d_ptr.data(),
+&QtDatePropertyManager::propertyChanged,
+&QtDatePropertyManager::valueChanged,
+&QtDatePropertyManager::rangeChanged,
+property, maxVal);
+}
+/*!
+\fn void QtDatePropertyManager::setRange(QtProperty *property, const QDate &minimum, const 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, const QDate &minVal, const QDate &maxVal)
+{
+void (QtDatePropertyManagerPrivate::*setSubPropertyRange)(QtProperty *, const QDate &,
+const QDate &, const QDate &) = 0;
+setBorderValues<const 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;
+Q_DECLARE_PUBLIC(QtTimePropertyManager)
+public:
+explicit QtTimePropertyManagerPrivate(QtTimePropertyManager *q);
+const QString m_format;
+typedef QMap<const QtProperty *, QTime> PropertyValueMap;
+PropertyValueMap 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, const 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 QtTimePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+return it.value().toString(d_ptr->m_format);
+}
+/*!
+\fn void QtTimePropertyManager::setValue(QtProperty *property, const QTime &value)
+Sets the value of the given \a property to \a value.
+\sa value(), valueChanged()
+*/
+void QtTimePropertyManager::setValue(QtProperty *property, const QTime &val)
+{
+setSimpleValue<const 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;
+Q_DECLARE_PUBLIC(QtDateTimePropertyManager)
+public:
+explicit QtDateTimePropertyManagerPrivate(QtDateTimePropertyManager *q);
+const QString m_format;
+typedef QMap<const QtProperty *, QDateTime> PropertyValueMap;
+PropertyValueMap 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 QtDateTimePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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;
+Q_DECLARE_PUBLIC(QtKeySequencePropertyManager)
+public:
+QString m_format;
+typedef QMap<const QtProperty *, QKeySequence> PropertyValueMap;
+PropertyValueMap 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 QtKeySequencePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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;
+Q_DECLARE_PUBLIC(QtCharPropertyManager)
+public:
+typedef QMap<const QtProperty *, QChar> PropertyValueMap;
+PropertyValueMap 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 QtCharPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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;
+Q_DECLARE_PUBLIC(QtLocalePropertyManager)
+public:
+QtLocalePropertyManagerPrivate();
+void slotEnumChanged(QtProperty *property, int value);
+void slotPropertyDestroyed(QtProperty *property);
+typedef QMap<const QtProperty *, QLocale> PropertyValueMap;
+PropertyValueMap m_values;
+QtEnumPropertyManager *m_enumPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToLanguage;
+QMap<const QtProperty *, QtProperty *> m_propertyToCountry;
+QMap<const QtProperty *, QtProperty *> m_languageToProperty;
+QMap<const QtProperty *, QtProperty *> m_countryToProperty;
+};
+QtLocalePropertyManagerPrivate::QtLocalePropertyManagerPrivate()
+{
+}
+void QtLocalePropertyManagerPrivate::slotEnumChanged(QtProperty *property, int value)
+{
+if (QtProperty *prop = m_languageToProperty.value(property, 0)) {
+const QLocale loc = m_values[prop];
+QLocale::Language newLanguage = loc.language();
+QLocale::Country newCountry = loc.country();
+metaEnumProvider()->indexToLocale(value, 0, &newLanguage, 0);
+QLocale newLoc(newLanguage, newCountry);
+q_ptr->setValue(prop, newLoc);
+} else if (QtProperty *prop = m_countryToProperty.value(property, 0)) {
+const QLocale loc = m_values[prop];
+QLocale::Language newLanguage = loc.language();
+QLocale::Country newCountry = loc.country();
+metaEnumProvider()->indexToLocale(m_enumPropertyManager->value(m_propertyToLanguage.value(prop)), value, &newLanguage, &newCountry);
+QLocale newLoc(newLanguage, newCountry);
+q_ptr->setValue(prop, newLoc);
+}
+}
+void QtLocalePropertyManagerPrivate::slotPropertyDestroyed(QtProperty *property)
+{
+if (QtProperty *subProp = m_languageToProperty.value(property, 0)) {
+m_propertyToLanguage[subProp] = 0;
+m_languageToProperty.remove(property);
+} else if (QtProperty *subProp = m_countryToProperty.value(property, 0)) {
+m_propertyToCountry[subProp] = 0;
+m_countryToProperty.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 country
+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, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotEnumChanged(QtProperty*,int)));
+connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+Destroys this manager, and all the properties it has created.
+*/
+QtLocalePropertyManager::~QtLocalePropertyManager()
+{
+clear();
+}
+/*!
+Returns the manager that creates the nested \e language
+and \e country 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 QtLocalePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+QLocale loc = it.value();
+int langIdx = 0;
+int countryIdx = 0;
+metaEnumProvider()->localeToIndex(loc.language(), loc.country(), &langIdx, &countryIdx);
+QString str = tr("%1, %2")
+.arg(metaEnumProvider()->languageEnumNames().at(langIdx))
+.arg(metaEnumProvider()->countryEnumNames(loc.language()).at(countryIdx));
+return str;
+}
+/*!
+\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 QtLocalePropertyManagerPrivate::PropertyValueMap::iterator 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 countryIdx = 0;
+metaEnumProvider()->localeToIndex(val.language(), val.country(), &langIdx, &countryIdx);
+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_propertyToCountry.value(property),
+metaEnumProvider()->countryEnumNames(val.language()));
+}
+d_ptr->m_enumPropertyManager->setValue(d_ptr->m_propertyToCountry.value(property), countryIdx);
+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 countryIdx = 0;
+metaEnumProvider()->localeToIndex(val.language(), val.country(), &langIdx, &countryIdx);
+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 *countryProp = d_ptr->m_enumPropertyManager->addProperty();
+countryProp->setPropertyName(tr("Country"));
+d_ptr->m_enumPropertyManager->setEnumNames(countryProp, metaEnumProvider()->countryEnumNames(val.language()));
+d_ptr->m_enumPropertyManager->setValue(countryProp, countryIdx);
+d_ptr->m_propertyToCountry[property] = countryProp;
+d_ptr->m_countryToProperty[countryProp] = property;
+property->addSubProperty(countryProp);
+}
+/*!
+\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 *countryProp = d_ptr->m_propertyToCountry[property];
+if (countryProp) {
+d_ptr->m_countryToProperty.remove(countryProp);
+delete countryProp;
+}
+d_ptr->m_propertyToCountry.remove(property);
+d_ptr->m_values.remove(property);
+}
+// QtPointPropertyManager
+class QtPointPropertyManagerPrivate
+{
+QtPointPropertyManager *q_ptr;
+Q_DECLARE_PUBLIC(QtPointPropertyManager)
+public:
+void slotIntChanged(QtProperty *property, int value);
+void slotPropertyDestroyed(QtProperty *property);
+typedef QMap<const QtProperty *, QPoint> PropertyValueMap;
+PropertyValueMap m_values;
+QtIntPropertyManager *m_intPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToX;
+QMap<const QtProperty *, QtProperty *> m_propertyToY;
+QMap<const QtProperty *, QtProperty *> m_xToProperty;
+QMap<const QtProperty *, QtProperty *> m_yToProperty;
+};
+void QtPointPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+if (QtProperty *xprop = m_xToProperty.value(property, 0)) {
+QPoint p = m_values[xprop];
+p.setX(value);
+q_ptr->setValue(xprop, p);
+} else if (QtProperty *yprop = m_yToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToX[pointProp] = 0;
+m_xToProperty.remove(property);
+} else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+m_propertyToY[pointProp] = 0;
+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, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotIntChanged(QtProperty*,int)));
+connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtPointPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QPoint v = it.value();
+return QString(tr("(%1, %2)").arg(QString::number(v.x()))
+.arg(QString::number(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, const QPoint &val)
+{
+const QtPointPropertyManagerPrivate::PropertyValueMap::iterator 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;
+Q_DECLARE_PUBLIC(QtPointFPropertyManager)
+public:
+struct Data
+{
+Data() : decimals(2) {}
+QPointF val;
+int decimals;
+};
+void slotDoubleChanged(QtProperty *property, double value);
+void slotPropertyDestroyed(QtProperty *property);
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap m_values;
+QtDoublePropertyManager *m_doublePropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToX;
+QMap<const QtProperty *, QtProperty *> m_propertyToY;
+QMap<const QtProperty *, QtProperty *> m_xToProperty;
+QMap<const QtProperty *, QtProperty *> m_yToProperty;
+};
+void QtPointFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
+{
+if (QtProperty *prop = m_xToProperty.value(property, 0)) {
+QPointF p = m_values[prop].val;
+p.setX(value);
+q_ptr->setValue(prop, p);
+} else if (QtProperty *prop = m_yToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToX[pointProp] = 0;
+m_xToProperty.remove(property);
+} else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+m_propertyToY[pointProp] = 0;
+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, SIGNAL(valueChanged(QtProperty*,double)),
+this, SLOT(slotDoubleChanged(QtProperty*,double)));
+connect(d_ptr->m_doublePropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtPointFPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QPointF v = it.value().val;
+const int dec =  it.value().decimals;
+return QString(tr("(%1, %2)").arg(QString::number(v.x(), 'f', dec))
+.arg(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, const QPointF &val)
+{
+const QtPointFPropertyManagerPrivate::PropertyValueMap::iterator 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 QtPointFPropertyManagerPrivate::PropertyValueMap::iterator 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;
+Q_DECLARE_PUBLIC(QtSizePropertyManager)
+public:
+void slotIntChanged(QtProperty *property, int value);
+void slotPropertyDestroyed(QtProperty *property);
+void setValue(QtProperty *property, const QSize &val);
+void setRange(QtProperty *property,
+const QSize &minVal, const QSize &maxVal, const QSize &val);
+struct Data
+{
+Data() : val(QSize(0, 0)), minVal(QSize(0, 0)), maxVal(QSize(INT_MAX, INT_MAX)) {}
+QSize val;
+QSize minVal;
+QSize maxVal;
+QSize minimumValue() const { return minVal; }
+QSize maximumValue() const { return maxVal; }
+void setMinimumValue(const QSize &newMinVal) { setSizeMinimumData(this, newMinVal); }
+void setMaximumValue(const QSize &newMaxVal) { setSizeMaximumData(this, newMaxVal); }
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap m_values;
+QtIntPropertyManager *m_intPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToW;
+QMap<const QtProperty *, QtProperty *> m_propertyToH;
+QMap<const QtProperty *, QtProperty *> m_wToProperty;
+QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+void QtSizePropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+QSize s = m_values[prop].val;
+s.setWidth(value);
+q_ptr->setValue(prop, s);
+} else if (QtProperty *prop = m_hToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToW[pointProp] = 0;
+m_wToProperty.remove(property);
+} else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+m_propertyToH[pointProp] = 0;
+m_hToProperty.remove(property);
+}
+}
+void QtSizePropertyManagerPrivate::setValue(QtProperty *property, const 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,
+const QSize &minVal, const QSize &maxVal, const 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, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotIntChanged(QtProperty*,int)));
+connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtSizePropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QSize v = it.value().val;
+return QString(tr("%1 x %2").arg(QString::number(v.width()))
+.arg(QString::number(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, const QSize &val)
+{
+setValueInRange<const 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, const QSize &minVal)
+{
+setBorderValue<const 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, const QSize &maxVal)
+{
+setBorderValue<const 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, const QSize &minVal, const QSize &maxVal)
+{
+setBorderValues<const 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;
+Q_DECLARE_PUBLIC(QtSizeFPropertyManager)
+public:
+void slotDoubleChanged(QtProperty *property, double value);
+void slotPropertyDestroyed(QtProperty *property);
+void setValue(QtProperty *property, const QSizeF &val);
+void setRange(QtProperty *property,
+const QSizeF &minVal, const QSizeF &maxVal, const QSizeF &val);
+struct Data
+{
+Data() : val(QSizeF(0, 0)), minVal(QSizeF(0, 0)), maxVal(QSizeF(INT_MAX, INT_MAX)), decimals(2) {}
+QSizeF val;
+QSizeF minVal;
+QSizeF maxVal;
+int decimals;
+QSizeF minimumValue() const { return minVal; }
+QSizeF maximumValue() const { return maxVal; }
+void setMinimumValue(const QSizeF &newMinVal) { setSizeMinimumData(this, newMinVal); }
+void setMaximumValue(const QSizeF &newMaxVal) { setSizeMaximumData(this, newMaxVal); }
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap m_values;
+QtDoublePropertyManager *m_doublePropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToW;
+QMap<const QtProperty *, QtProperty *> m_propertyToH;
+QMap<const QtProperty *, QtProperty *> m_wToProperty;
+QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+void QtSizeFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
+{
+if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+QSizeF s = m_values[prop].val;
+s.setWidth(value);
+q_ptr->setValue(prop, s);
+} else if (QtProperty *prop = m_hToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToW[pointProp] = 0;
+m_wToProperty.remove(property);
+} else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+m_propertyToH[pointProp] = 0;
+m_hToProperty.remove(property);
+}
+}
+void QtSizeFPropertyManagerPrivate::setValue(QtProperty *property, const 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,
+const QSizeF &minVal, const QSizeF &maxVal, const 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, SIGNAL(valueChanged(QtProperty*,double)),
+this, SLOT(slotDoubleChanged(QtProperty*,double)));
+connect(d_ptr->m_doublePropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtSizeFPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QSizeF v = it.value().val;
+const int dec = it.value().decimals;
+return QString(tr("%1 x %2").arg(QString::number(v.width(), 'f', dec))
+.arg(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, const QSizeF &val)
+{
+setValueInRange<const 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 QtSizeFPropertyManagerPrivate::PropertyValueMap::iterator 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, const QSizeF &minVal)
+{
+setBorderValue<const 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, const QSizeF &maxVal)
+{
+setBorderValue<const 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, const QSizeF &minVal, const QSizeF &maxVal)
+{
+setBorderValues<const 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;
+Q_DECLARE_PUBLIC(QtRectPropertyManager)
+public:
+void slotIntChanged(QtProperty *property, int value);
+void slotPropertyDestroyed(QtProperty *property);
+void setConstraint(QtProperty *property, const QRect &constraint, const QRect &val);
+struct Data
+{
+Data() : val(0, 0, 0, 0) {}
+QRect val;
+QRect constraint;
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap m_values;
+QtIntPropertyManager *m_intPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToX;
+QMap<const QtProperty *, QtProperty *> m_propertyToY;
+QMap<const QtProperty *, QtProperty *> m_propertyToW;
+QMap<const QtProperty *, QtProperty *> m_propertyToH;
+QMap<const QtProperty *, QtProperty *> m_xToProperty;
+QMap<const QtProperty *, QtProperty *> m_yToProperty;
+QMap<const QtProperty *, QtProperty *> m_wToProperty;
+QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+void QtRectPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+if (QtProperty *prop = m_xToProperty.value(property, 0)) {
+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, 0)) {
+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, 0)) {
+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, 0)) {
+m_propertyToX[pointProp] = 0;
+m_xToProperty.remove(property);
+} else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+m_propertyToY[pointProp] = 0;
+m_yToProperty.remove(property);
+} else if (QtProperty *pointProp = m_wToProperty.value(property, 0)) {
+m_propertyToW[pointProp] = 0;
+m_wToProperty.remove(property);
+} else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+m_propertyToH[pointProp] = 0;
+m_hToProperty.remove(property);
+}
+}
+void QtRectPropertyManagerPrivate::setConstraint(QtProperty *property,
+const QRect &constraint, const QRect &val)
+{
+const bool isNull = constraint.isNull();
+const int left   = isNull ? INT_MIN : constraint.left();
+const int right  = isNull ? INT_MAX : constraint.left() + constraint.width();
+const int top    = isNull ? INT_MIN : constraint.top();
+const int bottom = isNull ? INT_MAX : constraint.top() + constraint.height();
+const int width  = isNull ? INT_MAX : constraint.width();
+const int height = isNull ? 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, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotIntChanged(QtProperty*,int)));
+connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtRectPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QRect v = it.value().val;
+return QString(tr("[(%1, %2), %3 x %4]").arg(QString::number(v.x()))
+.arg(QString::number(v.y()))
+.arg(QString::number(v.width()))
+.arg(QString::number(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, const QRect &val)
+{
+const QtRectPropertyManagerPrivate::PropertyValueMap::iterator 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, const QRect &constraint)
+{
+const QtRectPropertyManagerPrivate::PropertyValueMap::iterator 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;
+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
+{
+Data() : val(0, 0, 0, 0), decimals(2) {}
+QRectF val;
+QRectF constraint;
+int decimals;
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap m_values;
+QtDoublePropertyManager *m_doublePropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToX;
+QMap<const QtProperty *, QtProperty *> m_propertyToY;
+QMap<const QtProperty *, QtProperty *> m_propertyToW;
+QMap<const QtProperty *, QtProperty *> m_propertyToH;
+QMap<const QtProperty *, QtProperty *> m_xToProperty;
+QMap<const QtProperty *, QtProperty *> m_yToProperty;
+QMap<const QtProperty *, QtProperty *> m_wToProperty;
+QMap<const QtProperty *, QtProperty *> m_hToProperty;
+};
+void QtRectFPropertyManagerPrivate::slotDoubleChanged(QtProperty *property, double value)
+{
+if (QtProperty *prop = m_xToProperty.value(property, 0)) {
+QRectF r = m_values[prop].val;
+r.moveLeft(value);
+q_ptr->setValue(prop, r);
+} else if (QtProperty *prop = m_yToProperty.value(property, 0)) {
+QRectF r = m_values[prop].val;
+r.moveTop(value);
+q_ptr->setValue(prop, r);
+} else if (QtProperty *prop = m_wToProperty.value(property, 0)) {
+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, 0)) {
+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, 0)) {
+m_propertyToX[pointProp] = 0;
+m_xToProperty.remove(property);
+} else if (QtProperty *pointProp = m_yToProperty.value(property, 0)) {
+m_propertyToY[pointProp] = 0;
+m_yToProperty.remove(property);
+} else if (QtProperty *pointProp = m_wToProperty.value(property, 0)) {
+m_propertyToW[pointProp] = 0;
+m_wToProperty.remove(property);
+} else if (QtProperty *pointProp = m_hToProperty.value(property, 0)) {
+m_propertyToH[pointProp] = 0;
+m_hToProperty.remove(property);
+}
+}
+void QtRectFPropertyManagerPrivate::setConstraint(QtProperty *property,
+const QRectF &constraint, const QRectF &val)
+{
+const bool isNull = constraint.isNull();
+const float left   = isNull ? FLT_MIN : constraint.left();
+const float right  = isNull ? FLT_MAX : constraint.left() + constraint.width();
+const float top    = isNull ? FLT_MIN : constraint.top();
+const float bottom = isNull ? FLT_MAX : constraint.top() + constraint.height();
+const float width  = isNull ? FLT_MAX : constraint.width();
+const float height = isNull ? FLT_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, SIGNAL(valueChanged(QtProperty*,double)),
+this, SLOT(slotDoubleChanged(QtProperty*,double)));
+connect(d_ptr->m_doublePropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtRectFPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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))
+.arg(QString::number(v.y(), 'f', dec))
+.arg(QString::number(v.width(), 'f', dec))
+.arg(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 QtRectFPropertyManagerPrivate::PropertyValueMap::iterator 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 QtRectFPropertyManagerPrivate::PropertyValueMap::iterator 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 QtRectFPropertyManagerPrivate::PropertyValueMap::iterator 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;
+Q_DECLARE_PUBLIC(QtEnumPropertyManager)
+public:
+struct Data
+{
+Data() : val(-1) {}
+int val;
+QStringList enumNames;
+QMap<int, QIcon> enumIcons;
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap 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 QtEnumPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QtEnumPropertyManagerPrivate::Data &data = it.value();
+const int v = data.val;
+if (v >= 0 && v < data.enumNames.count())
+return data.enumNames.at(v);
+return QString();
+}
+/*!
+\reimp
+*/
+QIcon QtEnumPropertyManager::valueIcon(const QtProperty *property) const
+{
+const QtEnumPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QIcon();
+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 QtEnumPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+if (it == d_ptr->m_values.end())
+return;
+QtEnumPropertyManagerPrivate::Data data = it.value();
+if (val >= data.enumNames.count())
+return;
+if (val < 0 && data.enumNames.count() > 0)
+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 QtEnumPropertyManagerPrivate::PropertyValueMap::iterator 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.count() > 0)
+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 QtEnumPropertyManagerPrivate::PropertyValueMap::iterator 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;
+Q_DECLARE_PUBLIC(QtFlagPropertyManager)
+public:
+void slotBoolChanged(QtProperty *property, bool value);
+void slotPropertyDestroyed(QtProperty *property);
+struct Data
+{
+Data() : val(-1) {}
+int val;
+QStringList flagNames;
+};
+typedef QMap<const QtProperty *, Data> PropertyValueMap;
+PropertyValueMap m_values;
+QtBoolPropertyManager *m_boolPropertyManager;
+QMap<const QtProperty *, QList<QtProperty *> > m_propertyToFlags;
+QMap<const QtProperty *, QtProperty *> m_flagToProperty;
+};
+void QtFlagPropertyManagerPrivate::slotBoolChanged(QtProperty *property, bool value)
+{
+QtProperty *prop = m_flagToProperty.value(property, 0);
+if (prop == 0)
+return;
+QListIterator<QtProperty *> itProp(m_propertyToFlags[prop]);
+int level = 0;
+while (itProp.hasNext()) {
+QtProperty *p = itProp.next();
+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, 0);
+if (flagProperty == 0)
+return;
+m_propertyToFlags[flagProperty].replace(m_propertyToFlags[flagProperty].indexOf(property), 0);
+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, SIGNAL(valueChanged(QtProperty*,bool)),
+this, SLOT(slotBoolChanged(QtProperty*,bool)));
+connect(d_ptr->m_boolPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtFlagPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+const QtFlagPropertyManagerPrivate::Data &data = it.value();
+QString str;
+int level = 0;
+const QChar bar = QLatin1Char('|');
+const QStringList::const_iterator fncend = data.flagNames.constEnd();
+for (QStringList::const_iterator it =  data.flagNames.constBegin(); it != fncend; ++it) {
+if (data.val & (1 << level)) {
+if (!str.isEmpty())
+str += bar;
+str += *it;
+}
+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 QtFlagPropertyManagerPrivate::PropertyValueMap::iterator 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.count()) - 1)
+return;
+if (val < 0)
+return;
+data.val = val;
+it.value() = data;
+QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
+int level = 0;
+while (itProp.hasNext()) {
+QtProperty *prop = itProp.next();
+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 QtFlagPropertyManagerPrivate::PropertyValueMap::iterator 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;
+QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
+while (itProp.hasNext()) {
+QtProperty *prop = itProp.next();
+if (prop) {
+delete prop;
+d_ptr->m_flagToProperty.remove(prop);
+}
+}
+d_ptr->m_propertyToFlags[property].clear();
+QStringListIterator itFlag(flagNames);
+while (itFlag.hasNext()) {
+const QString flagName = itFlag.next();
+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)
+{
+QListIterator<QtProperty *> itProp(d_ptr->m_propertyToFlags[property]);
+while (itProp.hasNext()) {
+QtProperty *prop = itProp.next();
+if (prop) {
+delete prop;
+d_ptr->m_flagToProperty.remove(prop);
+}
+}
+d_ptr->m_propertyToFlags.remove(property);
+d_ptr->m_values.remove(property);
+}
+// QtSizePolicyPropertyManager
+class QtSizePolicyPropertyManagerPrivate
+{
+QtSizePolicyPropertyManager *q_ptr;
+Q_DECLARE_PUBLIC(QtSizePolicyPropertyManager)
+public:
+QtSizePolicyPropertyManagerPrivate();
+void slotIntChanged(QtProperty *property, int value);
+void slotEnumChanged(QtProperty *property, int value);
+void slotPropertyDestroyed(QtProperty *property);
+typedef QMap<const QtProperty *, QSizePolicy> PropertyValueMap;
+PropertyValueMap m_values;
+QtIntPropertyManager *m_intPropertyManager;
+QtEnumPropertyManager *m_enumPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToHPolicy;
+QMap<const QtProperty *, QtProperty *> m_propertyToVPolicy;
+QMap<const QtProperty *, QtProperty *> m_propertyToHStretch;
+QMap<const QtProperty *, QtProperty *> m_propertyToVStretch;
+QMap<const QtProperty *, QtProperty *> m_hPolicyToProperty;
+QMap<const QtProperty *, QtProperty *> m_vPolicyToProperty;
+QMap<const QtProperty *, QtProperty *> m_hStretchToProperty;
+QMap<const QtProperty *, QtProperty *> m_vStretchToProperty;
+};
+QtSizePolicyPropertyManagerPrivate::QtSizePolicyPropertyManagerPrivate()
+{
+}
+void QtSizePolicyPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+if (QtProperty *prop = m_hStretchToProperty.value(property, 0)) {
+QSizePolicy sp = m_values[prop];
+sp.setHorizontalStretch(value);
+q_ptr->setValue(prop, sp);
+} else if (QtProperty *prop = m_vStretchToProperty.value(property, 0)) {
+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, 0)) {
+QSizePolicy sp = m_values[prop];
+sp.setHorizontalPolicy(metaEnumProvider()->indexToSizePolicy(value));
+q_ptr->setValue(prop, sp);
+} else if (QtProperty *prop = m_vPolicyToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToHStretch[pointProp] = 0;
+m_hStretchToProperty.remove(property);
+} else if (QtProperty *pointProp = m_vStretchToProperty.value(property, 0)) {
+m_propertyToVStretch[pointProp] = 0;
+m_vStretchToProperty.remove(property);
+} else if (QtProperty *pointProp = m_hPolicyToProperty.value(property, 0)) {
+m_propertyToHPolicy[pointProp] = 0;
+m_hPolicyToProperty.remove(property);
+} else if (QtProperty *pointProp = m_vPolicyToProperty.value(property, 0)) {
+m_propertyToVPolicy[pointProp] = 0;
+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, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotIntChanged(QtProperty*,int)));
+d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
+connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotEnumChanged(QtProperty*,int)));
+connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtSizePolicyPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+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, const QSizePolicy &val)
+{
+const QtSizePolicyPropertyManagerPrivate::PropertyValueMap::iterator 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.
+Q_GLOBAL_STATIC(QFontDatabase, fontDatabase)
+class QtFontPropertyManagerPrivate
+{
+QtFontPropertyManager *q_ptr;
+Q_DECLARE_PUBLIC(QtFontPropertyManager)
+public:
+QtFontPropertyManagerPrivate();
+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;
+typedef QMap<const QtProperty *, QFont> PropertyValueMap;
+PropertyValueMap m_values;
+QtIntPropertyManager *m_intPropertyManager;
+QtEnumPropertyManager *m_enumPropertyManager;
+QtBoolPropertyManager *m_boolPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToFamily;
+QMap<const QtProperty *, QtProperty *> m_propertyToPointSize;
+QMap<const QtProperty *, QtProperty *> m_propertyToBold;
+QMap<const QtProperty *, QtProperty *> m_propertyToItalic;
+QMap<const QtProperty *, QtProperty *> m_propertyToUnderline;
+QMap<const QtProperty *, QtProperty *> m_propertyToStrikeOut;
+QMap<const QtProperty *, QtProperty *> m_propertyToKerning;
+QMap<const QtProperty *, QtProperty *> m_familyToProperty;
+QMap<const QtProperty *, QtProperty *> m_pointSizeToProperty;
+QMap<const QtProperty *, QtProperty *> m_boldToProperty;
+QMap<const QtProperty *, QtProperty *> m_italicToProperty;
+QMap<const QtProperty *, QtProperty *> m_underlineToProperty;
+QMap<const QtProperty *, QtProperty *> m_strikeOutToProperty;
+QMap<const QtProperty *, QtProperty *> m_kerningToProperty;
+bool m_settingValue;
+QTimer *m_fontDatabaseChangeTimer;
+};
+QtFontPropertyManagerPrivate::QtFontPropertyManagerPrivate() :
+m_settingValue(false),
+m_fontDatabaseChangeTimer(0)
+{
+}
+void QtFontPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+if (m_settingValue)
+return;
+if (QtProperty *prop = m_pointSizeToProperty.value(property, 0)) {
+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, 0)) {
+QFont f = m_values[prop];
+f.setFamily(m_familyNames.at(value));
+q_ptr->setValue(prop, f);
+}
+}
+void QtFontPropertyManagerPrivate::slotBoolChanged(QtProperty *property, bool value)
+{
+if (m_settingValue)
+return;
+if (QtProperty *prop = m_boldToProperty.value(property, 0)) {
+QFont f = m_values[prop];
+f.setBold(value);
+q_ptr->setValue(prop, f);
+} else if (QtProperty *prop = m_italicToProperty.value(property, 0)) {
+QFont f = m_values[prop];
+f.setItalic(value);
+q_ptr->setValue(prop, f);
+} else if (QtProperty *prop = m_underlineToProperty.value(property, 0)) {
+QFont f = m_values[prop];
+f.setUnderline(value);
+q_ptr->setValue(prop, f);
+} else if (QtProperty *prop = m_strikeOutToProperty.value(property, 0)) {
+QFont f = m_values[prop];
+f.setStrikeOut(value);
+q_ptr->setValue(prop, f);
+} else if (QtProperty *prop = m_kerningToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToPointSize[pointProp] = 0;
+m_pointSizeToProperty.remove(property);
+} else if (QtProperty *pointProp = m_familyToProperty.value(property, 0)) {
+m_propertyToFamily[pointProp] = 0;
+m_familyToProperty.remove(property);
+} else if (QtProperty *pointProp = m_boldToProperty.value(property, 0)) {
+m_propertyToBold[pointProp] = 0;
+m_boldToProperty.remove(property);
+} else if (QtProperty *pointProp = m_italicToProperty.value(property, 0)) {
+m_propertyToItalic[pointProp] = 0;
+m_italicToProperty.remove(property);
+} else if (QtProperty *pointProp = m_underlineToProperty.value(property, 0)) {
+m_propertyToUnderline[pointProp] = 0;
+m_underlineToProperty.remove(property);
+} else if (QtProperty *pointProp = m_strikeOutToProperty.value(property, 0)) {
+m_propertyToStrikeOut[pointProp] = 0;
+m_strikeOutToProperty.remove(property);
+} else if (QtProperty *pointProp = m_kerningToProperty.value(property, 0)) {
+m_propertyToKerning[pointProp] = 0;
+m_kerningToProperty.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, SIGNAL(timeout()), q_ptr, SLOT(slotFontDatabaseDelayedChange()));
+}
+if (!m_fontDatabaseChangeTimer->isActive())
+m_fontDatabaseChangeTimer->start();
+}
+void QtFontPropertyManagerPrivate::slotFontDatabaseDelayedChange()
+{
+typedef QMap<const QtProperty *, QtProperty *> PropertyPropertyMap;
+// rescan available font names
+const QStringList oldFamilies = m_familyNames;
+m_familyNames = fontDatabase()->families();
+// Adapt all existing properties
+if (!m_propertyToFamily.empty()) {
+PropertyPropertyMap::const_iterator cend = m_propertyToFamily.constEnd();
+for (PropertyPropertyMap::const_iterator it = m_propertyToFamily.constBegin(); it != cend; ++it) {
+QtProperty *familyProp = it.value();
+const int oldIdx = m_enumPropertyManager->value(familyProp);
+int 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, SIGNAL(fontDatabaseChanged()), this, SLOT(slotFontDatabaseChanged()));
+d_ptr->m_intPropertyManager = new QtIntPropertyManager(this);
+connect(d_ptr->m_intPropertyManager, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotIntChanged(QtProperty*,int)));
+d_ptr->m_enumPropertyManager = new QtEnumPropertyManager(this);
+connect(d_ptr->m_enumPropertyManager, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotEnumChanged(QtProperty*,int)));
+d_ptr->m_boolPropertyManager = new QtBoolPropertyManager(this);
+connect(d_ptr->m_boolPropertyManager, SIGNAL(valueChanged(QtProperty*,bool)),
+this, SLOT(slotBoolChanged(QtProperty*,bool)));
+connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+connect(d_ptr->m_enumPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+connect(d_ptr->m_boolPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtFontPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+return QtPropertyBrowserUtils::fontValueText(it.value());
+}
+/*!
+\reimp
+*/
+QIcon QtFontPropertyManager::valueIcon(const QtProperty *property) const
+{
+const QtFontPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QIcon();
+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 QtFontPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
+if (it == d_ptr->m_values.end())
+return;
+const QFont oldVal = it.value();
+if (oldVal == val && oldVal.resolve() == val.resolve())
+return;
+it.value() = val;
+int 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_settingValue = settingValue;
+emit propertyChanged(property);
+emit valueChanged(property, val);
+}
+/*!
+\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.empty())
+d_ptr->m_familyNames = fontDatabase()->families();
+d_ptr->m_enumPropertyManager->setEnumNames(familyProp, d_ptr->m_familyNames);
+int 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"));
+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);
+}
+/*!
+\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);
+d_ptr->m_values.remove(property);
+}
+// QtColorPropertyManager
+class QtColorPropertyManagerPrivate
+{
+QtColorPropertyManager *q_ptr;
+Q_DECLARE_PUBLIC(QtColorPropertyManager)
+public:
+void slotIntChanged(QtProperty *property, int value);
+void slotPropertyDestroyed(QtProperty *property);
+typedef QMap<const QtProperty *, QColor> PropertyValueMap;
+PropertyValueMap m_values;
+QtIntPropertyManager *m_intPropertyManager;
+QMap<const QtProperty *, QtProperty *> m_propertyToR;
+QMap<const QtProperty *, QtProperty *> m_propertyToG;
+QMap<const QtProperty *, QtProperty *> m_propertyToB;
+QMap<const QtProperty *, QtProperty *> m_propertyToA;
+QMap<const QtProperty *, QtProperty *> m_rToProperty;
+QMap<const QtProperty *, QtProperty *> m_gToProperty;
+QMap<const QtProperty *, QtProperty *> m_bToProperty;
+QMap<const QtProperty *, QtProperty *> m_aToProperty;
+};
+void QtColorPropertyManagerPrivate::slotIntChanged(QtProperty *property, int value)
+{
+if (QtProperty *prop = m_rToProperty.value(property, 0)) {
+QColor c = m_values[prop];
+c.setRed(value);
+q_ptr->setValue(prop, c);
+} else if (QtProperty *prop = m_gToProperty.value(property, 0)) {
+QColor c = m_values[prop];
+c.setGreen(value);
+q_ptr->setValue(prop, c);
+} else if (QtProperty *prop = m_bToProperty.value(property, 0)) {
+QColor c = m_values[prop];
+c.setBlue(value);
+q_ptr->setValue(prop, c);
+} else if (QtProperty *prop = m_aToProperty.value(property, 0)) {
+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, 0)) {
+m_propertyToR[pointProp] = 0;
+m_rToProperty.remove(property);
+} else if (QtProperty *pointProp = m_gToProperty.value(property, 0)) {
+m_propertyToG[pointProp] = 0;
+m_gToProperty.remove(property);
+} else if (QtProperty *pointProp = m_bToProperty.value(property, 0)) {
+m_propertyToB[pointProp] = 0;
+m_bToProperty.remove(property);
+} else if (QtProperty *pointProp = m_aToProperty.value(property, 0)) {
+m_propertyToA[pointProp] = 0;
+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, SIGNAL(valueChanged(QtProperty*,int)),
+this, SLOT(slotIntChanged(QtProperty*,int)));
+connect(d_ptr->m_intPropertyManager, SIGNAL(propertyDestroyed(QtProperty*)),
+this, SLOT(slotPropertyDestroyed(QtProperty*)));
+}
+/*!
+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 QtColorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+return QtPropertyBrowserUtils::colorValueText(it.value());
+}
+/*!
+\reimp
+*/
+QIcon QtColorPropertyManager::valueIcon(const QtProperty *property) const
+{
+const QtColorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QIcon();
+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, const QColor &val)
+{
+const QtColorPropertyManagerPrivate::PropertyValueMap::iterator 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
+// Make sure icons are removed as soon as QApplication is destroyed, otherwise,
+// handles are leaked on X11.
+static void clearCursorDatabase();
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QtCursorDatabase, cursorDatabase, qAddPostRoutine(clearCursorDatabase))
+static void clearCursorDatabase()
+{
+cursorDatabase()->clear();
+}
+class QtCursorPropertyManagerPrivate
+{
+QtCursorPropertyManager *q_ptr;
+Q_DECLARE_PUBLIC(QtCursorPropertyManager)
+public:
+typedef QMap<const QtProperty *, QCursor> PropertyValueMap;
+PropertyValueMap 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 QtCursorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QString();
+return cursorDatabase()->cursorToShapeName(it.value());
+}
+/*!
+\reimp
+*/
+QIcon QtCursorPropertyManager::valueIcon(const QtProperty *property) const
+{
+const QtCursorPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
+if (it == d_ptr->m_values.constEnd())
+return QIcon();
+return cursorDatabase()->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 QtCursorPropertyManagerPrivate::PropertyValueMap::iterator 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.cpp"
+#include "qtpropertymanager.moc"