// Copyright (C) 2017 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only

/*!
    \page qtquickcontrols-customize.html
    \keyword Customizing Qt Quick Controls 2
    \title Customizing Qt Quick Controls
    \brief A set of UI controls to create user interfaces in Qt Quick

    Qt Quick Controls consist of a hierarchy (tree) of items. In order to
    provide a custom look and feel, the default QML implementation of each
    item can be replaced with a custom one.

    \section1 Customizing a Control

    Sometimes you'll want to create a "one-off" look for a specific part of
    your UI, and use a complete style everywhere else. Perhaps you're happy
    with the style you're using, but there's a certain button that has some
    special significance.

    The first way to create this button is to simply define it in-place,
    wherever it is needed. For example, perhaps you're not satisfied with the
    Basic style's Button having square corners. To make them rounded, you
    can override the \l {Control::}{background} item and set the radius
    property of Rectangle:

    \include customize-button-background.qdocinc file

    \note as the different items that make up a control in any given style are
    designed to work together, it may be necessary to override other items to
    get the look you're after. In addition, not all styles can be customized.
    See the note in \l {Customization Reference} for more information.

    The second way to create the button is good if you plan to use your rounded
    button in several places. It involves moving the code into its own QML file
    within your project.

    For this approach, we'll copy the background code from the Basic style's
    \c Button.qml. This file can be found in the following path in your Qt
    installation:

    \c {$QTDIR/qml/QtQuick/Controls/Basic/Button.qml}

    After doing that, we'll simply add the following line:

    \code
    radius: 4
    \endcode

    To avoid confusion with the controls in the
    module itself, we'll call the file \c MyButton.qml. To use the control in
    your application, refer to it by its filename:

    \qml
    import QtQuick.Controls.Basic

    ApplicationWindow {
        MyButton {
            text: qsTr("A Special Button")
        }
    }
    \endqml

    The third way to create the button is a bit more structured, both in terms
    of where the file sits in the file system and how it is used in QML. First,
    copy an existing file as you did above, but this time, put it into a
    subfolder in your project named (for example) \c controls. To use the
    control, first import the folder into a namespace:

    \qml
    import QtQuick.Controls.Basic
    import "controls" as MyControls

    ApplicationWindow {
        MyControls.Button {
            text: qsTr("A Special Button")
        }
    }
    \endqml

    As you now have the \c MyControls namespace, you can name the controls after
    their actual counterparts in the Qt Quick Controls module. You can repeat
    this process for any control that you wish to add.

    An added benefit of these three methods is that it's not necessary to
    implement the template from scratch.

    \note the three approaches mentioned here do not work for customizing the
    attached \l ToolTip, as that is a shared item created internally. To do
    a one-off customization of a \c ToolTip, see \l {Custom Tool Tips}. To
    customize the attached \c ToolTip, it must be provided as part of
    \l {Creating a Custom Style}{your own style}.

    \section1 Creating a Custom Style

    There are several ways to go about creating your own styles. Below, we'll
    explain the various approaches.

    \section2 Definition of a Style

    In Qt Quick Controls, a style is essentially a set of QML files within a
    single directory. There are four requirements for a style to be
    \l {Using Styles in Qt Quick Controls}{usable}:

    \list
    \li At least one QML file whose name matches a control (for example,
        \c Button.qml) must exist.
    \li Each QML file must contain the relevant type from the \l {Qt Quick Templates 2}
        {QtQuick.Templates} import as the root item. For example,
        Button.qml must contain a Button template as its root item.

        If we instead used the corresponding type from the \l {Qt Quick Controls}
        {QtQuick.Controls} import as we did in the previous section, it would not work:
        the control we were defining would try to derive from itself.
    \li A \l {Module Definition qmldir Files}{qmldir} file must exist alongside
        the QML file(s). Below is an example of a simple \c qmldir file for a style that
        provides a button:

        \badcode
        module MyStyle
        Button 2.15 Button.qml
        \endcode

        If you're using \l {Compile-Time Style Selection}{compile-time style
        selection}, the qmldir should also import the fallback style:

        \badcode
        # ...
        import QtQuick.Controls.Basic auto
        \endcode

        This can also be done for \l {Run-Time Style Selection}{run-time style selection}
        instead of using, for example, \l QQuickStyle::setFallbackStyle().

        The directory structure for such a style looks like this:

        \badcode
        MyStyle
        ├─── Button.qml
        └─── qmldir
        \endcode
    \li The files must be in a directory that is findable via the \l[QtQml]{QML Import Path}.

        For example, if the path to \e MyStyle directory mentioned above was
        \c /home/user/MyApp/MyStyle, then \c /home/user/MyApp must be added to
        the QML import path.

        To \l {Using Styles in Qt Quick Controls}{use} \e MyStyle in \e MyApp,
        refer to it by name:

        \list
        \li \c {./MyApp -style MyStyle}
        \endlist

        The style name must match the casing of the style directory; passing
        \e mystyle or \e MYSTYLE is not supported.
    \endlist

    By default, the styling system uses the Basic style as a fallback for
    controls that aren't implemented. To customize or extend any other built-in
    style, it is possible to specify a different fallback style using
    \l[QtQuickControls2]{QQuickStyle}.

    What this means is that you can implement as many controls as you like for
    your custom style, and place them almost anywhere. It also allows users to
    create their own styles for your application.

    \section3 Previewing Custom Styles in Qt Quick Designer

    Using the approach above, it is possible to preview a custom style
    in Qt Quick Designer. In order to do so,
    ensure that the project has a
    \l {Qt Quick Controls Configuration File}{qtquickcontrols2.conf} file,
    and that the following entry exists:

    \badcode
    [Controls]
    Style=MyStyle
    \endcode

    For more information, take a look at the
    \l {Qt Quick Controls - Flat Style}{Flat Style example}.

    \section2 Style-specific C++ Extensions

    Sometimes you may need to use C++ to extend your custom style.

    \list
    \li If the style that uses the type is the only style used by an
    application, register the type with the QML engine by adding the QML_ELEMENT
    macro and making the file part of your QML module:
    \br
    \br

    \if defined(onlinedocs)
        \tab {expose-cpp-to-qml}{tab-cmake}{CMake}{checked}
        \tab {expose-cpp-to-qml}{tab-qmake}{qmake}{}
        \tabcontent {tab-cmake}
    \else
        \section3 Using CMake
    \endif
        \badcode
        qt_add_qml_module(ACoolItem
            URI MyItems
            VERSION 1.0
            SOURCES
                acoolcppitem.cpp acoolcppitem.h
        )
        \endcode
    \if defined(onlinedocs)
        \endtabcontent
        \tabcontent {tab-qmake}
    \else
        \section3 Using QMake
    \endif
        \code
        CONFIG += qmltypes
        QML_IMPORT_NAME = MyItems
        QML_IMPORT_MAJOR_VERSION = 1
        \endcode

        If the header the class is declared in is not accessible from your
        project's include path, you may have to amend the include path so
        that the generated registration code can be compiled.

        \code
        INCLUDEPATH += MyItems
        \endcode
    \if defined(onlinedocs)
        \endtabcontent
    \endif

        See \l {Defining QML Types from C++} and \l {Building a QML application}
        for more information.
    \li If the style that uses the type is one of many styles used by an
        application, consider putting each style into a separate module. The
        modules will then be loaded on demand.
    \endlist

    \section3 Considerations for custom styles

    When implementing your own style and customizing controls, there are some
    points to keep in mind to ensure that your application is as performant as
    possible.

    \section4 Avoid assigning an id to styles' implementations of item delegates

    As explained in \l {Definition of a Style}, when you implement your
    own style for a control, you start off with the relevant template for
    that control. For example, a style's \c Button.qml will be structured
    similarly to this:

    \qml
    T.Button {
        // ...

        background: Rectangle {
            // ...
        }

        contentItem: Text {
            // ...
        }

        // ...
    }
    \endqml

    When you use a Button in your application, the \c background and
    \c contentItem items will be created and parented to the root \c Button
    item:

    \qml
    // Creates the Button root item, the Rectangle background,
    // and the Text contentItem.
    Button {
        text: qsTr("Confirm")
    }
    \endqml

    Suppose you then needed to do a one-off customization of the Button (as
    explained in \l {Customizing a Control}):

    \include customize-button-background.qdocinc file

    In QML, this would normally result in both the default \c background
    implementation and the one-off, custom \c background items being created.
    Qt Quick Controls uses a technique that avoids creating both items, and
    instead only creates the custom \c background, greatly improving the
    creation performance of controls.

    This technique relies on the absence of an \l {The id Attribute}{id} in the
    style's implementation of that item. If an id is assigned, the technique
    cannot work, and both items will be created. For example, it can be
    tempting to assign an id to the \c background or \c contentItem so that
    other objects within the file can refer to those items:

    \qml
    T.Button {
        // ...

        background: Rectangle {
            id: backgroundRect
            // ...
        }

        contentItem: Text {
            // Use backgroundRect in some way...
        }

        // ...
    }
    \endqml

    With this code, every time a Button instance with a customized background
    is created, both backgrounds will be created, resulting in sub-optimal
    creation performance.

    Prior to Qt 5.15, the old, unused background would be deleted to release
    the resources associated with it. However, as the control does not own the
    items, it should not delete them. As of Qt 5.15, old items are no longer
    deleted, and so the \c backgroundRect item will live longer than it needs
    to—typically until the application exits. Although the old item will be
    hidden, visually unparented from the control, and removed from the
    accessibility tree, it is important to keep the creation time and memory
    usage of these unused items in mind when assigning an id in this context.

    \section4 Avoid imperative assignments of custom items

    The technique mentioned in the section above only works when an item is
    \l {Prefer Declarative Bindings Over Imperative Assignments}{declaratively}
    assigned for the first time, and so imperative assignments will result in
    orphaned items. Always use declarative bindings to assign custom items
    when possible.

    \section4 Don't import QtQuick.Controls in QML implementations

    When writing the QML for your style's implementation of a control,
    it's important not to import \c {QtQuick.Controls}. Doing so will
    prevent the QML from being compiled by the QML compiler.

    \section4 Implement types used by other types

    Suppose you were using ScrollViews in your application, and decided that
    you want to customize their scroll bars. It is tempting to just implement a
    custom ScrollBar.qml and have ScrollView pick up the customized ScrollBar
    automatically. However, this will not work. You must implement both
    ScrollBar.qml \e and ScrollView.qml.

    \section3 Attached properties

    It is common for a style to have certain properties or attributes that
    apply to all controls. \l {Attached Properties and Attached Signal
    Handlers}{Attached properties} are a great way of extending an item in QML
    without having to modify any existing C++ belonging to that item. For
    example, both the \l {Material Style}{Material} and \l {Universal
    Style}{Universal} styles have an attached theme property that controls
    whether an item and its children will be rendered in a light or dark theme.

    As an example, let's add an attached property that controls elevation. Our
    style will illustrate the elevation with a drop shadow; the higher the
    elevation, the larger the shadow.

    The first step is to \l {\QC: Create Qt Quick Applications}
    {create a new Qt Quick Controls application} in \QC. After that, we
    \l {\QC: Create C++ classes}{add a C++ type} that stores the elevation. Since
    the type will be used for every control supported by our style, and because
    we may wish to add other attached properties later on, we'll call it
    MyStyle. Here is \c MyStyle.h:

    \code
    #ifndef MYSTYLE_H
    #define MYSTYLE_H

    #include <QObject>
    #include <QtQml>

    class MyStyle : public QObject
    {
        Q_OBJECT
        Q_PROPERTY(int elevation READ elevation WRITE setElevation NOTIFY elevationChanged)

    public:
        explicit MyStyle(QObject *parent = nullptr);

        static MyStyle *qmlAttachedProperties(QObject *object);

        int elevation() const;
        void setElevation(int elevation);

    signals:
        void elevationChanged();

    private:
        int m_elevation;
    };

    QML_DECLARE_TYPEINFO(MyStyle, QML_HAS_ATTACHED_PROPERTIES)

    #endif // MYSTYLE_H
    \endcode

    \c MyStyle.cpp:

    \code
    #include "mystyle.h"

    MyStyle::MyStyle(QObject *parent) :
        QObject(parent),
        m_elevation(0)
    {
    }

    MyStyle *MyStyle::qmlAttachedProperties(QObject *object)
    {
        return new MyStyle(object);
    }

    int MyStyle::elevation() const
    {
        return m_elevation;
    }

    void MyStyle::setElevation(int elevation)
    {
        if (elevation == m_elevation)
            return;

        m_elevation = elevation;
        emit elevationChanged();
    }
    \endcode

    The \c MyStyle type is special in the sense that it shouldn't be
    instantiated, but rather used for its attached properties. For that reason,
    we register it in the following manner in \c main.cpp:

    \code
    #include <QGuiApplication>
    #include <QQmlApplicationEngine>

    #include "mystyle.h"

    int main(int argc, char *argv[])
    {
        QGuiApplication app(argc, argv);

        qmlRegisterUncreatableType<MyStyle>("MyStyle", 1, 0, "MyStyle", "MyStyle is an attached property");

        QQmlApplicationEngine engine;
        // Make the directory containing our style known to the QML engine.
        engine.addImportPath(":/");
        engine.load(QUrl(QLatin1String("qrc:/main.qml")));

        return app.exec();
    }
    \endcode

    We then copy \c Button.qml from the Basic style in
    \c {$QTDIR/qml/QtQuick/Controls/Basic/} into a new \c myproject folder in our
    project directory. Add the newly copied \c Button.qml to \c qml.qrc, which is
    the resource file that contains our QML files.

    Next, we add a drop shadow to the \l {Control::}{background} delegate of
    the Button:

    \qml
    // ...
    import QtQuick.Effects
    import MyStyle
    // ...

    background: Rectangle {
        // ...

        layer.enabled: control.enabled && control.MyStyle.elevation > 0
        layer.effect: MultiEffect {
            shadowEnabled: true
            shadowHorizontalOffset: 3
            shadowVerticalOffset: 3
            shadowColor: control.visualFocus ? "#330066ff" : "#aaaaaa"
            shadowBlur: control.pressed ? 0.8 : 0.4
        }
    }
    \endqml

    Note that we:

    \list
    \li Don't bother using the drop shadow when the elevation is \c 0
    \li Change the shadow's color depending on whether or not the button has
        focus
    \li Make the size of the shadow depend on the elevation
    \endlist

    To try out the attached property, we create a \l Row with two Buttons in
    \c main.qml:

    \qml
    import QtQuick
    import QtQuick.Controls

    import MyStyle 1.0

    ApplicationWindow {
        id: window
        width: 400
        height: 400
        visible: true

        Row {
            spacing: 20
            anchors.centerIn: parent

            Button {
                text: "Button 1"
            }
            Button {
                text: "Button 2"
                MyStyle.elevation: 10
            }
        }
    }
    \endqml

    One button has no elevation, and the other has an elevation of \c 10.

    With that in place, we can run our example. To tell the application to
    use our new style, we pass \c {-style MyStyle} as an application
    argument, but there are \l {Using Styles in Qt Quick Controls}{many
    ways} to specify the style to use.

    The end result:

    \image qtquickcontrols-customize-buttons.png
           {Custom styled buttons}

    Note that the \c {import MyStyle 1.0} statement is only necessary
    because we are using the attached property belonging to \c MyStyle.
    Both buttons will use our custom style, even if we were to remove the
    import.

    \section1 Customization Reference

    The following snippets present examples where the Basic style's controls
    have been customized using the same approach as the
    \l {Customizing a Control} section. The code can be used as a starting
    point to implement a custom look and feel.

    \note The \l {macOS Style}{macOS} and \l {Windows Style}{Windows} styles
    are not suitable for customizing.
    \include customizing-native-styles.qdocinc

    \section2 Customizing ApplicationWindow

        ApplicationWindow consists of one visual item:
        \l {ApplicationWindow::background}{background}.

        \code
        import QtQuick
        import QtQuick.Controls.Basic

        ApplicationWindow {
            visible: true

            background: Rectangle {
                gradient: Gradient {
                    GradientStop { position: 0; color: "#ffffff" }
                    GradientStop { position: 1; color: "#c1bbf9" }
                }
            }
        }
        \endcode


    \section2 Customizing BusyIndicator

        BusyIndicator consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-busyindicator-custom.png
               {Custom styled busy indicator}

        \snippet qtquickcontrols-busyindicator-custom.qml file


    \section2 Customizing Button

        Button consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-button-custom.png
               {Custom styled button}

        \snippet qtquickcontrols-button-custom.qml file


    \section2 Customizing CheckBox

        CheckBox consists of three visual items: \l {Control::background}{background},
        \l {Control::}{contentItem} and \l {AbstractButton::indicator}{indicator}.

        \image qtquickcontrols-checkbox-custom.png
               {Custom styled checkbox}

        \snippet qtquickcontrols-checkbox-custom.qml file

    \section2 Customizing CheckDelegate

        CheckDelegate consists of three visual items: \l {Control::background}{background},
        \l {Control::}{contentItem} and \l {AbstractButton::indicator}{indicator}.

        \image qtquickcontrols-checkdelegate-custom.png
               {Custom styled check delegate}

        \snippet qtquickcontrols-checkdelegate-custom.qml file


    \section2 Customizing ComboBox

        ComboBox consists of \l {Control::background}{background},
        \l {Control::}{contentItem}, \l {ComboBox::popup}{popup},
        \l {ComboBox::indicator}{indicator}, and \l {ComboBox::delegate}{delegate}.

        \image qtquickcontrols-combobox-custom.png
               {Custom styled combo box}

        \snippet qtquickcontrols-combobox-custom.qml file

        As explained in \l {ComboBox Model Roles}, ComboBox supports multiple
        types of models.

        Since \l {qml-data-models}{all the models provide an anonymous property}
        with \c modelData, the following expression retrieves the right text in
        all cases:

        \code
        text: model[control.textRole]
        \endcode

        When you provide a specific \c textRole and a model with structured
        data that provides the selected role, this is expression is a regular
        property lookup. When you provide a model with singular data, such as
        a list of strings, and an empty \c textRole, this expression retrieves
        the \c modelData.

    \section2 Customizing DelayButton

        DelayButton consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-delaybutton-custom.png
               {Custom styled delay button}

        \snippet qtquickcontrols-delaybutton-custom.qml file


    \section2 Customizing Dial

        Dial consists of two visual items: \l {Control::background}{background}
        and \l {Dial::handle}{handle}.

        \image qtquickcontrols-dial-custom.png
               {Custom styled dial}

        \snippet qtquickcontrols-dial-custom.qml file


    \section2 Customizing Drawer

        Drawer can have a visual \l {Control::background}{background}
        item.

        \code
        background: Rectangle {
            Rectangle {
                x: parent.width - 1
                width: 1
                height: parent.height
                color: "#21be2b"
            }
        }
        \endcode


    \section2 Customizing Frame

        Frame consists of one visual item: \l {Control::background}{background}.

        \image qtquickcontrols-frame-custom.png
               {Custom styled frame}

        \snippet qtquickcontrols-frame-custom.qml file


    \section2 Customizing GroupBox

        GroupBox consists of two visual items: \l {Control::background}{background}
        and \l {GroupBox::label}{label}.

        \image qtquickcontrols-groupbox-custom.png
               {Custom styled group box}

        \snippet qtquickcontrols-groupbox-custom.qml file


    \section2 Customizing ItemDelegate

        ItemDelegate consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-itemdelegate-custom.png
               {Custom styled item delegate}

        \snippet qtquickcontrols-itemdelegate-custom.qml file


    \section2 Customizing Label

        Label can have a visual \l {Label::background}{background} item.

        \image qtquickcontrols-label-custom.png
               {Custom styled label}

        \snippet qtquickcontrols-label-custom.qml file


    \section2 Customizing Menu

        \list
            \li \l Menu consists of a visual \l {Popup::background}{background} item.
            \li \l MenuItem consists of four visual items: \l {Control::background}{background},
                \l {Control::}{contentItem}, \l {AbstractButton::}{indicator}, and
                \l {MenuItem::}{arrow}.
            \li \l MenuSeparator consists of a visual \l {Control::background}{background} and
                \l {Control::}{contentItem}.
        \endlist

        \image qtquickcontrols-menu-custom.png
               {Custom styled menu}

        \quotefromfile qtquickcontrols-menu-custom.qml
        \skipto import QtQuick
        \printuntil import QtQuick.Controls.Basic
        \skipto Menu
        \printto eof


    \section2 Customizing MenuBar

        MenuBar can have a visual \l {Control::background}{background} item,
        and MenuBarItem consists of two visual items: \l {Control::background}
        {background} and \l {Control::}{contentItem}.

        \image qtquickcontrols-menubar-custom.png
               {Custom styled menu bar with File and Edit menus}

        \quotefromfile qtquickcontrols-menubar-custom.qml
        \skipto import QtQuick
        \printuntil import QtQuick.Controls.Basic
        \skipto MenuBar
        \printto eof


    \section2 Customizing PageIndicator

        PageIndicator consists of a \l {Control::background}{background}, \l {Control::}{contentItem}, and \l {PageIndicator::delegate}{delegate}.

        \image qtquickcontrols-pageindicator-custom.png
               {Custom styled page indicator showing multiple pages}

        \snippet qtquickcontrols-pageindicator-custom.qml file


    \section2 Customizing Pane

        Pane consists of a \l {Control::background}{background}.

        \image qtquickcontrols-pane-custom.png
               {Custom styled pane with decorative background}

        \snippet qtquickcontrols-pane-custom.qml file


    \section2 Customizing Popup

        Popup consists of a \l {Popup::background}{background} and
        \l {Popup::contentItem}{contentItem}.

        \image qtquickcontrols-popup-custom.png
               {Custom styled popup with border and shadow}

        \quotefromfile qtquickcontrols-popup-custom.qml
        \skipto import QtQuick
        \printuntil import QtQuick.Controls.Basic
        \codeline
        \skipto Popup
        \printuntil {
        \printuntil }
        \printuntil }
        \printuntil }


    \section2 Customizing ProgressBar

        ProgressBar consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-progressbar-custom.png
               {Custom styled progress bar showing partial completion}

        \snippet qtquickcontrols-progressbar-custom.qml file

        Above, the contentItem is also animated to represent an
        \l {ProgressBar::}{indeterminate} progress bar state.


    \section2 Customizing RadioButton

        RadioButton consists of three visual items: \l {Control::background}{background},
        \l {Control::}{contentItem} and \l {AbstractButton::indicator}{indicator}.

        \image qtquickcontrols-radiobutton-custom.png
               {Custom styled radio button in selected state}

        \snippet qtquickcontrols-radiobutton-custom.qml file


    \section2 Customizing RadioDelegate

        RadioDelegate consists of three visual items: \l {Control::background}{background},
        \l {Control::}{contentItem} and \l {AbstractButton::indicator}{indicator}.

        \image qtquickcontrols-radiodelegate-custom.png
               {Custom styled radio delegate in list}

        \snippet qtquickcontrols-radiodelegate-custom.qml file


    \section2 Customizing RangeSlider

        RangeSlider consists of three visual items:
        \l {Control::background}{background},
        \l {RangeSlider::first}{first.handle} and
        \l {RangeSlider::second.handle}{second.handle}.

        \image qtquickcontrols-rangeslider-custom.png
               {Custom styled range slider}

        \snippet qtquickcontrols-rangeslider-custom.qml file


    \section2 Customizing RoundButton

        RoundButton can be customized in the same manner as
        \l {Customizing Button}{Button}.


    \section2 Customizing ScrollBar

        ScrollBar consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-scrollbar-custom.png
               {Custom styled scroll bar}

        \snippet qtquickcontrols-scrollbar-custom.qml file


    \section2 Customizing ScrollIndicator

        ScrollIndicator consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-scrollindicator-custom.png
               {Custom styled scroll indicator}

        \snippet qtquickcontrols-scrollindicator-custom.qml file


    \section2 Customizing ScrollView

        ScrollView consists of a \l {Control::background}{background} item,
        and horizontal and vertical scroll bars.

        \image qtquickcontrols-scrollview-custom.png
               {Custom styled scroll view}

        \snippet qtquickcontrols-scrollview-custom.qml file


    \section2 Customizing Slider

        Slider consists of two visual items: \l {Control::background}{background},
        and \l {Slider::handle}{handle}.

        \image qtquickcontrols-slider-custom.png
               {Custom styled slider}

        \snippet qtquickcontrols-slider-custom.qml file


    \section2 Customizing SpinBox

        SpinBox consists of four visual items: \l {Control::background}{background},
        \l {Control::}{contentItem}, \l {SpinBox::up.indicator}{up indicator},
        and \l {SpinBox::down.indicator}{down indicator}.

        \image qtquickcontrols-spinbox-custom.png
               {Custom styled spin box}

        \snippet qtquickcontrols-spinbox-custom.qml file


    \section2 Customizing SplitView

        SplitView consists of a visual \l {SplitView::handle}{handle} delegate.

        \image qtquickcontrols-splitview-custom.png
               {Custom styled split view}

        \snippet qtquickcontrols-splitview-custom.qml 1


    \section2 Customizing StackView

        StackView can have a visual \l {Control::background}{background}
        item, and it allows customizing the transitions that are used for
        push, pop, and replace operations.

        \snippet qtquickcontrols-stackview-custom.qml file


    \section2 Customizing SwipeDelegate

        SwipeDelegate consists of six visual items: \l {Control::background}{background},
        \l {Control::}{contentItem}, \l {AbstractButton::indicator}{indicator},
        \c swipe.left, \c swipe.right, and \c swipe.behind.

        \image qtquickcontrols-swipedelegate-custom.png
               {Custom styled swipe delegate}

        \snippet qtquickcontrols-swipedelegate-custom.qml file


    \section2 Customizing SwipeView

        SwipeView can have a visual \l {Control::background}{background}
        item. The navigation is implemented by the \l {Control::}{contentItem}.

        \snippet qtquickcontrols-swipeview-custom.qml file


    \section2 Customizing Switch

        Switch consists of three visual items: \l {Control::background}{background},
        \l {Control::}{contentItem} and \l {AbstractButton::indicator}{indicator}.

        \image qtquickcontrols-switch-custom.png
               {Custom styled switch}

        \snippet qtquickcontrols-switch-custom.qml file

    \section2 Customizing SwitchDelegate

        SwitchDelegate consists of three visual items: \l {Control::background}{background},
        \l {Control::}{contentItem} and \l {AbstractButton::indicator}{indicator}.

        \image qtquickcontrols-switchdelegate-custom.png
               {Custom styled switch delegate}

        \snippet qtquickcontrols-switchdelegate-custom.qml file


    \section2 Customizing TabBar

        TabBar consists of two visual items: \l {Control::background}{background},
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-tabbar-custom.png
               {Custom styled tab bar}

        \snippet qtquickcontrols-tabbar-custom.qml file


    \section2 Customizing TabButton

        TabButton can be customized in the same manner as
        \l {Customizing Button}{Button}.


    \section2 Customizing TextArea

        TextArea consists of a \l {TextArea::background}{background} item.

        \image qtquickcontrols-textarea-custom.png
               {Custom styled text area}

        \snippet qtquickcontrols-textarea-custom.qml file


    \section2 Customizing TextField

        TextField consists of a \l {TextField::background}{background} item.

        \image qtquickcontrols-textfield-custom.png
               {Custom styled text field}

        \snippet qtquickcontrols-textfield-custom.qml file


    \section2 Customizing ToolBar

        ToolBar consists of one visual item: \l {Control::background}{background}.

        \image qtquickcontrols-toolbar-custom.png
               {Custom styled tool bar}

        \snippet qtquickcontrols-toolbar-custom.qml file


    \section2 Customizing ToolButton

        ToolButton consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-toolbutton-custom.png
               {Custom styled tool button}

        \snippet qtquickcontrols-toolbutton-custom.qml file


    \section2 Customizing ToolSeparator

        ToolSeparator consists of two visual items: \l {Control::background}{background}
        and \l {Control::}{contentItem}.

        \image qtquickcontrols-toolseparator-custom.png
               {Custom styled tool separator}

        \snippet qtquickcontrols-toolseparator-custom.qml file


    \section2 Customizing ToolTip

        ToolTip consists of two visual items: \l {Popup::background}{background}
        and \l {Popup::}{contentItem}.

        \quotefromfile qtquickcontrols-tooltip-custom.qml
        \skipto import QtQuick
        \printuntil import QtQuick.Controls.Basic
        \skipto ToolTip
        \printuntil }
        \printuntil }
        \printuntil }

        \include qquicktooltip.qdocinc customize-note

    \section2 Customizing Tumbler

        Tumbler consists of three visual items:
        \l {Control::background}{background},
        \l {Control::}{contentItem}, and
        \l {Tumbler::delegate}{delegate}.

        \image qtquickcontrols-tumbler-custom.png
               {Custom styled tumbler}

        \snippet qtquickcontrols-tumbler-custom.qml file

        If you want to define your own contentItem, use either a \l ListView or
        \l PathView as the root item. For a wrapping Tumbler, use PathView:

        \snippet qtquickcontrols-tumbler-pathView.qml contentItem

        For a non-wrapping Tumbler, use ListView:

        \snippet qtquickcontrols-tumbler-listView.qml contentItem

    \section2 Customizing TableViewDelegate

        TableViewDelegate inherits \l ItemDelegate, which means that it's composed of two
        visual items:
        \l [QML]{Control::}{background} and
        \l [QML]{Control::}{contentItem}.

        You can always assign your own custom edit delegate to
        \l [QML]{TableView::}{editDelegate} if you have needs
        outside what the default edit delegate offers.

        \image qtquickcontrols-tableviewdelegate-custom.png
               {Custom styled table view delegate}

        \snippet qtquickcontrols-tableviewdelegate-custom.qml delegate

    \section2 Customizing HeaderViewDelegate

        HeaderViewDelegate inherits \l TableViewDelegate, which means that it's
        composed of two items:
        \l [QML]{Control::}{background} and
        \l [QML]{Control::}{contentItem}.
        You can always customize them with any arbitrary items.

        \image qtquickcontrols-headerviewdelegate-custom.png
               {Custom styled header view delegate}

        Here is an example of customizing the horizontal header view delegate:

        \snippet qtquickcontrols-headerviewdelegate-custom.qml horizontal-delegate

        Here is an example of customizing the vertical header view delegate:

        \snippet qtquickcontrols-headerviewdelegate-custom.qml vertical-delegate
*/
