Revision control
++ // Copyright (C) 2025 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ #include "qqstylekitcontrol_p.h"
++ #include "qqstylekitstyle_p.h"
++ #include "qqstylekittheme_p.h"
++ #include "qqstylekitcontrolproperties_p.h"
++ #include "qqstylekitpropertyresolver_p.h"
++
++ QT_BEGIN_NAMESPACE
++
++ // ************* ControlStyleProperties ****************
++
++ /*!
++ \qmltype ControlStyleProperties
++ \inqmlmodule Qt.labs.StyleKit
++ \brief Defines the stylable properties for a control.
++
++ ControlStyleProperties defines the stylable properties for a
++ control: the visual building blocks \l background, \l indicator, \l handle,
++ and \l text, as well as layout properties like \l padding, \l spacing,
++ and \l transition.
++
++ The style properties are accessed through inherited types such as
++ \l ControlStyle and \l StyleReader.
++
++ \labs
++
++ \sa ControlStyle, StyleReader, ControlStateStyle, DelegateStyle
++ */
++
++ /*!
++ \qmlproperty DelegateStyle ControlStyleProperties::background
++
++ Grouped property for styling the background of a control.
++
++ The background delegate is typically the main visual rectangle behind
++ the control. Use it to set \l {DelegateStyle::color}{colors},
++ \l {DelegateStyle::border}{borders},
++ \l {DelegateStyle::radius}{radii},
++ \l {DelegateStyle::shadow}{shadows},
++ \l {DelegateStyle::gradient}{gradients},
++ and \l {DelegateStyle::image}{images}.
++
++ \note The default \l {Style.fallbackStyle}{fallback style} sets \c {background.visible}
++ to \c false for controls that typically should not draw a background,
++ such as \l [QtQuickControls]{CheckBox}, \l [QtQuickControls]{RadioButton},
++ and \l [QtQuickControls]{Slider}. To show their background, set
++ \c {background.visible} to \c true explicitly.
++ */
++
++ /*!
++ \qmlproperty real ControlStyleProperties::bottomPadding
++
++ The \l [QtQuickControls]{Control Layout}{bottom padding}
++ of the control. If not set, falls back to \l padding.
++
++ \sa padding, topPadding, leftPadding, rightPadding
++ */
++
++ /*!
++ \qmlproperty HandleStyle ControlStyleProperties::handle
++
++ Grouped property for styling the handle of a control.
++
++ The handle is used by controls such as \l [QtQuickControls]{Switch},
++ \l [QtQuickControls]{Slider}, and \l [QtQuickControls]{RangeSlider}.
++ For a RangeSlider, the two handles can be styled individually through
++ \l {HandleStyle.first}{handle.first} and \l {HandleStyle.second}{handle.second}.
++
++ \sa HandleStyle, DelegateStyle
++ */
++
++ /*!
++ \qmlproperty IndicatorStyle ControlStyleProperties::indicator
++
++ Grouped property for styling the indicator of a control. For a
++ \l {StylableControls::}{checkBox}, the indicator is the
++ frame, and its \l {IndicatorStyle::}{foreground} is the check mark.
++ For a \l {StylableControls::}{slider}, the indicator is
++ the groove, and the foreground is the fill.
++
++ \sa DelegateStyle
++ */
++
++ /*!
++ \qmlproperty real ControlStyleProperties::leftPadding
++
++ The \l [QtQuickControls]{Control Layout}{left padding} of the control. If not set, falls back to
++ \l padding.
++
++ \sa padding, rightPadding, topPadding, bottomPadding
++ */
++
++ /*!
++ \qmlproperty real ControlStyleProperties::padding
++
++ The uniform spacing between the
++ \l [QtQuickControls]{Control Layout}{control's content area and the
++ bounds of the control}. Setting this provides a default value for
++ \l leftPadding, \l rightPadding, \l topPadding, and \l bottomPadding.
++ Each side can be overridden individually.
++
++ \sa leftPadding, rightPadding, topPadding, bottomPadding
++ */
++
++ /*!
++ \qmlproperty real ControlStyleProperties::rightPadding
++
++ The \l [QtQuickControls]{Control Layout}{right padding} of the control.
++ If not set, falls back to \l padding.
++
++ \sa padding, leftPadding, topPadding, bottomPadding
++ */
++
++ /*!
++ \qmlproperty real ControlStyleProperties::spacing
++
++ The spacing between visual elements inside the control, for example
++ between an indicator and a label.
++ */
++
++ /*!
++ \qmlproperty TextStyle ControlStyleProperties::text
++
++ Grouped property for styling the text label of a control.
++ */
++
++ /*!
++ \qmlproperty real ControlStyleProperties::topPadding
++
++ The \l [QtQuickControls]{Control Layout}{top padding}
++ of the control. If not set, falls back to \l padding.
++
++ \sa padding, bottomPadding, leftPadding, rightPadding
++ */
++
++ /*!
++ \qmlproperty Transition ControlStyleProperties::transition
++
++ A \l [QtQuick]{Transition} used to animate style properties when the
++ control enters a new state, such as \l {ControlStateStyle::}{hovered}
++ or \l {ControlStateStyle::}{pressed}. If set
++ to \c null (the default), property changes are applied immediately
++ without animation.
++
++ \snippet DelegateStyle_transitions.qml custom transition
++
++ To avoid repeating the same target properties for each delegate,
++ StyleKit provides \l StyleAnimation for convenience, which can be
++ used instead of, or in combination with, the
++ \l {Animation and Transitions in Qt Quick}{standard animations:}
++
++ \snippet DelegateStyle_transitions.qml transition
++
++ \note For color properties that participate in a transition, prefer
++ \l {Qt.alpha} over \c "transparent"
++ (e.g. \c {menuBarItem.background.color: Qt.alpha(palette.accent, 0)}).
++ \c "transparent" is \c {Qt.rgba(0, 0, 0, 0)}, which can pull interpolated
++ colors toward black during the transition.
++ */
++
++ // ************* DelegateStyle ****************
++
++ /*!
++ \qmltype DelegateStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \brief Defines the visual appearance of an element within a control.
++
++ DelegateStyle describes the visual appearance of a visual element
++ within a \l ControlStyle, such as its \l {ControlStyleProperties::}{background},
++ \l {ControlStyleProperties::}{indicator}, or a sub-element like
++ \l {IndicatorStyle::foreground}{indicator.foreground}.
++ It provides properties for controlling
++ \l {DelegateStyle::width}{size},
++ \l {DelegateStyle::}{color}, \l {DelegateStyle::}{border},
++ \l {DelegateStyle::}{radius}, \l {DelegateStyle::}{shadow},
++ \l {DelegateStyle::}{image}, \l {DelegateStyle::}{opacity}, and more.
++
++ \labs
++
++ \sa ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty Qt::Alignment DelegateStyle::alignment
++
++ The alignment of the delegate within its parent. The default
++ value is \c {Qt.AlignLeft | Qt.AlignVCenter}.
++ */
++
++ /*!
++ \qmlproperty BorderStyle DelegateStyle::border
++
++ Grouped property for styling the border of this delegate.
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::bottomLeftRadius
++
++ The bottom-left corner radius. If not set, falls back to \l radius.
++
++ \sa radius, topLeftRadius, topRightRadius, bottomRightRadius
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::bottomMargin
++
++ The bottom margin of this delegate. If not set, falls back to
++ \l margins.
++
++ \sa margins, topMargin, leftMargin, rightMargin
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::bottomRightRadius
++
++ The bottom-right corner radius. If not set, falls back to \l radius.
++
++ \sa radius, topLeftRadius, topRightRadius, bottomLeftRadius
++ */
++
++ /*!
++ \qmlproperty bool DelegateStyle::clip
++
++ Whether the delegate clips its contents. The default value is \c false.
++ */
++
++ /*!
++ \qmlproperty color DelegateStyle::color
++
++ The fill color of this delegate. The default value is \c transparent.
++
++ Unlike a Quick \l [QtQuick]{Rectangle}, where a gradient replaces
++ the color, StyleKit draws the \l gradient on top of the color. This
++ means you can use a semi-transparent gradient as an overlay (for
++ example, a subtle shading effect) while the color shows through
++ underneath.
++
++ \snippet ControlStateStyle_properties.qml color and gradient
++
++ \sa gradient, opacity
++ */
++
++ /*!
++ \qmlproperty QObject DelegateStyle::data
++
++ An arbitrary object that can be used for passing
++ custom data from the style to a custom \l delegate component.
++
++ This allows you to define custom style properties beyond what the
++ StyleKit API provides. The data object can vary between states and
++ themes, making it possible to style elements in a custom \l delegate
++ that are not covered by the built-in properties.
++
++ The following snippet uses a custom delegate that draws an overlay
++ \l Text whose color varies depending on the control's state. The delegate
++ inherits \l StyledItem, which is optional but ensures the rest of
++ the button background is rendered normally.
++
++ \snippet DelegateStyle_delegates.qml data
++
++ \note The \c data object is propagated as a whole. Unlike regular style
++ properties, individual properties \e inside the data object do not
++ propagate separately.
++
++ \sa delegate
++ */
++
++ /*!
++ \qmlproperty Component DelegateStyle::delegate
++
++ The delegate used to render the DelegateStyle in a
++ \l {Qt Quick Controls}{Qt Quick Control}.
++
++ The default value is \c null, in which case \l StyledItem is used
++ for rendering instead. If you want to hide the delegate altogether
++ (and prevent if from being created), set \l visible to \c false.
++
++ The delegate needs to define the following required properties:
++ \qml
++ required property DelegateStyle delegateStyle
++ required property QtObject control
++ \endqml
++
++ \c delegateStyle points to the DelegateStyle that describes how the
++ delegate should be styled. \c control points to the
++ \l {Qt Quick Controls}{Qt Quick Control} that owns the delegate. The latter
++ can be used to resolve additional information about the control not
++ available from the style.
++
++ If you know the specific type of the owning control, you can use it
++ instead of \l QtObject for the \c control property. For example, since
++ a handle delegate in the snippet below is always used inside a Slider, the
++ type can be set to \l {Qt Quick Templates 2 QML Types}{T.Slider}:
++
++ \snippet DelegateStyle_delegates.qml delegate
++
++ \note If a DelegateStyle has a \l {shadow}{drop shadow} defined, it will be
++ drawn separately by a \l {ShadowStyle::delegate}{shadow delegate.}
++
++ \sa data, visible, StyledItem
++ */
++
++ /*!
++ \qmlproperty Gradient DelegateStyle::gradient
++
++ The gradient of this delegate. The default value is \c null (no gradient).
++
++ Unlike a Quick \l [QtQuick]{Rectangle}, where a gradient replaces
++ the color, StyleKit draws the \l gradient on top of the color. This
++ means you can use a semi-transparent gradient as an overlay (for
++ example, a subtle shading effect) while the color shows through
++ underneath.
++
++ \snippet ControlStateStyle_properties.qml color and gradient
++
++ \sa color
++ */
++
++ /*!
++ \qmlproperty ImageStyle DelegateStyle::image
++
++ Grouped property for placing an image inside this delegate.
++
++ \sa ImageStyle
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::width
++
++ The width of this delegate.
++
++ \note This property will only set the delegate width when \l fillWidth is \c false. This also
++ applies when \l fillWidth is set higher up in the style hierarchy, for example
++ in the \l {Style::fallbackStyle}{fallback style}.
++
++ If this delegate is at the root of the control — for example the
++ \l {ControlStyleProperties::background}{background} or the
++ \l {ControlStyleProperties::indicator}{indicator} — it will also be included when
++ calculating the \l [QtQuick]{Item::implicitWidth}{implicit width} of the control, even when \l fillWidth is \c true.
++
++ \sa height, fillWidth, minimumWidth, {StyleKit Property Resolution}
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::height
++
++ The height of this delegate.
++
++ \note This property will only set the delegate height when \l fillHeight is \c false. This also
++ applies when \l fillHeight is set higher up in the style hierarchy, for example
++ in the \l {Style::fallbackStyle}{fallback style}.
++
++ If this delegate is at the root of the control — for example the
++ \l {ControlStyleProperties::background}{background} or the
++ \l {ControlStyleProperties::indicator}{indicator} — it will also be included when
++ calculating the \l [QtQuick]{Item::implicitHeight}{implicit height} of the control, even when \l fillHeight is \c true.
++
++ \sa width, fillHeight, minimumHeight, {StyleKit Property Resolution}
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::leftMargin
++
++ The left margin of this delegate. If not set, falls back to
++ \l margins.
++
++ \sa margins, rightMargin, topMargin, bottomMargin
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::margins
++
++ The uniform margin around this delegate. Setting this provides a
++ default value for \l leftMargin, \l rightMargin, \l topMargin,
++ and \l bottomMargin. Each side can be overridden individually.
++
++ \sa leftMargin, rightMargin, topMargin, bottomMargin
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::minimumWidth
++
++ The minimum width of this delegate. The delegate will not be sized
++ smaller than this value.
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::minimumHeight
++
++ The minimum height of this delegate. The delegate will not be sized
++ smaller than this value.
++ */
++
++ /*!
++ \qmlproperty bool DelegateStyle::fillWidth
++
++ Whether the delegate should fill the available width of the parent item.
++
++ Some delegates, such as the groove of a \l [QtQuickControls]{Slider}, are
++ often expected to fill the available width of the control, rather than
++ having a fixed implicit width. This can be achieved by setting
++ \c fillWidth to \c true. To add some space between the delegate and the
++ edges of its parent, use the \l margins properties.
++
++ If \c fillWidth is \c false, the delegate's width is determined by its \l width.
++
++ \sa fillHeight, width
++ */
++
++ /*!
++ \qmlproperty bool DelegateStyle::fillHeight
++
++ Whether the delegate should fill the available height of the parent item.
++
++ Some delegates, such as the foreground of a checkbox indicator, are often expected
++ to fill the available height (and width) of the indicator, rather than
++ having a fixed height. This can be achieved by setting
++ \c fillHeight to \c true. To add some space between the delegate and the
++ edges of its parent, use the \l margins properties.
++
++ If \c fillHeight is \c false, the delegate's height is determined by its \l height.
++
++ \sa fillWidth, height
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::opacity
++
++ The opacity of this delegate, from \c 0.0 (fully transparent) to
++ \c 1.0 (fully opaque). The default value is \c 1.0.
++
++ \sa visible, color
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::radius
++
++ The corner radius applied to all four corners of this delegate.
++ Individual corners can be overridden with \l topLeftRadius,
++ \l topRightRadius, \l bottomLeftRadius, and \l bottomRightRadius.
++
++ \sa topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::rightMargin
++
++ The right margin of this delegate. If not set, falls back to
++ \l margins.
++
++ \sa margins, leftMargin, topMargin, bottomMargin
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::rotation
++
++ The rotation of this delegate, in degrees.
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::scale
++
++ The scale factor of this delegate. The default value is \c 1.0.
++ */
++
++ /*!
++ \qmlproperty ShadowStyle DelegateStyle::shadow
++
++ Grouped property for styling a drop shadow behind this delegate.
++
++ \sa ShadowStyle
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::topLeftRadius
++
++ The top-left corner radius. If not set, falls back to \l radius.
++
++ \sa radius, topRightRadius, bottomLeftRadius, bottomRightRadius
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::topMargin
++
++ The top margin of this delegate. If not set, falls back to
++ \l margins.
++
++ \sa margins, bottomMargin, leftMargin, rightMargin
++ */
++
++ /*!
++ \qmlproperty real DelegateStyle::topRightRadius
++
++ The top-right corner radius. If not set, falls back to \l radius.
++
++ \sa radius, topLeftRadius, bottomLeftRadius, bottomRightRadius
++ */
++
++ /*!
++ \qmlproperty bool DelegateStyle::visible
++
++ Whether this delegate is visible. The default value is \c true.
++
++ \note Although the default value is \c true, the
++ \l {Style::fallbackStyle}{fallback style} (which overrides many of the default
++ values) sets \c {background.visible} to \c false for controls that typically
++ should not draw a background, such as \l [QtQuickControls]{CheckBox},
++ \l [QtQuickControls]{RadioButton}, and \l [QtQuickControls]{Slider}.
++
++ When \c visible is \c false, the \l delegate will not be created. If you need
++ a hidden delegate to be created, consider setting \l opacity to \c 0 instead.
++
++ \sa opacity
++ */
++
++ // ************* ImageStyle ****************
++
++ /*!
++ \qmltype ImageStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \brief Defines the image style for a delegate.
++
++ ImageStyle provides properties for placing an image inside a
++ \l DelegateStyle. It is available as the
++ \l {DelegateStyle::image}{image} grouped property on any delegate.
++
++ \labs
++
++ \sa DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty color ImageStyle::color
++
++ A color overlay applied to the image. This is typically used to tint
++ monochrome icons to match the style's color scheme.
++ */
++
++ /*!
++ \qmlproperty enumeration ImageStyle::fillMode
++
++ How the image should be scaled or tiled within the delegate. The
++ value is one of the \l [QtQuick]{Image::fillMode}{Image.fillMode}
++ enum values.
++ */
++
++ /*!
++ \qmlproperty url ImageStyle::source
++
++ The URL of the image to display inside the delegate.
++ */
++
++ // ************* BorderStyle ****************
++
++ /*!
++ \qmltype BorderStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \brief Defines the border style for a delegate.
++
++ BorderStyle provides properties for the border drawn around a
++ \l DelegateStyle. It is available as the
++ \l {DelegateStyle::border}{border} grouped property on any delegate.
++
++ \labs
++
++ \sa DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty color BorderStyle::color
++
++ The color of the border. The default value is \c transparent.
++ */
++
++ /*!
++ \qmlproperty real BorderStyle::width
++
++ The width of the border in pixels.
++ */
++
++ // ************* ShadowStyle ****************
++
++ /*!
++ \qmltype ShadowStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \brief Defines the drop shadow style for a delegate.
++
++ ShadowStyle provides properties for rendering a drop shadow behind
++ a \l DelegateStyle. It is available as the
++ \l {DelegateStyle::shadow}{shadow} grouped property on any delegate.
++
++ \snippet DelegateStyle_shadow.qml drop shadow
++
++ By adjusting scale and color, shadows can also be used to create
++ glow effects. The following snippet adds a diffuse white glow to
++ the handle of a \l [QtQuickControls]{Switch} that intensifies
++ when checked:
++
++ \snippet DelegateStyle_shadow.qml glow
++
++ \labs
++
++ \sa DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty real ShadowStyle::blur
++
++ The blur of the shadow. A value of \c 0.0 produces a sharp shadow, while
++ larger values produce a softer, more diffuse shadow.
++ The default value is \c 10.0.
++ */
++
++ /*!
++ \qmlproperty color ShadowStyle::color
++
++ The color of the shadow. The default value is \c transparent, which
++ means that no shadow will be drawn by default.
++
++ \sa visible, opacity
++ */
++
++ /*!
++ \qmlproperty Component ShadowStyle::delegate
++
++ A custom QML \l [QML]{Component} that replaces the default shadow
++ rendering. When set, StyleKit instantiates this component instead
++ of drawing the default shadow.
++ */
++
++ /*!
++ \qmlproperty real ShadowStyle::horizontalOffset
++
++ The horizontal offset of the shadow from the delegate, in pixels.
++ */
++
++ /*!
++ \qmlproperty real ShadowStyle::opacity
++
++ The opacity of the shadow, from \c 0.0 (fully transparent) to
++ \c 1.0 (fully opaque). The default value is \c 1.0.
++
++ \sa visible, color
++ */
++
++ /*!
++ \qmlproperty real ShadowStyle::scale
++
++ The scale factor of the shadow relative to the delegate.
++ The default value is \c 1.0.
++ */
++
++ /*!
++ \qmlproperty real ShadowStyle::verticalOffset
++
++ The vertical offset of the shadow from the delegate, in pixels.
++ */
++
++ /*!
++ \qmlproperty bool ShadowStyle::visible
++
++ Whether the shadow is visible. The default value is \c true.
++
++ However, since the default shadow \l color is \c transparent,
++ the shadow will not be visible unless a different color is set.
++
++ \sa opacity
++ */
++
++ // ************* HandleStyle ****************
++
++ /*!
++ \qmltype HandleStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \inherits DelegateStyle
++ \brief Defines the handle style for controls such as \l [QtQuickControls]{Switch},
++ \l [QtQuickControls]{Slider} and \l [QtQuickControls]{RangeSlider}.
++
++ HandleStyle extends \l DelegateStyle with properties that are specific to
++ styling a handle.
++
++ Some controls have more than one handle. For example,
++ \l [QtQuickControls]{RangeSlider} has both a \l [QtQuickControls]{RangeSlider::}{first} and a \l [QtQuickControls]{RangeSlider::}{second} handle.
++ These can be styled independently using the \l first and \l second
++ sub-handles, \c {slider.handle.first} and \c {slider.handle.second}.
++ Properties not set on a sub-handle fall back to the handle itself.
++
++ \labs
++
++ \sa DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty DelegateStyle HandleStyle::first
++
++ Grouped property for styling the first handle of for example a
++ \l [QtQuickControls]{RangeSlider}. Unset properties fall back to
++ the HandleStyle itself.
++ */
++
++ /*!
++ \qmlproperty DelegateStyle HandleStyle::second
++
++ Grouped property for styling the second handle of for example a
++ \l [QtQuickControls]{RangeSlider}. Unset properties fall back to
++ the HandleStyle itself.
++ */
++
++ // ************* SubIndicatorStyle ****************
++
++ /*!
++ \qmltype SubIndicatorStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \inherits DelegateStyle
++ \brief Defines the style for a sub-indicator delegate.
++
++ SubIndicatorStyle extends \l DelegateStyle with a \l foreground
++ property. It is used for styling sub-indicator delegates such as
++ \l {IndicatorStyle::first}{indicator.first} and
++ \l {IndicatorStyle::second}{indicator.second} in controls
++ with multiple indicators, like \l [QtQuickControls]{SpinBox}.
++ For SpinBox, \c {indicator.first} styles the increment button, and
++ \c {indicator.second} styles the decrement button.
++ It is equivalent to \l IndicatorStyle, but does not itself
++ contain sub-indicators.
++
++ \labs
++
++ \sa IndicatorStyle, DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty DelegateStyle SubIndicatorStyle::foreground
++
++ Grouped property for styling the foreground element of this
++ indicator. The foreground typically represents a checkmark, icon
++ or arrow rendered inside the indicator.
++ */
++
++ // ************* IndicatorStyle ****************
++
++ /*!
++ \qmltype IndicatorStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \inherits DelegateStyle
++ \brief Defines the style for a control's indicator.
++
++ IndicatorStyle extends \l DelegateStyle with properties that are specific to
++ styling an indicator.
++
++ The IndicatorStyle itself describes the indicator background, while the
++ \l foreground describes the content drawn inside it. For example,
++ \c {checkBox.indicator} styles the check box frame and
++ \c {checkBox.indicator.foreground} styles the check mark. For
++ \l {StylableControls::}{switchControl},
++ \l {StylableControls::}{slider} and
++ \l {StylableControls::}{progressBar}, the indicator styles
++ the groove and the foreground styles the fill.
++
++ \snippet DelegateStyle_indicator.qml checkBox
++
++ Some controls have more than one indicator. For example,
++ \l [QtQuickControls]{SpinBox} has both an increment and a decrement
++ button. These can be styled independently using the \l first and \l second
++ sub-indicators, \c {spinBox.indicator.first} and
++ \c {spinBox.indicator.second}. For SpinBox, \c {indicator.first} styles
++ the increment button, and \c {indicator.second} styles the decrement
++ button. Properties not set on a sub-indicator fall back to the indicator
++ itself.
++
++ \note The \c up and \c down properties are kept as aliases for
++ \c first and \c second for backward compatibility. New code
++ should use \c first and \c second, as these names are generic and can be
++ used by controls with sub-indicators that do not represent up/down actions.
++ The compatibility aliases may be removed in a future version.
++
++ \snippet DelegateStyle_indicator.qml up and down indicator
++
++ \labs
++
++ \sa SubIndicatorStyle, DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty DelegateStyle IndicatorStyle::foreground
++
++ Grouped property for styling the foreground element of this
++ indicator. For example, \c {checkBox.indicator} describes
++ the check box frame, while \c {checkBox.indicator.foreground} is the check mark.
++
++ For controls like \l {StylableControls::}{slider},
++ \l {StylableControls::}{progressBar}, and
++ \l {StylableControls::}{switchControl}, the \c {indicator.foreground}
++ represents the progress track or fill within the groove, while the \c indicator
++ itself represents the groove.
++ */
++
++ /*!
++ \qmlproperty SubIndicatorStyle IndicatorStyle::first
++
++ Grouped property for styling the first sub-indicator of controls that
++ expose multiple indicators. For \l [QtQuickControls]{SpinBox}, this
++ styles the increment button.
++ Unset properties fall back to the indicator itself.
++
++ \note The \c up property is kept as an alias for \c first for backward
++ compatibility. New code should use \c first, as this name is generic
++ and can be used by controls with sub-indicators that do not represent
++ up actions. The compatibility alias may be removed in a future version.
++
++ \sa second
++ */
++
++ /*!
++ \qmlproperty SubIndicatorStyle IndicatorStyle::second
++
++ Grouped property for styling the second sub-indicator of for example a
++ \l [QtQuickControls]{SpinBox}.
++ Unset properties fall back to the indicator itself.
++
++ \note The \c down property is kept as an alias for \c second for backward
++ compatibility. New code should use \c second, as this name is generic
++ and can be used by controls with sub-indicators that do not represent
++ down actions. The compatibility alias may be removed in a future version.
++
++ \sa first
++ */
++
++ // ************* TextStyle ****************
++
++ /*!
++ \qmltype TextStyle
++ \inqmlmodule Qt.labs.StyleKit
++ \brief Defines the text style for a control's label.
++
++ TextStyle provides properties for controlling the appearance of
++ text labels within a control, such as
++ \l color, \l alignment and \l padding,
++ and certain font-related properties such as
++ \l {TextStyle::}{bold},
++ \l {TextStyle::}{italic}, and
++ \l {TextStyle::pointSize}{font size}.
++
++ It is available as the \l {ControlStyleProperties::text}{text}
++ grouped property on every \l ControlStateStyle.
++
++ \labs
++
++ \sa DelegateStyle, ControlStyle, ControlStateStyle,
++ {qtlabsstylekit-fallbackstyle.html}{FallbackStyle Reference}
++ */
++
++ /*!
++ \qmlproperty Qt::Alignment TextStyle::alignment
++
++ The alignment of the text within its available area.
++ */
++
++ /*!
++ \qmlproperty bool TextStyle::bold
++
++ Whether the text should be rendered in bold. The default value
++ is \c false.
++
++ \sa italic
++ */
++
++ /*!
++ \qmlproperty real TextStyle::bottomPadding
++
++ The bottom padding around the text. If not set, falls back to
++ \l padding.
++
++ \sa padding, topPadding, leftPadding, rightPadding
++ */
++
++ /*!
++ \qmlproperty color TextStyle::color
++
++ The color of the text.
++ */
++
++ /*!
++ \qmlproperty bool TextStyle::italic
++
++ Whether the text should be rendered in italic. The default value
++ is \c false.
++
++ \sa bold
++ */
++
++ /*!
++ \qmlproperty real TextStyle::leftPadding
++
++ The left padding around the text. If not set, falls back to
++ \l padding.
++
++ \sa padding, rightPadding, topPadding, bottomPadding
++ */
++
++ /*!
++ \qmlproperty real TextStyle::padding
++
++ The uniform padding around the text. Setting this provides a
++ default value for \l leftPadding, \l rightPadding, \l topPadding,
++ and \l bottomPadding. Each side can be overridden individually.
++
++ \sa leftPadding, rightPadding, topPadding, bottomPadding
++ */
++
++ /*!
++ \qmlproperty real TextStyle::pointSize
++
++ The point size of the text font.
++ */
++
++ /*!
++ \qmlproperty real TextStyle::rightPadding
++
++ The right padding around the text. If not set, falls back to
++ \l padding.
++
++ \sa padding, leftPadding, topPadding, bottomPadding
++ */
++
++ /*!
++ \qmlproperty real TextStyle::topPadding
++
++ The top padding around the text. If not set, falls back to
++ \l padding.
++
++ \sa padding, bottomPadding, leftPadding, rightPadding
++ */
++
++ /*!
++ \qmlproperty TextStyle TextStyle::first
++
++ Grouped property for styling the first text element in controls that
++ expose two separate text labels. Unset properties fall back to
++ \l {ControlStyleProperties::text}{text} itself.
++
++ \sa second
++ */
++
++ /*!
++ \qmlproperty TextStyle TextStyle::second
++
++ Grouped property for styling the second text element in controls that
++ expose two separate text labels. Unset properties fall back to
++ \l {ControlStyleProperties::text}{text} itself.
++
++ \sa first
++ */
++
++ // ************* QQStyleKitPropertyGroup ****************
++
++ QQStyleKitPropertyGroup::QQStyleKitPropertyGroup(QQSK::PropertyGroup, QObject *parent)
++ : QObject(parent)
++ {
++ }
++
++ QQStyleKitControlProperties *QQStyleKitPropertyGroup::controlProperties() const
++ {
++ if (isControlProperties()) {
++ Q_ASSERT(qobject_cast<const QQStyleKitControlProperties *>(this));
++ auto *self = const_cast<QQStyleKitPropertyGroup *>(this);
++ return static_cast<QQStyleKitControlProperties *>(self);
++ }
++ Q_ASSERT(qobject_cast<const QQStyleKitControlProperties *>(parent()));
++ return static_cast<QQStyleKitControlProperties *>(parent());
++ }
++
++ template<typename T>
++ T *QQStyleKitPropertyGroup::lazyCreateGroup(T * const &ptr, QQSK::PropertyGroup group) const
++ {
++ T *nestedGroup = QQSK::lazyCreate(ptr, controlProperties(), group);
++
++ // Nested groups inherit path flags from their parents
++ nestedGroup->m_pathFlags = m_pathFlags;
++
++ if (group == QQSK::PropertyGroup::DelegateSubtype1) {
++ /* The subtype is stripped from a group's core path, and stored as a flag. This is because
++ * during style property look-up, we want to check many different alternative paths where
++ * the core group path can occur, some with, and some without, the subtype included.
++ * Whether or not to include a subtype is therefore decided as late as possible, when
++ * creating a QQStyleKitPropertyPath, and then depending on the usage. */
++ nestedGroup->m_pathFlags.setFlag(QQSK::PropertyPathFlag::DelegateSubtype1);
++ nestedGroup->m_groupSpace = m_groupSpace;
++ } else if (group == QQSK::PropertyGroup::DelegateSubtype2) {
++ nestedGroup->m_pathFlags.setFlag(QQSK::PropertyPathFlag::DelegateSubtype2);
++ nestedGroup->m_groupSpace = m_groupSpace;
++ } else {
++ /* Calculate the available property ID space for the nested group. This is done by
++ * dividing the available space inside _this_ group on the number of potential groups
++ * that _this_ group can potentially contain. */
++ const PropertyPathId nestedGroupIndex = PropertyPathId(group);
++ const PropertyPathId nestedGroupSize = m_groupSpace.size / nestedGroupCount;
++ nestedGroup->m_groupSpace.size = nestedGroupSize;
++ nestedGroup->m_groupSpace.start = m_groupSpace.start + (nestedGroupIndex * nestedGroupSize);
++ /* Ensure that we haven’t exhausted the available PropertyPathId space. There must be
++ * enough room remaining to assign IDs for all properties defined in QQSK::Property.
++ * If this assertion triggers, consider switching to a wider PropertyPathId type or
++ * optimizing how the space is allocated. For example, certain nested paths (such as
++ * control.handle.indicator) can never occur, yet we currently reserve INNER_GROUP_COUNT
++ * for every nesting level, which is wasteful. */
++ Q_ASSERT(nestedGroupSize >= PropertyPathId(QQSK::Property::COUNT));
++ }
++ return nestedGroup;
++ }
++
++ /* This macro will check if the caller has the same group path as \a GROUP_PATH.
++ * This is needed since a QQSK::Property (e.g Color) can sometimes be a
++ * property in several different subclasses of QQStyleKitPropertyGroup.
++ * For example, both control.background.color and control.indicator.color has a
++ * color property. But the group path differs, so they are in reality two completely
++ * different properties. And in that case, when the former changes value, we want to
++ * emit changes globally only to that property, and not the latter.
++ * The caller of this macro will therefore need to go through all the usages of its
++ * subclass in the API, to figure out which group itself is an instance of. For the
++ * one that is a match, the macro will go through all readers and emit the same
++ * signal for them. */
++ #define CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(CONTROL_PROPERTIES, GROUP_PATH) \
++ if (this == CONTROL_PROPERTIES -> GROUP_PATH ) { \
++ for (QQStyleKitReader *reader : QQStyleKitReader::s_allReaders) { \
++ const auto baseTypes = QQStyleKitPropertyResolver::baseTypesForType(reader->controlType()); \
++ if (reader->controlType() != controlType && !baseTypes.contains(controlType)) \
++ continue; \
++ reader->clearLocalStorage(); \
++ ((reader-> GROUP_PATH ->*changedSignals)(), ...); \
++ } \
++ return; \
++ }
++
++ template<typename SUBCLASS>
++ void QQStyleKitPropertyGroup::handleStylePropertyChanged(void (SUBCLASS::*changedSignal)()) {
++ handleStylePropertiesChanged<SUBCLASS>(changedSignal);
++ }
++
++ template <typename SUBCLASS, typename... CHANGED_SIGNALS>
++ void QQStyleKitPropertyGroup::handleStylePropertiesChanged(CHANGED_SIGNALS... changedSignals)
++ {
++ /* This function will check which subclass of QQStyleKitProperties this
++ * group is (nested) inside. Based on that, it will decide if the signals
++ * should be emitted locally or not, and if the changed properties affects
++ * all existing QQStyleKitReaders, and therefore will need to be
++ * emitted 'globally'. Note that it only makes sense to call this function
++ * for changed properties that are available from a QQStyleKitReader.
++ * Properities only available from e.g QQStyleKitControl (such as
++ * variations), are anyway not readable from a QQStyleKitReader. */
++ static_assert(std::is_base_of<QQStyleKitPropertyGroup, SUBCLASS>::value,
++ "SUBCLASS must inherit QQStyleKitPropertyGroup");
++
++ auto *group = static_cast<SUBCLASS *>(this);
++ const QQSK::Subclass objectWrittenTo = controlProperties()->subclass();
++
++ if (objectWrittenTo == QQSK::Subclass::QQStyleKitState) {
++ ((group->*changedSignals)(), ...);
++
++ if (shouldEmitGlobally()) {
++ const QQStyleKitControl *control = controlProperties()->asQQStyleKitState()->control();
++ const QQStyleKitExtendableControlType type = control->controlType();
++ group->emitGlobally(type, changedSignals...);
++ }
++ return;
++ }
++
++ if (objectWrittenTo == QQSK::Subclass::QQStyleKitReader) {
++ /* Unless the StyleReader has told us not to emit any signals (because it's only
++ * syncing it's own local storage with old values before starting a transition), we
++ * emit the signal like normal. This will cause the control to repaint (perhaps
++ * using a transition). */
++ if (shouldEmitLocally()) {
++ QQStyleKitReader *reader = controlProperties()->asQQStyleKitReader();
++ /* Readers notify their consumer in two different ways depending on who is
++ * consuming them. A QML control binds to the reader's change signals, so we
++ * emit those directly. A widget consumer (m_target set) doesn't listen on
++ * signals; it repaints in response to a QEvent::StyleAnimationUpdate posted
++ * to the widget, and only while a transition is actually running. */
++ if (!reader->m_target)
++ ((group->*changedSignals)(), ...);
++ else
++ QCoreApplication::postEvent(reader->m_target, new QEvent(QEvent::StyleAnimationUpdate));
++ }
++ return;
++ }
++
++ Q_UNREACHABLE();
++ }
++
++ void QQStyleKitPropertyGroup::emitChangedForAllStylePropertiesRecursive(EmitFlags emitFlags)
++ {
++ /* This function will emit changed signals for all style properties in the
++ * StyleKit API (for a single QQStyleKitReader), which is needed after
++ * doing a style-, or theme change. */
++ const QMetaObject *meta = metaObject();
++ if (meta->inherits(&QQStyleKitControlProperties::staticMetaObject)) {
++ /* Subclasses of QQStyleKitControlProperties, such as QQStyleKitReader, add
++ * properties that describe the state of the control (hovered, checked, etc.)
++ * rather than its style. Those should not be emitted from here. */
++ meta = &QQStyleKitControlProperties::staticMetaObject;
++ }
++
++ const int startIndex = QQStyleKitPropertyGroup::staticMetaObject.propertyOffset();
++ for (int i = startIndex; i < meta->propertyCount(); ++i) {
++ const QMetaProperty prop = meta->property(i);
++ const QMetaObject* propMetaObject = QMetaType::fromName(prop.typeName()).metaObject();
++ if (propMetaObject && propMetaObject->inherits(&QQStyleKitPropertyGroup::staticMetaObject)) {
++ /* Nested groups are handled by forEachExistingNestedGroup() below. Reading them
++ * through their property getters from here would lazily create them. */
++ continue;
++ }
++
++ if (!emitFlags.testFlag(EmitFlag::AllProperties)) {
++ // Only emit for color properties when the Colors flag is set
++ if (emitFlags.testFlag(EmitFlag::Colors)) {
++ if (prop.metaType() != QMetaType::fromType<QColor>())
++ continue;
++ }
++ }
++
++ /* Emit the changed signal for the property.
++ * Note: even if we call invoke() for every style property, only the signals that
++ * are connected to something (e.g. a binding) end up doing any real work. If
++ * isSignalConnected() is false, the emit will exit early. */
++ Q_ASSERT(prop.hasNotifySignal());
++ QMetaMethod notify = prop.notifySignal();
++ notify.invoke(this, Qt::DirectConnection);
++ }
++
++ /* Recurse into the nested groups, but only the ones that have been created. Since
++ * nested groups are lazily created when first read, a group that doesn't exist has
++ * never been read, so there are no bindings to it that would need to be notified. */
++ forEachExistingNestedGroup([emitFlags](QQStyleKitPropertyGroup *group) {
++ group->emitChangedForAllStylePropertiesRecursive(emitFlags);
++ });
++ }
++
++ void QQStyleKitPropertyGroup::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ /* Subclasses with nested groups should override this function and call f for
++ * each nested group that has been created, mirroring the groups that the subclass
++ * creates with lazyCreateGroup(). Nested groups are lazily created when read, so a
++ * group that hasn't been created has never been read either. Using the member
++ * pointers directly (as opposed to the property getters) avoids creating them by
++ * accident. Overrides should not call this base implementation. */
++ Q_UNUSED(f);
++
++ #ifdef QT_DEBUG
++ /* Verify that this group has no nested groups, since it would otherwise need to
++ * override this function. */
++ const QMetaObject *meta = metaObject();
++ const int startIndex = QQStyleKitPropertyGroup::staticMetaObject.propertyOffset();
++ for (int i = startIndex; i < meta->propertyCount(); ++i) {
++ const QMetaProperty prop = meta->property(i);
++ const QMetaObject *propMetaObject = QMetaType::fromName(prop.typeName()).metaObject();
++ Q_ASSERT_X(!propMetaObject || !propMetaObject->inherits(&QQStyleKitPropertyGroup::staticMetaObject),
++ meta->className(), "Classes with nested property groups must override forEachExistingNestedGroup()");
++ }
++ #endif
++ }
++
++ bool QQStyleKitPropertyGroup::shouldEmitLocally()
++ {
++ return !controlProperties()->asQQStyleKitReader()->dontEmitChangedSignals();
++ }
++
++ bool QQStyleKitPropertyGroup::shouldEmitGlobally()
++ {
++ QQStyleKitStyle *parentStyle = controlProperties()->style();
++ if (!parentStyle)
++ return false;
++
++ if (parentStyle->loaded() && !parentStyle->m_isUpdatingPalette) {
++ /* When a property has changed in the 'global' QQStyleKitStyle itself, it can
++ * potentially affect all control instances. We therefore need to go through all
++ * QQStyleKitReaders and inform that their own local property that matches the
++ * 'global' property needs to be re-read. We emit the signals directly, omitting any
++ * applied transitions in the QQStyleKitReaders, to optimize for speed. The exception
++ * is if we're just updating the palette in the Style to match the palette in the current
++ * control / QQStyleKitReader. Such a change will only affect a single control. */
++ return parentStyle == QQStyleKitStyle::current();
++ }
++ return false;
++ }
++
++ // ************* QQStyleKitImageProperties ****************
++
++ QQStyleKitImageProperties::QQStyleKitImageProperties(QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitPropertyGroup(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitImageProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ // Go through all instances of QQStyleKitImageProperties
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, background()->image());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, handle()->image());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->image());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->foreground()->image());
++ }
++
++ QUrl QQStyleKitImageProperties::source() const
++ {
++ return styleProperty<QUrl>(QQSK::Property::Source);
++ }
++
++ void QQStyleKitImageProperties::setSource(const QUrl &source)
++ {
++ if (setStyleProperty(QQSK::Property::Source, source))
++ handleStylePropertyChanged(&QQStyleKitImageProperties::sourceChanged);
++ }
++
++ QColor QQStyleKitImageProperties::color() const
++ {
++ return styleProperty<QColor>(QQSK::Property::Color);
++ }
++
++ void QQStyleKitImageProperties::setColor(const QColor &color)
++ {
++ if (setStyleProperty(QQSK::Property::Color, color))
++ handleStylePropertyChanged(&QQStyleKitImageProperties::colorChanged);
++ }
++
++ QQuickImage::FillMode QQStyleKitImageProperties::fillMode() const
++ {
++ return styleProperty<QQuickImage::FillMode>(QQSK::Property::FillMode);
++ }
++
++ void QQStyleKitImageProperties::setFillMode(QQuickImage::FillMode fillMode)
++ {
++ if (setStyleProperty(QQSK::Property::FillMode, fillMode))
++ handleStylePropertyChanged(&QQStyleKitImageProperties::fillModeChanged);
++ }
++
++ // ************* QQStyleKitBorderProperties ****************
++
++ QQStyleKitBorderProperties::QQStyleKitBorderProperties(QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitPropertyGroup(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitBorderProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ // Go through all instances of QQStyleKitBorderProperties
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, background()->border());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, handle()->border());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->border());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->foreground()->border());
++ }
++
++ qreal QQStyleKitBorderProperties::width() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Width);
++ }
++
++ void QQStyleKitBorderProperties::setWidth(qreal width)
++ {
++ if (setStyleProperty(QQSK::Property::Width, width))
++ handleStylePropertyChanged(&QQStyleKitBorderProperties::widthChanged);
++ }
++
++ QColor QQStyleKitBorderProperties::color() const
++ {
++ return styleProperty<QColor>(QQSK::Property::Color, Qt::transparent);
++ }
++
++ void QQStyleKitBorderProperties::setColor(const QColor &color)
++ {
++ if (setStyleProperty(QQSK::Property::Color, color))
++ handleStylePropertyChanged(&QQStyleKitBorderProperties::colorChanged);
++ }
++
++ // ************* QQStyleKitShadowProperties ****************
++
++ QQStyleKitShadowProperties::QQStyleKitShadowProperties(QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitPropertyGroup(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitShadowProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ // Go through all instances of QQStyleKitShadowProperties
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, background()->shadow());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, handle()->shadow());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->shadow());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->foreground()->shadow());
++ }
++
++ QColor QQStyleKitShadowProperties::color() const
++ {
++ return styleProperty<QColor>(QQSK::Property::Color, Qt::transparent);
++ }
++
++ void QQStyleKitShadowProperties::setColor(QColor color)
++ {
++ if (setStyleProperty(QQSK::Property::Color, color))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::colorChanged);
++ }
++
++ qreal QQStyleKitShadowProperties::opacity() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Opacity, 1.0);
++ }
++
++ void QQStyleKitShadowProperties::setOpacity(qreal opacity)
++ {
++ if (setStyleProperty(QQSK::Property::Opacity, opacity))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::opacityChanged);
++ }
++
++ qreal QQStyleKitShadowProperties::scale() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Scale, 1.0);
++ }
++
++ void QQStyleKitShadowProperties::setScale(qreal scale)
++ {
++ if (setStyleProperty(QQSK::Property::Scale, scale))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::scaleChanged);
++ }
++
++ qreal QQStyleKitShadowProperties::verticalOffset() const
++ {
++ return styleProperty<qreal>(QQSK::Property::VOffset);
++ }
++
++ void QQStyleKitShadowProperties::setVerticalOffset(qreal verticalOffset)
++ {
++ if (setStyleProperty(QQSK::Property::VOffset, verticalOffset))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::verticalOffsetChanged);
++ }
++
++ qreal QQStyleKitShadowProperties::horizontalOffset() const
++ {
++ return styleProperty<qreal>(QQSK::Property::HOffset);
++ }
++
++ void QQStyleKitShadowProperties::setHorizontalOffset(qreal horizontalOffset)
++ {
++ if (setStyleProperty(QQSK::Property::HOffset, horizontalOffset))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::horizontalOffsetChanged);
++ }
++
++ qreal QQStyleKitShadowProperties::blur() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Blur, 10.0);
++ }
++
++ void QQStyleKitShadowProperties::setBlur(qreal blur)
++ {
++ if (setStyleProperty(QQSK::Property::Blur, blur))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::blurChanged);
++ }
++
++ bool QQStyleKitShadowProperties::visible() const
++ {
++ return styleProperty<bool>(QQSK::Property::Visible, true);
++ }
++
++ void QQStyleKitShadowProperties::setVisible(bool visible)
++ {
++ if (setStyleProperty(QQSK::Property::Visible, visible))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::visibleChanged);
++ }
++
++ QQmlComponent *QQStyleKitShadowProperties::delegate() const
++ {
++ return styleProperty<QQmlComponent *>(QQSK::Property::Delegate);
++ }
++
++ void QQStyleKitShadowProperties::setDelegate(QQmlComponent *delegate)
++ {
++ if (setStyleProperty(QQSK::Property::Delegate, delegate))
++ handleStylePropertyChanged(&QQStyleKitShadowProperties::delegateChanged);
++ }
++
++ // ************* QQStyleKitDelegateProperties ****************
++
++ QQStyleKitDelegateProperties::QQStyleKitDelegateProperties(QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitPropertyGroup(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitDelegateProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ // Go through all instances of QQStyleKitDelegateProperties
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, background());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, handle());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->foreground());
++ }
++
++ void QQStyleKitDelegateProperties::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ // Keep in sync with the nested groups this class creates with lazyCreateGroup()
++ if (m_image)
++ f(m_image);
++ if (m_border)
++ f(m_border);
++ if (m_shadow)
++ f(m_shadow);
++ }
++
++ qreal QQStyleKitDelegateProperties::radius() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Radius);
++ }
++
++ void QQStyleKitDelegateProperties::setRadius(qreal radius)
++ {
++ if (setStyleProperty(QQSK::Property::Radius, radius))
++ handleStylePropertiesChanged<QQStyleKitDelegateProperties>(
++ &QQStyleKitDelegateProperties::radiusChanged,
++ &QQStyleKitDelegateProperties::topLeftRadiusChanged,
++ &QQStyleKitDelegateProperties::topRightRadiusChanged,
++ &QQStyleKitDelegateProperties::bottomLeftRadiusChanged,
++ &QQStyleKitDelegateProperties::bottomRightRadiusChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::topLeftRadius() const
++ {
++ return styleProperty<qreal>(QQSK::Property::TopLeftRadius, QQSK::Property::Radius);
++ }
++
++ void QQStyleKitDelegateProperties::setTopLeftRadius(qreal radius)
++ {
++ if (setStyleProperty(QQSK::Property::TopLeftRadius, radius))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::topLeftRadiusChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::topRightRadius() const
++ {
++ return styleProperty<qreal>(QQSK::Property::TopRightRadius, QQSK::Property::Radius);
++ }
++
++ void QQStyleKitDelegateProperties::setTopRightRadius(qreal radius)
++ {
++ if (setStyleProperty(QQSK::Property::TopRightRadius, radius))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::topRightRadiusChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::bottomLeftRadius() const
++ {
++ return styleProperty<qreal>(QQSK::Property::BottomLeftRadius, QQSK::Property::Radius);
++ }
++
++ void QQStyleKitDelegateProperties::setBottomLeftRadius(qreal radius)
++ {
++ if (setStyleProperty(QQSK::Property::BottomLeftRadius, radius))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::bottomLeftRadiusChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::bottomRightRadius() const
++ {
++ return styleProperty<qreal>(QQSK::Property::BottomRightRadius, QQSK::Property::Radius);
++ }
++
++ void QQStyleKitDelegateProperties::setBottomRightRadius(qreal radius)
++ {
++ if (setStyleProperty(QQSK::Property::BottomRightRadius, radius))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::bottomRightRadiusChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::scale() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Scale, 1.0);
++ }
++
++ void QQStyleKitDelegateProperties::setScale(qreal scale)
++ {
++ if (setStyleProperty(QQSK::Property::Scale, scale))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::scaleChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::rotation() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Rotation);
++ }
++
++ void QQStyleKitDelegateProperties::setRotation(qreal rotation)
++ {
++ if (setStyleProperty(QQSK::Property::Rotation, rotation))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::rotationChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::width() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Width);
++ }
++
++ void QQStyleKitDelegateProperties::setWidth(qreal width)
++ {
++ if (setStyleProperty(QQSK::Property::Width, width))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::widthChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::height() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Height);
++ }
++
++ void QQStyleKitDelegateProperties::setHeight(qreal height)
++ {
++ if (setStyleProperty(QQSK::Property::Height, height))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::heightChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::minimumWidth() const
++ {
++ return styleProperty<qreal>(QQSK::Property::MinimumWidth);
++ }
++
++ void QQStyleKitDelegateProperties::setMinimumWidth(qreal width)
++ {
++ if (setStyleProperty(QQSK::Property::MinimumWidth, width))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::minimumWidthChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::minimumHeight() const
++ {
++ return styleProperty<qreal>(QQSK::Property::MinimumHeight);
++ }
++
++ void QQStyleKitDelegateProperties::setMinimumHeight(qreal height)
++ {
++ if (setStyleProperty(QQSK::Property::MinimumHeight, height))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::minimumHeightChanged);
++ }
++
++ bool QQStyleKitDelegateProperties::fillWidth() const
++ {
++ return styleProperty<bool>(QQSK::Property::FillWidth);
++ }
++
++ void QQStyleKitDelegateProperties::setFillWidth(bool fill)
++ {
++ if (setStyleProperty(QQSK::Property::FillWidth, fill))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::fillWidthChanged);
++ }
++
++ bool QQStyleKitDelegateProperties::fillHeight() const
++ {
++ return styleProperty<bool>(QQSK::Property::FillHeight);
++ }
++
++ void QQStyleKitDelegateProperties::setFillHeight(bool fill)
++ {
++ if (setStyleProperty(QQSK::Property::FillHeight, fill))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::fillHeightChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::margins() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Margins);
++ }
++
++ void QQStyleKitDelegateProperties::setMargins(qreal margins)
++ {
++ if (setStyleProperty(QQSK::Property::Margins, margins))
++ handleStylePropertiesChanged<QQStyleKitDelegateProperties>(
++ &QQStyleKitDelegateProperties::marginsChanged,
++ &QQStyleKitDelegateProperties::leftMarginChanged,
++ &QQStyleKitDelegateProperties::rightMarginChanged,
++ &QQStyleKitDelegateProperties::topMarginChanged,
++ &QQStyleKitDelegateProperties::bottomMarginChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::leftMargin() const
++ {
++ return styleProperty<qreal>(QQSK::Property::LeftMargin, QQSK::Property::Margins);
++ }
++
++ void QQStyleKitDelegateProperties::setLeftMargin(qreal margin)
++ {
++ if (setStyleProperty(QQSK::Property::LeftMargin, margin))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::leftMarginChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::rightMargin() const
++ {
++ return styleProperty<qreal>(QQSK::Property::RightMargin, QQSK::Property::Margins);
++ }
++
++ void QQStyleKitDelegateProperties::setRightMargin(qreal margin)
++ {
++ if (setStyleProperty(QQSK::Property::RightMargin, margin))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::rightMarginChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::topMargin() const
++ {
++ return styleProperty<qreal>(QQSK::Property::TopMargin, QQSK::Property::Margins);
++ }
++
++ void QQStyleKitDelegateProperties::setTopMargin(qreal margin)
++ {
++ if (setStyleProperty(QQSK::Property::TopMargin, margin))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::topMarginChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::bottomMargin() const
++ {
++ return styleProperty<qreal>(QQSK::Property::BottomMargin, QQSK::Property::Margins);
++ }
++
++ void QQStyleKitDelegateProperties::setBottomMargin(qreal margin)
++ {
++ if (setStyleProperty(QQSK::Property::BottomMargin, margin))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::bottomMarginChanged);
++ }
++
++ Qt::Alignment QQStyleKitDelegateProperties::alignment() const
++ {
++ return styleProperty<Qt::Alignment>(QQSK::Property::Alignment, Qt::AlignLeft | Qt::AlignVCenter);
++ }
++
++ void QQStyleKitDelegateProperties::setAlignment(Qt::Alignment alignment)
++ {
++ if (setStyleProperty(QQSK::Property::Alignment, alignment))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::alignmentChanged);
++ }
++
++ qreal QQStyleKitDelegateProperties::opacity() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Opacity, 1.0);
++ }
++
++ void QQStyleKitDelegateProperties::setOpacity(qreal opacity)
++ {
++ if (setStyleProperty(QQSK::Property::Opacity, opacity))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::opacityChanged);
++ }
++
++ QColor QQStyleKitDelegateProperties::color() const
++ {
++ return styleProperty<QColor>(QQSK::Property::Color, Qt::transparent);
++ }
++
++ void QQStyleKitDelegateProperties::setColor(const QColor &color)
++ {
++ if (setStyleProperty(QQSK::Property::Color, color))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::colorChanged);
++ }
++
++ bool QQStyleKitDelegateProperties::visible() const
++ {
++ return styleProperty<bool>(QQSK::Property::Visible, true);
++ }
++
++ void QQStyleKitDelegateProperties::setVisible(bool visible)
++ {
++ if (setStyleProperty(QQSK::Property::Visible, visible))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::visibleChanged);
++ }
++
++ bool QQStyleKitDelegateProperties::clip() const
++ {
++ return styleProperty<bool>(QQSK::Property::Clip, false);
++ }
++
++ void QQStyleKitDelegateProperties::setClip(bool clip)
++ {
++ if (setStyleProperty(QQSK::Property::Clip, clip))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::clipChanged);
++ }
++
++ QQuickGradient *QQStyleKitDelegateProperties::gradient() const
++ {
++ return styleProperty<QQuickGradient *>(QQSK::Property::Gradient);
++ }
++
++ void QQStyleKitDelegateProperties::setGradient(QQuickGradient *gradient)
++ {
++ if (setStyleProperty(QQSK::Property::Gradient, gradient))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::gradientChanged);
++ }
++
++ QObject *QQStyleKitDelegateProperties::data() const
++ {
++ return styleProperty<QObject *>(QQSK::Property::Data);
++ }
++
++ void QQStyleKitDelegateProperties::setData(QObject *data)
++ {
++ if (setStyleProperty(QQSK::Property::Data, data))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::dataChanged);
++ }
++
++ QQmlComponent *QQStyleKitDelegateProperties::delegate() const
++ {
++ return styleProperty<QQmlComponent *>(QQSK::Property::Delegate);
++ }
++
++ void QQStyleKitDelegateProperties::setDelegate(QQmlComponent *delegate)
++ {
++ if (setStyleProperty(QQSK::Property::Delegate, delegate))
++ handleStylePropertyChanged(&QQStyleKitDelegateProperties::delegateChanged);
++ }
++
++ QQStyleKitBorderProperties *QQStyleKitDelegateProperties::border() const
++ {
++ return lazyCreateGroup(m_border, QQSK::PropertyGroup::Border);
++ }
++
++ QQStyleKitShadowProperties *QQStyleKitDelegateProperties::shadow() const
++ {
++ return lazyCreateGroup(m_shadow, QQSK::PropertyGroup::Shadow);
++ }
++
++ QQStyleKitImageProperties *QQStyleKitDelegateProperties::image() const
++ {
++ return lazyCreateGroup(m_image, QQSK::PropertyGroup::Image);
++ }
++
++ // ************* QQStyleKitHandleProperties ****************
++
++ QQStyleKitHandleProperties::QQStyleKitHandleProperties(QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitDelegateProperties(group, parent)
++ {
++ }
++
++ void QQStyleKitHandleProperties::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ // Keep in sync with the nested groups this class creates with lazyCreateGroup()
++ QQStyleKitDelegateProperties::forEachExistingNestedGroup(f);
++ if (m_first)
++ f(m_first);
++ if (m_second)
++ f(m_second);
++ }
++
++ QQStyleKitDelegateProperties *QQStyleKitHandleProperties::first() const
++ {
++ return lazyCreateGroup(m_first, QQSK::PropertyGroup::DelegateSubtype1);
++ }
++
++ QQStyleKitDelegateProperties *QQStyleKitHandleProperties::second() const
++ {
++ return lazyCreateGroup(m_second, QQSK::PropertyGroup::DelegateSubtype2);
++ }
++
++ // ************* QQStyleKitIndicatorProperties ****************
++
++ QQStyleKitIndicatorProperties::QQStyleKitIndicatorProperties(
++ QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitDelegateProperties(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitIndicatorProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ // Go through all instances of QQStyleKitIndicatorProperties
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->first());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator()->second());
++ }
++
++ void QQStyleKitIndicatorProperties::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ // Keep in sync with the nested groups this class creates with lazyCreateGroup()
++ QQStyleKitDelegateProperties::forEachExistingNestedGroup(f);
++ if (m_foreground)
++ f(m_foreground);
++ }
++
++ QQStyleKitDelegateProperties *QQStyleKitIndicatorProperties::foreground() const
++ {
++ return lazyCreateGroup(m_foreground, QQSK::PropertyGroup::Foreground);
++ }
++
++ // ************* QQStyleKitIndicatorWithSubTypes ****************
++
++ QQStyleKitIndicatorWithSubTypes::QQStyleKitIndicatorWithSubTypes(
++ QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitDelegateProperties(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitIndicatorWithSubTypes::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ // Go through all instances of QQStyleKitIndicatorWithSubTypes
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, indicator());
++ }
++
++ void QQStyleKitIndicatorWithSubTypes::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ // Keep in sync with the nested groups this class creates with lazyCreateGroup()
++ QQStyleKitDelegateProperties::forEachExistingNestedGroup(f);
++ if (m_foreground)
++ f(m_foreground);
++ if (m_first)
++ f(m_first);
++ if (m_second)
++ f(m_second);
++ }
++
++ QQStyleKitDelegateProperties *QQStyleKitIndicatorWithSubTypes::foreground() const
++ {
++ return lazyCreateGroup(m_foreground, QQSK::PropertyGroup::Foreground);
++ }
++
++ QQStyleKitIndicatorProperties *QQStyleKitIndicatorWithSubTypes::up() const
++ {
++ return first();
++ }
++
++ QQStyleKitIndicatorProperties *QQStyleKitIndicatorWithSubTypes::down() const
++ {
++ return second();
++ }
++
++ QQStyleKitIndicatorProperties *QQStyleKitIndicatorWithSubTypes::first() const
++ {
++ return lazyCreateGroup(m_first, QQSK::PropertyGroup::DelegateSubtype1);
++ }
++
++ QQStyleKitIndicatorProperties *QQStyleKitIndicatorWithSubTypes::second() const
++ {
++ return lazyCreateGroup(m_second, QQSK::PropertyGroup::DelegateSubtype2);
++ }
++
++ // ************* QQStyleKitTextProperties ****************
++ QQStyleKitTextProperties::QQStyleKitTextProperties(QQSK::PropertyGroup group, QQStyleKitControlProperties *parent)
++ : QQStyleKitPropertyGroup(group, parent)
++ {
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitTextProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ const QQStyleKitControlProperties *cp = controlProperties();
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, text());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, text()->first());
++ CONDITIONALLY_EMIT_SIGNALS_GLOBALLY_FOR(cp, text()->second());
++ }
++
++ void QQStyleKitTextProperties::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ // Keep in sync with the nested groups this class creates with lazyCreateGroup()
++ if (m_first)
++ f(m_first);
++ if (m_second)
++ f(m_second);
++ }
++
++ QColor QQStyleKitTextProperties::color() const
++ {
++ return styleProperty<QColor>(QQSK::Property::Color);
++ }
++
++ void QQStyleKitTextProperties::setColor(const QColor &color)
++ {
++ if (setStyleProperty(QQSK::Property::Color, color))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::colorChanged);
++ }
++
++ Qt::Alignment QQStyleKitTextProperties::alignment() const
++ {
++ return styleProperty<Qt::Alignment>(QQSK::Property::Alignment);
++ }
++
++ void QQStyleKitTextProperties::setAlignment(Qt::Alignment alignment)
++ {
++ if (setStyleProperty(QQSK::Property::Alignment, alignment))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::alignmentChanged);
++ }
++
++ bool QQStyleKitTextProperties::bold() const
++ {
++ return styleProperty<bool>(QQSK::Property::Bold, false);
++ }
++
++ void QQStyleKitTextProperties::setBold(bool bold)
++ {
++ if (setStyleProperty(QQSK::Property::Bold, bold))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::boldChanged);
++ }
++
++ bool QQStyleKitTextProperties::italic() const
++ {
++ return styleProperty<bool>(QQSK::Property::Italic, false);
++ }
++
++ void QQStyleKitTextProperties::setItalic(bool italic)
++ {
++ if (setStyleProperty(QQSK::Property::Italic, italic))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::italicChanged);
++ }
++
++ qreal QQStyleKitTextProperties::pointSize() const
++ {
++ return styleProperty<qreal>(QQSK::Property::PointSize, QFont().pointSize());
++ }
++
++ void QQStyleKitTextProperties::setPointSize(qreal pointSize)
++ {
++ if (setStyleProperty(QQSK::Property::PointSize, pointSize))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::pointSizeChanged);
++ }
++
++ qreal QQStyleKitTextProperties::padding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Padding);
++ }
++
++ void QQStyleKitTextProperties::setPadding(qreal padding)
++ {
++ if (setStyleProperty(QQSK::Property::Padding, padding))
++ handleStylePropertiesChanged<QQStyleKitTextProperties>(
++ &QQStyleKitTextProperties::paddingChanged,
++ &QQStyleKitTextProperties::leftPaddingChanged,
++ &QQStyleKitTextProperties::rightPaddingChanged,
++ &QQStyleKitTextProperties::topPaddingChanged,
++ &QQStyleKitTextProperties::bottomPaddingChanged);
++ }
++
++ qreal QQStyleKitTextProperties::leftPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::LeftPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitTextProperties::setLeftPadding(qreal padding)
++ {
++ if (setStyleProperty(QQSK::Property::LeftPadding, padding))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::leftPaddingChanged);
++ }
++
++ qreal QQStyleKitTextProperties::rightPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::RightPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitTextProperties::setRightPadding(qreal padding)
++ {
++ if (setStyleProperty(QQSK::Property::RightPadding, padding))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::rightPaddingChanged);
++ }
++
++ qreal QQStyleKitTextProperties::topPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::TopPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitTextProperties::setTopPadding(qreal padding)
++ {
++ if (setStyleProperty(QQSK::Property::TopPadding, padding))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::topPaddingChanged);
++ }
++
++ qreal QQStyleKitTextProperties::bottomPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::BottomPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitTextProperties::setBottomPadding(qreal padding)
++ {
++ if (setStyleProperty(QQSK::Property::BottomPadding, padding))
++ handleStylePropertyChanged(&QQStyleKitTextProperties::bottomPaddingChanged);
++ }
++
++ QQStyleKitTextProperties *QQStyleKitTextProperties::first() const
++ {
++ return lazyCreateGroup(m_first, QQSK::PropertyGroup::DelegateSubtype1);
++ }
++
++ QQStyleKitTextProperties *QQStyleKitTextProperties::second() const
++ {
++ return lazyCreateGroup(m_second, QQSK::PropertyGroup::DelegateSubtype2);
++ }
++
++ // ************* QQStyleKitControlProperties ****************
++
++ QQStyleKitControlProperties::QQStyleKitControlProperties(QQSK::PropertyGroup group, QObject *parent)
++ : QQStyleKitPropertyGroup(group, parent)
++ {
++ /* Calculate the free space storage ID space that can accommodate all unique style
++ * properties that may be applied to a control. Since we'll prepend different states
++ * and subtypes during the property propagation lookup phase later, we need to reserve
++ * ID space for them both already now. More docs about the property space is written in
++ * the implementation of QQStyleKitPropertyPath. */
++ m_groupSpace.size = nestedGroupsStartSize;
++ m_groupSpace.start = 0;
++
++ if (group == QQSK::PropertyGroup::GlobalFlag) {
++ /* A property path may include pseudo-groups that offers a convenient API for
++ * reading properties with specific options applied. The 'global' group is one such
++ * pseudo-group. When it is prefixed to a property path, it indicates that the property
++ * should be read directly from the style, bypassing any active transitions that might
++ * otherwise affect its value.
++ * Note: The global group should be ignored when computing a PropertyPathId, as it
++ * only affect _where_ the property should be read from, not its ID. */
++ m_pathFlags.setFlag(QQSK::PropertyPathFlag::Global);
++ }
++ }
++
++ QQStyleKitStyle *QQStyleKitControlProperties::style() const
++ {
++ if (subclass() == QQSK::Subclass::QQStyleKitState) {
++ /* A QQStyleKitControlState (and its subclasses) should always be a (grand)child of a
++ * QQStyleKitStyle. And it belongs to that style, even it that style is not the
++ * currently active application style. This is opposed to a QQStyleKitReader,
++ * that normally belongs / communicates with the currently active style.
++ * NOTE: a style can also be a fallback style for another style (which can be recursive,
++ * meaning that a fallback style can also have its own fallback style, and so on). But
++ * this function will return the nearest style, and not the root style */
++ QObject *obj = parent();
++ while (obj && !obj->metaObject()->inherits(&QQStyleKitStyle::staticMetaObject))
++ obj = obj->parent();
++ return obj ? static_cast<QQStyleKitStyle *>(obj) : nullptr;
++ }
++
++ if (subclass() == QQSK::Subclass::QQStyleKitReader) {
++ const auto *reader = static_cast<const QQStyleKitReader *>(this);
++ if (reader->m_explicitStyle)
++ return reader->m_explicitStyle;
++ }
++
++ // For a QQStyleKitReader without an explicit style, we return the currently active style for now
++ return QQStyleKitStyle::current();
++ }
++
++ QQSK::Subclass QQStyleKitControlProperties::subclass() const
++ {
++ /* QQStyleKitControlProperties is subclassed by several different classes in this
++ * framework. As such, it's basically just an interface because it only declares the
++ * different properties that can be read or written to in a QQStyleKitStyle, such as
++ * hovered.background.color or pressed.indicator.foreground.color. It says nothing
++ * about how those properties are stored, instead that is up to each individual
++ * subclass to decide */
++ if (metaObject()->inherits(&QQStyleKitReader::staticMetaObject))
++ return QQSK::Subclass::QQStyleKitReader;
++ if (metaObject()->inherits(&QQStyleKitControlState::staticMetaObject))
++ return QQSK::Subclass::QQStyleKitState;
++ Q_UNREACHABLE();
++ }
++
++ QQStyleKitReader *QQStyleKitControlProperties::asQQStyleKitReader() const
++ {
++ Q_ASSERT(subclass() == QQSK::Subclass::QQStyleKitReader);
++ return static_cast<QQStyleKitReader *>(const_cast<QQStyleKitControlProperties *>(this));
++ }
++
++ QQStyleKitControlState *QQStyleKitControlProperties::asQQStyleKitState() const
++ {
++ Q_ASSERT(subclass() == QQSK::Subclass::QQStyleKitState);
++ Q_ASSERT(metaObject()->inherits(&QQStyleKitControlState::staticMetaObject));
++ return static_cast<QQStyleKitControlState *>(const_cast<QQStyleKitControlProperties *>(this));
++ }
++
++ void QQStyleKitControlProperties::forEachUsedDelegate(
++ std::function<void (QQStyleKitDelegateProperties *, QQSK::Delegate, const QString &)> f)
++ {
++ // If adding more delegates here, remember to keep StyleAnimation.qml in sync
++ if (m_background)
++ f(m_background, QQSK::Delegate::Background, "background"_L1);
++
++ if (m_indicator) {
++ f(m_indicator, QQSK::Delegate::Indicator, "indicator"_L1);
++ if (m_indicator->m_foreground)
++ f(m_indicator->m_foreground, QQSK::Delegate::IndicatorForeground, "indicator.foreground"_L1);
++ if (m_indicator->m_first) {
++ f(m_indicator->m_first, QQSK::Delegate::IndicatorFirst, "indicator.first"_L1);
++ if (m_indicator->m_first->m_foreground)
++ f(m_indicator->m_first->m_foreground, QQSK::Delegate::IndicatorFirstForeground, "indicator.first.foreground"_L1);
++ }
++ if (m_indicator->m_second) {
++ f(m_indicator->m_second, QQSK::Delegate::IndicatorSecond, "indicator.second"_L1);
++ if (m_indicator->m_second->m_foreground)
++ f(m_indicator->m_second->m_foreground, QQSK::Delegate::IndicatorSecondForeground, "indicator.second.foreground"_L1);
++ }
++ }
++
++ if (m_handle) {
++ f(m_handle, QQSK::Delegate::Handle, "handle"_L1);
++ if (m_handle->m_first)
++ f(m_handle->m_first, QQSK::Delegate::HandleFirst, "handle.first"_L1);
++ if (m_handle->m_second)
++ f(m_handle->m_second, QQSK::Delegate::HandleSecond, "handle.second"_L1);
++ }
++ }
++
++ void QQStyleKitControlProperties::emitChangedForAllStyleProperties(EmitFlags emitFlags)
++ {
++ /* This brute-force function will emit update signals for _all_ style properties
++ * in the QQStyleKitStyle API. Doing so is typically needed after a style-, or theme
++ * change, as we don't know which properties are affected by such a big change. */
++ emitChangedForAllStylePropertiesRecursive(emitFlags);
++ }
++
++ template <typename... CHANGED_SIGNALS>
++ void QQStyleKitControlProperties::emitGlobally(
++ QQStyleKitExtendableControlType controlType, CHANGED_SIGNALS... changedSignals) const
++ {
++ for (QQStyleKitReader *reader : QQStyleKitReader::s_allReaders) {
++ if (reader->controlType() != controlType)
++ continue;
++ ((reader->*changedSignals)(), ...);
++ }
++ }
++
++ void QQStyleKitControlProperties::forEachExistingNestedGroup(
++ const std::function<void (QQStyleKitPropertyGroup *)> &f) const
++ {
++ // Keep in sync with the nested groups this class creates with lazyCreateGroup()
++ if (m_background)
++ f(m_background);
++ if (m_handle)
++ f(m_handle);
++ if (m_indicator)
++ f(m_indicator);
++ if (m_text)
++ f(m_text);
++ }
++
++ qreal QQStyleKitControlProperties::spacing() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Spacing);
++ }
++
++ void QQStyleKitControlProperties::setSpacing(qreal spacing)
++ {
++ if (setStyleProperty(QQSK::Property::Spacing, spacing))
++ handleStylePropertyChanged(&QQStyleKitControlProperties::spacingChanged);
++ }
++
++ qreal QQStyleKitControlProperties::padding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::Padding);
++ }
++
++ void QQStyleKitControlProperties::setPadding(qreal padding)
++ {
++ if (setStyleProperty(QQSK::Property::Padding, padding))
++ handleStylePropertiesChanged<QQStyleKitControlProperties>(
++ &QQStyleKitControlProperties::paddingChanged,
++ &QQStyleKitControlProperties::leftPaddingChanged,
++ &QQStyleKitControlProperties::rightPaddingChanged,
++ &QQStyleKitControlProperties::topPaddingChanged,
++ &QQStyleKitControlProperties::bottomPaddingChanged);
++ }
++
++ qreal QQStyleKitControlProperties::leftPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::LeftPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitControlProperties::setLeftPadding(qreal leftPadding)
++ {
++ if (setStyleProperty(QQSK::Property::LeftPadding, leftPadding))
++ handleStylePropertyChanged(&QQStyleKitControlProperties::leftPaddingChanged);
++ }
++
++ qreal QQStyleKitControlProperties::rightPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::RightPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitControlProperties::setRightPadding(qreal rightPadding)
++ {
++ if (setStyleProperty(QQSK::Property::RightPadding, rightPadding))
++ handleStylePropertyChanged(&QQStyleKitControlProperties::rightPaddingChanged);
++ }
++
++ qreal QQStyleKitControlProperties::topPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::TopPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitControlProperties::setTopPadding(qreal topPadding)
++ {
++ if (setStyleProperty(QQSK::Property::TopPadding, topPadding))
++ handleStylePropertyChanged(&QQStyleKitControlProperties::topPaddingChanged);
++ }
++
++ qreal QQStyleKitControlProperties::bottomPadding() const
++ {
++ return styleProperty<qreal>(QQSK::Property::BottomPadding, QQSK::Property::Padding);
++ }
++
++ void QQStyleKitControlProperties::setBottomPadding(qreal bottomPadding)
++ {
++ if (setStyleProperty(QQSK::Property::BottomPadding, bottomPadding))
++ handleStylePropertyChanged(&QQStyleKitControlProperties::bottomPaddingChanged);
++ }
++
++ QQuickTransition *QQStyleKitControlProperties::transition() const
++ {
++ return styleProperty<QQuickTransition *>(QQSK::Property::Transition);
++ }
++
++ void QQStyleKitControlProperties::setTransition(QQuickTransition *transition)
++ {
++ if (setStyleProperty(QQSK::Property::Transition, transition))
++ handleStylePropertyChanged(&QQStyleKitControlProperties::transitionChanged);
++ }
++
++ QQStyleKitTextProperties *QQStyleKitControlProperties::text() const
++ {
++ return lazyCreateGroup(m_text, QQSK::PropertyGroup::Text);
++ }
++
++ QQStyleKitDelegateProperties *QQStyleKitControlProperties::background() const
++ {
++ return lazyCreateGroup(m_background, QQSK::PropertyGroup::Background);
++ }
++
++ QQStyleKitHandleProperties *QQStyleKitControlProperties::handle() const
++ {
++ return lazyCreateGroup(m_handle, QQSK::PropertyGroup::Handle);
++ }
++
++ QQStyleKitIndicatorWithSubTypes *QQStyleKitControlProperties::indicator() const
++ {
++ return lazyCreateGroup(m_indicator, QQSK::PropertyGroup::Indicator);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqstylekitcontrolproperties_p.cpp"