more operations for QskGradientStops

Otherwise it won't work for WAsm.
According to the doc: "The name after the project has to be unique
for each call."

.github/workflows/cmake.yml

@@ -202,7 +202,6 @@ jobs:
           install-deps: "true"
           modules: "qtwebengine"
           cached: ${{ steps.cache-qt-5-15.outputs.cache-hit }}
-          setup-python: "false"
           tools: ""
           set-env: "true"
           tools-only: "false"
@@ -216,7 +215,6 @@ jobs:
           install-deps: "true"
           modules: "qtwebengine qtshadertools"
           cached: ${{ steps.cache-qt-6-2.outputs.cache-hit }}
-          setup-python: "false"
           tools: ""
           set-env: "true"
           tools-only: "false"

cmake/QskBuildFunctions.cmake

@@ -149,7 +149,7 @@ function(qsk_add_example target)
 
 endfunction()
 
-function(qsk_add_shaders target)
+function(qsk_add_shaders target shader_name)
 
     cmake_parse_arguments( arg "" "" "FILES" ${ARGN} )
 
@@ -160,7 +160,7 @@ function(qsk_add_shaders target)
         list(APPEND outfiles "${qsbname}.qsb")
     endforeach()
 
-    qt6_add_shaders( ${target} "qskshaders" BATCHABLE PRECOMPILE QUIET
+    qt6_add_shaders( ${target} ${shader_name} BATCHABLE PRECOMPILE QUIET
         PREFIX "/qskinny/shaders" ${ARGV} OUTPUTS ${outfiles} )
 
     # pass on OUTPUT_TARGETS to the caller of this function

designsystems/material3/QskMaterial3ProgressBarSkinlet.cpp

@@ -5,9 +5,7 @@
 
 #include "QskMaterial3ProgressBarSkinlet.h"
 #include <QskProgressBar.h>
-#include <QskBoxShapeMetrics.h>
-#include <QskBoxBorderMetrics.h>
-#include <QskBoxBorderColors.h>
+#include <QskBoxHints.h>
 #include <QskMargins.h>
 #include <QskClipNode.h>
 #include <QskSGNode.h>
@@ -65,11 +63,11 @@ QSGNode* QskMaterial3ProgressBarSkinlet::updateStopIndicatorNode(
     else         
         rect.setBottom( rect.top() + rect.width() );
 
-    const auto color = progressBar->gradientHint( Q::Fill ).endColor();
-    const auto shape = progressBar->boxShapeHint( Q::Fill );
+    QskBoxHints hints;
+    hints.shape = progressBar->boxShapeHint( Q::Fill );
+    hints.gradient = progressBar->gradientHint( Q::Fill ).endColor();
 
-    return updateBoxNode( progressBar, node, rect, shape,
-        QskBoxBorderMetrics(), QskBoxBorderColors(), color );
+    return updateBoxNode( progressBar, node, rect, hints );
 }
 
 QSGNode* QskMaterial3ProgressBarSkinlet::updateGrooveClipNode(

examples/iotdashboard/StorageBarSkinlet.cpp

@@ -14,8 +14,8 @@ StorageBarSkinlet::StorageBarSkinlet( QskSkin* skin )
     setNodeRoles( { Pictures, Music, Videos, Documents, Others, Free } );
 }
 
-QRectF StorageBarSkinlet::subControlRect( const QskSkinnable* skinnable, const QRectF& contentsRect,
-    QskAspect::Subcontrol subControl ) const
+QRectF StorageBarSkinlet::subControlRect( const QskSkinnable* skinnable,
+    const QRectF& contentsRect, QskAspect::Subcontrol subControl ) const
 {
     const auto* const bar = static_cast< const S* >( skinnable );
 
@@ -70,35 +70,29 @@ QRectF StorageBarSkinlet::subControlRect( const QskSkinnable* skinnable, const Q
     return Inherited::subControlRect( skinnable, contentsRect, subControl );
 }
 
-namespace
-{
-    inline QSGNode* updateSegmentBoxNode(
-        const S* const skinnable, const QskAspect::Subcontrol& subcontrol, QSGNode* const node )
-    {
-        return QskSkinlet::updateBoxNode( skinnable, node, skinnable->subControlRect( subcontrol ),
-            skinnable->gradientHint( subcontrol ), subcontrol );
-    }
-}
-
 QSGNode* StorageBarSkinlet::updateSubNode(
     const QskSkinnable* const skinnable, const quint8 nodeRole, QSGNode* const node ) const
 {
-    const auto* const bar = static_cast< const S* >( skinnable );
-
     switch ( nodeRole )
     {
         case Pictures:
-            return updateSegmentBoxNode( bar, S::Pictures, node );
+            return updateBoxNode( skinnable, node, S::Pictures );
+
         case Music:
-            return updateSegmentBoxNode( bar, S::Music, node );
+            return updateBoxNode( skinnable, node, S::Music );
+
         case Videos:
-            return updateSegmentBoxNode( bar, S::Videos, node );
+            return updateBoxNode( skinnable, node, S::Videos );
+
         case Documents:
-            return updateSegmentBoxNode( bar, S::Documents, node );
+            return updateBoxNode( skinnable, node, S::Documents );
+
         case Others:
-            return updateSegmentBoxNode( bar, S::Others, node );
+            return updateBoxNode( skinnable, node, S::Others );
+
         case Free:
-            return updateSegmentBoxNode( bar, S::Free, node );
+            return updateBoxNode( skinnable, node, S::Free );
+
         default:
             return Inherited::updateSubNode( skinnable, nodeRole, node );
     }

playground/CMakeLists.txt

@@ -9,7 +9,6 @@ add_subdirectory(shadows)
 add_subdirectory(shapes)
 add_subdirectory(charts)
 add_subdirectory(plots)
-add_subdirectory(drawer)
 
 if (BUILD_INPUTCONTEXT)
     add_subdirectory(inputpanel)

playground/drawer/CMakeLists.txt

@@ -1,6 +0,0 @@
-############################################################################
-# QSkinny - Copyright (C) 2016 Uwe Rathmann
-#           SPDX-License-Identifier: BSD-3-Clause
-############################################################################
-
-qsk_add_example(drawer main.cpp)

playground/drawer/main.cpp

@@ -1,144 +0,0 @@
-/******************************************************************************
- * QSkinny - Copyright (C) 2016 Uwe Rathmann
- *           SPDX-License-Identifier: BSD-3-Clause
- *****************************************************************************/
-
-#include "SkinnyShortcut.h"
-
-#include <QskRgbValue.h>
-#include <QskControl.h>
-#include <QskDrawer.h>
-#include <QskPushButton.h>
-#include <QskFocusIndicator.h>
-#include <QskWindow.h>
-#include <QskEvent.h>
-#include <QskAnimationHint.h>
-
-#include <QGuiApplication>
-
-namespace
-{
-    class Drawer : public QskDrawer
-    {
-      public:
-        Drawer( Qt::Edge edge,  QQuickItem* parent )
-            : QskDrawer( parent )
-        {
-            setEdge( edge );
-
-            auto content = new QskControl( this );
-            content->setObjectName( "Content" );
-            content->setAutoLayoutChildren( true );
-            content->setMargins( 20 );
-
-            auto button = new QskPushButton( "Push Me", content );
-            button->setSizePolicy( QskSizePolicy::Fixed, QskSizePolicy::Fixed );
-            button->setLayoutAlignmentHint( Qt::AlignCenter );
-
-            const auto size = content->sizeHint();
-
-            switch( edge )
-            {
-                case Qt::LeftEdge:
-                    setPanel( QskRgb::Tomato );
-                    break;
-
-                case Qt::RightEdge:
-                    setPanel( QskRgb::Orchid );
-                    content->setFixedWidth( 1.5 * size.width() );
-                    break;
-
-                case Qt::TopEdge:
-                    setPanel( QskRgb::Chartreuse );
-                    break;
-
-                case Qt::BottomEdge:
-                    setPanel( QskRgb::Wheat );
-                    content->setFixedHeight( 2 * size.height() );
-                    break;
-            }
-        }
-
-      private:
-        void setPanel( const QColor& color )
-        {
-            setGradientHint( Panel, color );
-        }
-    };
-
-    class DrawerBox : public QskControl
-    {
-      public:
-        DrawerBox( QQuickItem* parent = nullptr )
-            : QskControl( parent )
-        {
-            setBackgroundColor( QskRgb::LightSteelBlue );
-
-            setMargins( 10 );
-            setAutoLayoutChildren( true );
-
-            for ( int i = 0; i < 4; i++ )
-            {
-                const auto edge = static_cast< Qt::Edge >( 1 << i );
-
-                auto dragMargin = 30; // the default setting is pretty small
-                if ( edge == Qt::TopEdge )
-                {
-                    // to check if dragging works above the button
-                    dragMargin = 120;
-                }
-
-                auto drawer = new Drawer( edge, this );
-                drawer->setDragMargin( dragMargin );
-
-                connect( drawer, &QskPopup::openChanged,
-                    this, &DrawerBox::setDrawersLocked );
-                
-                m_drawers[i] = drawer;
-            }
-
-            auto button = new QskPushButton( "Push Me", this );
-            button->setPreferredHeight( 100 );
-        }
-
-      private:
-        void setDrawersLocked( bool locked )
-        {
-            for ( auto drawer : m_drawers )
-            {
-                if ( !drawer->isOpen() )
-                    drawer->setInteractive( !locked );
-            }
-        }
-
-        Drawer* m_drawers[4];
-    };
-
-    class MainBox : public QskControl
-    {
-      public:
-        MainBox( QQuickItem* parent = nullptr )
-            : QskControl( parent )
-        {
-            setMargins( 40 );
-            setAutoLayoutChildren( true );
-
-            ( void ) new DrawerBox( this );
-        }
-    };
-}
-
-int main( int argc, char* argv[] )
-{
-    QGuiApplication app( argc, argv );
-
-    SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts );
-
-    QskWindow window;
-    window.addItem( new QskFocusIndicator() );
-    window.addItem( new MainBox() );
-    window.resize( 600, 600 );
-    window.show();
-
-    return app.exec();
-}

playground/plots/PlotCursorSkinlet.cpp

@@ -9,6 +9,7 @@
 #include <QskSGNode.h>
 #include <QskTextOptions.h>
 #include <QskTextColors.h>
+#include <QskBoxHints.h>
 
 #include <QskPlotCurve.h>
 #include <QskPlotCorridor.h>
@@ -143,8 +144,10 @@ QSGNode* PlotCursorSkinlet::updateSampleNode( const QskSkinnable* skinnable,
 
     if ( subControl == Q::LabelPanel )
     {
-        const auto gradient = skinnable->gradientHint( aspect );
-        return updateBoxNode( skinnable, node, rect, gradient, subControl );
+        auto hints = skinnable->boxHints( subControl );
+        hints.gradient = skinnable->gradientHint( aspect );
+
+        return updateBoxNode( skinnable, node, rect, hints );
     }
 
     if ( subControl == Q::LabelText )

playground/shadows/CMakeLists.txt

@@ -35,6 +35,6 @@ if (QT_VERSION_MAJOR VERSION_GREATER_EQUAL 6)
         shaders/arcshadow-vulkan.vert
         shaders/arcshadow-vulkan.frag
     )
-    qsk_add_shaders( ${target} FILES ${SHADERS} OUTPUT_TARGETS shader_target)
+    qsk_add_shaders( ${target} "qskArcShaders" FILES ${SHADERS} OUTPUT_TARGETS shader_target)
 endif()
 

playground/shadows/ShadowedArc.cpp

@@ -8,7 +8,7 @@
 
 #include <QskSkinlet.h>
 #include <QskArcNode.h>
-#include <QskArcMetrics.h>
+#include <QskArcHints.h>
 #include <QskShadowMetrics.h>
 #include <QskSGNode.h>
 #include <QskRgbValue.h>
@@ -107,14 +107,7 @@ namespace
             return nullptr;
 
         auto arcNode = QskSGNode::ensureNode< QskArcNode >( node );
-
-        const auto metrics = arc->arcMetricsHint( Q::Arc );
-        const auto fillGradient = arc->gradientHint( Q::Arc );
-
-        const auto borderColor = arc->color( Q::Arc | QskAspect::Border );
-        const auto borderWidth = arc->metric( Q::Arc | QskAspect::Border );
-
-        arcNode->setArcData( rect, metrics, borderWidth, borderColor, fillGradient );
+        arcNode->setArcData( rect, arc->arcHints( Q::Arc ) );
 
         return arcNode;
     }

playground/shadows/Slider.cpp

@@ -21,6 +21,7 @@ Slider::Slider( const QString& text, qreal min, qreal max,
     m_slider->setBoundaries( min, max );
     m_slider->setStepSize( step );
     m_slider->setSnapping( true );
+    m_slider->setTickPolicy( Qsk::Never ); // too many steps
     m_slider->setValue( value );
 
     m_valueLabel = new QskTextLabel( this );

src/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 list(APPEND HEADERS
     common/QskArcMetrics.h
+    common/QskArcHints.h
     common/QskAspect.h
     common/QskBoxBorderColors.h
     common/QskBoxBorderMetrics.h
@@ -41,6 +42,7 @@ list(APPEND HEADERS
 
 list(APPEND SOURCES
     common/QskArcMetrics.cpp
+    common/QskArcHints.cpp
     common/QskAspect.cpp
     common/QskBoxBorderColors.cpp
     common/QskBoxBorderMetrics.cpp
@@ -508,7 +510,7 @@ else()
 endif()
 
 if (QT_VERSION_MAJOR VERSION_GREATER_EQUAL 6)
-    qsk_add_shaders( ${target} FILES ${SHADERS} OUTPUT_TARGETS shader_target)
+    qsk_add_shaders( ${target} "qskshaders" FILES ${SHADERS} OUTPUT_TARGETS shader_target)
 endif()
 
 target_include_directories(${target} PUBLIC

src/common/QskArcHints.cpp

@@ -0,0 +1,69 @@
+/******************************************************************************
+ * QSkinny - Copyright (C) The authors
+ *           SPDX-License-Identifier: BSD-3-Clause
+ *****************************************************************************/
+
+#include "QskArcHints.h"
+#include "QskRgbValue.h"
+
+static inline qreal qskInterpolated( qreal from, qreal to, qreal ratio )
+{
+    return from + ( to - from ) * ratio;
+}
+
+QskArcHints::QskArcHints()
+{
+}
+
+QskArcHints::QskArcHints( const QskArcMetrics& metrics, qreal borderWidth,
+        const QColor& borderColor, const QskGradient& gradient )
+    : metrics( metrics )
+    , borderWidth( borderWidth )
+    , borderColor( borderColor )
+    , gradient( gradient )
+{
+}
+
+bool QskArcHints::isVisible() const
+{
+    if ( metrics.isNull() ) 
+        return false;
+                
+    if ( borderWidth > 0.0 && borderColor.isValid() && borderColor.alpha() > 0 )
+        return true;
+                
+    return gradient.isVisible();
+}
+
+QskArcHints QskArcHints::toAbsolute( const QSizeF& size ) const noexcept
+{
+    return QskArcHints( metrics.toAbsolute( size ),
+        borderWidth, borderColor, gradient );
+}
+
+QskArcHints QskArcHints::interpolated(
+    const QskArcHints& to, qreal value ) const noexcept
+{
+    return QskArcHints(
+        metrics.interpolated( to.metrics, value ),
+        qskInterpolated( borderWidth, to.borderWidth, value ),
+        QskRgb::interpolated( borderColor, to.borderColor, value ),
+        gradient.interpolated( to.gradient, value )
+    );
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+
+#include <qdebug.h>
+
+QDebug operator<<( QDebug debug, const QskArcHints& hints )
+{
+    debug << hints.metrics << hints.borderWidth
+        << hints.borderColor << hints.gradient;
+
+    return debug;
+}
+
+#endif
+
+#include "moc_QskArcHints.cpp"

src/common/QskArcHints.h

@@ -0,0 +1,47 @@
+/******************************************************************************
+ * QSkinny - Copyright (C) The authors
+ *           SPDX-License-Identifier: BSD-3-Clause
+ *****************************************************************************/
+
+#ifndef QSK_ARC_HINTS_H
+#define QSK_ARC_HINTS_H
+
+#include "QskArcMetrics.h"
+#include "QskGradient.h"
+#include <qcolor.h>
+
+class QSK_EXPORT QskArcHints
+{
+    Q_GADGET
+
+    Q_PROPERTY( QskArcMetrics metrics MEMBER metrics )
+    Q_PROPERTY( qreal borderWidth MEMBER borderWidth )
+    Q_PROPERTY( QColor borderColor MEMBER borderColor )
+
+  public:
+    QskArcHints();
+    QskArcHints( const QskArcMetrics&, qreal borderWidth,
+        const QColor& borderColor, const QskGradient& );
+
+    QskArcHints toAbsolute( const QSizeF& ) const noexcept;
+
+    QskArcHints interpolated(
+        const QskArcHints&, qreal value ) const noexcept;
+
+    bool isVisible() const;
+
+    QskArcMetrics metrics;
+    qreal borderWidth = 0.0;
+
+    QColor borderColor;
+    QskGradient gradient;
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+
+class QDebug;
+QSK_EXPORT QDebug operator<<( QDebug, const QskArcHints& );
+
+#endif
+
+#endif

src/common/QskGradient.cpp

@@ -81,7 +81,7 @@ QskGradient::QskGradient( const QColor& color1, const QColor& color2 )
 QskGradient::QskGradient( QGradient::Preset preset )
     : QskGradient()
 {
-    setStops( qskBuildGradientStops( QGradient( preset ).stops() ) );
+    setStops( qskFromQGradientStops( QGradient( preset ).stops() ) );
 }
 
 QskGradient::QskGradient( const QVector< QskGradientStop >& stops )
@@ -165,7 +165,7 @@ QskGradient::QskGradient( const QGradient& qGradient )
         }
     }
 
-    setStops( qskBuildGradientStops( qGradient.stops() ) );
+    setStops( qskFromQGradientStops( qGradient.stops() ) );
 }
 
 QskGradient::QskGradient( const QskGradient& other ) noexcept
@@ -305,7 +305,7 @@ void QskGradient::setStops( const QColor& color1, const QColor& color2 )
 
 void QskGradient::setStops( QGradient::Preset preset )
 {
-    const auto stops = qskBuildGradientStops( QGradient( preset ).stops() );
+    const auto stops = qskFromQGradientStops( QGradient( preset ).stops() );
     setStops( stops );
 }
 

src/common/QskGradientStop.cpp

@@ -23,6 +23,31 @@ static void qskRegisterGradientStop()
 
 Q_CONSTRUCTOR_FUNCTION( qskRegisterGradientStop )
 
+static inline qreal qskBoundedStopPos( qreal pos )
+{
+    if ( ( pos < 0.0 ) || qFuzzyIsNull( pos ) )
+        return 0.0;
+
+    if ( ( pos > 1.0 ) || qFuzzyCompare( pos, 1.0 ) )
+        return 1.0;
+
+    return pos;
+}
+
+static inline QVector< QskGradientStop >
+qskNormalizedStops( const QVector< QskGradientStop >& stops )
+{
+    auto s = stops;
+
+    if ( s.first().position() > 0.0 )
+        s.prepend( QskGradientStop( 0.0, s.first().color() ) );
+
+    if ( s.last().position() < 1.0 )
+        s.append( QskGradientStop( 1.0, s.last().color() ) );
+
+    return s;
+}
+
 void QskGradientStop::setPosition( qreal position ) noexcept
 {
     m_position = position;
@@ -56,26 +81,19 @@ QskHashValue QskGradientStop::hash( QskHashValue seed ) const noexcept
     return qHashBits( &m_color, sizeof( m_color ), hash );
 }
 
-QColor QskGradientStop::interpolated(
-    const QskGradientStop& s1, const QskGradientStop& s2, qreal position ) noexcept
+QskGradientStop QskGradientStop::interpolated(
+    const QskGradientStop& to, qreal ratio ) const
 {
-    if ( s1.color() == s2.color() )
-        return s1.color();
+    return QskGradientStop(
+        m_position + ( to.m_position - m_position ) * ratio,
+        QskRgb::interpolated( m_color, to.m_color, ratio )
+    );
+}
 
-    auto min = &s1;
-    auto max = &s2;
-
-    if ( min->position() > max->position() )
-        std::swap( min, max );
-
-    if ( position <= min->position() )
-        return min->color();
-
-    if ( position >= max->position() )
-        return max->color();
-
-    const qreal r = ( position - min->position() ) / ( max->position() - min->position() );
-    return QskRgb::interpolated( min->color(), max->color(), r );
+QVariant QskGradientStop::interpolate(
+    const QskGradientStop& from, const QskGradientStop& to, qreal ratio )
+{
+    return QVariant::fromValue( from.interpolated( to, ratio ) );
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -95,19 +113,23 @@ QDebug operator<<( QDebug debug, const QskGradientStop& stop )
 
 #endif
 
-#include "moc_QskGradientStop.cpp"
-
 // some helper functions around QskGradientStops
 
-static inline QColor qskInterpolatedColor(
-    const QskGradientStops& stops, int index1, int index2, qreal position )
+static inline QColor qskColorAtPosition(
+    const QskGradientStop& s1, const QskGradientStop& s2, qreal pos )
 {
-    const auto max = static_cast< int >( stops.count() ) - 1;
+    const auto dp = s2.position() - s1.position();
+    if ( qFuzzyIsNull( dp ) )
+        return s1.color();
 
-    index1 = qBound( 0, index1, max );
-    index2 = qBound( 0, index2, max );
+    return QskRgb::interpolated(
+        s1.color(), s2.color(), ( pos - s1.position() ) / dp );
+}
 
-    return QskGradientStop::interpolated( stops[ index1 ], stops[ index2 ], position );
+static inline QskGradientStop qskCreateStopAtPosition(
+    const QskGradientStop& s1, const QskGradientStop& s2, qreal pos )
+{
+    return { pos, qskColorAtPosition( s1, s2, pos ) };
 }
 
 bool qskIsVisible( const QskGradientStops& stops ) noexcept
@@ -278,43 +300,126 @@ QColor qskInterpolatedColorAt( const QskGradientStops& stops, qreal pos ) noexce
     if ( stops.isEmpty() )
         return QColor();
 
-    pos = qBound( 0.0, pos, 1.0 );
-
     if ( pos <= stops.first().position() )
         return stops.first().color();
 
     for ( int i = 1; i < stops.count(); i++ )
     {
-        if ( pos <= stops[i].position() )
-            return qskInterpolatedColor( stops, i - 1, i, pos );
+        if ( pos <= stops[ i ].position() )
+            return qskColorAtPosition( stops[ i - 1 ], stops[ i ], pos );
     }
 
     return stops.last().color();
 }
 
-QskGradientStops qskExtractedGradientStops(
-    const QskGradientStops& gradientStops, qreal from, qreal to )
+QskGradientStops qskReplacedGradientStops( const QskGradientStops& gradientStops,
+    const QskGradientStop& stop1, const QskGradientStop& stop2 )
 {
-    if ( ( from > to ) || ( from > 1.0 ) || gradientStops.isEmpty() )
-        return QskGradientStops();
-
-    if ( ( from <= 0.0 ) && ( to >= 1.0 ) )
+    if ( stop1.position() >= stop2.position() )
         return gradientStops;
 
-    from = qMax( from, 0.0 );
-    to = qMin( to, 1.0 );
+    const auto s1 = QskGradientStop( qskBoundedStopPos( stop1.position() ), stop1.color() );
+    const auto s2 = QskGradientStop( qskBoundedStopPos( stop2.position() ), stop2.color() );
 
-    QVector< QskGradientStop > stops1 = gradientStops;
+    QskGradientStops stops;
 
-#if 1
-    // not the most efficient implementation - maybe later TODO ...
+    if ( s1.position() == 0.0 && s2.position() == 1.0 )
+    {
+        stops = { s1, s2 };
+    }
+    else if ( qskIsMonochrome( gradientStops ) )
+    {
+        stops.reserve( 4 );
 
-    if ( stops1.first().position() > 0.0 )
-        stops1.prepend( QskGradientStop( 0.0, stops1.first().color() ) );
+        const auto c = gradientStops.isEmpty()
+            ? QColor::fromRgba( 0 ) : gradientStops.first().color();
 
-    if ( stops1.last().position() < 1.0 )
-        stops1.append( QskGradientStop( 1.0, stops1.last().color() ) );
-#endif
+        if ( s1.position() > 0.0 )
+            stops += { s1.position(), c };
+
+        stops += s1;
+        stops += s2;
+
+        if ( s2.position() < 1.0 )
+            stops += { s2.position(), c };
+    }
+    else
+    {
+        // not the most efficient implementation - maybe later TODO ...
+        const auto stops0 = qskNormalizedStops( gradientStops );
+
+        int i = 0;
+
+        if ( s1.position() > 0.0 )
+        {
+            while ( s1.position() > stops0[i].position() )
+                stops += stops0[i++];
+
+            if ( s1.position() == stops0[i].position() )
+                stops += stops0[i++];
+            else
+                stops += qskCreateStopAtPosition( stops0[i - 1], stops0[i], s1.position() );
+        }
+
+        stops += s1;
+
+        while ( s2.position() > stops0[i].position() )
+            i++;
+
+        stops += s2;
+
+        if ( s2.position() < 1.0 )
+        {
+            while ( stops0[i + 1].position() == s2.position() )
+                i++;
+
+            if ( s2.position() != stops0[i].position() )
+                stops += qskCreateStopAtPosition( stops0[i - 1], stops0[i], s2.position() );
+
+            while( i < stops0.count() )
+                stops += stops0[i++];
+        }
+    }
+
+    return stops;
+}
+
+QskGradientStops qskClippedGradientStops(
+    const QskGradientStops& stops, qreal from, qreal to )
+{
+    return qskReplacedGradientStops( stops, { from, 0 }, { to, 0 } );
+}
+
+QskGradientStops qskExtractedGradientStops(
+    const QskGradientStops& stops, qreal from, qreal to )
+{
+    if ( ( from > to ) || ( to > 1.0 ) || ( from < 0.0 ) || stops.isEmpty() )
+        return QskGradientStops();
+
+    from = qskBoundedStopPos( from );
+    to = qskBoundedStopPos( to );
+
+    if ( ( from == 0.0 ) && ( to == 1.0 ) )
+        return stops;
+
+    if ( from == to )
+    {
+        const auto color = qskInterpolatedColorAt( stops, from );
+
+        QVector< QskGradientStop > s;
+        s.reserve( 2 );
+        s += QskGradientStop( 0.0, color );
+        s += QskGradientStop( 1.0, color );
+
+        return s;
+    }
+
+    /*
+        For situations where we have no stops at 0.0 and 1.0 we insert them
+        manually. Not the most efficient implementation, but we avoid having
+        to deal with these situations for the moment. TODO ...
+     */
+    const auto stops1 = qskNormalizedStops( stops );
 
     QVector< QskGradientStop > stops2;
     stops2.reserve( stops1.count() );
@@ -331,26 +436,26 @@ QskGradientStops qskExtractedGradientStops(
     {
         int i = 0;
 
-        for ( ; i < stops1.count(); i++ )
+        if ( from == 0.0 )
         {
-            if ( stops1[i].position() > from )
-                break;
+            stops2 += stops1[i++];
+        }
+        else
+        {
+            while( stops1[++i].position() <= from ); // skip leading stops
+
+            stops2 += QskGradientStop( 0.0,
+                qskColorAtPosition( stops1[i - 1], stops1[ i ], from ) );
         }
 
-        stops2 += QskGradientStop( 0.0,
-            qskInterpolatedColor( stops1, i - 1, i, from ) );
-
-        for ( ; i < stops1.count(); i++ )
+        while ( stops1[i].position() < to )
         {
-            if ( stops1[i].position() >= to )
-                break;
-
             const auto pos = ( stops1[i].position() - from ) / ( to - from );
-            stops2 += QskGradientStop( pos, stops1[i].color() );
+            stops2 += QskGradientStop( pos, stops1[i++].color() );
         }
 
         stops2 += QskGradientStop( 1.0,
-            qskInterpolatedColor( stops1, i, i + 1, to ) );
+            qskColorAtPosition( stops1[i - 1], stops1[ i ], to ) );
     }
 
     return stops2;
@@ -367,7 +472,7 @@ QskGradientStops qskRevertedGradientStops( const QskGradientStops& stops )
     return s;
 }
 
-QVector< QskGradientStop > qskBuildGradientStops( const QGradientStops& qtStops )
+QVector< QskGradientStop > qskFromQGradientStops( const QGradientStops& qtStops )
 {
     QVector< QskGradientStop > stops;
     stops.reserve( qtStops.count() );
@@ -463,3 +568,5 @@ QGradientStops qskToQGradientStops( const QskGradientStops& stops )
 
     return qStops;
 }
+
+#include "moc_QskGradientStop.cpp"

src/common/QskGradientStop.h

@@ -45,8 +45,10 @@ class QSK_EXPORT QskGradientStop
     void setRgb( QRgb ) noexcept;
     QRgb rgb() const noexcept;
 
-    static QColor interpolated(
-        const QskGradientStop&, const QskGradientStop&, qreal position ) noexcept;
+    QskGradientStop interpolated( const QskGradientStop&, qreal ) const;
+
+    static QVariant interpolate( const QskGradientStop&,
+        const QskGradientStop&, qreal );
 
     QskHashValue hash( QskHashValue seed ) const noexcept;
 
@@ -129,27 +131,48 @@ QSK_EXPORT QskGradientStops qskInterpolatedGradientStops(
     const QskGradientStops&, bool, const QskGradientStops&, bool,
     qreal ratio );
 
+// interpolating colors in direction of a color.
 QSK_EXPORT QskGradientStops qskInterpolatedGradientStops(
     const QskGradientStops&, const QColor&, qreal ratio );
 
+// interpolating colors starting from a color.
 QSK_EXPORT QskGradientStops qskInterpolatedGradientStops(
     const QColor&, const QskGradientStops&, qreal ratio );
 
+// interpolating the opacity of the colors
 QSK_EXPORT QskGradientStops qskTransparentGradientStops(
     const QskGradientStops&, qreal ratio );
 
+// extracting the colors of [from, to ] and stretching them to [0.0, 1.0]
 QSK_EXPORT QskGradientStops qskExtractedGradientStops(
     const QskGradientStops&, qreal from, qreal to );
 
+// reverting the color stops
+QSK_EXPORT QskGradientStops qskRevertedGradientStops( const QskGradientStops& );
+
+QSK_EXPORT QskGradientStops qskReplacedGradientStops(
+    const QskGradientStops&, const QskGradientStop&, const QskGradientStop& );
+
+QSK_EXPORT QskGradientStops qskClippedGradientStops(
+    const QskGradientStops&, qreal from, qreal to );
+
+/*
+   creating equidistant color stops from a list of colors.
+   when discrete is true the result will contain 2 stops at each position
+   one with the previous and one with the following color so that the
+   interval [pos1-pos2] will be monochrome.
+ */
 QSK_EXPORT QskGradientStops qskBuildGradientStops(
     const QVector< QRgb >&, bool discrete = false );
 
 QSK_EXPORT QskGradientStops qskBuildGradientStops(
     const QVector< QColor >&, bool discrete = false );
 
-QSK_EXPORT QskGradientStops qskRevertedGradientStops( const QskGradientStops& );
-
-QSK_EXPORT QskGradientStops qskBuildGradientStops( const QVector< QGradientStop >& );
+/*
+   convert color stops from/to a vector of QGradientStop, that can be
+   used for QGradients.
+ */
+QSK_EXPORT QskGradientStops qskFromQGradientStops( const QVector< QGradientStop >& );
 QSK_EXPORT QVector< QGradientStop > qskToQGradientStops( const QVector< QskGradientStop >& );
 
 #endif

src/common/QskTextColors.h

@@ -41,7 +41,7 @@ class QSK_EXPORT QskTextColors
     void setLinkColor( QRgb );
     void setLinkColor( Qt::GlobalColor );
 
-    QskTextColors interpolated( const QskTextColors&, qreal value ) const;
+    QskTextColors interpolated( const QskTextColors&, qreal ratio ) const;
 
     static QVariant interpolate( const QskTextColors&,
         const QskTextColors&, qreal ratio );

src/controls/QskMenuSkinlet.cpp

@@ -9,6 +9,7 @@
 #include "QskGraphic.h"
 #include "QskColorFilter.h"
 #include "QskTextOptions.h"
+#include "QskBoxHints.h"
 #include "QskFunctions.h"
 #include "QskMargins.h"
 #include "QskFunctions.h"
@@ -572,11 +573,13 @@ QSGNode* QskMenuSkinlet::updateSampleNode( const QskSkinnable* skinnable,
 
     if ( subControl == Q::Separator )
     {
-        auto gradient = menu->gradientHint( subControl );
+        auto hints = skinnable->boxHints( subControl );
+
+        auto& gradient = hints.gradient;
         if ( ( gradient.type() == QskGradient::Stops ) && !gradient.isMonochrome() )
             gradient.setLinearDirection( Qt::Vertical );
 
-        return updateBoxNode( menu, node, rect, gradient, subControl );
+        return updateBoxNode( menu, node, rect, hints );
     }
 
     return nullptr;

src/controls/QskPopupSkinlet.cpp

@@ -6,6 +6,7 @@
 #include "QskPopupSkinlet.h"
 #include "QskPopup.h"
 #include "QskRgbValue.h"
+#include "QskBoxHints.h"
 
 static inline QRgb qskInterpolatedRgb( QRgb rgb, qreal factor )
 {
@@ -58,7 +59,9 @@ QSGNode* QskPopupSkinlet::updateOverlayNode(
     if ( rect.isEmpty() )
         return nullptr;
 
-    auto gradient = popup->gradientHint( Q::Overlay );
+    auto hints = popup->boxHints( Q::Overlay );
+
+    auto& gradient = hints.gradient;
 
     if ( gradient.isVisible() && factor != 1.0 )
     {
@@ -70,7 +73,7 @@ QSGNode* QskPopupSkinlet::updateOverlayNode(
         gradient.setStops( stops );
     }
 
-    return updateBoxNode( popup, node, rect, gradient, QskPopup::Overlay );
+    return updateBoxNode( popup, node, rect, hints );
 }
 
 #include "moc_QskPopupSkinlet.cpp"

src/controls/QskProgressBarSkinlet.cpp

@@ -6,7 +6,7 @@
 #include "QskProgressBarSkinlet.h"
 #include "QskProgressBar.h"
 #include "QskIntervalF.h"
-#include "QskBoxBorderMetrics.h"
+#include "QskBoxHints.h"
 
 #include <qeasingcurve.h>
 #include <cmath>
@@ -50,41 +50,6 @@ static QskIntervalF qskFillInterval( const QskProgressIndicator* indicator )
     return QskIntervalF( pos1, pos2 );
 }
 
-static QskGradient qskFillGradient( const QskProgressBar* progressBar )
-{
-    auto gradient = progressBar->gradientHint( Q::Fill );
-
-    if ( gradient.isVisible() && !gradient.isMonochrome()
-        && ( gradient.type() == QskGradient::Stops ) )
-    {
-        /*
-            When having stops only we use a linear gradient,
-            where the colors are increasing in direction of the
-            progress value. We interprete the gradient as a
-            definition for the 100% situation and have to adjust
-            the stops for smaller bars.
-
-            For this situation it would be more convenient to
-            adjust the start/stop positions, but the box renderer is
-            not supporting this yet. TODO ...
-         */
-
-        const auto intv = qskFillInterval( progressBar );
-
-        const auto stops = qskExtractedGradientStops(
-            gradient.stops(), intv.lowerBound(), intv.upperBound() );
-
-        gradient.setStops( stops );
-
-        gradient.setLinearDirection( progressBar->orientation() );
-
-        if ( progressBar->orientation() == Qt::Vertical || progressBar->layoutMirroring() )
-            gradient.reverse();
-    }
-
-    return gradient;
-}
-
 QskProgressBarSkinlet::QskProgressBarSkinlet( QskSkin* skin )
     : Inherited( skin )
 {
@@ -122,9 +87,40 @@ QSGNode* QskProgressBarSkinlet::updateFillNode(
     if ( rect.isEmpty() )
         return nullptr;
 
-    const auto progressBar = static_cast< const Q* >( indicator );
-    return updateBoxNode( indicator, node, rect,
-        qskFillGradient( progressBar ), Q::Fill );
+    auto hints = indicator->boxHints( Q::Fill );
+
+    auto& gradient = hints.gradient;
+
+    if ( gradient.isVisible() && !gradient.isMonochrome()
+         && ( gradient.type() == QskGradient::Stops ) )
+    {
+        /*
+            When having stops only we use a linear gradient,
+            where the colors are increasing in direction of the
+            progress value. We interprete the gradient as a
+            definition for the 100% situation and have to adjust
+            the stops for smaller bars.
+
+            For this situation it would be more convenient to
+            adjust the start/stop positions, but the box renderer is
+            not supporting this yet. TODO ...
+         */
+
+        const auto intv = qskFillInterval( indicator );
+
+        const auto stops = qskExtractedGradientStops(
+            gradient.stops(), intv.lowerBound(), intv.upperBound() );
+
+        gradient.setStops( stops );
+
+        const auto orientation = static_cast< const Q* >( indicator )->orientation();
+        gradient.setLinearDirection( orientation );
+
+        if ( orientation == Qt::Vertical || indicator->layoutMirroring() )
+            gradient.reverse();
+    }
+
+    return updateBoxNode( indicator, node, rect, hints );
 }
 
 QRectF QskProgressBarSkinlet::grooveRect(

src/controls/QskProgressRingSkinlet.cpp

@@ -4,7 +4,7 @@
  *****************************************************************************/
 
 #include "QskProgressRingSkinlet.h"
-#include "QskArcMetrics.h"
+#include "QskArcHints.h"
 #include "QskProgressRing.h"
 #include "QskIntervalF.h"
 
@@ -85,8 +85,12 @@ QSGNode* QskProgressRingSkinlet::updateGrooveNode(
                 endAngle = fillAngles.first - 360.0 + spacing;
             }
 
-            return updateArcNode( ring, node,
-                startAngle, endAngle - startAngle, Q::Groove );
+            auto hints = indicator->arcHints( Q::Groove );
+            hints.metrics.setStartAngle( startAngle );
+            hints.metrics.setSpanAngle( endAngle - startAngle );
+
+            const auto rect = indicator->subControlRect( Q::Groove );
+            return updateArcNode( ring, node, rect, hints );
         }
     }
 
@@ -104,16 +108,14 @@ QSGNode* QskProgressRingSkinlet::updateFillNode(
     if ( rect.isEmpty() )
         return nullptr;
 
-    const auto metrics = ring->arcMetricsHint( subControl );
-    if ( metrics.isNull() )
-        return nullptr;
-
-    auto gradient = ring->gradientHint( subControl );
-    if ( !gradient.isVisible() )
+    auto hints = ring->arcHints( subControl );
+    if ( !hints.isVisible() )
         return nullptr;
 
     const auto intv = qskFillInterval( ring );
 
+    auto& gradient = hints.gradient;
+
     if ( ( gradient.type() == QskGradient::Stops ) && !gradient.isMonochrome() )
     {
         const auto stops = qskExtractedGradientStops( gradient.stops(),
@@ -121,14 +123,15 @@ QSGNode* QskProgressRingSkinlet::updateFillNode(
 
         gradient.setStops( stops );
 
-        if ( metrics.spanAngle() < 0.0 )
+        if ( hints.metrics.spanAngle() < 0.0 )
             gradient.reverse();
     }
 
-    const auto angles = qskFillAngles( metrics, intv );
+    const auto angles = qskFillAngles( hints.metrics, intv );
+    hints.metrics.setStartAngle( angles.first );
+    hints.metrics.setSpanAngle( angles.second - angles.first );
 
-    return updateArcNode( ring, node, rect, gradient,
-        angles.first, angles.second - angles.first, subControl );
+    return updateArcNode( ring, node, rect, hints );
 }
 
 QSizeF QskProgressRingSkinlet::sizeHint( const QskSkinnable* skinnable,

src/controls/QskSeparatorSkinlet.cpp

@@ -6,6 +6,7 @@
 #include "QskSeparatorSkinlet.h"
 #include "QskSeparator.h"
 
+#include "QskBoxHints.h"
 #include "QskGradientDirection.h"
 #include "QskAspect.h"
 
@@ -42,8 +43,12 @@ QSGNode* QskSeparatorSkinlet::updateSubNode(
             using Q = QskSeparator;
 
             const auto rect = separator->subControlRect( Q::Panel );
+            if ( rect.isEmpty() )
+                return nullptr;
 
-            auto gradient = separator->gradientHint( Q::Panel );
+            auto hints = separator->boxHints( Q::Panel );
+
+            auto& gradient = hints.gradient;
             if ( ( gradient.type() == QskGradient::Stops ) && !gradient.isMonochrome() )
             {
                 // gradient in opposite orientation
@@ -53,7 +58,7 @@ QSGNode* QskSeparatorSkinlet::updateSubNode(
                 gradient.setLinearDirection( orientation );
             }
 
-            return updateBoxNode( separator, node, rect, gradient, Q::Panel );
+            return updateBoxNode( separator, node, rect, hints );
         }
     }
 

src/controls/QskSkinlet.cpp

@@ -7,9 +7,7 @@
 
 #include "QskArcNode.h"
 #include "QskAspect.h"
-#include "QskArcMetrics.h"
-#include "QskBoxBorderColors.h"
-#include "QskBoxBorderMetrics.h"
+#include "QskArcHints.h"
 #include "QskBoxNode.h"
 #include "QskBoxRectangleNode.h"
 #include "QskBoxShapeMetrics.h"
@@ -156,18 +154,6 @@ static inline bool qskIsBoxVisible( const QskBoxBorderMetrics& borderMetrics,
     return !borderMetrics.isNull() && borderColors.isVisible();
 }
 
-static inline bool qskIsArcVisible( const QskArcMetrics& arcMetrics,
-    qreal borderWidth, const QColor borderColor, const QskGradient& gradient )
-{
-    if ( arcMetrics.isNull() )
-        return false;
-
-    if ( borderWidth > 0.0 && borderColor.isValid() && borderColor.alpha() > 0 )
-        return true;
-
-    return gradient.isVisible();
-}
-
 static inline bool qskIsLineVisible( const QColor& lineColor, qreal lineWidth )
 {
     return ( lineWidth > 0.0 ) && lineColor.isValid() && ( lineColor.alpha() > 0 );
@@ -202,22 +188,18 @@ static inline QQuickWindow* qskWindowOfSkinnable( const QskSkinnable* skinnable
     return nullptr;
 }
 
-static inline QSGNode* qskUpdateBoxNode(
-    const QskSkinnable* skinnable, QSGNode* node, const QRectF& rect,
-    const QskBoxShapeMetrics& shape, const QskBoxBorderMetrics& borderMetrics,
-    const QskBoxBorderColors& borderColors, const QskGradient& gradient,
-    const QskShadowMetrics& shadowMetrics, const QColor& shadowColor )
+static inline QSGNode* qskUpdateBoxNode( const QskSkinnable* skinnable,
+    QSGNode* node, const QRectF& rect, const QskBoxHints& hints )
 {
     if ( !rect.isEmpty() )
     {
-        if ( qskIsBoxVisible( borderMetrics, borderColors, gradient )
-            || qskIsShadowVisible( shadowMetrics, shadowColor ) )
+        if ( qskIsBoxVisible( hints.borderMetrics, hints.borderColors, hints.gradient )
+            || qskIsShadowVisible( hints.shadowMetrics, hints.shadowColor ) )
         {
             if ( auto window = qskWindowOfSkinnable( skinnable ) )
             {
                 auto boxNode = QskSGNode::ensureNode< QskBoxNode >( node );
-                boxNode->updateNode( window, rect, shape, borderMetrics,
-                    borderColors, gradient, shadowMetrics, shadowColor );
+                boxNode->updateNode( window, rect, hints );
 
                 return boxNode;
             }
@@ -227,21 +209,20 @@ static inline QSGNode* qskUpdateBoxNode(
     return nullptr;
 }
 
-static inline QSGNode* qskUpdateArcNode(
-    const QskSkinnable*, QSGNode* node, const QRectF& rect,
-    qreal borderWidth, const QColor borderColor,
-    const QskGradient& gradient, const QskArcMetrics& metrics )
+static inline QSGNode* qskUpdateArcNode( const QskSkinnable* skinnable,
+    QSGNode* node, const QRectF& rect, const QskArcHints& hints )
 {
-    if ( rect.isEmpty() )
-        return nullptr;
+    Q_UNUSED( skinnable );
 
-    if ( !qskIsArcVisible( metrics, borderWidth, borderColor, gradient ) )
-        return nullptr;
+    if ( !rect.isEmpty() && hints.isVisible() )
+    {
+        auto arcNode = QskSGNode::ensureNode< QskArcNode >( node );
+        arcNode->setArcData( rect, hints );
 
-    auto arcNode = QskSGNode::ensureNode< QskArcNode >( node );
-    arcNode->setArcData( rect, metrics, borderWidth, borderColor, gradient );
+        return arcNode;
+    }
 
-    return arcNode;
+    return nullptr;
 }
 
 static inline QSGNode* qskUpdateLineNode(
@@ -434,54 +415,30 @@ void QskSkinlet::replaceChildNode( quint8 role,
 QSGNode* QskSkinlet::updateBoxNode( const QskSkinnable* skinnable,
     QSGNode* node, QskAspect::Subcontrol subControl ) const
 {
-    const auto rect = qskSubControlRect( this, skinnable, subControl );
-    return updateBoxNode( skinnable, node, rect, subControl );
+    auto r = qskSubControlRect( this, skinnable, subControl );
+    if ( r.isEmpty() )
+        return nullptr;
+
+    r = r.marginsRemoved( skinnable->marginHint( subControl ) );
+
+    return qskUpdateBoxNode( skinnable, node,
+        r, skinnable->boxHints( subControl ) );
 }
 
 QSGNode* QskSkinlet::updateBoxNode( const QskSkinnable* skinnable,
     QSGNode* node, const QRectF& rect, QskAspect::Subcontrol subControl )
 {
-    const auto fillGradient = skinnable->gradientHint( subControl );
-    return updateBoxNode( skinnable, node, rect, fillGradient, subControl );
-}
-
-QSGNode* QskSkinlet::updateBoxNode( const QskSkinnable* skinnable,
-    QSGNode* node, const QRectF& rect, const QskGradient& fillGradient,
-    QskAspect::Subcontrol subControl )
-{
-    const auto margins = skinnable->marginHint( subControl );
-
-    const auto boxRect = rect.marginsRemoved( margins );
-    if ( boxRect.isEmpty() )
+    if ( rect.isEmpty() )
         return nullptr;
 
-    const auto borderMetrics = skinnable->boxBorderMetricsHint( subControl );
-    const auto borderColors = skinnable->boxBorderColorsHint( subControl );
-    const auto shape = skinnable->boxShapeHint( subControl );
-    const auto shadowMetrics = skinnable->shadowMetricsHint( subControl );
-    const auto shadowColor = skinnable->shadowColorHint( subControl );
-
-    return qskUpdateBoxNode( skinnable, node,
-        boxRect, shape, borderMetrics, borderColors, fillGradient,
-        shadowMetrics, shadowColor );
-}
-
-QSGNode* QskSkinlet::updateBoxNode(
-    const QskSkinnable* skinnable, QSGNode* node, const QRectF& rect,
-    const QskBoxShapeMetrics& shape, const QskBoxBorderMetrics& borderMetrics,
-    const QskBoxBorderColors& borderColors, const QskGradient& fillGradient )
-{
-    return qskUpdateBoxNode( skinnable, node,
-        rect, shape, borderMetrics, borderColors, fillGradient,
-        QskShadowMetrics(), QColor() );
+    const auto r = rect.marginsRemoved( skinnable->marginHint( subControl ) );
+    return qskUpdateBoxNode( skinnable, node, r, skinnable->boxHints( subControl ) );
 }
 
 QSGNode* QskSkinlet::updateBoxNode( const QskSkinnable* skinnable,
     QSGNode* node, const QRectF& rect, const QskBoxHints& hints )
 {
-    return qskUpdateBoxNode( skinnable, node, rect,
-        hints.shape, hints.borderMetrics, hints.borderColors, hints.gradient,
-        hints.shadowMetrics, hints.shadowColor );
+    return qskUpdateBoxNode( skinnable, node, rect, hints );
 }
 
 QSGNode* QskSkinlet::updateInterpolatedBoxNode(
@@ -526,79 +483,24 @@ QSGNode* QskSkinlet::updateInterpolatedBoxNode(
 QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
     QSGNode* node, QskAspect::Subcontrol subControl ) const
 {
-    const auto rect = qskSubControlRect( this, skinnable, subControl );
-    return updateArcNode( skinnable, node, rect, subControl );
+    auto rect = qskSubControlRect( this, skinnable, subControl );
+    rect = rect.marginsRemoved( skinnable->marginHint( subControl ) );
+
+    return qskUpdateArcNode( skinnable,
+        node, rect, skinnable->arcHints( subControl ) );
+}
+
+QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
+    QSGNode* node, const QRectF& rect, const QskArcHints& hints )
+{
+    return qskUpdateArcNode( skinnable, node, rect, hints );
 }
 
 QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
     QSGNode* node, const QRectF& rect, QskAspect::Subcontrol subControl )
 {
-    const auto fillGradient = skinnable->gradientHint( subControl );
-    return updateArcNode( skinnable, node, rect, fillGradient, subControl );
-}
-
-QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
-    QSGNode* node, const QRectF& rect, const QskGradient& fillGradient,
-    QskAspect::Subcontrol subControl )
-{
-    const auto metrics = skinnable->arcMetricsHint( subControl );
-    const auto r = rect.marginsRemoved( skinnable->marginHint( subControl ) );
-
-    const qreal borderWidth = skinnable->metric( subControl | QskAspect::Border );
-
-    QColor borderColor;
-    if ( borderWidth > 0.0 )
-        borderColor = skinnable->color( subControl | QskAspect::Border );
-
     return qskUpdateArcNode( skinnable, node,
-        r, borderWidth, borderColor, fillGradient, metrics );
-}
-
-QSGNode* QskSkinlet::updateArcNode(
-    const QskSkinnable* skinnable, QSGNode* node, const QRectF& rect,
-    qreal borderWidth, const QColor& borderColor,
-    const QskGradient& fillGradient, const QskArcMetrics& metrics )
-{
-    return qskUpdateArcNode( skinnable, node, rect,
-        borderWidth, borderColor, fillGradient, metrics );
-}
-
-QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
-    QSGNode* node, qreal startAngle, qreal spanAngle,
-    QskAspect::Subcontrol subControl ) const
-{
-    const auto rect = qskSubControlRect( this, skinnable, subControl );
-
-    return updateArcNode( skinnable, node,
-        rect, startAngle, spanAngle, subControl );
-}
-
-QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
-    QSGNode* node, const QRectF& rect, qreal startAngle, qreal spanAngle,
-    QskAspect::Subcontrol subControl )
-{
-    const auto fillGradient = skinnable->gradientHint( subControl );
-    return updateArcNode( skinnable, node, rect,
-        fillGradient, startAngle, spanAngle, subControl );
-}
-
-QSGNode* QskSkinlet::updateArcNode( const QskSkinnable* skinnable,
-    QSGNode* node, const QRectF& rect, const QskGradient& fillGradient,
-    qreal startAngle, qreal spanAngle, QskAspect::Subcontrol subControl )
-{
-    auto arcMetrics = skinnable->arcMetricsHint( subControl );
-    arcMetrics.setStartAngle( startAngle );
-    arcMetrics.setSpanAngle( spanAngle );
-
-    const qreal borderWidth = skinnable->metric( subControl | QskAspect::Border );
-
-    QColor borderColor;
-    if ( borderWidth > 0.0 )
-        borderColor = skinnable->color( subControl | QskAspect::Border );
-
-    const auto r = rect.marginsRemoved( skinnable->marginHint( subControl ) );
-    return updateArcNode( skinnable, node, r,
-        borderWidth, borderColor, fillGradient, arcMetrics );
+        rect, skinnable->arcHints( subControl ) );
 }
 
 QSGNode* QskSkinlet::updateLineNode( const QskSkinnable* skinnable,

src/controls/QskSkinlet.h

@@ -23,10 +23,8 @@ class QskColorFilter;
 class QskGraphic;
 class QskTextOptions;
 class QskTextColors;
-class QskBoxShapeMetrics;
-class QskBoxBorderMetrics;
-class QskBoxBorderColors;
 class QskBoxHints;
+class QskArcHints;
 
 class QSGNode;
 
@@ -76,13 +74,6 @@ class QSK_EXPORT QskSkinlet
     static QSGNode* updateBoxNode( const QskSkinnable*, QSGNode*,
         const QRectF&, QskAspect::Subcontrol );
 
-    static QSGNode* updateBoxNode( const QskSkinnable*, QSGNode*,
-        const QRectF&, const QskGradient&, QskAspect::Subcontrol );
-
-    static QSGNode* updateBoxNode( const QskSkinnable*, QSGNode*,
-        const QRectF&, const QskBoxShapeMetrics&, const QskBoxBorderMetrics&,
-        const QskBoxBorderColors&, const QskGradient& );
-
     static QSGNode* updateBoxNode( const QskSkinnable*, QSGNode*,
         const QRectF&, const QskBoxHints& );
 
@@ -94,18 +85,7 @@ class QSK_EXPORT QskSkinlet
         const QRectF&, QskAspect::Subcontrol );
 
     static QSGNode* updateArcNode( const QskSkinnable*, QSGNode*,
-        const QRectF&, const QskGradient&, QskAspect::Subcontrol );
-
-    static QSGNode* updateArcNode( const QskSkinnable*, QSGNode*,
-        const QRectF&, qreal borderWidth, const QColor& borderColor,
-        const QskGradient&, const QskArcMetrics& );
-
-    static QSGNode* updateArcNode( const QskSkinnable*, QSGNode*,
-        const QRectF&, qreal startAngle, qreal spanAngle, QskAspect::Subcontrol );
-
-    static QSGNode* updateArcNode( const QskSkinnable*, QSGNode*,
-        const QRectF&, const QskGradient&, qreal startAngle, qreal spanAngle,
-        QskAspect::Subcontrol );
+        const QRectF&, const QskArcHints& );
 
     static QSGNode* updateLineNode( const QskSkinnable*, QSGNode*,
         const QLineF&, QskAspect::Subcontrol );
@@ -156,10 +136,6 @@ class QSK_EXPORT QskSkinlet
     QSGNode* updateArcNode( const QskSkinnable*, QSGNode*,
         QskAspect::Subcontrol ) const;
 
-    QSGNode* updateArcNode( const QskSkinnable*, QSGNode*,
-        qreal startAngle, qreal spanAngle,
-        QskAspect::Subcontrol ) const;
-
     QSGNode* updateBoxClipNode( const QskSkinnable*, QSGNode*,
         QskAspect::Subcontrol ) const;
 

src/controls/QskSkinnable.cpp

@@ -6,7 +6,7 @@
 #include "QskSkinnable.h"
 
 #include "QskAnimationHint.h"
-#include "QskArcMetrics.h"
+#include "QskArcHints.h"
 #include "QskAspect.h"
 #include "QskColorFilter.h"
 #include "QskControl.h"
@@ -637,9 +637,23 @@ QColor QskSkinnable::shadowColorHint( QskAspect aspect, QskSkinHintStatus* statu
 QskBoxHints QskSkinnable::boxHints( QskAspect aspect ) const
 {
     return QskBoxHints(
-        boxShapeHint( aspect ), boxBorderMetricsHint( aspect ),
-        boxBorderColorsHint( aspect ), gradientHint( aspect ),
-        shadowMetricsHint( aspect ), shadowColorHint( aspect ) );
+        boxShapeHint( aspect ),
+        boxBorderMetricsHint( aspect ),
+        boxBorderColorsHint( aspect ),
+        gradientHint( aspect ),
+        shadowMetricsHint( aspect ),
+        shadowColorHint( aspect )
+    );
+}
+
+QskArcHints QskSkinnable::arcHints( QskAspect aspect ) const
+{
+    return QskArcHints(
+        arcMetricsHint( aspect ),
+        metric( aspect | QskAspect::Border ),
+        color( aspect | QskAspect::Border ),
+        gradientHint( aspect )
+    );
 }
 
 bool QskSkinnable::setArcMetricsHint(

src/controls/QskSkinnable.h

@@ -22,6 +22,7 @@ class QDebug;
 class QSGNode;
 class QQuickItem;
 
+class QskArcHints;
 class QskArcMetrics;
 class QskControl;
 class QskAnimationHint;
@@ -226,6 +227,7 @@ class QSK_EXPORT QskSkinnable
     QColor shadowColorHint( QskAspect, QskSkinHintStatus* = nullptr ) const;
 
     QskBoxHints boxHints( QskAspect ) const;
+    QskArcHints arcHints( QskAspect ) const;
 
     bool setArcMetricsHint( QskAspect, const QskArcMetrics& );
     bool resetArcMetricsHint( QskAspect );

src/controls/QskSlider.cpp

@@ -197,6 +197,23 @@ bool QskSlider::hasOrigin() const
     return m_data->hasOrigin;
 }
 
+void QskSlider::setTickPolicy( Qsk::Policy policy )
+{
+    if ( setFlagHint( Tick | QskAspect::Option, policy ) )
+        Q_EMIT tickPolicyChanged( policy );
+}
+
+void QskSlider::resetTickPolicy()
+{
+    if ( resetSkinHint( Tick | QskAspect::Option ) )
+        Q_EMIT tickPolicyChanged( tickPolicy() );
+}
+
+Qsk::Policy QskSlider::tickPolicy() const
+{
+    return flagHint< Qsk::Policy >( Tick | QskAspect::Option, Qsk::Maybe );
+}
+
 QskAspect::Variation QskSlider::effectiveVariation() const
 {
     return static_cast< QskAspect::Variation >( m_data->orientation );

src/controls/QskSlider.h

@@ -22,6 +22,9 @@ class QSK_EXPORT QskSlider : public QskBoundedValueInput
     Q_PROPERTY( bool tracking READ isTracking
         WRITE setTracking NOTIFY trackingChanged )
 
+    Q_PROPERTY( Qsk::Policy tickPolicy READ tickPolicy
+        WRITE setTickPolicy RESET resetTickPolicy NOTIFY tickPolicyChanged )
+
     Q_PROPERTY( qreal origin READ origin
         WRITE setOrigin RESET resetOrigin NOTIFY originChanged )
 
@@ -39,6 +42,10 @@ class QSK_EXPORT QskSlider : public QskBoundedValueInput
     void setOrientation( Qt::Orientation );
     Qt::Orientation orientation() const;
 
+    void setTickPolicy( Qsk::Policy );
+    void resetTickPolicy();
+    Qsk::Policy tickPolicy() const;
+
     void setInverted( bool );
     bool isInverted() const;
 
@@ -61,6 +68,7 @@ class QSK_EXPORT QskSlider : public QskBoundedValueInput
     void invertedChanged( bool );
     void trackingChanged( bool );
     void originChanged( qreal );
+    void tickPolicyChanged( Qsk::Policy );
 
   protected:
     void mousePressEvent( QMouseEvent* ) override;

src/controls/QskSliderSkinlet.cpp

@@ -388,10 +388,7 @@ bool QskSliderSkinlet::hasGraduation( const QskSlider* slider ) const
 {
     if ( slider->stepSize() )
     {
-        const auto policy = slider->flagHint< Qsk::Policy >(
-            Q::Tick | QskAspect::Option, Qsk::Never );
-
-        switch( policy )
+        switch( slider->tickPolicy() )
         {
             case Qsk::Always:
                 return true;

src/controls/QskTabBar.cpp

@@ -129,7 +129,7 @@ namespace
         {
             if ( qskIsAncestorOf( this, item ) )
             {
-                const auto pos = mapFromItem( item, QPointF() );
+                const auto pos = mapFromItem( item, QPointF() ) + scrollPos();
                 ensureVisible( QRectF( pos.x(), pos.y(), item->width(), item->height() ) );
             }
         }

src/controls/QskVariantAnimator.cpp

@@ -13,6 +13,7 @@
 #include "QskGraduationMetrics.h"
 #include "QskColorFilter.h"
 #include "QskGradient.h"
+#include "QskGradientStop.h"
 #include "QskMargins.h"
 #include "QskIntervalF.h"
 #include "QskTextColors.h"
@@ -43,6 +44,7 @@ static void qskRegisterInterpolator()
     qRegisterAnimationInterpolator< QskColorFilter >( QskColorFilter::interpolate );
     qRegisterAnimationInterpolator< QskIntervalF >( QskIntervalF::interpolate );
     qRegisterAnimationInterpolator< QskMargins >( QskMargins::interpolate );
+    qRegisterAnimationInterpolator< QskGradientStop >( QskGradientStop::interpolate );
     qRegisterAnimationInterpolator< QskGradient >( QskGradient::interpolate );
     qRegisterAnimationInterpolator< QskBoxShapeMetrics >( QskBoxShapeMetrics::interpolate );
     qRegisterAnimationInterpolator< QskBoxBorderMetrics >( QskBoxBorderMetrics::interpolate );

src/nodes/QskArcNode.cpp

@@ -4,11 +4,10 @@
  *****************************************************************************/
 
 #include "QskArcNode.h"
-#include "QskArcMetrics.h"
+#include "QskArcHints.h"
 #include "QskArcRenderNode.h"
 #include "QskArcRenderer.h"
 #include "QskMargins.h"
-#include "QskGradient.h"
 #include "QskSGNode.h"
 #include "QskRgbValue.h"
 
@@ -58,24 +57,21 @@ QskArcNode::~QskArcNode()
 {
 }
 
-void QskArcNode::setArcData( const QRectF& rect,
-    const QskArcMetrics& arcMetrics, const QskGradient& gradient )
-{
-    setArcData( rect, arcMetrics, 0.0, QColor(), gradient );
-}
-
-void QskArcNode::setArcData( const QRectF& rect, const QskArcMetrics& arcMetrics,
-    const qreal borderWidth, const QColor& borderColor, const QskGradient& gradient )
+void QskArcNode::setArcData( const QRectF& rect, const QskArcHints& hints )
 {
     using namespace QskSGNode;
 
     QskArcRenderNode* arcNode = nullptr;
     QskArcRenderNode* fillNode = nullptr;
 
-    if ( !( rect.isEmpty() || arcMetrics.isNull() ) )
+    if ( !rect.isEmpty() && hints.isVisible() )
     {
+        const auto& gradient = hints.gradient;
+        const auto borderWidth = hints.borderWidth;
+        const auto borderColor = hints.borderColor;
+
         const bool radial = false;
-        const auto metricsArc = arcMetrics.toAbsolute( rect.size() );
+        const auto metricsArc = hints.metrics.toAbsolute( rect.size() );
 
         const auto hasFilling = gradient.isVisible();
         const auto hasBorder = ( borderWidth > 0.0 ) && QskRgb::isVisible( borderColor );

src/nodes/QskArcNode.h

@@ -9,8 +9,7 @@
 #include "QskGlobal.h"
 #include <qsgnode.h>
 
-class QskArcMetrics;
-class QskGradient;
+class QskArcHints;
 
 class QSK_EXPORT QskArcNode : public QSGNode
 {
@@ -18,10 +17,7 @@ class QSK_EXPORT QskArcNode : public QSGNode
     QskArcNode();
     ~QskArcNode() override;
 
-    void setArcData( const QRectF&, const QskArcMetrics&, const QskGradient& );
-
-    void setArcData( const QRectF&, const QskArcMetrics&,
-        qreal borderWidth, const QColor& borderColor, const QskGradient& );
+    void setArcData( const QRectF&, const QskArcHints& );
 };
 
 #endif

src/nodes/QskBoxNode.cpp

@@ -8,12 +8,8 @@
 #include "QskBoxRectangleNode.h"
 #include "QskSGNode.h"
 
-#include "QskGradient.h"
+#include "QskBoxHints.h"
 #include "QskGradientDirection.h"
-#include "QskShadowMetrics.h"
-#include "QskBoxBorderMetrics.h"
-#include "QskBoxBorderColors.h"
-#include "QskBoxShapeMetrics.h"
 #include "QskRgbValue.h"
 
 namespace
@@ -60,10 +56,8 @@ QskBoxNode::~QskBoxNode()
 {
 }
 
-void QskBoxNode::updateNode( const QQuickWindow* window, const QRectF& rect,
-    const QskBoxShapeMetrics& shapeMetrics, const QskBoxBorderMetrics& borderMetrics,
-    const QskBoxBorderColors& borderColors, const QskGradient& gradient,
-    const QskShadowMetrics& shadowMetrics, const QColor& shadowColor )
+void QskBoxNode::updateNode( const QQuickWindow* window,
+    const QRectF& rect, const QskBoxHints& hints )
 {
     using namespace QskSGNode;
 
@@ -74,6 +68,13 @@ void QskBoxNode::updateNode( const QQuickWindow* window, const QRectF& rect,
 
     if ( !rect.isEmpty() )
     {
+        const auto& shapeMetrics = hints.shape;
+        const auto& borderMetrics = hints.borderMetrics;
+        const auto& borderColors = hints.borderColors;
+        const auto& gradient = hints.gradient;
+        const auto& shadowMetrics = hints.shadowMetrics;
+        const auto& shadowColor = hints.shadowColor;
+
         const auto hasFilling = gradient.isVisible();
         const auto hasBorder = !borderMetrics.isNull() && borderColors.isVisible();
         const auto hasShadow = !shadowMetrics.isNull() && QskRgb::isVisible( shadowColor );

src/nodes/QskBoxNode.h

@@ -9,14 +9,8 @@
 #include "QskGlobal.h"
 #include <qsgnode.h>
 
-class QskShadowMetrics;
-class QskBoxShapeMetrics;
-class QskBoxBorderMetrics;
-class QskBoxBorderColors;
-class QskGradient;
-class QskShadowMetrics;
+class QskBoxHints;
 class QQuickWindow;
-class QColor;
 
 class QSK_EXPORT QskBoxNode : public QSGNode
 {
@@ -24,10 +18,7 @@ class QSK_EXPORT QskBoxNode : public QSGNode
     QskBoxNode();
     ~QskBoxNode() override;
 
-    void updateNode( const QQuickWindow*, const QRectF&,
-        const QskBoxShapeMetrics&, const QskBoxBorderMetrics&,
-        const QskBoxBorderColors&, const QskGradient&,
-        const QskShadowMetrics&, const QColor& shadowColor );
+    void updateNode( const QQuickWindow*, const QRectF&, const QskBoxHints& );
 };
 
 #endif

src/nodes/QskGradientMaterial.cpp

@@ -54,16 +54,16 @@ namespace
         }
 
 #if QT_VERSION >= QT_VERSION_CHECK( 6, 0, 0 )
-        // make Qt 5/6 APIs matching
-
         QSGMaterialShader* createShader(
             QSGRendererInterface::RenderMode ) const override final
+#else
+        QSGMaterialShader* createShader() const override final
+#endif
         {
-            return createShader();
+            return createMaterialShader();
         }
 
-        virtual QSGMaterialShader* createShader() const = 0;
-#endif
+        virtual QSGMaterialShader* createMaterialShader() const = 0;
 
         virtual bool setGradient( const QskGradient& ) = 0;
     };
@@ -217,7 +217,7 @@ namespace
                 return GradientMaterial::compare( other );
         }
 
-        QSGMaterialShader* createShader() const override;
+        QSGMaterialShader* createMaterialShader() const override;
 
         /*
             xy: position
@@ -299,7 +299,7 @@ namespace
     };
 #endif
 
-    QSGMaterialShader* LinearMaterial::createShader() const
+    QSGMaterialShader* LinearMaterial::createMaterialShader() const
     {
 #if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
         if ( !( flags() & QSGMaterial::RhiShaderWanted ) )
@@ -371,7 +371,7 @@ namespace
             }
         }
 
-        QSGMaterialShader* createShader() const override;
+        QSGMaterialShader* createMaterialShader() const override;
 
         QVector2D m_center;
         QVector2D m_radius;
@@ -465,7 +465,7 @@ namespace
     };
 #endif
 
-    QSGMaterialShader* RadialMaterial::createShader() const
+    QSGMaterialShader* RadialMaterial::createMaterialShader() const
     {
 #ifdef SHADER_GL
         if ( !( flags() & QSGMaterial::RhiShaderWanted ) )
@@ -575,7 +575,7 @@ namespace
             return GradientMaterial::compare( other );
         }
 
-        QSGMaterialShader* createShader() const override;
+        QSGMaterialShader* createMaterialShader() const override;
 
         QVector2D m_center;
         float m_aspectRatio = 1.0;
@@ -685,7 +685,7 @@ namespace
     };
 #endif
 
-    QSGMaterialShader* ConicMaterial::createShader() const
+    QSGMaterialShader* ConicMaterial::createMaterialShader() const
     {
 #ifdef SHADER_GL
         if ( !( flags() & QSGMaterial::RhiShaderWanted ) )