1447 lines
47 KiB
C++
1447 lines
47 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
**
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** This file is part of a Qt Solutions component.
|
|
**
|
|
** You may use this file under the terms of the BSD license as follows:
|
|
**
|
|
** "Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions are
|
|
** met:
|
|
** * Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** * Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in
|
|
** the documentation and/or other materials provided with the
|
|
** distribution.
|
|
** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
|
|
** the names of its contributors may be used to endorse or promote
|
|
** products derived from this software without specific prior written
|
|
** permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
|
|
**
|
|
****************************************************************************/
|
|
|
|
#pragma GCC system_header
|
|
#pragma GCC diagnostic ignored "-Wswitch-default"
|
|
#pragma GCC diagnostic ignored "-Wfloat-equal"
|
|
#pragma GCC diagnostic ignored "-Wshadow"
|
|
|
|
|
|
#ifndef QTPROPERTYMANAGER_H
|
|
#define QTPROPERTYMANAGER_H
|
|
|
|
#include <QtCore/QLocale>
|
|
#include <QtCore/QDateTime>
|
|
#include <QtCore/QMetaEnum>
|
|
#include <QLineEdit>
|
|
#include <QtGui/QIcon>
|
|
#include <climits>
|
|
|
|
#include "qtpropertybrowser.h"
|
|
|
|
#if QT_VERSION >= 0x040400
|
|
QT_BEGIN_NAMESPACE
|
|
#endif
|
|
|
|
class QDate;
|
|
class QTime;
|
|
class QDateTime;
|
|
class QLocale;
|
|
|
|
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());
|
|
}
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtGroupPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtGroupPropertyManager(QObject *parent = 0);
|
|
~QtGroupPropertyManager();
|
|
|
|
protected:
|
|
virtual bool hasValue(const QtProperty *property) const;
|
|
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
};
|
|
|
|
class QtIntPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtIntPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtIntPropertyManager(QObject *parent = 0);
|
|
~QtIntPropertyManager();
|
|
|
|
int value(const QtProperty *property) const;
|
|
int minimum(const QtProperty *property) const;
|
|
int maximum(const QtProperty *property) const;
|
|
int singleStep(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, int val);
|
|
void setMinimum(QtProperty *property, int minVal);
|
|
void setMaximum(QtProperty *property, int maxVal);
|
|
void setRange(QtProperty *property, int minVal, int maxVal);
|
|
void setSingleStep(QtProperty *property, int step);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, int val);
|
|
void rangeChanged(QtProperty *property, int minVal, int maxVal);
|
|
void singleStepChanged(QtProperty *property, int step);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtIntPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtIntPropertyManager)
|
|
Q_DISABLE_COPY(QtIntPropertyManager)
|
|
};
|
|
class QtIntPropertyManagerPrivate
|
|
{
|
|
QtIntPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtIntPropertyManager)
|
|
public:
|
|
QtIntPropertyManagerPrivate() : q_ptr(NULL) {}
|
|
|
|
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 QtBoolPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtBoolPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtBoolPropertyManager(QObject *parent = 0);
|
|
~QtBoolPropertyManager();
|
|
|
|
bool value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, bool val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, bool val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
QIcon valueIcon(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtBoolPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtBoolPropertyManager)
|
|
Q_DISABLE_COPY(QtBoolPropertyManager)
|
|
};
|
|
|
|
class QtBoolPropertyManagerPrivate
|
|
{
|
|
QtBoolPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtBoolPropertyManager)
|
|
public:
|
|
QtBoolPropertyManagerPrivate() :q_ptr(NULL) {}
|
|
QMap<const QtProperty *, bool> m_values;
|
|
};
|
|
|
|
|
|
class QtDoublePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtDoublePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtDoublePropertyManager(QObject *parent = 0);
|
|
~QtDoublePropertyManager();
|
|
|
|
double value(const QtProperty *property) const;
|
|
double minimum(const QtProperty *property) const;
|
|
double maximum(const QtProperty *property) const;
|
|
double singleStep(const QtProperty *property) const;
|
|
int decimals(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, double val);
|
|
void setMinimum(QtProperty *property, double minVal);
|
|
void setMaximum(QtProperty *property, double maxVal);
|
|
void setRange(QtProperty *property, double minVal, double maxVal);
|
|
void setSingleStep(QtProperty *property, double step);
|
|
void setDecimals(QtProperty *property, int prec);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, double val);
|
|
void rangeChanged(QtProperty *property, double minVal, double maxVal);
|
|
void singleStepChanged(QtProperty *property, double step);
|
|
void decimalsChanged(QtProperty *property, int prec);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtDoublePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtDoublePropertyManager)
|
|
Q_DISABLE_COPY(QtDoublePropertyManager)
|
|
};
|
|
class QtDoublePropertyManagerPrivate
|
|
{
|
|
QtDoublePropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtDoublePropertyManager)
|
|
public:
|
|
QtDoublePropertyManagerPrivate() : q_ptr(NULL) {}
|
|
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 QtStringPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtStringPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtStringPropertyManager(QObject *parent = 0);
|
|
~QtStringPropertyManager();
|
|
|
|
QString value(const QtProperty *property) const;
|
|
QRegExp regExp(const QtProperty *property) const;
|
|
EchoMode echoMode(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QString &val);
|
|
void setRegExp(QtProperty *property, const QRegExp ®Exp);
|
|
void setEchoMode(QtProperty *property, EchoMode echoMode);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QString &val);
|
|
void regExpChanged(QtProperty *property, const QRegExp ®Exp);
|
|
void echoModeChanged(QtProperty *property, const int);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
QString displayText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtStringPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtStringPropertyManager)
|
|
Q_DISABLE_COPY(QtStringPropertyManager)
|
|
};
|
|
|
|
class QtStringPropertyManagerPrivate
|
|
{
|
|
QtStringPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtStringPropertyManager)
|
|
public:
|
|
QtStringPropertyManagerPrivate() : q_ptr(NULL) {}
|
|
|
|
struct Data
|
|
{
|
|
Data() : regExp(QString(QLatin1Char('*')), Qt::CaseSensitive,
|
|
QRegExp::Wildcard), echoMode(QLineEdit::Normal)
|
|
{
|
|
}
|
|
QString val;
|
|
QRegExp regExp;
|
|
int echoMode;
|
|
};
|
|
|
|
typedef QMap<const QtProperty *, Data> PropertyValueMap;
|
|
QMap<const QtProperty *, Data> m_values;
|
|
};
|
|
class QtDatePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtDatePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtDatePropertyManager(QObject *parent = 0);
|
|
~QtDatePropertyManager();
|
|
|
|
QDate value(const QtProperty *property) const;
|
|
QDate minimum(const QtProperty *property) const;
|
|
QDate maximum(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QDate &val);
|
|
void setMinimum(QtProperty *property, const QDate &minVal);
|
|
void setMaximum(QtProperty *property, const QDate &maxVal);
|
|
void setRange(QtProperty *property, const QDate &minVal,
|
|
const QDate &maxVal);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QDate &val);
|
|
void rangeChanged(QtProperty *property, const QDate &minVal,
|
|
const QDate &maxVal);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtDatePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtDatePropertyManager)
|
|
Q_DISABLE_COPY(QtDatePropertyManager)
|
|
};
|
|
class QtDatePropertyManagerPrivate
|
|
{
|
|
QtDatePropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtDatePropertyManager)
|
|
public:
|
|
QtDatePropertyManagerPrivate() : q_ptr(NULL) {}
|
|
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 QtTimePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtTimePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtTimePropertyManager(QObject *parent = 0);
|
|
~QtTimePropertyManager();
|
|
|
|
QTime value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QTime &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QTime &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtTimePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtTimePropertyManager)
|
|
Q_DISABLE_COPY(QtTimePropertyManager)
|
|
};
|
|
class QtTimePropertyManagerPrivate
|
|
{
|
|
QtTimePropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtTimePropertyManager)
|
|
public:
|
|
QtTimePropertyManagerPrivate() : q_ptr(NULL) {}
|
|
QString m_format;
|
|
|
|
typedef QMap<const QtProperty *, QTime> PropertyValueMap;
|
|
PropertyValueMap m_values;
|
|
};
|
|
|
|
|
|
class QtDateTimePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtDateTimePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtDateTimePropertyManager(QObject *parent = 0);
|
|
~QtDateTimePropertyManager();
|
|
|
|
QDateTime value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QDateTime &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QDateTime &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtDateTimePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtDateTimePropertyManager)
|
|
Q_DISABLE_COPY(QtDateTimePropertyManager)
|
|
};
|
|
class QtDateTimePropertyManagerPrivate
|
|
{
|
|
QtDateTimePropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtDateTimePropertyManager)
|
|
public:
|
|
QtDateTimePropertyManagerPrivate() : q_ptr(NULL) {}
|
|
QString m_format;
|
|
|
|
typedef QMap<const QtProperty *, QDateTime> PropertyValueMap;
|
|
PropertyValueMap m_values;
|
|
};
|
|
|
|
|
|
class QtKeySequencePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtKeySequencePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtKeySequencePropertyManager(QObject *parent = 0);
|
|
~QtKeySequencePropertyManager();
|
|
|
|
QKeySequence value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QKeySequence &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QKeySequence &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtKeySequencePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtKeySequencePropertyManager)
|
|
Q_DISABLE_COPY(QtKeySequencePropertyManager)
|
|
};
|
|
class QtKeySequencePropertyManagerPrivate
|
|
{
|
|
QtKeySequencePropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtKeySequencePropertyManager)
|
|
public:
|
|
QtKeySequencePropertyManagerPrivate() : q_ptr(NULL) {}
|
|
QString m_format;
|
|
|
|
typedef QMap<const QtProperty *, QKeySequence> PropertyValueMap;
|
|
PropertyValueMap m_values;
|
|
};
|
|
|
|
|
|
class QtCharPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtCharPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtCharPropertyManager(QObject *parent = 0);
|
|
~QtCharPropertyManager();
|
|
|
|
QChar value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QChar &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QChar &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtCharPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtCharPropertyManager)
|
|
Q_DISABLE_COPY(QtCharPropertyManager)
|
|
};
|
|
class QtCharPropertyManagerPrivate
|
|
{
|
|
QtCharPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtCharPropertyManager)
|
|
public:
|
|
QtCharPropertyManagerPrivate() : q_ptr(NULL) {}
|
|
typedef QMap<const QtProperty *, QChar> PropertyValueMap;
|
|
PropertyValueMap m_values;
|
|
};
|
|
|
|
|
|
class QtEnumPropertyManager;
|
|
class QtLocalePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtLocalePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtLocalePropertyManager(QObject *parent = 0);
|
|
~QtLocalePropertyManager();
|
|
|
|
QtEnumPropertyManager *subEnumPropertyManager() const;
|
|
|
|
QLocale value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QLocale &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QLocale &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtLocalePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtLocalePropertyManager)
|
|
Q_DISABLE_COPY(QtLocalePropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
|
|
|
|
class QtPointPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtPointPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtPointPropertyManager(QObject *parent = 0);
|
|
~QtPointPropertyManager();
|
|
|
|
QtIntPropertyManager *subIntPropertyManager() const;
|
|
|
|
QPoint value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QPoint &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QPoint &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtPointPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtPointPropertyManager)
|
|
Q_DISABLE_COPY(QtPointPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtPointPropertyManagerPrivate
|
|
{
|
|
QtPointPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtPointPropertyManager)
|
|
public:
|
|
QtPointPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_intPropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtPointFPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtPointFPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtPointFPropertyManager(QObject *parent = 0);
|
|
~QtPointFPropertyManager();
|
|
|
|
QtDoublePropertyManager *subDoublePropertyManager() const;
|
|
|
|
QPointF value(const QtProperty *property) const;
|
|
int decimals(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QPointF &val);
|
|
void setDecimals(QtProperty *property, int prec);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QPointF &val);
|
|
void decimalsChanged(QtProperty *property, int prec);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtPointFPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtPointFPropertyManager)
|
|
Q_DISABLE_COPY(QtPointFPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
class QtPointFPropertyManagerPrivate
|
|
{
|
|
QtPointFPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtPointFPropertyManager)
|
|
public:
|
|
QtPointFPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_doublePropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtSizePropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtSizePropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtSizePropertyManager(QObject *parent = 0);
|
|
~QtSizePropertyManager();
|
|
|
|
QtIntPropertyManager *subIntPropertyManager() const;
|
|
|
|
QSize value(const QtProperty *property) const;
|
|
QSize minimum(const QtProperty *property) const;
|
|
QSize maximum(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QSize &val);
|
|
void setMinimum(QtProperty *property, const QSize &minVal);
|
|
void setMaximum(QtProperty *property, const QSize &maxVal);
|
|
void setRange(QtProperty *property, const QSize &minVal,
|
|
const QSize &maxVal);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QSize &val);
|
|
void rangeChanged(QtProperty *property, const QSize &minVal,
|
|
const QSize &maxVal);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtSizePropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtSizePropertyManager)
|
|
Q_DISABLE_COPY(QtSizePropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtSizePropertyManagerPrivate
|
|
{
|
|
QtSizePropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtSizePropertyManager)
|
|
public:
|
|
QtSizePropertyManagerPrivate()
|
|
: q_ptr(NULL), m_intPropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtSizeFPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtSizeFPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtSizeFPropertyManager(QObject *parent = 0);
|
|
~QtSizeFPropertyManager();
|
|
|
|
QtDoublePropertyManager *subDoublePropertyManager() const;
|
|
|
|
QSizeF value(const QtProperty *property) const;
|
|
QSizeF minimum(const QtProperty *property) const;
|
|
QSizeF maximum(const QtProperty *property) const;
|
|
int decimals(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QSizeF &val);
|
|
void setMinimum(QtProperty *property, const QSizeF &minVal);
|
|
void setMaximum(QtProperty *property, const QSizeF &maxVal);
|
|
void setRange(QtProperty *property, const QSizeF &minVal,
|
|
const QSizeF &maxVal);
|
|
void setDecimals(QtProperty *property, int prec);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QSizeF &val);
|
|
void rangeChanged(QtProperty *property, const QSizeF &minVal,
|
|
const QSizeF &maxVal);
|
|
void decimalsChanged(QtProperty *property, int prec);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtSizeFPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtSizeFPropertyManager)
|
|
Q_DISABLE_COPY(QtSizeFPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtSizeFPropertyManagerPrivate
|
|
{
|
|
QtSizeFPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtSizeFPropertyManager)
|
|
public:
|
|
QtSizeFPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_doublePropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtRectPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtRectPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtRectPropertyManager(QObject *parent = 0);
|
|
~QtRectPropertyManager();
|
|
|
|
QtIntPropertyManager *subIntPropertyManager() const;
|
|
|
|
QRect value(const QtProperty *property) const;
|
|
QRect constraint(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QRect &val);
|
|
void setConstraint(QtProperty *property, const QRect &constraint);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QRect &val);
|
|
void constraintChanged(QtProperty *property, const QRect &constraint);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtRectPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtRectPropertyManager)
|
|
Q_DISABLE_COPY(QtRectPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtRectPropertyManagerPrivate
|
|
{
|
|
QtRectPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtRectPropertyManager)
|
|
public:
|
|
QtRectPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_intPropertyManager(NULL) {}
|
|
|
|
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;
|
|
};
|
|
|
|
class QtRectFPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtRectFPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtRectFPropertyManager(QObject *parent = 0);
|
|
~QtRectFPropertyManager();
|
|
|
|
QtDoublePropertyManager *subDoublePropertyManager() const;
|
|
|
|
QRectF value(const QtProperty *property) const;
|
|
QRectF constraint(const QtProperty *property) const;
|
|
int decimals(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QRectF &val);
|
|
void setConstraint(QtProperty *property, const QRectF &constraint);
|
|
void setDecimals(QtProperty *property, int prec);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QRectF &val);
|
|
void constraintChanged(QtProperty *property, const QRectF &constraint);
|
|
void decimalsChanged(QtProperty *property, int prec);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtRectFPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtRectFPropertyManager)
|
|
Q_DISABLE_COPY(QtRectFPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtRectFPropertyManagerPrivate
|
|
{
|
|
QtRectFPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtRectFPropertyManager)
|
|
public:
|
|
QtRectFPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_doublePropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtEnumPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtEnumPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtEnumPropertyManager(QObject *parent = 0);
|
|
~QtEnumPropertyManager();
|
|
|
|
int value(const QtProperty *property) const;
|
|
QStringList enumNames(const QtProperty *property) const;
|
|
QMap<int, QIcon> enumIcons(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, int val);
|
|
void setEnumNames(QtProperty *property, const QStringList &names);
|
|
void setEnumIcons(QtProperty *property, const QMap<int, QIcon> &icons);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, int val);
|
|
void enumNamesChanged(QtProperty *property, const QStringList &names);
|
|
void enumIconsChanged(QtProperty *property, const QMap<int, QIcon> &icons);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
QIcon valueIcon(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtEnumPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtEnumPropertyManager)
|
|
Q_DISABLE_COPY(QtEnumPropertyManager)
|
|
};
|
|
|
|
class QtEnumPropertyManagerPrivate
|
|
{
|
|
QtEnumPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtEnumPropertyManager)
|
|
public:
|
|
QtEnumPropertyManagerPrivate() : q_ptr(NULL) {}
|
|
|
|
struct Data
|
|
{
|
|
Data() : val(-1) {}
|
|
int val;
|
|
QStringList enumNames;
|
|
QMap<int, QIcon> enumIcons;
|
|
};
|
|
|
|
typedef QMap<const QtProperty *, Data> PropertyValueMap;
|
|
PropertyValueMap m_values;
|
|
};
|
|
|
|
class QtFlagPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtFlagPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtFlagPropertyManager(QObject *parent = 0);
|
|
~QtFlagPropertyManager();
|
|
|
|
QtBoolPropertyManager *subBoolPropertyManager() const;
|
|
|
|
int value(const QtProperty *property) const;
|
|
QStringList flagNames(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, int val);
|
|
void setFlagNames(QtProperty *property, const QStringList &names);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, int val);
|
|
void flagNamesChanged(QtProperty *property, const QStringList &names);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtFlagPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtFlagPropertyManager)
|
|
Q_DISABLE_COPY(QtFlagPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty *, bool))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtFlagPropertyManagerPrivate
|
|
{
|
|
QtFlagPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtFlagPropertyManager)
|
|
public:
|
|
QtFlagPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_boolPropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtSizePolicyPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtSizePolicyPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtSizePolicyPropertyManager(QObject *parent = 0);
|
|
~QtSizePolicyPropertyManager();
|
|
|
|
QtIntPropertyManager *subIntPropertyManager() const;
|
|
QtEnumPropertyManager *subEnumPropertyManager() const;
|
|
|
|
QSizePolicy value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QSizePolicy &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QSizePolicy &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtSizePolicyPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtSizePolicyPropertyManager)
|
|
Q_DISABLE_COPY(QtSizePolicyPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
class QtFontPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtFontPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtFontPropertyManager(QObject *parent = 0);
|
|
~QtFontPropertyManager();
|
|
|
|
QtIntPropertyManager *subIntPropertyManager() const;
|
|
QtEnumPropertyManager *subEnumPropertyManager() const;
|
|
QtBoolPropertyManager *subBoolPropertyManager() const;
|
|
|
|
QFont value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QFont &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QFont &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
QIcon valueIcon(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtFontPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtFontPropertyManager)
|
|
Q_DISABLE_COPY(QtFontPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty *, bool))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
Q_PRIVATE_SLOT(d_func(), void slotFontDatabaseChanged())
|
|
Q_PRIVATE_SLOT(d_func(), void slotFontDatabaseDelayedChange())
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
class QtColorPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtColorPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtColorPropertyManager(QObject *parent = 0);
|
|
~QtColorPropertyManager();
|
|
|
|
QtIntPropertyManager *subIntPropertyManager() const;
|
|
|
|
QColor value(const QtProperty *property) const;
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QColor &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QColor &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
QIcon valueIcon(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtColorPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtColorPropertyManager)
|
|
Q_DISABLE_COPY(QtColorPropertyManager)
|
|
Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))
|
|
Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))
|
|
};
|
|
|
|
class QtColorPropertyManagerPrivate
|
|
{
|
|
QtColorPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtColorPropertyManager)
|
|
public:
|
|
QtColorPropertyManagerPrivate()
|
|
: q_ptr(NULL), m_intPropertyManager(NULL) {}
|
|
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;
|
|
};
|
|
|
|
class QtCursorPropertyManagerPrivate;
|
|
|
|
|
|
class QT_QTPROPERTYBROWSER_EXPORT QtCursorPropertyManager
|
|
: public QtAbstractPropertyManager
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
explicit QtCursorPropertyManager(QObject *parent = 0);
|
|
~QtCursorPropertyManager();
|
|
|
|
#ifndef QT_NO_CURSOR
|
|
QCursor value(const QtProperty *property) const;
|
|
#endif
|
|
|
|
public Q_SLOTS:
|
|
void setValue(QtProperty *property, const QCursor &val);
|
|
Q_SIGNALS:
|
|
void valueChanged(QtProperty *property, const QCursor &val);
|
|
protected:
|
|
QString valueText(const QtProperty *property) const;
|
|
QIcon valueIcon(const QtProperty *property) const;
|
|
virtual void initializeProperty(QtProperty *property);
|
|
virtual void uninitializeProperty(QtProperty *property);
|
|
private:
|
|
QtCursorPropertyManagerPrivate *d_ptr;
|
|
Q_DECLARE_PRIVATE(QtCursorPropertyManager)
|
|
Q_DISABLE_COPY(QtCursorPropertyManager)
|
|
};
|
|
|
|
class QtCursorPropertyManagerPrivate
|
|
{
|
|
QtCursorPropertyManager *q_ptr;
|
|
Q_DECLARE_PUBLIC(QtCursorPropertyManager)
|
|
public:
|
|
QtCursorPropertyManagerPrivate() : q_ptr(NULL) {}
|
|
typedef QMap<const QtProperty *, QCursor> PropertyValueMap;
|
|
PropertyValueMap m_values;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
class QtMetaEnumWrapper
|
|
: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QSizePolicy::Policy policy READ policy)
|
|
public:
|
|
QSizePolicy::Policy policy() const { return QSizePolicy::Ignored; }
|
|
private:
|
|
explicit QtMetaEnumWrapper(QObject *parent) : QObject(parent) {}
|
|
};
|
|
|
|
|
|
#if QT_VERSION >= 0x040400
|
|
QT_END_NAMESPACE
|
|
#endif
|
|
|
|
#endif
|