source: trunk/doc/src/qtdesigner.qdoc@ 321

Last change on this file since 321 was 2, checked in by Dmitry A. Kuminov, 16 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.

File size: 51.0 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information ([email protected])
5**
6** This file is part of the documentation of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file. Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42/*!
43 \module QtDesigner
44 \title QtDesigner Module
45 \contentspage Qt's Modules
46 \previouspage Qt3Support
47 \nextpage QtUiTools
48 \ingroup modules
49
50 \brief The QtDesigner module provides classes that allow you to
51 create your own custom widget plugins for Qt Designer, and classes
52 that enable you to access Qt Designer's components.
53
54 In addition, the QFormBuilder class provides the possibility of
55 constructing user interfaces from \c .ui files at run-time.
56
57 To include the definitions of the module's classes, use the
58 following directive:
59
60 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 0
61
62 To link against the module, add this line to your \c qmake .pro
63 file:
64
65 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 1
66
67 \note These classes are part of the \l{Open Source Versions of Qt} and
68 \l{Qt Commercial Editions}{Qt Full Framework Edition} for commercial
69 users.
70
71 \tableofcontents
72
73 \section1 Creating Custom Widget Plugins
74
75 When implementing a custom widget plugin for \QD, you must
76 subclass QDesignerCustomWidgetInterface to expose your custom
77 widget to \QD. A single custom widget plugin is built as a
78 separate library. If you want to include several custom widget
79 plugins in the same library, you must in addition subclass
80 QDesignerCustomWidgetCollectionInterface.
81
82 To provide your custom widget plugin with the expected behavior
83 and functionality within \QD's workspace you can subclass the
84 associated extension classes:
85
86 The QDesignerContainerExtension class allows you to add pages to a
87 custom multi-page container. The QDesignerTaskMenuExtension class
88 allows you to add custom menu entries to \QD's task menu. The
89 QDesignerMemberSheetExtension class allows you to manipulate a
90 widget's member functions which is displayed when configuring
91 connections using \QD's mode for editing signals and slots. And
92 finally, the QDesignerPropertySheetExtension class allows you to
93 manipulate a widget's properties which is displayed in \QD's
94 property editor.
95
96 \image qtdesignerextensions.png
97
98 In \QD the extensions are not created until they are required. For
99 that reason, when implementing extensions, you must also subclass
100 QExtensionFactory, i.e create a class that is able to make
101 instances of your extensions. In addition, you must make \QD's
102 extension manager register your factory; the extension manager
103 controls the construction of extensions as they are required, and
104 you can access it through QDesignerFormEditorInterface and
105 QExtensionManager.
106
107 For a complete example creating a custom widget plugin with an
108 extension, see the \l {designer/taskmenuextension}{Task Menu
109 Extension} or \l {designer/containerextension}{Container
110 Extension} examples.
111
112 \section1 Retrieving Access to \QD Components
113
114 The purpose of the classes mentioned in this section is to provide
115 access to \QD's components, managers and workspace, and they are
116 not intended to be instantiated directly.
117
118 \QD is composed by several components. It has an action editor, a
119 property editor, widget box and object inspector which you can
120 view in its workspace.
121
122 \image qtdesignerscreenshot.png
123
124 \QD also has an object that works behind the scene; it contains
125 the logic that integrates all of \QD's components into a coherent
126 application. You can access this object, using the
127 QDesignerFormEditorInterface, to retrieve interfaces to \QD's
128 components:
129
130 \list
131 \o QDesignerActionEditorInterface
132 \o QDesignerObjectInspectorInterface
133 \o QDesignerPropertyEditorInterface
134 \o QDesignerWidgetBoxInterface
135 \endlist
136
137 In addition, you can use QDesignerFormEditorInterface to retrieve
138 interfaces to \QD's extension manager (QExtensionManager) and form
139 window manager (QDesignerFormWindowManagerInterface). The
140 extension manager controls the construction of extensions as they
141 are required, while the form window manager controls the form
142 windows appearing in \QD's workspace.
143
144 Once you have an interface to \QD's form window manager
145 (QDesignerFormWindowManagerInterface), you also have access to all
146 the form windows currently appearing in \QD's workspace: The
147 QDesignerFormWindowInterface class allows you to query and
148 manipulate the form windows, and it provides an interface to the
149 form windows' cursors. QDesignerFormWindowCursorInterface is a
150 convenience class allowing you to query and modify a given form
151 window's widget selection, and in addition modify the properties
152 of all the form's widgets.
153
154 \section1 Creating User Interfaces at Run-Time
155
156 The \c QtDesigner module contains the QFormBuilder class that
157 provides a mechanism for dynamically creating user interfaces at
158 run-time, based on \c .ui files created with \QD. This class is
159 typically used by custom components and applications that embed
160 \QD. Standalone applications that need to dynamically generate
161 user interfaces at run-time use the QUiLoader class, found in
162 the QtUiTools module.
163
164 For a complete example using QUiLoader, see
165 the \l {designer/calculatorbuilder}{Calculator Builder example}.
166
167 \sa {Qt Designer Manual}, {QtUiTools Module}
168*/
169
170/*!
171 \class QDesignerMemberSheetExtension
172
173 \brief The QDesignerMemberSheetExtension class allows you to
174 manipulate a widget's member functions which is displayed when
175 configuring connections using Qt Designer's mode for editing
176 signals and slots.
177
178 \inmodule QtDesigner
179
180 QDesignerMemberSheetExtension is a collection of functions that is
181 typically used to query a widget's member functions, and to
182 manipulate the member functions' appearance in \QD's signals and
183 slots editing mode. For example:
184
185 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 2
186
187 When implementing a custom widget plugin, a pointer to \QD's
188 current QDesignerFormEditorInterface object (\c formEditor in the
189 example above) is provided by the
190 QDesignerCustomWidgetInterface::initialize() function's parameter.
191
192 The member sheet (and any other extension), can be retrieved by
193 querying \QD's extension manager using the qt_extension()
194 function. When you want to release the extension, you only need to
195 delete the pointer.
196
197 All widgets have a default member sheet used in \QD's signals and
198 slots editing mode with the widget's member functions. But
199 QDesignerMemberSheetExtension also provides an interface for
200 creating custom member sheet extensions.
201
202 \warning \QD uses the QDesignerMemberSheetExtension to facilitate
203 the signal and slot editing mode. Whenever a connection between
204 two widgets is requested, \QD will query for the widgets' member
205 sheet extensions. If a widget has an implemented member sheet
206 extension, this extension will override the default member sheet.
207
208 To create a member sheet extension, your extension class must
209 inherit from both QObject and QDesignerMemberSheetExtension. Then,
210 since we are implementing an interface, we must ensure that it's
211 made known to the meta object system using the Q_INTERFACES()
212 macro:
213
214 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 3
215
216 This enables \QD to use qobject_cast() to query for
217 supported interfaces using nothing but a QObject pointer.
218
219 In \QD the extensions are not created until they are
220 required. For that reason, when implementing a member sheet
221 extension, you must also create a QExtensionFactory, i.e a class
222 that is able to make an instance of your extension, and register
223 it using \QD's \l {QExtensionManager}{extension manager}.
224
225 When a widget's member sheet extension is required, \QD's \l
226 {QExtensionManager}{extension manager} will run through all its
227 registered factories calling QExtensionFactory::createExtension()
228 for each until the first one that is able to create a member sheet
229 extension for that widget, is found. This factory will then make
230 an instance of the extension. If no such factory is found, \QD
231 will use the default member sheet.
232
233 There are four available types of extensions in \QD:
234 QDesignerContainerExtension, QDesignerMemberSheetExtension,
235 QDesignerPropertySheetExtension and
236 QDesignerTaskMenuExtension. \QD's behavior is the same whether the
237 requested extension is associated with a multi page container, a
238 member sheet, a property sheet or a task menu.
239
240 The QExtensionFactory class provides a standard extension
241 factory, and can also be used as an interface for custom
242 extension factories. You can either create a new
243 QExtensionFactory and reimplement the
244 QExtensionFactory::createExtension() function. For example:
245
246 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 4
247
248 Or you can use an existing factory, expanding the
249 QExtensionFactory::createExtension() function to make the factory
250 able to create a member sheet extension as well. For example:
251
252 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 5
253
254 For a complete example using an extension class, see \l
255 {designer/taskmenuextension}{Task Menu Extension example}. The
256 example shows how to create a custom widget plugin for Qt
257 Designer, and how to to use the QDesignerTaskMenuExtension class
258 to add custom items to \QD's task menu.
259
260 \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
261 Extensions}
262*/
263
264/*!
265 \fn QDesignerMemberSheetExtension::~QDesignerMemberSheetExtension()
266
267 Destroys the member sheet extension.
268*/
269
270/*!
271 \fn int QDesignerMemberSheetExtension::count() const
272
273 Returns the extension's number of member functions.
274*/
275
276/*!
277 \fn int QDesignerMemberSheetExtension::indexOf(const QString &name) const
278
279 Returns the index of the member function specified by the given \a
280 name.
281
282 \sa memberName()
283*/
284
285/*!
286 \fn QString QDesignerMemberSheetExtension::memberName(int index) const
287
288 Returns the name of the member function with the given \a index.
289
290 \sa indexOf()
291*/
292
293/*!
294 \fn QString QDesignerMemberSheetExtension::memberGroup(int index) const
295
296 Returns the name of the member group specified for the function
297 with the given \a index.
298
299 \sa indexOf(), setMemberGroup()
300*/
301
302/*!
303 \fn void QDesignerMemberSheetExtension::setMemberGroup(int index, const QString &group)
304
305 Sets the member group of the member function with the given \a
306 index, to \a group.
307
308 \sa indexOf(), memberGroup()
309*/
310
311/*!
312 \fn bool QDesignerMemberSheetExtension::isVisible(int index) const
313
314 Returns true if the member function with the given \a index is
315 visible in \QD's signal and slot editor, otherwise false.
316
317 \sa indexOf(), setVisible()
318*/
319
320/*!
321 \fn void QDesignerMemberSheetExtension::setVisible(int index, bool visible)
322
323 If \a visible is true, the member function with the given \a index
324 is visible in \QD's signals and slots editing mode; otherwise the
325 member function is hidden.
326
327 \sa indexOf(), isVisible()
328*/
329
330/*!
331 \fn virtual bool QDesignerMemberSheetExtension::isSignal(int index) const
332
333 Returns true if the member function with the given \a index is a
334 signal, otherwise false.
335
336 \sa indexOf()
337*/
338
339/*!
340 \fn bool QDesignerMemberSheetExtension::isSlot(int index) const
341
342 Returns true if the member function with the given \a index is a
343 slot, otherwise false.
344
345 \sa indexOf()
346*/
347
348/*!
349 \fn bool QDesignerMemberSheetExtension::inheritedFromWidget(int index) const
350
351 Returns true if the member function with the given \a index is
352 inherited from QWidget, otherwise false.
353
354 \sa indexOf()
355*/
356
357/*!
358 \fn QString QDesignerMemberSheetExtension::declaredInClass(int index) const
359
360 Returns the name of the class in which the member function with
361 the given \a index is declared.
362
363 \sa indexOf()
364*/
365
366/*!
367 \fn QString QDesignerMemberSheetExtension::signature(int index) const
368
369 Returns the signature of the member function with the given \a
370 index.
371
372 \sa indexOf()
373*/
374
375/*!
376 \fn QList<QByteArray> QDesignerMemberSheetExtension::parameterTypes(int index) const
377
378 Returns the parameter types of the member function with the given
379 \a index, as a QByteArray list.
380
381 \sa indexOf(), parameterNames()
382*/
383
384/*!
385 \fn QList<QByteArray> QDesignerMemberSheetExtension::parameterNames(int index) const
386
387 Returns the parameter names of the member function with the given
388 \a index, as a QByteArray list.
389
390 \sa indexOf(), parameterTypes()
391*/
392
393
394// Doc: Interface only
395
396/*!
397 \class QDesignerLayoutDecorationExtension
398 \brief The QDesignerLayoutDecorationExtension class provides an extension to a layout in \QD.
399 \inmodule QtDesigner
400 \internal
401*/
402
403/*!
404 \enum QDesignerLayoutDecorationExtension::InsertMode
405
406 This enum describes the modes that are used to insert items into a layout.
407
408 \value InsertWidgetMode Widgets are inserted into empty cells in a layout.
409 \value InsertRowMode Whole rows are inserted into a vertical or grid layout.
410 \value InsertColumnMode Whole columns are inserted into a horizontal or grid layout.
411*/
412
413/*!
414 \fn virtual QDesignerLayoutDecorationExtension::~QDesignerLayoutDecorationExtension()
415
416 Destroys the extension.
417*/
418
419/*!
420 \fn virtual QList<QWidget*> QDesignerLayoutDecorationExtension::widgets(QLayout *layout) const
421
422 Returns the widgets that are managed by the given \a layout.
423
424 \sa insertWidget(), removeWidget()
425*/
426
427/*!
428 \fn QRect QDesignerLayoutDecorationExtension::itemInfo(int index) const
429
430 Returns the rectangle covered by the item at the given \a index in the layout.
431*/
432
433/*!
434 \fn int QDesignerLayoutDecorationExtension::indexOf(QWidget *widget) const
435
436 Returns the index of the specified \a widget in the layout.
437*/
438
439/*!
440 \fn int QDesignerLayoutDecorationExtension::indexOf(QLayoutItem *item) const
441
442 Returns the index of the specified layout \a item.
443*/
444
445/*!
446 \fn QDesignerLayoutDecorationExtension::InsertMode QDesignerLayoutDecorationExtension::currentInsertMode() const
447
448 Returns the current insertion mode.
449*/
450
451/*!
452 \fn int QDesignerLayoutDecorationExtension::currentIndex() const
453
454 Returns the current index in the layout.
455*/
456
457/*!
458 \fn QPair<int, int> QDesignerLayoutDecorationExtension::currentCell() const
459
460 Returns a pair containing the row and column of the current cell in the layout.
461*/
462
463/*!
464 \fn void QDesignerLayoutDecorationExtension::insertWidget(QWidget *widget, const QPair<int, int> &cell)
465
466 Inserts the given \a widget into the specified \a cell in the layout.
467
468 \sa removeWidget()
469*/
470
471/*!
472 \fn void QDesignerLayoutDecorationExtension::removeWidget(QWidget *widget)
473
474 Removes the specified \a widget from the layout.
475
476 \sa insertWidget()
477*/
478
479/*!
480 \fn void QDesignerLayoutDecorationExtension::insertRow(int row)
481
482 Inserts a new row into the form at the position specified by \a row.
483*/
484
485/*!
486 \fn void QDesignerLayoutDecorationExtension::insertColumn(int column)
487
488 Inserts a new column into the form at the position specified by \a column.
489*/
490
491/*!
492 \fn void QDesignerLayoutDecorationExtension::simplify()
493
494 Simplifies the layout by removing unnecessary empty rows and columns, and by changing the
495 number of rows or columns spanned by widgets.
496*/
497
498/*!
499 \fn int QDesignerLayoutDecorationExtension::findItemAt(const QPoint &position) const
500
501 Returns the index of the item in the layout that covers the given \a position.
502*/
503
504/*!
505 \fn int QDesignerLayoutDecorationExtension::findItemAt(int row, int column) const
506
507 Returns the item in the layout that occupies the specified \a row and \a column in the layout.
508
509 Currently, this only applies to grid layouts.
510*/
511
512/*!
513 \fn void QDesignerLayoutDecorationExtension::adjustIndicator(const QPoint &position, int index)
514
515 Adjusts the indicator for the item specified by \a index so that
516 it lies at the given \a position on the form.
517*/
518
519
520// Doc: Interface only
521
522/*!
523 \class QDesignerContainerExtension
524 \brief The QDesignerContainerExtension class allows you to add pages to
525 a custom multi-page container in Qt Designer's workspace.
526 \inmodule QtDesigner
527
528 QDesignerContainerExtension provide an interface for creating
529 custom container extensions. A container extension consists of a
530 collection of functions that \QD needs to manage a multi-page
531 container plugin, and a list of the container's pages.
532
533 \image containerextension-example.png
534
535 \warning This is \e not an extension for container plugins in
536 general, only custom \e multi-page containers.
537
538 To create a container extension, your extension class must inherit
539 from both QObject and QDesignerContainerExtension. For example:
540
541 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 6
542
543 Since we are implementing an interface, we must ensure that it's
544 made known to the meta object system using the Q_INTERFACES()
545 macro. This enables \QD to use the qobject_cast() function to
546 query for supported interfaces using nothing but a QObject
547 pointer.
548
549 You must reimplement several functions to enable \QD to manage a
550 custom multi-page container widget: \QD uses count() to keep track
551 of the number pages in your container, widget() to return the page
552 at a given index in the list of the container's pages, and
553 currentIndex() to return the list index of the selected page. \QD
554 uses the addWidget() function to add a given page to the
555 container, expecting it to be appended to the list of pages, while
556 it expects the insertWidget() function to add a given page to the
557 container by inserting it at a given index.
558
559 In \QD the extensions are not created until they are
560 required. For that reason you must also create a
561 QExtensionFactory, i.e a class that is able to make an instance of
562 your extension, and register it using \QD's \l
563 {QExtensionManager}{extension manager}.
564
565 When a container extension is required, \QD's \l
566 {QExtensionManager}{extension manager} will run through all its
567 registered factories calling QExtensionFactory::createExtension()
568 for each until the first one that is able to create a container
569 extension, is found. This factory will then create the extension
570 for the plugin.
571
572 There are four available types of extensions in \QD:
573 QDesignerContainerExtension , QDesignerMemberSheetExtension,
574 QDesignerPropertySheetExtension and QDesignerTaskMenuExtension.
575 \QD's behavior is the same whether the requested extension is
576 associated with a multi page container, a member sheet, a property
577 sheet or a task menu.
578
579 The QExtensionFactory class provides a standard extension factory,
580 and can also be used as an interface for custom extension
581 factories. You can either create a new QExtensionFactory and
582 reimplement the QExtensionFactory::createExtension() function. For
583 example:
584
585 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 7
586
587 Or you can use an existing factory, expanding the
588 QExtensionFactory::createExtension() function to make the factory
589 able to create a container extension as well. For example:
590
591 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 8
592
593 For a complete example using the QDesignerContainerExtension
594 class, see the \l {designer/containerextension}{Container
595 Extension example}. The example shows how to create a custom
596 multi-page plugin for \QD.
597
598 \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
599 Extensions}
600*/
601
602/*!
603 \fn QDesignerContainerExtension::~QDesignerContainerExtension()
604
605 Destroys the extension.
606*/
607
608/*!
609 \fn int QDesignerContainerExtension::count() const
610
611 Returns the number of pages in the container.
612*/
613
614/*!
615 \fn QWidget *QDesignerContainerExtension::widget(int index) const
616
617 Returns the page at the given \a index in the extension's list of
618 pages.
619
620 \sa addWidget(), insertWidget()
621*/
622
623/*!
624 \fn int QDesignerContainerExtension::currentIndex() const
625
626 Returns the index of the currently selected page in the
627 container.
628
629 \sa setCurrentIndex()
630*/
631
632/*!
633 \fn void QDesignerContainerExtension::setCurrentIndex(int index)
634
635 Sets the the currently selected page in the container to be the
636 page at the given \a index in the extension's list of pages.
637
638 \sa currentIndex()
639*/
640
641/*!
642 \fn void QDesignerContainerExtension::addWidget(QWidget *page)
643
644 Adds the given \a page to the container by appending it to the
645 extension's list of pages.
646
647 \sa insertWidget(), remove(), widget()
648*/
649
650/*!
651 \fn void QDesignerContainerExtension::insertWidget(int index, QWidget *page)
652
653 Adds the given \a page to the container by inserting it at the
654 given \a index in the extension's list of pages.
655
656 \sa addWidget(), remove(), widget()
657*/
658
659/*!
660 \fn void QDesignerContainerExtension::remove(int index)
661
662 Removes the page at the given \a index from the extension's list
663 of pages.
664
665 \sa addWidget(), insertWidget()
666*/
667
668
669// Doc: Interface only
670
671/*!
672 \class QDesignerTaskMenuExtension
673 \brief The QDesignerTaskMenuExtension class allows you to add custom
674 menu entries to Qt Designer's task menu.
675 \inmodule QtDesigner
676
677 QDesignerTaskMenuExtension provides an interface for creating
678 custom task menu extensions. It is typically used to create task
679 menu entries that are specific to a plugin in \QD.
680
681 \QD uses the QDesignerTaskMenuExtension to feed its task
682 menu. Whenever a task menu is requested, \QD will query
683 for the selected widget's task menu extension.
684
685 \image taskmenuextension-example-faded.png
686
687 A task menu extension is a collection of QActions. The actions
688 appear as entries in the task menu when the plugin with the
689 specified extension is selected. The image above shows the custom
690 \gui {Edit State...} action which appears in addition to \QD's
691 default task menu entries: \gui Cut, \gui Copy, \gui Paste etc.
692
693 To create a custom task menu extension, your extension class must
694 inherit from both QObject and QDesignerTaskMenuExtension. For
695 example:
696
697 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 9
698
699 Since we are implementing an interface, we must ensure that it
700 is made known to the meta-object system using the Q_INTERFACES()
701 macro. This enables \QD to use the qobject_cast() function to
702 query for supported interfaces using nothing but a QObject
703 pointer.
704
705 You must reimplement the taskActions() function to return a list
706 of actions that will be included in \QD task menu. Optionally, you
707 can reimplement the preferredEditAction() function to set the
708 action that is invoked when selecting your plugin and pressing
709 \key F2. The preferred edit action must be one of the actions
710 returned by taskActions() and, if it's not defined, pressing the
711 \key F2 key will simply be ignored.
712
713 In \QD, extensions are not created until they are required. A
714 task menu extension, for example, is created when you click the
715 right mouse button over a widget in \QD's workspace. For that
716 reason you must also construct an extension factory, using either
717 QExtensionFactory or a subclass, and register it using \QD's
718 \l {QExtensionManager}{extension manager}.
719
720 When a task menu extension is required, \QD's \l
721 {QExtensionManager}{extension manager} will run through all its
722 registered factories calling QExtensionFactory::createExtension()
723 for each until it finds one that is able to create a task menu
724 extension for the selected widget. This factory will then make an
725 instance of the extension.
726
727 There are four available types of extensions in \QD:
728 QDesignerContainerExtension, QDesignerMemberSheetExtension,
729 QDesignerPropertySheetExtension, and QDesignerTaskMenuExtension.
730 \QD's behavior is the same whether the requested extension is
731 associated with a container, a member sheet, a property sheet or a
732 task menu.
733
734 The QExtensionFactory class provides a standard extension factory,
735 and can also be used as an interface for custom extension
736 factories. You can either create a new QExtensionFactory and
737 reimplement the QExtensionFactory::createExtension() function. For
738 example:
739
740 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 10
741
742 Or you can use an existing factory, expanding the
743 QExtensionFactory::createExtension() function to make the factory
744 able to create a task menu extension as well. For example:
745
746 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 11
747
748 For a complete example using the QDesignerTaskMenuExtension class,
749 see the \l {designer/taskmenuextension}{Task Menu Extension
750 example}. The example shows how to create a custom widget plugin
751 for \QD, and how to to use the QDesignerTaskMenuExtension
752 class to add custom items to \QD's task menu.
753
754 \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
755 Extensions}
756*/
757
758/*!
759 \fn QDesignerTaskMenuExtension::~QDesignerTaskMenuExtension()
760
761 Destroys the task menu extension.
762*/
763
764/*!
765 \fn QAction *QDesignerTaskMenuExtension::preferredEditAction() const
766
767 Returns the action that is invoked when selecting a plugin with
768 the specified extension and pressing \key F2.
769
770 The action must be one of the actions returned by taskActions().
771*/
772
773/*!
774 \fn QList<QAction*> QDesignerTaskMenuExtension::taskActions() const
775
776 Returns the task menu extension as a list of actions which will be
777 included in \QD's task menu when a plugin with the specified
778 extension is selected.
779
780 The function must be reimplemented to add actions to the list.
781*/
782
783
784// Doc: Interface only
785
786/*!
787 \class QDesignerCustomWidgetCollectionInterface
788
789 \brief The QDesignerCustomWidgetCollectionInterface class allows
790 you to include several custom widgets in one single library.
791
792 \inmodule QtDesigner
793
794 When implementing a custom widget plugin, you build it as a
795 separate library. If you want to include several custom widget
796 plugins in the same library, you must in addition subclass
797 QDesignerCustomWidgetCollectionInterface.
798
799 QDesignerCustomWidgetCollectionInterface contains one single
800 function returning a list of the collection's
801 QDesignerCustomWidgetInterface objects. For example, if you have
802 several custom widgets \c CustomWidgetOne, \c CustomWidgetTwo and
803 \c CustomWidgetThree, the class definition may look like this:
804
805 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 12
806
807 In the class constructor you add the interfaces to your custom
808 widgets to the list which you return in the customWidgets()
809 function:
810
811 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 13
812
813 Note that instead of exporting each custom widget plugin using the
814 Q_EXPORT_PLUGIN2() macro, you export the entire collection. The
815 Q_EXPORT_PLUGIN2() macro ensures that \QD can access and construct
816 the custom widgets. Without this macro, there is no way for \QD to
817 use them.
818
819 \sa QDesignerCustomWidgetInterface, {Creating Custom Widgets for
820 Qt Designer}
821*/
822
823/*!
824 \fn QDesignerCustomWidgetCollectionInterface::~QDesignerCustomWidgetCollectionInterface() {
825
826 Destroys the custom widget collection interface.
827*/
828
829/*!
830 \fn QList<QDesignerCustomWidgetInterface*> QDesignerCustomWidgetCollectionInterface::customWidgets() const
831
832 Returns a list of interfaces to the collection's custom widgets.
833*/
834
835
836// Doc: Interface only
837
838/*!
839 \class QDesignerCustomWidgetInterface
840
841 \brief The QDesignerCustomWidgetInterface class enables Qt Designer
842 to access and construct custom widgets.
843
844 \inmodule QtDesigner
845
846 QDesignerCustomWidgetInterface provides a custom widget with an
847 interface. The class contains a set of functions that must be subclassed
848 to return basic information about the widget, such as its class name and
849 the name of its header file. Other functions must be implemented to
850 initialize the plugin when it is loaded, and to construct instances of
851 the custom widget for \QD to use.
852
853 When implementing a custom widget you must subclass
854 QDesignerCustomWidgetInterface to expose your widget to \QD. For
855 example, this is the declaration for the plugin used in the
856 \l{Custom Widget Plugin Example}{Custom Widget Plugin example} that
857 enables an analog clock custom widget to be used by \QD:
858
859 \snippet examples/designer/customwidgetplugin/customwidgetplugin.h 0
860
861 Note that the only part of the class definition that is specific
862 to this particular custom widget is the class name. In addition,
863 since we are implementing an interface, we must ensure that it's
864 made known to the meta object system using the Q_INTERFACES()
865 macro. This enables \QD to use the qobject_cast() function to
866 query for supported interfaces using nothing but a QObject
867 pointer.
868
869 After \QD loads a custom widget plugin, it calls the interface's
870 initialize() function to enable it to set up any resources that it
871 may need. This function is called with a QDesignerFormEditorInterface
872 parameter that provides the plugin with a gateway to all of \QD's API.
873
874 \QD constructs instances of the custom widget by calling the plugin's
875 createWidget() function with a suitable parent widget. Plugins must
876 construct and return an instance of a custom widget with the specified
877 parent widget.
878
879 In the implementation of the class you must remember to export
880 your custom widget plugin to \QD using the Q_EXPORT_PLUGIN2()
881 macro. For example, if a library called \c libcustomwidgetplugin.so
882 (on Unix) or \c libcustomwidget.dll (on Windows) contains a widget
883 class called \c MyCustomWidget, we can export it by adding the
884 following line to the file containing the plugin implementation:
885
886 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 14
887
888 This macro ensures that \QD can access and construct the custom widget.
889 Without this macro, there is no way for \QD to use it.
890
891 When implementing a custom widget plugin, you build it as a
892 separate library. If you want to include several custom widget
893 plugins in the same library, you must in addition subclass
894 QDesignerCustomWidgetCollectionInterface.
895
896 \warning If your custom widget plugin contains QVariant
897 properties, be aware that only the following \l
898 {QVariant::Type}{types} are supported:
899
900 \list
901 \o QVariant::ByteArray
902 \o QVariant::Bool
903 \o QVariant::Color
904 \o QVariant::Cursor
905 \o QVariant::Date
906 \o QVariant::DateTime
907 \o QVariant::Double
908 \o QVariant::Int
909 \o QVariant::Point
910 \o QVariant::Rect
911 \o QVariant::Size
912 \o QVariant::SizePolicy
913 \o QVariant::String
914 \o QVariant::Time
915 \o QVariant::UInt
916 \endlist
917
918 For a complete example using the QDesignerCustomWidgetInterface
919 class, see the \l {designer/customwidgetplugin}{Custom Widget
920 Example}. The example shows how to create a custom widget plugin
921 for \QD.
922
923 \sa QDesignerCustomWidgetCollectionInterface {Creating Custom
924 Widgets for Qt Designer}
925*/
926
927/*!
928 \fn QDesignerCustomWidgetInterface::~QDesignerCustomWidgetInterface()
929
930 Destroys the custom widget interface.
931*/
932
933/*!
934 \fn QString QDesignerCustomWidgetInterface::name() const
935
936 Returns the class name of the custom widget supplied by the interface.
937
938 The name returned \e must be identical to the class name used for the
939 custom widget.
940*/
941
942/*!
943 \fn QString QDesignerCustomWidgetInterface::group() const
944
945 Returns the name of the group to which the custom widget belongs.
946*/
947
948/*!
949 \fn QString QDesignerCustomWidgetInterface::toolTip() const
950
951 Returns a short description of the widget that can be used by \QD
952 in a tool tip.
953*/
954
955/*!
956 \fn QString QDesignerCustomWidgetInterface::whatsThis() const
957
958 Returns a description of the widget that can be used by \QD in
959 "What's This?" help for the widget.
960*/
961
962/*!
963 \fn QString QDesignerCustomWidgetInterface::includeFile() const
964
965 Returns the path to the include file that \l uic uses when
966 creating code for the custom widget.
967*/
968
969/*!
970 \fn QIcon QDesignerCustomWidgetInterface::icon() const
971
972 Returns the icon used to represent the custom widget in \QD's
973 widget box.
974*/
975
976/*!
977 \fn bool QDesignerCustomWidgetInterface::isContainer() const
978
979 Returns true if the custom widget is intended to be used as a
980 container; otherwise returns false.
981
982 Most custom widgets are not used to hold other widgets, so their
983 implementations of this function will return false, but custom
984 containers will return true to ensure that they behave correctly
985 in \QD.
986*/
987
988/*!
989 \fn QWidget *QDesignerCustomWidgetInterface::createWidget(QWidget *parent)
990
991 Returns a new instance of the custom widget, with the given \a
992 parent.
993*/
994
995/*!
996 \fn bool QDesignerCustomWidgetInterface::isInitialized() const
997
998 Returns true if the widget has been initialized; otherwise returns
999 false.
1000
1001 \sa initialize()
1002*/
1003
1004/*!
1005 \fn void QDesignerCustomWidgetInterface::initialize(QDesignerFormEditorInterface *formEditor)
1006
1007 Initializes the widget for use with the specified \a formEditor
1008 interface.
1009
1010 \sa isInitialized()
1011*/
1012
1013/*!
1014 \fn QString QDesignerCustomWidgetInterface::domXml() const
1015
1016 Returns the XML that is used to describe the custom widget's
1017 properties to \QD.
1018*/
1019
1020/*!
1021 \fn QString QDesignerCustomWidgetInterface::codeTemplate() const
1022
1023 This function is reserved for future use by \QD.
1024
1025 \omit
1026 Returns the code template that \QD includes in forms that contain
1027 the custom widget when they are saved.
1028 \endomit
1029*/
1030
1031/*!
1032 \macro QDESIGNER_WIDGET_EXPORT
1033 \relates QDesignerCustomWidgetInterface
1034 \since 4.1
1035
1036 This macro is used when defining custom widgets to ensure that they are
1037 correctly exported from plugins for use with \QD.
1038
1039 On some platforms, the symbols required by \QD to create new widgets
1040 are removed from plugins by the build system, making them unusable.
1041 Using this macro ensures that the symbols are retained on those platforms,
1042 and has no side effects on other platforms.
1043
1044 For example, the \l{designer/worldtimeclockplugin}{World Time Clock Plugin}
1045 example exports a custom widget class with the following declaration:
1046
1047 \snippet examples/designer/worldtimeclockplugin/worldtimeclock.h 0
1048 \dots
1049 \snippet examples/designer/worldtimeclockplugin/worldtimeclock.h 2
1050
1051 \sa {Creating Custom Widgets for Qt Designer}
1052*/
1053
1054
1055// Doc: Abstract class
1056
1057/*!
1058 \class QDesignerDnDItemInterface
1059 \brief The QDesignerDnDItemInterface class provides an interface that is used to manage items
1060 during a drag and drop operation.
1061 \inmodule QtDesigner
1062 \internal
1063*/
1064
1065/*!
1066 \enum QDesignerDnDItemInterface::DropType
1067
1068 This enum describes the result of a drag and drop operation.
1069
1070 \value MoveDrop The item was moved.
1071 \value CopyDrop The item was copied.
1072*/
1073
1074/*!
1075 \fn QDesignerDnDItemInterface::QDesignerDnDItemInterface()
1076
1077 Constructs a new interface to a drag and drop item.
1078*/
1079
1080/*!
1081 \fn QDesignerDnDItemInterface::~QDesignerDnDItemInterface()
1082
1083 Destroys the interface to the item.
1084*/
1085
1086/*!
1087 \fn DomUI *QDesignerDnDItemInterface::domUi() const
1088
1089 Returns a user interface object for the item.
1090*/
1091
1092/*!
1093 \fn QWidget *QDesignerDnDItemInterface::widget() const
1094
1095 Returns the widget being copied or moved in the drag and drop operation.
1096
1097 \sa source()
1098*/
1099
1100/*!
1101 \fn QWidget *QDesignerDnDItemInterface::decoration() const
1102
1103 Returns the widget used to represent the item.
1104*/
1105
1106/*!
1107 \fn QPoint QDesignerDnDItemInterface::hotSpot() const
1108
1109 Returns the cursor's hotspot.
1110
1111 \sa QDrag::hotSpot()
1112*/
1113
1114/*!
1115 \fn DropType QDesignerDnDItemInterface::type() const
1116
1117 Returns the type of drag and drop operation in progress.
1118*/
1119
1120/*!
1121 \fn QWidget *QDesignerDnDItemInterface::source() const
1122
1123 Returns the widget that is the source of the drag and drop operation; i.e. the original
1124 container of the widget being dragged.
1125
1126 \sa widget()
1127*/
1128
1129
1130// Doc: Abstract class
1131
1132/*!
1133 \class QDesignerIconCacheInterface
1134 \brief The QDesignerIconCacheInterface class provides an interface to \QD's icon cache.
1135 \inmodule QtDesigner
1136 \internal
1137*/
1138
1139/*!
1140 \fn QDesignerIconCacheInterface::QDesignerIconCacheInterface(QObject *parent)
1141
1142 Constructs a new interface with the given \a parent.
1143*/
1144
1145/*!
1146 \fn QIcon QDesignerIconCacheInterface::nameToIcon(const QString &filePath, const QString &qrcPath)
1147
1148 Returns the icon associated with the name specified by \a filePath in the resource
1149 file specified by \a qrcPath.
1150
1151 If \a qrcPath refers to a valid resource file, the name used for the file path is a path
1152 within those resources; otherwise the file path refers to a local file.
1153
1154 \sa {The Qt Resource System}, nameToPixmap()
1155*/
1156
1157/*!
1158 \fn QPixmap QDesignerIconCacheInterface::nameToPixmap(const QString &filePath, const QString &qrcPath)
1159
1160 Returns the pixmap associated with the name specified by \a filePath in the resource
1161 file specified by \a qrcPath.
1162
1163 If \a qrcPath refers to a valid resource file, the name used for the file path is a path
1164 within those resources; otherwise the file path refers to a local file.
1165
1166 \sa {The Qt Resource System}, nameToIcon()
1167*/
1168
1169/*!
1170 \fn QString QDesignerIconCacheInterface::iconToFilePath(const QIcon &icon) const
1171
1172 Returns the file path associated with the given \a icon. The file path is a path within
1173 an application resources.
1174*/
1175
1176/*!
1177 \fn QString QDesignerIconCacheInterface::iconToQrcPath(const QIcon &icon) const
1178
1179 Returns the path to the resource file that refers to the specified \a icon. The resource
1180 path refers to a local file.
1181*/
1182
1183/*!
1184 \fn QString QDesignerIconCacheInterface::pixmapToFilePath(const QPixmap &pixmap) const
1185
1186 Returns the file path associated with the given \a pixmap. The file path is a path within
1187 an application resources.
1188*/
1189
1190/*!
1191 \fn QString QDesignerIconCacheInterface::pixmapToQrcPath(const QPixmap &pixmap) const
1192
1193 Returns the path to the resource file that refers to the specified \a pixmap. The resource
1194 path refers to a local file.
1195*/
1196
1197/*!
1198 \fn QList<QPixmap> QDesignerIconCacheInterface::pixmapList() const
1199
1200 Returns a list of pixmaps for the icons provided by the icon cache.
1201*/
1202
1203/*!
1204 \fn QList<QIcon> QDesignerIconCacheInterface::iconList() const
1205
1206 Returns a list of icons provided by the icon cache.
1207*/
1208
1209/*!
1210 \fn QString QDesignerIconCacheInterface::resolveQrcPath(const QString &filePath, const QString &qrcPath, const QString &workingDirectory) const
1211
1212 Returns a path to a resource specified by the \a filePath within
1213 the resource file located at \a qrcPath. If \a workingDirectory is
1214 a valid path to a directory, the path returned will be relative to
1215 that directory; otherwise an absolute path is returned.
1216
1217 \omit
1218 ### Needs checking
1219 \endomit
1220*/
1221
1222
1223// Doc: Interface only
1224
1225/*!
1226 \class QDesignerPropertySheetExtension
1227
1228 \brief The QDesignerPropertySheetExtension class allows you to
1229 manipulate a widget's properties which is displayed in Qt
1230 Designer's property editor.
1231
1232 \sa QDesignerDynamicPropertySheetExtension
1233
1234 \inmodule QtDesigner
1235
1236 QDesignerPropertySheetExtension provides a collection of functions that
1237 are typically used to query a widget's properties, and to
1238 manipulate the properties' appearance in the property editor. For
1239 example:
1240
1241 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 15
1242
1243 Note that if you change the value of a property using the
1244 QDesignerPropertySheetExtension::setProperty() function, the undo
1245 stack is not updated. To ensure that a property's value can be
1246 reverted using the undo stack, you must use the
1247 QDesignerFormWindowCursorInterface::setProperty() function, or its
1248 buddy \l
1249 {QDesignerFormWindowCursorInterface::setWidgetProperty()}{setWidgetProperty()},
1250 instead.
1251
1252 When implementing a custom widget plugin, a pointer to \QD's
1253 current QDesignerFormEditorInterface object (\c formEditor in the
1254 example above) is provided by the
1255 QDesignerCustomWidgetInterface::initialize() function's parameter.
1256
1257 The property sheet, or any other extension, can be retrieved by
1258 querying \QD's extension manager using the qt_extension()
1259 function. When you want to release the extension, you only need to
1260 delete the pointer.
1261
1262 All widgets have a default property sheet which populates \QD's
1263 property editor with the widget's properties (i.e the ones defined
1264 with the Q_PROPERTY() macro). But QDesignerPropertySheetExtension
1265 also provides an interface for creating custom property sheet
1266 extensions.
1267
1268 \warning \QD uses the QDesignerPropertySheetExtension to feed its
1269 property editor. Whenever a widget is selected in its workspace,
1270 \QD will query for the widget's property sheet extension. If the
1271 selected widget has an implemented property sheet extension, this
1272 extension will override the default property sheet.
1273
1274 To create a property sheet extension, your extension class must
1275 inherit from both QObject and
1276 QDesignerPropertySheetExtension. Then, since we are implementing
1277 an interface, we must ensure that it's made known to the meta
1278 object system using the Q_INTERFACES() macro:
1279
1280 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 16
1281
1282 This enables \QD to use qobject_cast() to query for supported
1283 interfaces using nothing but a QObject pointer.
1284
1285 In \QD the extensions are not created until they are
1286 required. For that reason, when implementing a property sheet
1287 extension, you must also create a QExtensionFactory, i.e a class
1288 that is able to make an instance of your extension, and register
1289 it using \QD's \l {QExtensionManager}{extension manager}.
1290
1291 When a property sheet extension is required, \QD's \l
1292 {QExtensionManager}{extension manager} will run through all its
1293 registered factories calling QExtensionFactory::createExtension()
1294 for each until the first one that is able to create a property
1295 sheet extension for the selected widget, is found. This factory
1296 will then make an instance of the extension. If no such factory
1297 can be found, \QD will use the default property sheet.
1298
1299 There are four available types of extensions in \QD:
1300 QDesignerContainerExtension, QDesignerMemberSheetExtension,
1301 QDesignerPropertySheetExtension and QDesignerTaskMenuExtension. Qt
1302 Designer's behavior is the same whether the requested extension is
1303 associated with a multi page container, a member sheet, a property
1304 sheet or a task menu.
1305
1306 The QExtensionFactory class provides a standard extension factory,
1307 and can also be used as an interface for custom extension
1308 factories. You can either create a new QExtensionFactory and
1309 reimplement the QExtensionFactory::createExtension() function. For
1310 example:
1311
1312 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 17
1313
1314 Or you can use an existing factory, expanding the
1315 QExtensionFactory::createExtension() function to make the factory
1316 able to create a property sheet extension extension as well. For
1317 example:
1318
1319 \snippet doc/src/snippets/code/doc_src_qtdesigner.qdoc 18
1320
1321 For a complete example using an extension class, see the \l
1322 {designer/taskmenuextension}{Task Menu Extension example}. The
1323 example shows how to create a custom widget plugin for Qt
1324 Designer, and how to to use the QDesignerTaskMenuExtension class
1325 to add custom items to \QD's task menu.
1326
1327 \sa QExtensionFactory, QExtensionManager, {Creating Custom Widget
1328 Extensions}
1329*/
1330
1331/*!
1332 \fn QDesignerPropertySheetExtension::~QDesignerPropertySheetExtension()
1333
1334 Destroys the property sheet extension.
1335*/
1336
1337/*!
1338 \fn int QDesignerPropertySheetExtension::count() const
1339
1340 Returns the selected widget's number of properties.
1341*/
1342
1343/*!
1344 \fn int QDesignerPropertySheetExtension::indexOf(const QString &name) const
1345
1346 Returns the index for a given property \a name.
1347
1348 \sa propertyName()
1349*/
1350
1351/*!
1352 \fn QString QDesignerPropertySheetExtension::propertyName(int index) const
1353
1354 Returns the name of the property at the given \a index.
1355
1356 \sa indexOf()
1357*/
1358
1359/*!
1360 \fn QString QDesignerPropertySheetExtension::propertyGroup(int index) const
1361
1362 Returns the property group for the property at the given \a index.
1363
1364 \QD's property editor supports property groups, i.e. sections of
1365 related properties. A property can be related to a group using the
1366 setPropertyGroup() function. The default group of any property is
1367 the name of the class that defines it. For example, the
1368 QObject::objectName property appears within the QObject property
1369 group.
1370
1371 \sa indexOf(), setPropertyGroup()
1372*/
1373
1374/*!
1375 \fn void QDesignerPropertySheetExtension::setPropertyGroup(int index, const QString &group)
1376
1377 Sets the property group for the property at the given \a index to
1378 \a group.
1379
1380 Relating a property to a group makes it appear within that group's
1381 section in the property editor. The default property group of any
1382 property is the name of the class that defines it. For example,
1383 the QObject::objectName property appears within the QObject
1384 property group.
1385
1386 \sa indexOf(), property(), propertyGroup()
1387*/
1388
1389/*!
1390 \fn bool QDesignerPropertySheetExtension::hasReset(int index) const
1391
1392 Returns true if the property at the given \a index has a reset
1393 button in \QD's property editor, otherwise false.
1394
1395 \sa indexOf(), reset()
1396*/
1397
1398/*!
1399 \fn bool QDesignerPropertySheetExtension::reset(int index)
1400
1401 Resets the value of the property at the given \a index, to the
1402 default value. Returns true if a default value could be found, otherwise false.
1403
1404 \sa indexOf(), hasReset(), isChanged()
1405*/
1406
1407/*!
1408 \fn bool QDesignerPropertySheetExtension::isVisible(int index) const
1409
1410 Returns true if the property at the given \a index is visible in
1411 \QD's property editor, otherwise false.
1412
1413 \sa indexOf(), setVisible()
1414*/
1415
1416/*!
1417 \fn void QDesignerPropertySheetExtension::setVisible(int index, bool visible)
1418
1419 If \a visible is true, the property at the given \a index is
1420 visible in \QD's property editor; otherwise the property is
1421 hidden.
1422
1423 \sa indexOf(), isVisible()
1424*/
1425
1426/*!
1427 \fn bool QDesignerPropertySheetExtension::isAttribute(int index) const
1428
1429 Returns true if the property at the given \a index is an attribute,
1430 which will be \e excluded from the .ui file, otherwise false.
1431
1432 \sa indexOf(), setAttribute()
1433*/
1434
1435/*!
1436 \fn void QDesignerPropertySheetExtension::setAttribute(int index, bool attribute)
1437
1438 If \a attribute is true, the property at the given \a index is
1439 made an attribute which will be \e excluded from the .ui file;
1440 otherwise it will be included.
1441
1442 \sa indexOf(), isAttribute()
1443*/
1444
1445/*!
1446 \fn QVariant QDesignerPropertySheetExtension::property(int index) const
1447
1448 Returns the value of the property at the given \a index.
1449
1450 \sa indexOf(), setProperty(), propertyGroup()
1451*/
1452
1453/*!
1454 \fn void QDesignerPropertySheetExtension::setProperty(int index, const QVariant &value)
1455
1456 Sets the \a value of the property at the given \a index.
1457
1458 \warning If you change the value of a property using this
1459 function, the undo stack is not updated. To ensure that a
1460 property's value can be reverted using the undo stack, you must
1461 use the QDesignerFormWindowCursorInterface::setProperty()
1462 function, or its buddy \l
1463 {QDesignerFormWindowCursorInterface::setWidgetProperty()}{setWidgetProperty()},
1464 instead.
1465
1466 \sa indexOf(), property(), propertyGroup()
1467*/
1468
1469/*!
1470 \fn bool QDesignerPropertySheetExtension::isChanged(int index) const
1471
1472 Returns true if the value of the property at the given \a index
1473 differs from the property's default value, otherwise false.
1474
1475 \sa indexOf(), setChanged(), reset()
1476*/
1477
1478/*!
1479 \fn void QDesignerPropertySheetExtension::setChanged(int index, bool changed)
1480
1481 Sets whether the property at the given \a index is different from
1482 its default value, or not, depending on the \a changed parameter.
1483
1484 \sa indexOf(), isChanged()
1485*/
1486
1487// Doc: Interface only
1488
1489/*!
1490 \class QDesignerDynamicPropertySheetExtension
1491
1492 \brief The QDesignerDynamicPropertySheetExtension class allows you to
1493 manipulate a widget's dynamic properties in Qt Designer's property editor.
1494
1495 \sa QDesignerPropertySheetExtension, {QObject#Dynamic Properties}{Dynamic Properties}
1496
1497 \inmodule QtDesigner
1498 \since 4.3
1499*/
1500
1501/*!
1502 \fn QDesignerDynamicPropertySheetExtension::~QDesignerDynamicPropertySheetExtension()
1503
1504 Destroys the dynamic property sheet extension.
1505*/
1506
1507/*!
1508 \fn bool QDesignerDynamicPropertySheetExtension::dynamicPropertiesAllowed() const
1509
1510 Returns true if the widget supports dynamic properties; otherwise returns false.
1511*/
1512
1513/*!
1514 \fn int QDesignerDynamicPropertySheetExtension::addDynamicProperty(const QString &propertyName, const QVariant &value)
1515
1516 Adds a dynamic property named \a propertyName and sets its value to \a value.
1517 Returns the index of the property if it was added successfully; otherwise returns -1 to
1518 indicate failure.
1519*/
1520
1521/*!
1522 \fn bool QDesignerDynamicPropertySheetExtension::removeDynamicProperty(int index)
1523
1524 Removes the dynamic property at the given \a index.
1525 Returns true if the operation succeeds; otherwise returns false.
1526*/
1527
1528/*!
1529 \fn bool QDesignerDynamicPropertySheetExtension::isDynamicProperty(int index) const
1530
1531 Returns true if the property at the given \a index is a dynamic property; otherwise
1532 returns false.
1533*/
1534
1535/*!
1536 \fn bool QDesignerDynamicPropertySheetExtension::canAddDynamicProperty(const QString &propertyName) const
1537
1538 Returns true if \a propertyName is a valid, unique name for a dynamic
1539 property; otherwise returns false.
1540
1541*/
Note: See TracBrowser for help on using the repository browser.