1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the tools applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #ifndef QTPROPERTYMANAGER_H

    43 #define QTPROPERTYMANAGER_H

    44 

    45 #include "qtpropertybrowser.h"

    46 

    47 QT_BEGIN_NAMESPACE

    48 

    49 class QDate;

    50 class QTime;

    51 class QDateTime;

    52 class QLocale;

    53 

    54 class QtGroupPropertyManager : public QtAbstractPropertyManager

    55 {

    56     Q_OBJECT

    57 public:

    58     QtGroupPropertyManager(QObject *parent = 0);

    59     ~QtGroupPropertyManager();

    60 

    61 protected:

    62     virtual bool hasValue(const QtProperty *property) const;

    63 

    64     virtual void initializeProperty(QtProperty *property);

    65     virtual void uninitializeProperty(QtProperty *property);

    66 };

    67 

    68 class QtIntPropertyManagerPrivate;

    69 

    70 class QtIntPropertyManager : public QtAbstractPropertyManager

    71 {

    72     Q_OBJECT

    73 public:

    74     QtIntPropertyManager(QObject *parent = 0);

    75     ~QtIntPropertyManager();

    76 

    77     int value(const QtProperty *property) const;

    78     int minimum(const QtProperty *property) const;

    79     int maximum(const QtProperty *property) const;

    80     int singleStep(const QtProperty *property) const;

    81 

    82 public Q_SLOTS:

    83     void setValue(QtProperty *property, int val);

    84     void setMinimum(QtProperty *property, int minVal);

    85     void setMaximum(QtProperty *property, int maxVal);

    86     void setRange(QtProperty *property, int minVal, int maxVal);

    87     void setSingleStep(QtProperty *property, int step);

    88 Q_SIGNALS:

    89     void valueChanged(QtProperty *property, int val);

    90     void rangeChanged(QtProperty *property, int minVal, int maxVal);

    91     void singleStepChanged(QtProperty *property, int step);

    92 protected:

    93     QString valueText(const QtProperty *property) const;

    94     virtual void initializeProperty(QtProperty *property);

    95     virtual void uninitializeProperty(QtProperty *property);

    96 private:

    97     QScopedPointer<QtIntPropertyManagerPrivate> d_ptr;

    98     Q_DECLARE_PRIVATE(QtIntPropertyManager)

    99     Q_DISABLE_COPY(QtIntPropertyManager)

   100 };

   101 

   102 class QtBoolPropertyManagerPrivate;

   103 

   104 class QtBoolPropertyManager : public QtAbstractPropertyManager

   105 {

   106     Q_OBJECT

   107 public:

   108     QtBoolPropertyManager(QObject *parent = 0);

   109     ~QtBoolPropertyManager();

   110 

   111     bool value(const QtProperty *property) const;

   112 

   113 public Q_SLOTS:

   114     void setValue(QtProperty *property, bool val);

   115 Q_SIGNALS:

   116     void valueChanged(QtProperty *property, bool val);

   117 protected:

   118     QString valueText(const QtProperty *property) const;

   119     QIcon valueIcon(const QtProperty *property) const;

   120     virtual void initializeProperty(QtProperty *property);

   121     virtual void uninitializeProperty(QtProperty *property);

   122 private:

   123     QScopedPointer<QtBoolPropertyManagerPrivate> d_ptr;

   124     Q_DECLARE_PRIVATE(QtBoolPropertyManager)

   125     Q_DISABLE_COPY(QtBoolPropertyManager)

   126 };

   127 

   128 class QtDoublePropertyManagerPrivate;

   129 

   130 class QtDoublePropertyManager : public QtAbstractPropertyManager

   131 {

   132     Q_OBJECT

   133 public:

   134     QtDoublePropertyManager(QObject *parent = 0);

   135     ~QtDoublePropertyManager();

   136 

   137     double value(const QtProperty *property) const;

   138     double minimum(const QtProperty *property) const;

   139     double maximum(const QtProperty *property) const;

   140     double singleStep(const QtProperty *property) const;

   141     int decimals(const QtProperty *property) const;

   142 

   143 public Q_SLOTS:

   144     void setValue(QtProperty *property, double val);

   145     void setMinimum(QtProperty *property, double minVal);

   146     void setMaximum(QtProperty *property, double maxVal);

   147     void setRange(QtProperty *property, double minVal, double maxVal);

   148     void setSingleStep(QtProperty *property, double step);

   149     void setDecimals(QtProperty *property, int prec);

   150 Q_SIGNALS:

   151     void valueChanged(QtProperty *property, double val);

   152     void rangeChanged(QtProperty *property, double minVal, double maxVal);

   153     void singleStepChanged(QtProperty *property, double step);

   154     void decimalsChanged(QtProperty *property, int prec);

   155 protected:

   156     QString valueText(const QtProperty *property) const;

   157     virtual void initializeProperty(QtProperty *property);

   158     virtual void uninitializeProperty(QtProperty *property);

   159 private:

   160     QScopedPointer<QtDoublePropertyManagerPrivate> d_ptr;

   161     Q_DECLARE_PRIVATE(QtDoublePropertyManager)

   162     Q_DISABLE_COPY(QtDoublePropertyManager)

   163 };

   164 

   165 class QtStringPropertyManagerPrivate;

   166 

   167 class QtStringPropertyManager : public QtAbstractPropertyManager

   168 {

   169     Q_OBJECT

   170 public:

   171     QtStringPropertyManager(QObject *parent = 0);

   172     ~QtStringPropertyManager();

   173 

   174     QString value(const QtProperty *property) const;

   175     QRegExp regExp(const QtProperty *property) const;

   176 

   177 public Q_SLOTS:

   178     void setValue(QtProperty *property, const QString &val);

   179     void setRegExp(QtProperty *property, const QRegExp &regExp);

   180 Q_SIGNALS:

   181     void valueChanged(QtProperty *property, const QString &val);

   182     void regExpChanged(QtProperty *property, const QRegExp &regExp);

   183 protected:

   184     QString valueText(const QtProperty *property) const;

   185     virtual void initializeProperty(QtProperty *property);

   186     virtual void uninitializeProperty(QtProperty *property);

   187 private:

   188     QScopedPointer<QtStringPropertyManagerPrivate> d_ptr;

   189     Q_DECLARE_PRIVATE(QtStringPropertyManager)

   190     Q_DISABLE_COPY(QtStringPropertyManager)

   191 };

   192 

   193 class QtDatePropertyManagerPrivate;

   194 

   195 class QtDatePropertyManager : public QtAbstractPropertyManager

   196 {

   197     Q_OBJECT

   198 public:

   199     QtDatePropertyManager(QObject *parent = 0);

   200     ~QtDatePropertyManager();

   201 

   202     QDate value(const QtProperty *property) const;

   203     QDate minimum(const QtProperty *property) const;

   204     QDate maximum(const QtProperty *property) const;

   205 

   206 public Q_SLOTS:

   207     void setValue(QtProperty *property, const QDate &val);

   208     void setMinimum(QtProperty *property, const QDate &minVal);

   209     void setMaximum(QtProperty *property, const QDate &maxVal);

   210     void setRange(QtProperty *property, const QDate &minVal, const QDate &maxVal);

   211 Q_SIGNALS:

   212     void valueChanged(QtProperty *property, const QDate &val);

   213     void rangeChanged(QtProperty *property, const QDate &minVal, const QDate &maxVal);

   214 protected:

   215     QString valueText(const QtProperty *property) const;

   216     virtual void initializeProperty(QtProperty *property);

   217     virtual void uninitializeProperty(QtProperty *property);

   218 private:

   219     QScopedPointer<QtDatePropertyManagerPrivate> d_ptr;

   220     Q_DECLARE_PRIVATE(QtDatePropertyManager)

   221     Q_DISABLE_COPY(QtDatePropertyManager)

   222 };

   223 

   224 class QtTimePropertyManagerPrivate;

   225 

   226 class QtTimePropertyManager : public QtAbstractPropertyManager

   227 {

   228     Q_OBJECT

   229 public:

   230     QtTimePropertyManager(QObject *parent = 0);

   231     ~QtTimePropertyManager();

   232 

   233     QTime value(const QtProperty *property) const;

   234 

   235 public Q_SLOTS:

   236     void setValue(QtProperty *property, const QTime &val);

   237 Q_SIGNALS:

   238     void valueChanged(QtProperty *property, const QTime &val);

   239 protected:

   240     QString valueText(const QtProperty *property) const;

   241     virtual void initializeProperty(QtProperty *property);

   242     virtual void uninitializeProperty(QtProperty *property);

   243 private:

   244     QScopedPointer<QtTimePropertyManagerPrivate> d_ptr;

   245     Q_DECLARE_PRIVATE(QtTimePropertyManager)

   246     Q_DISABLE_COPY(QtTimePropertyManager)

   247 };

   248 

   249 class QtDateTimePropertyManagerPrivate;

   250 

   251 class QtDateTimePropertyManager : public QtAbstractPropertyManager

   252 {

   253     Q_OBJECT

   254 public:

   255     QtDateTimePropertyManager(QObject *parent = 0);

   256     ~QtDateTimePropertyManager();

   257 

   258     QDateTime value(const QtProperty *property) const;

   259 

   260 public Q_SLOTS:

   261     void setValue(QtProperty *property, const QDateTime &val);

   262 Q_SIGNALS:

   263     void valueChanged(QtProperty *property, const QDateTime &val);

   264 protected:

   265     QString valueText(const QtProperty *property) const;

   266     virtual void initializeProperty(QtProperty *property);

   267     virtual void uninitializeProperty(QtProperty *property);

   268 private:

   269     QScopedPointer<QtDateTimePropertyManagerPrivate> d_ptr;

   270     Q_DECLARE_PRIVATE(QtDateTimePropertyManager)

   271     Q_DISABLE_COPY(QtDateTimePropertyManager)

   272 };

   273 

   274 class QtKeySequencePropertyManagerPrivate;

   275 

   276 class QtKeySequencePropertyManager : public QtAbstractPropertyManager

   277 {

   278     Q_OBJECT

   279 public:

   280     QtKeySequencePropertyManager(QObject *parent = 0);

   281     ~QtKeySequencePropertyManager();

   282 

   283     QKeySequence value(const QtProperty *property) const;

   284 

   285 public Q_SLOTS:

   286     void setValue(QtProperty *property, const QKeySequence &val);

   287 Q_SIGNALS:

   288     void valueChanged(QtProperty *property, const QKeySequence &val);

   289 protected:

   290     QString valueText(const QtProperty *property) const;

   291     virtual void initializeProperty(QtProperty *property);

   292     virtual void uninitializeProperty(QtProperty *property);

   293 private:

   294     QScopedPointer<QtKeySequencePropertyManagerPrivate> d_ptr;

   295     Q_DECLARE_PRIVATE(QtKeySequencePropertyManager)

   296     Q_DISABLE_COPY(QtKeySequencePropertyManager)

   297 };

   298 

   299 class QtCharPropertyManagerPrivate;

   300 

   301 class QtCharPropertyManager : public QtAbstractPropertyManager

   302 {

   303     Q_OBJECT

   304 public:

   305     QtCharPropertyManager(QObject *parent = 0);

   306     ~QtCharPropertyManager();

   307 

   308     QChar value(const QtProperty *property) const;

   309 

   310 public Q_SLOTS:

   311     void setValue(QtProperty *property, const QChar &val);

   312 Q_SIGNALS:

   313     void valueChanged(QtProperty *property, const QChar &val);

   314 protected:

   315     QString valueText(const QtProperty *property) const;

   316     virtual void initializeProperty(QtProperty *property);

   317     virtual void uninitializeProperty(QtProperty *property);

   318 private:

   319     QScopedPointer<QtCharPropertyManagerPrivate> d_ptr;

   320     Q_DECLARE_PRIVATE(QtCharPropertyManager)

   321     Q_DISABLE_COPY(QtCharPropertyManager)

   322 };

   323 

   324 class QtEnumPropertyManager;

   325 class QtLocalePropertyManagerPrivate;

   326 

   327 class QtLocalePropertyManager : public QtAbstractPropertyManager

   328 {

   329     Q_OBJECT

   330 public:

   331     QtLocalePropertyManager(QObject *parent = 0);

   332     ~QtLocalePropertyManager();

   333 

   334     QtEnumPropertyManager *subEnumPropertyManager() const;

   335 

   336     QLocale value(const QtProperty *property) const;

   337 

   338 public Q_SLOTS:

   339     void setValue(QtProperty *property, const QLocale &val);

   340 Q_SIGNALS:

   341     void valueChanged(QtProperty *property, const QLocale &val);

   342 protected:

   343     QString valueText(const QtProperty *property) const;

   344     virtual void initializeProperty(QtProperty *property);

   345     virtual void uninitializeProperty(QtProperty *property);

   346 private:

   347     QScopedPointer<QtLocalePropertyManagerPrivate> d_ptr;

   348     Q_DECLARE_PRIVATE(QtLocalePropertyManager)

   349     Q_DISABLE_COPY(QtLocalePropertyManager)

   350     Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))

   351     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   352 };

   353 

   354 class QtPointPropertyManagerPrivate;

   355 

   356 class QtPointPropertyManager : public QtAbstractPropertyManager

   357 {

   358     Q_OBJECT

   359 public:

   360     QtPointPropertyManager(QObject *parent = 0);

   361     ~QtPointPropertyManager();

   362 

   363     QtIntPropertyManager *subIntPropertyManager() const;

   364 

   365     QPoint value(const QtProperty *property) const;

   366 

   367 public Q_SLOTS:

   368     void setValue(QtProperty *property, const QPoint &val);

   369 Q_SIGNALS:

   370     void valueChanged(QtProperty *property, const QPoint &val);

   371 protected:

   372     QString valueText(const QtProperty *property) const;

   373     virtual void initializeProperty(QtProperty *property);

   374     virtual void uninitializeProperty(QtProperty *property);

   375 private:

   376     QScopedPointer<QtPointPropertyManagerPrivate> d_ptr;

   377     Q_DECLARE_PRIVATE(QtPointPropertyManager)

   378     Q_DISABLE_COPY(QtPointPropertyManager)

   379     Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))

   380     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   381 };

   382 

   383 class QtPointFPropertyManagerPrivate;

   384 

   385 class QtPointFPropertyManager : public QtAbstractPropertyManager

   386 {

   387     Q_OBJECT

   388 public:

   389     QtPointFPropertyManager(QObject *parent = 0);

   390     ~QtPointFPropertyManager();

   391 

   392     QtDoublePropertyManager *subDoublePropertyManager() const;

   393 

   394     QPointF value(const QtProperty *property) const;

   395     int decimals(const QtProperty *property) const;

   396 

   397 public Q_SLOTS:

   398     void setValue(QtProperty *property, const QPointF &val);

   399     void setDecimals(QtProperty *property, int prec);

   400 Q_SIGNALS:

   401     void valueChanged(QtProperty *property, const QPointF &val);

   402     void decimalsChanged(QtProperty *property, int prec);

   403 protected:

   404     QString valueText(const QtProperty *property) const;

   405     virtual void initializeProperty(QtProperty *property);

   406     virtual void uninitializeProperty(QtProperty *property);

   407 private:

   408     QScopedPointer<QtPointFPropertyManagerPrivate> d_ptr;

   409     Q_DECLARE_PRIVATE(QtPointFPropertyManager)

   410     Q_DISABLE_COPY(QtPointFPropertyManager)

   411     Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))

   412     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   413 };

   414 

   415 class QtSizePropertyManagerPrivate;

   416 

   417 class QtSizePropertyManager : public QtAbstractPropertyManager

   418 {

   419     Q_OBJECT

   420 public:

   421     QtSizePropertyManager(QObject *parent = 0);

   422     ~QtSizePropertyManager();

   423 

   424     QtIntPropertyManager *subIntPropertyManager() const;

   425 

   426     QSize value(const QtProperty *property) const;

   427     QSize minimum(const QtProperty *property) const;

   428     QSize maximum(const QtProperty *property) const;

   429 

   430 public Q_SLOTS:

   431     void setValue(QtProperty *property, const QSize &val);

   432     void setMinimum(QtProperty *property, const QSize &minVal);

   433     void setMaximum(QtProperty *property, const QSize &maxVal);

   434     void setRange(QtProperty *property, const QSize &minVal, const QSize &maxVal);

   435 Q_SIGNALS:

   436     void valueChanged(QtProperty *property, const QSize &val);

   437     void rangeChanged(QtProperty *property, const QSize &minVal, const QSize &maxVal);

   438 protected:

   439     QString valueText(const QtProperty *property) const;

   440     virtual void initializeProperty(QtProperty *property);

   441     virtual void uninitializeProperty(QtProperty *property);

   442 private:

   443     QScopedPointer<QtSizePropertyManagerPrivate> d_ptr;

   444     Q_DECLARE_PRIVATE(QtSizePropertyManager)

   445     Q_DISABLE_COPY(QtSizePropertyManager)

   446     Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))

   447     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   448 };

   449 

   450 class QtSizeFPropertyManagerPrivate;

   451 

   452 class QtSizeFPropertyManager : public QtAbstractPropertyManager

   453 {

   454     Q_OBJECT

   455 public:

   456     QtSizeFPropertyManager(QObject *parent = 0);

   457     ~QtSizeFPropertyManager();

   458 

   459     QtDoublePropertyManager *subDoublePropertyManager() const;

   460 

   461     QSizeF value(const QtProperty *property) const;

   462     QSizeF minimum(const QtProperty *property) const;

   463     QSizeF maximum(const QtProperty *property) const;

   464     int decimals(const QtProperty *property) const;

   465 

   466 public Q_SLOTS:

   467     void setValue(QtProperty *property, const QSizeF &val);

   468     void setMinimum(QtProperty *property, const QSizeF &minVal);

   469     void setMaximum(QtProperty *property, const QSizeF &maxVal);

   470     void setRange(QtProperty *property, const QSizeF &minVal, const QSizeF &maxVal);

   471     void setDecimals(QtProperty *property, int prec);

   472 Q_SIGNALS:

   473     void valueChanged(QtProperty *property, const QSizeF &val);

   474     void rangeChanged(QtProperty *property, const QSizeF &minVal, const QSizeF &maxVal);

   475     void decimalsChanged(QtProperty *property, int prec);

   476 protected:

   477     QString valueText(const QtProperty *property) const;

   478     virtual void initializeProperty(QtProperty *property);

   479     virtual void uninitializeProperty(QtProperty *property);

   480 private:

   481     QScopedPointer<QtSizeFPropertyManagerPrivate> d_ptr;

   482     Q_DECLARE_PRIVATE(QtSizeFPropertyManager)

   483     Q_DISABLE_COPY(QtSizeFPropertyManager)

   484     Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))

   485     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   486 };

   487 

   488 class QtRectPropertyManagerPrivate;

   489 

   490 class QtRectPropertyManager : public QtAbstractPropertyManager

   491 {

   492     Q_OBJECT

   493 public:

   494     QtRectPropertyManager(QObject *parent = 0);

   495     ~QtRectPropertyManager();

   496 

   497     QtIntPropertyManager *subIntPropertyManager() const;

   498 

   499     QRect value(const QtProperty *property) const;

   500     QRect constraint(const QtProperty *property) const;

   501 

   502 public Q_SLOTS:

   503     void setValue(QtProperty *property, const QRect &val);

   504     void setConstraint(QtProperty *property, const QRect &constraint);

   505 Q_SIGNALS:

   506     void valueChanged(QtProperty *property, const QRect &val);

   507     void constraintChanged(QtProperty *property, const QRect &constraint);

   508 protected:

   509     QString valueText(const QtProperty *property) const;

   510     virtual void initializeProperty(QtProperty *property);

   511     virtual void uninitializeProperty(QtProperty *property);

   512 private:

   513     QScopedPointer<QtRectPropertyManagerPrivate> d_ptr;

   514     Q_DECLARE_PRIVATE(QtRectPropertyManager)

   515     Q_DISABLE_COPY(QtRectPropertyManager)

   516     Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))

   517     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   518 };

   519 

   520 class QtRectFPropertyManagerPrivate;

   521 

   522 class QtRectFPropertyManager : public QtAbstractPropertyManager

   523 {

   524     Q_OBJECT

   525 public:

   526     QtRectFPropertyManager(QObject *parent = 0);

   527     ~QtRectFPropertyManager();

   528 

   529     QtDoublePropertyManager *subDoublePropertyManager() const;

   530 

   531     QRectF value(const QtProperty *property) const;

   532     QRectF constraint(const QtProperty *property) const;

   533     int decimals(const QtProperty *property) const;

   534 

   535 public Q_SLOTS:

   536     void setValue(QtProperty *property, const QRectF &val);

   537     void setConstraint(QtProperty *property, const QRectF &constraint);

   538     void setDecimals(QtProperty *property, int prec);

   539 Q_SIGNALS:

   540     void valueChanged(QtProperty *property, const QRectF &val);

   541     void constraintChanged(QtProperty *property, const QRectF &constraint);

   542     void decimalsChanged(QtProperty *property, int prec);

   543 protected:

   544     QString valueText(const QtProperty *property) const;

   545     virtual void initializeProperty(QtProperty *property);

   546     virtual void uninitializeProperty(QtProperty *property);

   547 private:

   548     QScopedPointer<QtRectFPropertyManagerPrivate> d_ptr;

   549     Q_DECLARE_PRIVATE(QtRectFPropertyManager)

   550     Q_DISABLE_COPY(QtRectFPropertyManager)

   551     Q_PRIVATE_SLOT(d_func(), void slotDoubleChanged(QtProperty *, double))

   552     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   553 };

   554 

   555 class QtEnumPropertyManagerPrivate;

   556 

   557 class QtEnumPropertyManager : public QtAbstractPropertyManager

   558 {

   559     Q_OBJECT

   560 public:

   561     QtEnumPropertyManager(QObject *parent = 0);

   562     ~QtEnumPropertyManager();

   563 

   564     int value(const QtProperty *property) const;

   565     QStringList enumNames(const QtProperty *property) const;

   566     QMap<int, QIcon> enumIcons(const QtProperty *property) const;

   567 

   568 public Q_SLOTS:

   569     void setValue(QtProperty *property, int val);

   570     void setEnumNames(QtProperty *property, const QStringList &names);

   571     void setEnumIcons(QtProperty *property, const QMap<int, QIcon> &icons);

   572 Q_SIGNALS:

   573     void valueChanged(QtProperty *property, int val);

   574     void enumNamesChanged(QtProperty *property, const QStringList &names);

   575     void enumIconsChanged(QtProperty *property, const QMap<int, QIcon> &icons);

   576 protected:

   577     QString valueText(const QtProperty *property) const;

   578     QIcon valueIcon(const QtProperty *property) const;

   579     virtual void initializeProperty(QtProperty *property);

   580     virtual void uninitializeProperty(QtProperty *property);

   581 private:

   582     QScopedPointer<QtEnumPropertyManagerPrivate> d_ptr;

   583     Q_DECLARE_PRIVATE(QtEnumPropertyManager)

   584     Q_DISABLE_COPY(QtEnumPropertyManager)

   585 };

   586 

   587 class QtFlagPropertyManagerPrivate;

   588 

   589 class QtFlagPropertyManager : public QtAbstractPropertyManager

   590 {

   591     Q_OBJECT

   592 public:

   593     QtFlagPropertyManager(QObject *parent = 0);

   594     ~QtFlagPropertyManager();

   595 

   596     QtBoolPropertyManager *subBoolPropertyManager() const;

   597 

   598     int value(const QtProperty *property) const;

   599     QStringList flagNames(const QtProperty *property) const;

   600 

   601 public Q_SLOTS:

   602     void setValue(QtProperty *property, int val);

   603     void setFlagNames(QtProperty *property, const QStringList &names);

   604 Q_SIGNALS:

   605     void valueChanged(QtProperty *property, int val);

   606     void flagNamesChanged(QtProperty *property, const QStringList &names);

   607 protected:

   608     QString valueText(const QtProperty *property) const;

   609     virtual void initializeProperty(QtProperty *property);

   610     virtual void uninitializeProperty(QtProperty *property);

   611 private:

   612     QScopedPointer<QtFlagPropertyManagerPrivate> d_ptr;

   613     Q_DECLARE_PRIVATE(QtFlagPropertyManager)

   614     Q_DISABLE_COPY(QtFlagPropertyManager)

   615     Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty *, bool))

   616     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   617 };

   618 

   619 class QtSizePolicyPropertyManagerPrivate;

   620 

   621 class QtSizePolicyPropertyManager : public QtAbstractPropertyManager

   622 {

   623     Q_OBJECT

   624 public:

   625     QtSizePolicyPropertyManager(QObject *parent = 0);

   626     ~QtSizePolicyPropertyManager();

   627 

   628     QtIntPropertyManager *subIntPropertyManager() const;

   629     QtEnumPropertyManager *subEnumPropertyManager() const;

   630 

   631     QSizePolicy value(const QtProperty *property) const;

   632 

   633 public Q_SLOTS:

   634     void setValue(QtProperty *property, const QSizePolicy &val);

   635 Q_SIGNALS:

   636     void valueChanged(QtProperty *property, const QSizePolicy &val);

   637 protected:

   638     QString valueText(const QtProperty *property) const;

   639     virtual void initializeProperty(QtProperty *property);

   640     virtual void uninitializeProperty(QtProperty *property);

   641 private:

   642     QScopedPointer<QtSizePolicyPropertyManagerPrivate> d_ptr;

   643     Q_DECLARE_PRIVATE(QtSizePolicyPropertyManager)

   644     Q_DISABLE_COPY(QtSizePolicyPropertyManager)

   645     Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))

   646     Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))

   647     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   648 };

   649 

   650 class QtFontPropertyManagerPrivate;

   651 

   652 class QtFontPropertyManager : public QtAbstractPropertyManager

   653 {

   654     Q_OBJECT

   655 public:

   656     QtFontPropertyManager(QObject *parent = 0);

   657     ~QtFontPropertyManager();

   658 

   659     QtIntPropertyManager *subIntPropertyManager() const;

   660     QtEnumPropertyManager *subEnumPropertyManager() const;

   661     QtBoolPropertyManager *subBoolPropertyManager() const;

   662 

   663     QFont value(const QtProperty *property) const;

   664 

   665 public Q_SLOTS:

   666     void setValue(QtProperty *property, const QFont &val);

   667 Q_SIGNALS:

   668     void valueChanged(QtProperty *property, const QFont &val);

   669 protected:

   670     QString valueText(const QtProperty *property) const;

   671     QIcon valueIcon(const QtProperty *property) const;

   672     virtual void initializeProperty(QtProperty *property);

   673     virtual void uninitializeProperty(QtProperty *property);

   674 private:

   675     QScopedPointer<QtFontPropertyManagerPrivate> d_ptr;

   676     Q_DECLARE_PRIVATE(QtFontPropertyManager)

   677     Q_DISABLE_COPY(QtFontPropertyManager)

   678     Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))

   679     Q_PRIVATE_SLOT(d_func(), void slotEnumChanged(QtProperty *, int))

   680     Q_PRIVATE_SLOT(d_func(), void slotBoolChanged(QtProperty *, bool))

   681     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   682     Q_PRIVATE_SLOT(d_func(), void slotFontDatabaseChanged())

   683     Q_PRIVATE_SLOT(d_func(), void slotFontDatabaseDelayedChange())

   684 };

   685 

   686 class QtColorPropertyManagerPrivate;

   687 

   688 class QtColorPropertyManager : public QtAbstractPropertyManager

   689 {

   690     Q_OBJECT

   691 public:

   692     QtColorPropertyManager(QObject *parent = 0);

   693     ~QtColorPropertyManager();

   694 

   695     QtIntPropertyManager *subIntPropertyManager() const;

   696 

   697     QColor value(const QtProperty *property) const;

   698 

   699 public Q_SLOTS:

   700     void setValue(QtProperty *property, const QColor &val);

   701 Q_SIGNALS:

   702     void valueChanged(QtProperty *property, const QColor &val);

   703 protected:

   704     QString valueText(const QtProperty *property) const;

   705     QIcon valueIcon(const QtProperty *property) const;

   706     virtual void initializeProperty(QtProperty *property);

   707     virtual void uninitializeProperty(QtProperty *property);

   708 private:

   709     QScopedPointer<QtColorPropertyManagerPrivate> d_ptr;

   710     Q_DECLARE_PRIVATE(QtColorPropertyManager)

   711     Q_DISABLE_COPY(QtColorPropertyManager)

   712     Q_PRIVATE_SLOT(d_func(), void slotIntChanged(QtProperty *, int))

   713     Q_PRIVATE_SLOT(d_func(), void slotPropertyDestroyed(QtProperty *))

   714 };

   715 

   716 class QtCursorPropertyManagerPrivate;

   717 

   718 class QtCursorPropertyManager : public QtAbstractPropertyManager

   719 {

   720     Q_OBJECT

   721 public:

   722     QtCursorPropertyManager(QObject *parent = 0);

   723     ~QtCursorPropertyManager();

   724 

   725 #ifndef QT_NO_CURSOR

   726     QCursor value(const QtProperty *property) const;

   727 #endif

   728 

   729 public Q_SLOTS:

   730     void setValue(QtProperty *property, const QCursor &val);

   731 Q_SIGNALS:

   732     void valueChanged(QtProperty *property, const QCursor &val);

   733 protected:

   734     QString valueText(const QtProperty *property) const;

   735     QIcon valueIcon(const QtProperty *property) const;

   736     virtual void initializeProperty(QtProperty *property);

   737     virtual void uninitializeProperty(QtProperty *property);

   738 private:

   739     QScopedPointer<QtCursorPropertyManagerPrivate> d_ptr;

   740     Q_DECLARE_PRIVATE(QtCursorPropertyManager)

   741     Q_DISABLE_COPY(QtCursorPropertyManager)

   742 };

   743 

   744 QT_END_NAMESPACE

   745 

   746 #endif