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 QTEDITORFACTORY_H

    43 #define QTEDITORFACTORY_H

    44 

    45 #include "qtpropertymanager.h"

    46 

    47 QT_BEGIN_NAMESPACE

    48 

    49 class QtSpinBoxFactoryPrivate;

    50 

    51 class QtSpinBoxFactory : public QtAbstractEditorFactory<QtIntPropertyManager>

    52 {

    53     Q_OBJECT

    54 public:

    55     QtSpinBoxFactory(QObject *parent = 0);

    56     ~QtSpinBoxFactory();

    57 protected:

    58     void connectPropertyManager(QtIntPropertyManager *manager);

    59     QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,

    60                 QWidget *parent);

    61     void disconnectPropertyManager(QtIntPropertyManager *manager);

    62 private:

    63     QScopedPointer<QtSpinBoxFactoryPrivate> d_ptr;

    64     Q_DECLARE_PRIVATE(QtSpinBoxFactory)

    65     Q_DISABLE_COPY(QtSpinBoxFactory)

    66     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))

    67     Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))

    68     Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))

    69     Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))

    70     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

    71 };

    72 

    73 class QtSliderFactoryPrivate;

    74 

    75 class QtSliderFactory : public QtAbstractEditorFactory<QtIntPropertyManager>

    76 {

    77     Q_OBJECT

    78 public:

    79     QtSliderFactory(QObject *parent = 0);

    80     ~QtSliderFactory();

    81 protected:

    82     void connectPropertyManager(QtIntPropertyManager *manager);

    83     QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,

    84                 QWidget *parent);

    85     void disconnectPropertyManager(QtIntPropertyManager *manager);

    86 private:

    87     QScopedPointer<QtSliderFactoryPrivate> d_ptr;

    88     Q_DECLARE_PRIVATE(QtSliderFactory)

    89     Q_DISABLE_COPY(QtSliderFactory)

    90     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))

    91     Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))

    92     Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))

    93     Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))

    94     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

    95 };

    96 

    97 class QtScrollBarFactoryPrivate;

    98 

    99 class QtScrollBarFactory : public QtAbstractEditorFactory<QtIntPropertyManager>

   100 {

   101     Q_OBJECT

   102 public:

   103     QtScrollBarFactory(QObject *parent = 0);

   104     ~QtScrollBarFactory();

   105 protected:

   106     void connectPropertyManager(QtIntPropertyManager *manager);

   107     QWidget *createEditor(QtIntPropertyManager *manager, QtProperty *property,

   108                 QWidget *parent);

   109     void disconnectPropertyManager(QtIntPropertyManager *manager);

   110 private:

   111     QScopedPointer<QtScrollBarFactoryPrivate> d_ptr;

   112     Q_DECLARE_PRIVATE(QtScrollBarFactory)

   113     Q_DISABLE_COPY(QtScrollBarFactory)

   114     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))

   115     Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, int, int))

   116     Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, int))

   117     Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))

   118     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   119 };

   120 

   121 class QtCheckBoxFactoryPrivate;

   122 

   123 class QtCheckBoxFactory : public QtAbstractEditorFactory<QtBoolPropertyManager>

   124 {

   125     Q_OBJECT

   126 public:

   127     QtCheckBoxFactory(QObject *parent = 0);

   128     ~QtCheckBoxFactory();

   129 protected:

   130     void connectPropertyManager(QtBoolPropertyManager *manager);

   131     QWidget *createEditor(QtBoolPropertyManager *manager, QtProperty *property,

   132                 QWidget *parent);

   133     void disconnectPropertyManager(QtBoolPropertyManager *manager);

   134 private:

   135     QScopedPointer<QtCheckBoxFactoryPrivate> d_ptr;

   136     Q_DECLARE_PRIVATE(QtCheckBoxFactory)

   137     Q_DISABLE_COPY(QtCheckBoxFactory)

   138     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, bool))

   139     Q_PRIVATE_SLOT(d_func(), void slotSetValue(bool))

   140     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   141 };

   142 

   143 class QtDoubleSpinBoxFactoryPrivate;

   144 

   145 class QtDoubleSpinBoxFactory : public QtAbstractEditorFactory<QtDoublePropertyManager>

   146 {

   147     Q_OBJECT

   148 public:

   149     QtDoubleSpinBoxFactory(QObject *parent = 0);

   150     ~QtDoubleSpinBoxFactory();

   151 protected:

   152     void connectPropertyManager(QtDoublePropertyManager *manager);

   153     QWidget *createEditor(QtDoublePropertyManager *manager, QtProperty *property,

   154                 QWidget *parent);

   155     void disconnectPropertyManager(QtDoublePropertyManager *manager);

   156 private:

   157     QScopedPointer<QtDoubleSpinBoxFactoryPrivate> d_ptr;

   158     Q_DECLARE_PRIVATE(QtDoubleSpinBoxFactory)

   159     Q_DISABLE_COPY(QtDoubleSpinBoxFactory)

   160     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, double))

   161     Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *, double, double))

   162     Q_PRIVATE_SLOT(d_func(), void slotSingleStepChanged(QtProperty *, double))

   163     Q_PRIVATE_SLOT(d_func(), void slotDecimalsChanged(QtProperty *, int))

   164     Q_PRIVATE_SLOT(d_func(), void slotSetValue(double))

   165     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   166 };

   167 

   168 class QtLineEditFactoryPrivate;

   169 

   170 class QtLineEditFactory : public QtAbstractEditorFactory<QtStringPropertyManager>

   171 {

   172     Q_OBJECT

   173 public:

   174     QtLineEditFactory(QObject *parent = 0);

   175     ~QtLineEditFactory();

   176 protected:

   177     void connectPropertyManager(QtStringPropertyManager *manager);

   178     QWidget *createEditor(QtStringPropertyManager *manager, QtProperty *property,

   179                 QWidget *parent);

   180     void disconnectPropertyManager(QtStringPropertyManager *manager);

   181 private:

   182     QScopedPointer<QtLineEditFactoryPrivate> d_ptr;

   183     Q_DECLARE_PRIVATE(QtLineEditFactory)

   184     Q_DISABLE_COPY(QtLineEditFactory)

   185     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QString &))

   186     Q_PRIVATE_SLOT(d_func(), void slotRegExpChanged(QtProperty *, const QRegExp &))

   187     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QString &))

   188     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   189 };

   190 

   191 class QtDateEditFactoryPrivate;

   192 

   193 class QtDateEditFactory : public QtAbstractEditorFactory<QtDatePropertyManager>

   194 {

   195     Q_OBJECT

   196 public:

   197     QtDateEditFactory(QObject *parent = 0);

   198     ~QtDateEditFactory();

   199 protected:

   200     void connectPropertyManager(QtDatePropertyManager *manager);

   201     QWidget *createEditor(QtDatePropertyManager *manager, QtProperty *property,

   202                 QWidget *parent);

   203     void disconnectPropertyManager(QtDatePropertyManager *manager);

   204 private:

   205     QScopedPointer<QtDateEditFactoryPrivate> d_ptr;

   206     Q_DECLARE_PRIVATE(QtDateEditFactory)

   207     Q_DISABLE_COPY(QtDateEditFactory)

   208     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QDate &))

   209     Q_PRIVATE_SLOT(d_func(), void slotRangeChanged(QtProperty *,

   210                         const QDate &, const QDate &))

   211     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QDate &))

   212     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   213 };

   214 

   215 class QtTimeEditFactoryPrivate;

   216 

   217 class QtTimeEditFactory : public QtAbstractEditorFactory<QtTimePropertyManager>

   218 {

   219     Q_OBJECT

   220 public:

   221     QtTimeEditFactory(QObject *parent = 0);

   222     ~QtTimeEditFactory();

   223 protected:

   224     void connectPropertyManager(QtTimePropertyManager *manager);

   225     QWidget *createEditor(QtTimePropertyManager *manager, QtProperty *property,

   226                 QWidget *parent);

   227     void disconnectPropertyManager(QtTimePropertyManager *manager);

   228 private:

   229     QScopedPointer<QtTimeEditFactoryPrivate> d_ptr;

   230     Q_DECLARE_PRIVATE(QtTimeEditFactory)

   231     Q_DISABLE_COPY(QtTimeEditFactory)

   232     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QTime &))

   233     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QTime &))

   234     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   235 };

   236 

   237 class QtDateTimeEditFactoryPrivate;

   238 

   239 class QtDateTimeEditFactory : public QtAbstractEditorFactory<QtDateTimePropertyManager>

   240 {

   241     Q_OBJECT

   242 public:

   243     QtDateTimeEditFactory(QObject *parent = 0);

   244     ~QtDateTimeEditFactory();

   245 protected:

   246     void connectPropertyManager(QtDateTimePropertyManager *manager);

   247     QWidget *createEditor(QtDateTimePropertyManager *manager, QtProperty *property,

   248                 QWidget *parent);

   249     void disconnectPropertyManager(QtDateTimePropertyManager *manager);

   250 private:

   251     QScopedPointer<QtDateTimeEditFactoryPrivate> d_ptr;

   252     Q_DECLARE_PRIVATE(QtDateTimeEditFactory)

   253     Q_DISABLE_COPY(QtDateTimeEditFactory)

   254     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QDateTime &))

   255     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QDateTime &))

   256     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   257 };

   258 

   259 class QtKeySequenceEditorFactoryPrivate;

   260 

   261 class QtKeySequenceEditorFactory : public QtAbstractEditorFactory<QtKeySequencePropertyManager>

   262 {

   263     Q_OBJECT

   264 public:

   265     QtKeySequenceEditorFactory(QObject *parent = 0);

   266     ~QtKeySequenceEditorFactory();

   267 protected:

   268     void connectPropertyManager(QtKeySequencePropertyManager *manager);

   269     QWidget *createEditor(QtKeySequencePropertyManager *manager, QtProperty *property,

   270                 QWidget *parent);

   271     void disconnectPropertyManager(QtKeySequencePropertyManager *manager);

   272 private:

   273     QScopedPointer<QtKeySequenceEditorFactoryPrivate> d_ptr;

   274     Q_DECLARE_PRIVATE(QtKeySequenceEditorFactory)

   275     Q_DISABLE_COPY(QtKeySequenceEditorFactory)

   276     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QKeySequence &))

   277     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QKeySequence &))

   278     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   279 };

   280 

   281 class QtCharEditorFactoryPrivate;

   282 

   283 class QtCharEditorFactory : public QtAbstractEditorFactory<QtCharPropertyManager>

   284 {

   285     Q_OBJECT

   286 public:

   287     QtCharEditorFactory(QObject *parent = 0);

   288     ~QtCharEditorFactory();

   289 protected:

   290     void connectPropertyManager(QtCharPropertyManager *manager);

   291     QWidget *createEditor(QtCharPropertyManager *manager, QtProperty *property,

   292                 QWidget *parent);

   293     void disconnectPropertyManager(QtCharPropertyManager *manager);

   294 private:

   295     QScopedPointer<QtCharEditorFactoryPrivate> d_ptr;

   296     Q_DECLARE_PRIVATE(QtCharEditorFactory)

   297     Q_DISABLE_COPY(QtCharEditorFactory)

   298     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QChar &))

   299     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QChar &))

   300     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   301 };

   302 

   303 class QtEnumEditorFactoryPrivate;

   304 

   305 class QtEnumEditorFactory : public QtAbstractEditorFactory<QtEnumPropertyManager>

   306 {

   307     Q_OBJECT

   308 public:

   309     QtEnumEditorFactory(QObject *parent = 0);

   310     ~QtEnumEditorFactory();

   311 protected:

   312     void connectPropertyManager(QtEnumPropertyManager *manager);

   313     QWidget *createEditor(QtEnumPropertyManager *manager, QtProperty *property,

   314                 QWidget *parent);

   315     void disconnectPropertyManager(QtEnumPropertyManager *manager);

   316 private:

   317     QScopedPointer<QtEnumEditorFactoryPrivate> d_ptr;

   318     Q_DECLARE_PRIVATE(QtEnumEditorFactory)

   319     Q_DISABLE_COPY(QtEnumEditorFactory)

   320     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, int))

   321     Q_PRIVATE_SLOT(d_func(), void slotEnumNamesChanged(QtProperty *,

   322                         const QStringList &))

   323     Q_PRIVATE_SLOT(d_func(), void slotEnumIconsChanged(QtProperty *,

   324                         const QMap<int, QIcon> &))

   325     Q_PRIVATE_SLOT(d_func(), void slotSetValue(int))

   326     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   327 };

   328 

   329 class QtCursorEditorFactoryPrivate;

   330 

   331 class QtCursorEditorFactory : public QtAbstractEditorFactory<QtCursorPropertyManager>

   332 {

   333     Q_OBJECT

   334 public:

   335     QtCursorEditorFactory(QObject *parent = 0);

   336     ~QtCursorEditorFactory();

   337 protected:

   338     void connectPropertyManager(QtCursorPropertyManager *manager);

   339     QWidget *createEditor(QtCursorPropertyManager *manager, QtProperty *property,

   340                 QWidget *parent);

   341     void disconnectPropertyManager(QtCursorPropertyManager *manager);

   342 private:

   343     QScopedPointer<QtCursorEditorFactoryPrivate> d_ptr;

   344     Q_DECLARE_PRIVATE(QtCursorEditorFactory)

   345     Q_DISABLE_COPY(QtCursorEditorFactory)

   346     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QCursor &))

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

   348     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   349 };

   350 

   351 class QtColorEditorFactoryPrivate;

   352 

   353 class QtColorEditorFactory : public QtAbstractEditorFactory<QtColorPropertyManager>

   354 {

   355     Q_OBJECT

   356 public:

   357     QtColorEditorFactory(QObject *parent = 0);

   358     ~QtColorEditorFactory();

   359 protected:

   360     void connectPropertyManager(QtColorPropertyManager *manager);

   361     QWidget *createEditor(QtColorPropertyManager *manager, QtProperty *property,

   362                 QWidget *parent);

   363     void disconnectPropertyManager(QtColorPropertyManager *manager);

   364 private:

   365     QScopedPointer<QtColorEditorFactoryPrivate> d_ptr;

   366     Q_DECLARE_PRIVATE(QtColorEditorFactory)

   367     Q_DISABLE_COPY(QtColorEditorFactory)

   368     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QColor &))

   369     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   370     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QColor &))

   371 };

   372 

   373 class QtFontEditorFactoryPrivate;

   374 

   375 class QtFontEditorFactory : public QtAbstractEditorFactory<QtFontPropertyManager>

   376 {

   377     Q_OBJECT

   378 public:

   379     QtFontEditorFactory(QObject *parent = 0);

   380     ~QtFontEditorFactory();

   381 protected:

   382     void connectPropertyManager(QtFontPropertyManager *manager);

   383     QWidget *createEditor(QtFontPropertyManager *manager, QtProperty *property,

   384                 QWidget *parent);

   385     void disconnectPropertyManager(QtFontPropertyManager *manager);

   386 private:

   387     QScopedPointer<QtFontEditorFactoryPrivate> d_ptr;

   388     Q_DECLARE_PRIVATE(QtFontEditorFactory)

   389     Q_DISABLE_COPY(QtFontEditorFactory)

   390     Q_PRIVATE_SLOT(d_func(), void slotPropertyChanged(QtProperty *, const QFont &))

   391     Q_PRIVATE_SLOT(d_func(), void slotEditorDestroyed(QObject *))

   392     Q_PRIVATE_SLOT(d_func(), void slotSetValue(const QFont &))

   393 };

   394 

   395 QT_END_NAMESPACE

   396 

   397 #endif