aboutsummaryrefslogtreecommitdiffstats
path: root/src/imports/controls/doc/src/qtquickcontrols2-differences.qdoc
blob: 40080840682dc7b11cb381105a4850ff3df522cb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Free Documentation License Usage
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of
** this file. Please review the following information to ensure
** the GNU Free Documentation License version 1.3 requirements
** will be met: https://www.gnu.org/licenses/fdl-1.3.html.
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \page qtquickcontrols2-differences.html
    \title Differences with Qt Quick Controls 1

    Qt Quick Controls 1 was originally developed to support desktop platforms,
    with mobile and embedded support coming shortly afterwards. They have a
    very broad scope, in that they provide a styling system flexible enough to
    allow the development of applications that have either a platform-dependent
    or platform-independent style.

    On embedded systems, where the hardware has limited resources, this approach
    can be inefficient. Qt Quick Controls 2 was designed to solve this problem,
    using
    \l {https://blog.qt.io/blog/2015/03/31/qt-quick-controls-for-embedded/}{benchmarks}
    to guide the development.

    \section2 C++ and QML

    In many cases, the internal state of a control can be more efficiently
    processed in C++. For example, handling input events in C++ makes a
    difference for controls that would otherwise need to create internal
    MouseAreas and attached Keys objects.

    \section2 Styles

    Not only does handling events and logic in C++ increase performance, but it
    allows the visual QML layer to be a simple, declarative layer on top. This
    is reflected in the structure of the controls project: all visual
    implementations sit in the \e imports folder, so that users who want to
    create their own complete style can copy the folder and start tweaking.
    Read more about implementing a style plugin
    \l {Creating a Custom Style}{here}.

    In Qt Quick Controls 2, styles no longer provide components that are
    dynamically instantiated by controls, but controls themselves consist of
    item delegates that can be replaced. In effect, this means that delegates
    are Qt Quick items that are instantiated on the spot, as properties of the
    control, and are simply parented to the control.

    \section2 Modularity and Simplicity

    When it comes to more complex controls, it is sometimes better to split
    them up into separate building blocks. As an example, the complex
    ScrollView control:

    \qml
    ScrollView {
        horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
        Flickable {
            // ...
        }
    }
    \endqml

    Is replaced with simple ScrollBar/ScrollIndicator controls that can be
    attached to any Flickable:

    \qml
    Flickable {
        // ...
        ScrollBar.vertical: ScrollBar { }
    }
    \endqml

    The API of Qt Quick Controls 2 aims to be clean and simple. Common
    operations are easy, and more advanced ones are liberally documented with
    snippets that can be copied into your code.

    \section2 Feature Comparison Table

    \table
    \header
        \li
        \li Qt Quick Controls 1
        \li Qt Quick Controls 2
    \row
        \li Stylable delegates
        \li Yes
        \li Yes
    \row
        \li Pre-built native styles
        \li Yes
        \li No
    \row
        \li Runtime style/theme changes
        \li Yes \sup 1
        \li Yes \sup 2
    \row
        \li Can be used on Desktop
        \li Yes
        \li Yes
    \row
        \li Can be used on Mobile
        \li Yes \sup 3
        \li Yes
    \row
        \li Can be used on Embedded
        \li Yes \sup 3
        \li Yes
    \row
        \li Internal event handling
        \li QML
        \li C++
    \endtable

    \list 1
    \li Not officially supported, but technically possible via private APIs
    \li Only themes for specific styles can be changed at runtime, styles are fixed
    \li Performance may not be optimal
    \endlist

    \section2 Porting Qt Quick Controls 1 Code

    The API of Qt Quick Controls 2 is very similar to Qt Quick Controls 1, but it
    does come with some changes necessary to facilitate the improvements. The
    majority of changes are to do with styling; all of a control's delegates
    are now accessible in the control itself, instead of in a separate style
    object.

    For example, to style a button in Qt Quick Controls 1:

    \qml
    Button {
        style: ButtonStyle {
            label: Label {
                // ...
            }
        }
    }
    \endqml

    To style a button in Qt Quick Controls 2:

    \qml
    Button {
        contentItem: Label {
            // ...
        }
    }
    \endqml

    \section3 Preparing for Migration

    With this in mind, a good way to prepare for a migration to Qt Quick
    Controls 2 is to place each control that you have a custom style for in its
    own QML file. For example, the Qt Quick Controls 1 button above could be
    moved to a file named \c Button.qml in a directory named \c controls, and
    used in the following manner:

    \qml
    import "controls" as Controls

    Controls.Button {
        // ...
    }
    \endqml

    This works with both modules, and will reduce the amount of work needed
    when the migration begins.

    \section2 Type Comparison Table

    The first column lists all types available in \l {Qt Quick Controls 1},
    \l {Qt Quick Dialogs}, and \l {Qt Quick Extras}.
    The second column documents the respective type in Qt Quick Controls 2.
    When a direct alternative is not available, the third column contains
    an alternative that provides related functionality. The last column
    contains some remarks about the differences between the types in the
    different modules.

    \table
    \header
        \li Qt Quick Controls 1
        \li Qt Quick Controls 2
        \li Alternatives
        \li Remarks
    \row
        \li \l [QML QtQuickControls1] {Action}
        \li \l [QML QtQuickControls2] {Action}
        \li \l [QML QtQuick] {Shortcut} \br\sup {(Qt Quick)}
        \li
    \row
        \li \l [QML QtQuickControls1] {ApplicationWindow}
        \li \l [QML QtQuickControls2] {ApplicationWindow}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {BusyIndicator}
        \li \l [QML QtQuickControls2] {BusyIndicator}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {Button}
        \li \l [QML QtQuickControls2] {Button}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {Calendar}
        \li \mdash
        \li \l [QML QtLabsCalendar] {MonthGrid},\br
            \l [QML QtLabsCalendar] {DayOfWeekRow},\br
            \l [QML QtLabsCalendar] {WeekNumberColumn} \br\sup {(Qt Labs Calendar)}
        \li \list
                \li \b {Qt Labs Calendar}: \c MonthGrid, \c DayOfWeek, and \c WeekNumberColumn
                    are \e experimental unstyled building blocks for calendar views.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {CheckBox}
        \li \l [QML QtQuickControls2] {CheckBox}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {ComboBox}
        \li \l [QML QtQuickControls2] {ComboBox}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {ExclusiveGroup}
        \li \mdash
        \li \l [QML QtQuickControls2] {ActionGroup},\br
            \l [QML QtQuickControls2] {ButtonGroup} \br\sup {(Qt Quick Controls 2)}
        \li \list
                \li \b {Qt Quick Controls 2}: \c ActionGroup and \c ButtonGroup offer similar functionality.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {GroupBox}
        \li \l [QML QtQuickControls2] {GroupBox}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {Label}
        \li \l [QML QtQuickControls2] {Label}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {Menu}
        \li \l [QML QtQuickControls2] {Menu}
        \li \l [QML QtLabsPlatform] {Menu} \br\sup {(Qt Labs Platform)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c Menu is native on platforms where an
                    implementation is available in the Qt Platform Abstraction Layer.
                    Other platforms use a QML-based top-level menu popup window. \c Menu
                    supports traditional desktop style cascading submenus, but does not
                    work on Embedded Linux because \l EGLFS does not support multiple
                    top-level windows.
                \li \b {Qt Quick Controls 2}: \c Menu is a non-native \c Item-based popup
                    that is stacked above the application content. Due to this, menu popups
                    are restricted within window boundaries. \c Menu is fully customizable
                    using QML and Qt Quick, and allows adding any \c Items. Traditional
                    desktop oriented features, such as cascading submenus and visualizing
                    keyboard shortcuts are missing.
                \li \b {Qt Labs Platform}: \c Menu is an \e experimental native menu that
                    uses Qt Widgets as a fallback on platforms where a native implementation
                    is not available in the Qt Platform Abstraction Layer.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {MenuBar}
        \li \l [QML QtQuickControls2] {MenuBar}
        \li \l [QML QtLabsPlatform] {MenuBar} \br\sup {(Qt Labs Platform)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c MenuBar is native on platforms where an
                    implementation is available in the Qt Platform Abstraction Layer. Other
                    platforms use a QML-based menubar item stacked at the top of the window.
                \li \b {Qt Quick Controls 2}: \c MenuBar is a non-native QML-based menubar
                    that can be fully customized using QML and Qt Quick.
                \li \b {Qt Labs Platform}: \c MenuBar is an \e experimental native menubar.
                    It is only available on platforms where a native implementation is available
                    in the Qt Platform Abstraction Layer.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {MenuItem},\br
            \l [QML QtQuickControls1] {MenuSeparator}
        \li \l [QML QtQuickControls2] {MenuItem},\br
            \l [QML QtQuickControls2] {MenuSeparator}
        \li \l [QML QtLabsPlatform] {MenuItem},\br
            \l [QML QtLabsPlatform] {MenuSeparator} \br\sup {(Qt Labs Platform)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c MenuItem and \c MenuSeparator are native
                    on platforms where an implementation is available in the Qt Platform
                    Abstraction Layer. Other platforms use QML-based menu items and separators.
                \li \b {Qt Quick Controls 2}: \c MenuItem and \c MenuSeparator are a non-native
                    QML-based menu items and separators that can be fully customized using QML
                    and Qt Quick.
                \li \b {Qt Labs Platform}: \c MenuItem and \c MenuSeparator are \e experimental
                    native menu items and separators.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {ProgressBar}
        \li \l [QML QtQuickControls2] {ProgressBar}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {RadioButton}
        \li \l [QML QtQuickControls2] {RadioButton}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {ScrollView}
        \li \l [QML QtQuickControls2] {ScrollView}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {Slider}
        \li \l [QML QtQuickControls2] {Slider}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {SpinBox}
        \li \l [QML QtQuickControls2] {SpinBox}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {SplitView}
        \li \l [QML QtQuickControls2] {SplitView}
        \li
        \li \list
                \li \b {Qt Quick Controls 1}: Uses \l Layout attached properties
                    to specify size hints.
                \li \b {Qt Quick Controls 2}: Uses dedicated
                    \l [QML QtQuickControls2] {SplitView} attached properties
                    to specify size hints.
                    Allows \l {SplitView::saveState()}{saving} and
                    \l {SplitView::restoreState()}{restoring} state.
                    Separate attached \l SplitHandle API for managing split
                    handles.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {StackView},\br
            \l [QML QtQuickControls1] {StackViewDelegate},\br
            \l [QML QtQuickControls1] {Stack}
        \li \l [QML QtQuickControls2] {StackView}
        \li
        \li \list
                \li \b {Qt Quick Controls 2}: \c StackView provides customizable transitions
                    and attached properties via a single \c StackView type.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {StatusBar}
        \li \mdash
        \li \l [QML QtQuickControls2] {ToolBar} \br\sup {(Qt Quick Controls 2)}
        \li \list
                \li \b {Qt Quick Controls 2}: \c ApplicationWindow allows assigning any
                    item or control, such as \c ToolBar, as a header or footer.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {Switch}
        \li \l [QML QtQuickControls2] {Switch}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {TabView},\br
            \l [QML QtQuickControls1] {Tab}
        \li \mdash
        \li \l [QML QtQuickControls2] {TabBar},\br
            \l [QML QtQuickControls2] {TabButton} \br\sup {(Qt Quick Controls 2)}
        \li \list
                \li \b {Qt Quick Controls 2}: \c TabBar and \c TabButton offer similar
                    functionality, and can be used to build tabbed views.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {TableView}
        \li \mdash
        \li The new \l [QML QtQuick] {TableView} can be found in the Qt Quick
            module.
        \li
    \row
        \li \l [QML QtQuickControls1] {TextArea}
        \li \l [QML QtQuickControls2] {TextArea}
        \li
        \li \list
                \li \b {Qt Quick Controls 1}: \c TextArea inherits \c ScrollView and is therefore
                    always a scrollable editor.
                \li \b {Qt Quick Controls 2}: \c TextArea is a simpler multi-line editor that can
                    be optionally attached to a \c Flickable to provide scrolling functionality.
                    This allows using \c TextArea in a scrollable page without having two nested
                    scrollable areas, which can be problematic and cause usability issues.
            \endlist
    \row
        \li \l [QML QtQuickControls1] {TextField}
        \li \l [QML QtQuickControls2] {TextField}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {ToolBar}
        \li \l [QML QtQuickControls2] {ToolBar}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {ToolButton}
        \li \l [QML QtQuickControls2] {ToolButton}
        \li
        \li
    \row
        \li \l [QML QtQuickControls1] {TreeView}
        \li \mdash
        \li
        \li

    \header
        \li Qt Quick Dialogs
        \li Qt Quick Controls 2
        \li Alternatives
        \li Remarks
    \row
        \li \l [QML QtQuickDialogs] {Dialog}
        \li \mdash
        \li \l [QML QtQuickControls2] {Dialog}
        \li \list
                \li \b {Qt Quick Dialogs}: \c Dialog is either a top-level window or an \c Item-based popup
                    depending on whether the underlying platform supports multiple top-level windows.
                \li \b {Qt Quick Controls 2}: \c Dialog is not a top-level window, but an \c Item-based
                    popup that is stacked above the application content. Due to this, dialogs are restricted
                    within window boundaries.
            \endlist
    \row
        \li \l [QML QtQuickDialogs] {ColorDialog},\br
            \l [QML QtQuickDialogs] {FileDialog},\br
            \l [QML QtQuickDialogs] {FontDialog},\br
            \l [QML QtQuickDialogs] {MessageDialog}
        \li \mdash
        \li \l [QML QtLabsPlatform] {ColorDialog},\br
            \l [QML QtLabsPlatform] {FileDialog},\br
            \l [QML QtLabsPlatform] {FolderDialog},\br
            \l [QML QtLabsPlatform] {FontDialog},\br
            \l [QML QtLabsPlatform] {MessageDialog} \br\sup {(Qt Labs Platform)}
        \li \list
                \li \b {Qt Quick Dialogs}: Dialogs are native on platforms where an implementation
                    is available in the Qt Platform Abstraction Layer. Other platforms use either
                    Qt Widgets or QML-based dialogs depending on whether the underlying platform
                    supports multiple top-level windows.
                \li \b {Qt Labs Platform}: \e Experimental native dialogs that use Qt Widgets as
                    a fallback on platforms where a native implementation is not available in the
                    Qt Platform Abstraction Layer.
            \endlist

    \header
        \li Qt Quick Extras
        \li Qt Quick Controls 2
        \li Alternatives
        \li Remarks
    \row
        \li \l [QML QtQuickExtras] {CircularGauge}
        \li \mdash
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {DelayButton}
        \li \l [QML QtQuickControls2] {DelayButton}
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {Dial}
        \li \l [QML QtQuickControls2] {Dial}
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {Gauge}
        \li \mdash
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {Picture}
        \li \mdash
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {PieMenu}
        \li \mdash
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {StatusIndicator}
        \li \mdash
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {ToggleButton}
        \li \mdash
        \li
        \li
    \row
        \li \l [QML QtQuickExtras] {Tumbler},\br
            \l [QML QtQuickExtras] {TumblerColumn}
        \li \l [QML QtQuickControls2] {Tumbler}
        \li
        \li \list
                \li \b {Qt Quick Extras}: \c Tumbler can consist of multiple columns.
                \li \b {Qt Quick Controls 2}: \c Tumbler presents a single spinnable wheel.
                    Multiple columns can be created by placing multiple \c Tumblers next
                    to each other.
            \endlist

    \header
        \li No Predecessor
        \li Qt Quick Controls 2
        \li Alternatives
        \li Remarks
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {AbstractButton}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {ActionGroup}
        \li \l [QML QtQuickControls1] {ExclusiveGroup} \br\sup {(Qt Quick Controls 1)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c ExclusiveGroup offers similar functionality.
            \endlist
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {ButtonGroup}
        \li \l [QML QtQuickControls1] {ExclusiveGroup} \br\sup {(Qt Quick Controls 1)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c ExclusiveGroup offers similar functionality.
            \endlist
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {CheckDelegate}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Container}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Control}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Drawer}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Frame}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {ItemDelegate}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Page}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {PageIndicator}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Pane}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {Popup}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {RadioDelegate}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {RangeSlider}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {RoundButton}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {ScrollBar},\br
            \l [QML QtQuickControls2] {ScrollIndicator}
        \li \l [QML QtQuickControls1] {ScrollView} \br\sup {(Qt Quick Controls 1)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c ScrollView offers similar functionality.
                    It combines horizontal and vertical scrollbars, and the background and
                    frame around the scrollable view.
            \endlist
    \row
        \li \mdash
        \li \mdash
        \li \l [QML QtLabsPlatform] {StandardPaths} \br\sup {(Qt Labs Platform)}
        \li \list
                \li \b {Qt Quick Dialogs}: \c FileDialog offers a shortcut property that can be used
                    to access the most common standard paths.
                \li \b {Qt Labs Platform}: \c StandardPaths offers a separate type to give full access
                    to the standard paths.
            \endlist
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {SwipeDelegate}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {SwipeView}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {SwitchDelegate}
        \li
        \li
    \row
        \li \mdash
        \li \mdash
        \li \l [QML QtLabsPlatform] {SystemTrayIcon} \br\sup {(Qt Labs Platform)}
        \li \list
                \li \b {Qt Labs Platform}: \c SystemTrayIcon is an \e experimental native
                    system tray icon that uses Qt Widgets as a fallback on platforms where
                    a native implementation is not available in the Qt Platform Abstraction
                    Layer.
            \endlist
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {TabBar},\br
            \l [QML QtQuickControls2] {TabButton}
        \li \l [QML QtQuickControls1] {TabView} \br\sup {(Qt Quick Controls 1)}
        \li \list
                \li \b {Qt Quick Controls 1}: \c TabView offers similar functionality.
                    It combines the tab bar, background and frame around the tabs.
            \endlist
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {ToolSeparator}
        \li
        \li
    \row
        \li \mdash
        \li \l [QML QtQuickControls2] {ToolTip}
        \li
        \li \list
                \li \b {Qt Quick Controls 1}: \c Button and \c Action have built-in
                    Qt Widgets-based tooltips.
                \li \b {Qt Quick Controls 2}: \c ToolTip can be attached to any \c Item.
            \endlist
    \endtable

    \section1 Related Information

    \list
      \li \l{Qt Quick}
      \li \l{Qt Quick Controls 2 QML Types}
      \li \l{Qt Quick Controls 1 QML Types}
      \li \l{Qt Quick Extras QML Types}
      \li \l{Qt Labs Calendar QML Types}
      \li \l{Qt Labs Platform QML Types}
    \endlist
*/