--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/shared/qtpropertybrowser/qtpropertymanager.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,6422 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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 ®Exp)
+
+ This signal is emitted whenever a property created by this manager
+ changes its currenlty set regular expression, passing a pointer to
+ the \a property and the new \a regExp as parameters.
+
+ \sa setRegExp()
+*/
+
+/*!
+ Creates a manager with the given \a parent.
+*/
+QtStringPropertyManager::QtStringPropertyManager(QObject *parent)
+ : QtAbstractPropertyManager(parent), d_ptr(new QtStringPropertyManagerPrivate)
+{
+ d_ptr->q_ptr = this;
+}
+
+/*!
+ Destroys this manager, and all the properties it has created.
+*/
+QtStringPropertyManager::~QtStringPropertyManager()
+{
+ clear();
+}
+
+/*!
+ Returns the given \a property's value.
+
+ If the given property is not managed by this manager, this
+ function returns an empty string.
+
+ \sa setValue()
+*/
+QString QtStringPropertyManager::value(const QtProperty *property) const
+{
+ return getValue<QString>(d_ptr->m_values, property);
+}
+
+/*!
+ Returns the given \a property's currently set regular expression.
+
+ If the given \a property is not managed by this manager, this
+ function returns an empty expression.
+
+ \sa setRegExp()
+*/
+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 ®Exp)
+{
+ 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
+
+class QtBoolPropertyManagerPrivate
+{
+ QtBoolPropertyManager *q_ptr;
+ Q_DECLARE_PUBLIC(QtBoolPropertyManager)
+public:
+
+ QMap<const QtProperty *, bool> m_values;
+};
+
+/*!
+ \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;
+}
+
+// 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);
+}
+
+/*!
+ \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();
+
+ static const QIcon checkedIcon = drawCheckBox(true);
+ static const QIcon uncheckedIcon = drawCheckBox(false);
+ return it.value() ? checkedIcon : 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:
+
+ 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;
+};
+
+/*!
+ \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)
+{
+ d_ptr->q_ptr = this;
+
+ QLocale loc;
+ d_ptr->m_format = loc.dateFormat(QLocale::ShortFormat);
+}
+
+/*!
+ 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:
+
+ QString m_format;
+
+ typedef QMap<const QtProperty *, QTime> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*!
+ \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)
+{
+ d_ptr->q_ptr = this;
+
+ QLocale loc;
+ d_ptr->m_format = loc.timeFormat(QLocale::ShortFormat);
+}
+
+/*!
+ 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:
+
+ QString m_format;
+
+ typedef QMap<const QtProperty *, QDateTime> PropertyValueMap;
+ PropertyValueMap m_values;
+};
+
+/*! \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)
+{
+ d_ptr->q_ptr = this;
+
+ QLocale loc;
+ d_ptr->m_format = loc.dateFormat(QLocale::ShortFormat);
+ d_ptr->m_format += QLatin1Char(' ');
+ d_ptr->m_format += loc.timeFormat(QLocale::ShortFormat);
+}
+
+/*!
+ 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
+
+Q_GLOBAL_STATIC(QtCursorDatabase, cursorDatabase)
+
+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"