qtpropertymanager.h

Go to the documentation of this file.

/****************************************************************************
**
** 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.
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the 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.
**   * Neither the name of Digia Plc 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."
**
****************************************************************************/
 
 
#ifndef QTPROPERTYMANAGER_H
#define QTPROPERTYMANAGER_H
 
#include "qtpropertybrowser.h"
#include <QPushButton>
#include <QLineEdit>
 
#if QT_VERSION >= 0x040400
QT_BEGIN_NAMESPACE
#endif
 
class QDate;
class QTime;
class QDateTime;
class QLocale;
class QRegularExpression;
 
class QT_QTPROPERTYBROWSER_EXPORT QtGroupPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtGroupPropertyManager(QObject* parent = nullptr);
 
    ~QtGroupPropertyManager() override = default;
 
protected:
    bool hasValue(const QtProperty* property) const override;
 
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
};
 
class QtIntPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtIntPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtIntPropertyManager(QObject* parent = nullptr);
    ~QtIntPropertyManager() override;
 
    int value(const QtProperty* property) const;
    int minimum(const QtProperty* property) const;
    int maximum(const QtProperty* property) const;
    int singleStep(const QtProperty* property) const;
    bool isReadOnly(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);
    void setReadOnly(QtProperty* property, bool readOnly);
Q_SIGNALS:
    void valueChanged(QtProperty* property, int val);
    void rangeChanged(QtProperty* property, int minVal, int maxVal);
    void singleStepChanged(QtProperty* property, int step);
    void readOnlyChanged(QtProperty* property, bool readOnly);
protected:
    QString valueText(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtIntPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtIntPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtIntPropertyManager)
#else
    Q_DISABLE_COPY(QtIntPropertyManager)
#endif
};
 
class QtBoolPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtBoolPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtBoolPropertyManager(QObject* parent = nullptr);
    ~QtBoolPropertyManager() override;
 
    bool value(const QtProperty* property) const;
    bool textVisible(const QtProperty* property) const;
 
public Q_SLOTS:
    void setValue(QtProperty* property, bool val);
    void setTextVisible(QtProperty* property, bool textVisible);
Q_SIGNALS:
    void valueChanged(QtProperty* property, bool val);
    void textVisibleChanged(QtProperty* property, bool);
protected:
    QString valueText(const QtProperty* property) const override;
    QIcon valueIcon(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtBoolPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtBoolPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtBoolPropertyManager)
#else
    Q_DISABLE_COPY(QtBoolPropertyManager)
#endif
};
 
class QtDoublePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtDoublePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtDoublePropertyManager(QObject* parent = nullptr);
    ~QtDoublePropertyManager() override;
 
    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;
    bool isReadOnly(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);
    void setReadOnly(QtProperty* property, bool readOnly);
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);
    void readOnlyChanged(QtProperty* property, bool readOnly);
protected:
    QString valueText(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtDoublePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtDoublePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtDoublePropertyManager)
#else
    Q_DISABLE_COPY(QtDoublePropertyManager)
#endif
};
 
class QtStringPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtStringPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtStringPropertyManager(QObject* parent = nullptr);
    ~QtStringPropertyManager() override;
 
    QString value(const QtProperty* property) const;
    QRegularExpression regExp(const QtProperty* property) const;
    EchoMode echoMode(const QtProperty* property) const override;
    bool isReadOnly(const QtProperty* property) const;
 
public Q_SLOTS:
    void setValue(QtProperty* property, const QString& val);
    void setRegExp(QtProperty* property, const QRegularExpression& regExp);
    void setEchoMode(QtProperty* property, EchoMode echoMode);
    void setReadOnly(QtProperty* property, bool readOnly);
Q_SIGNALS:
    void valueChanged(QtProperty* property, const QString& val);
    void regExpChanged(QtProperty* property, const QRegularExpression& regExp);
    void echoModeChanged(QtProperty* property, const int);
    void readOnlyChanged(QtProperty* property, bool);
protected:
    QString valueText(const QtProperty* property) const override;
    QString displayText(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtStringPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtStringPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtStringPropertyManager)
#else
    Q_DISABLE_COPY(QtStringPropertyManager)
#endif
};
 
class QtDatePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtDatePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtDatePropertyManager(QObject* parent = nullptr);
    ~QtDatePropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtDatePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtDatePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtDatePropertyManager)
#else
    Q_DISABLE_COPY(QtDatePropertyManager)
#endif
};
 
class QtTimePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtTimePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtTimePropertyManager(QObject* parent = nullptr);
    ~QtTimePropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtTimePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtTimePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtTimePropertyManager)
#else
    Q_DISABLE_COPY(QtTimePropertyManager)
#endif
};
 
class QtDateTimePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtDateTimePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtDateTimePropertyManager(QObject* parent = nullptr);
    ~QtDateTimePropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtDateTimePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtDateTimePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtDateTimePropertyManager)
#else
    Q_DISABLE_COPY(QtDateTimePropertyManager)
#endif
};
 
class QtKeySequencePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtKeySequencePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtKeySequencePropertyManager(QObject* parent = nullptr);
    ~QtKeySequencePropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtKeySequencePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtKeySequencePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtKeySequencePropertyManager)
#else
    Q_DISABLE_COPY(QtKeySequencePropertyManager)
#endif
};
 
class QtCharPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtCharPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtCharPropertyManager(QObject* parent = nullptr);
    ~QtCharPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtCharPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtCharPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtCharPropertyManager)
#else
    Q_DISABLE_COPY(QtCharPropertyManager)
#endif
};
 
class QtEnumPropertyManager;
class QtLocalePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtLocalePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtLocalePropertyManager(QObject* parent = nullptr);
    ~QtLocalePropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtLocalePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtLocalePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtLocalePropertyManager)
#else
    Q_DISABLE_COPY(QtLocalePropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty*, int))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtPointPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtPointPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtPointPropertyManager(QObject* parent = nullptr);
    ~QtPointPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtPointPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtPointPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtPointPropertyManager)
#else
    Q_DISABLE_COPY(QtPointPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty*, int))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtPointFPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtPointFPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtPointFPropertyManager(QObject* parent = nullptr);
    ~QtPointFPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtPointFPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtPointFPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtPointFPropertyManager)
#else
    Q_DISABLE_COPY(QtPointFPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty*, double))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtSizePropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtSizePropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtSizePropertyManager(QObject* parent = nullptr);
    ~QtSizePropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtSizePropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtSizePropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtSizePropertyManager)
#else
    Q_DISABLE_COPY(QtSizePropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty*, int))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtSizeFPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtSizeFPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtSizeFPropertyManager(QObject* parent = nullptr);
    ~QtSizeFPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtSizeFPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtSizeFPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtSizeFPropertyManager)
#else
    Q_DISABLE_COPY(QtSizeFPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty*, double))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtRectPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtRectPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtRectPropertyManager(QObject* parent = nullptr);
    ~QtRectPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtRectPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtRectPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtRectPropertyManager)
#else
    Q_DISABLE_COPY(QtRectPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty*, int))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtRectFPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtRectFPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtRectFPropertyManager(QObject* parent = nullptr);
    ~QtRectFPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtRectFPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtRectFPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtRectFPropertyManager)
#else
    Q_DISABLE_COPY(QtRectFPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty*, double))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
 
class QtVector3DPropertyManagerPrivate;
class QVector3D;
 
class QT_QTPROPERTYBROWSER_EXPORT QtVector3DPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtVector3DPropertyManager(QObject* parent = nullptr);
    ~QtVector3DPropertyManager() override;
 
    QtDoublePropertyManager* subDoublePropertyManager() const;
 
    QVector3D value(const QtProperty* property) const;
    int decimals(const QtProperty* property) const;
 
public Q_SLOTS:
    void setValue(QtProperty* property, const QVector3D& val);
    void setDecimals(QtProperty* property, int prec);
Q_SIGNALS:
    void valueChanged(QtProperty* property, const QVector3D& val);
    void decimalsChanged(QtProperty* property, int prec);
protected:
    QString valueText(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtVector3DPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtVector3DPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtVector3DPropertyManager)
#else
    Q_DISABLE_COPY(QtVector3DPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty*, double))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtEnumPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtEnumPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtEnumPropertyManager(QObject* parent = nullptr);
    ~QtEnumPropertyManager() override;
 
    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 override;
    QIcon valueIcon(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtEnumPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtEnumPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtEnumPropertyManager)
#else
    Q_DISABLE_COPY(QtEnumPropertyManager)
#endif
};
 
class QtFlagPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtFlagPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtFlagPropertyManager(QObject* parent = nullptr);
    ~QtFlagPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtFlagPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtFlagPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtFlagPropertyManager)
#else
    Q_DISABLE_COPY(QtFlagPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty*, bool))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtSizePolicyPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtSizePolicyPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtSizePolicyPropertyManager(QObject* parent = nullptr);
    ~QtSizePolicyPropertyManager() override;
 
    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 override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtSizePolicyPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtSizePolicyPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtSizePolicyPropertyManager)
#else
    Q_DISABLE_COPY(QtSizePolicyPropertyManager)
#endif
    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 QtFontPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtFontPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtFontPropertyManager(QObject* parent = nullptr);
    ~QtFontPropertyManager() override;
 
    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 override;
    QIcon valueIcon(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtFontPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtFontPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtFontPropertyManager)
#else
    Q_DISABLE_COPY(QtFontPropertyManager)
#endif
    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 QtColorPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtColorPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtColorPropertyManager(QObject* parent = nullptr);
    ~QtColorPropertyManager() override;
 
    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 override;
    QIcon valueIcon(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtColorPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtColorPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtColorPropertyManager)
#else
    Q_DISABLE_COPY(QtColorPropertyManager)
#endif
    Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty*, int))
    Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty*))
};
 
class QtCursorPropertyManagerPrivate;
 
class QT_QTPROPERTYBROWSER_EXPORT QtCursorPropertyManager : public QtAbstractPropertyManager {
    Q_OBJECT
public:
    QtCursorPropertyManager(QObject* parent = nullptr);
    ~QtCursorPropertyManager() override;
 
#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 override;
    QIcon valueIcon(const QtProperty* property) const override;
    void initializeProperty(QtProperty* property) override;
    void uninitializeProperty(QtProperty* property) override;
private:
    QtCursorPropertyManagerPrivate* d_ptr;
    Q_DECLARE_PRIVATE(QtCursorPropertyManager)
#if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
    Q_DISABLE_COPY_MOVE(QtCursorPropertyManager)
#else
    Q_DISABLE_COPY(QtCursorPropertyManager)
#endif
};
 
#if QT_VERSION >= 0x040400
QT_END_NAMESPACE
#endif
 
#endif