moving alignment/retainSizeWhenHidden from layouts to QskControl

examples/automotive/SoundControl.cpp

@@ -359,7 +359,15 @@ class BalanceFadeControlBox final : public QskGridBox
     {
         MarkerControlButton* buttons[ 4 ];
         for ( int i = 0; i < 4; i++ )
-            buttons[ i ] = new MarkerControlButton( static_cast< Qsk::Direction >( i ) );
+        {
+            auto button = new MarkerControlButton( static_cast< Qsk::Direction >( i ) );
+            button->setLayoutAlignmentHint( Qt::AlignCenter );
+
+            connect( button, &QskPushButton::pressed,
+                this, [ this, button ]() { shift( button->offset() ); } );
+
+            buttons[ i ] = button;
+        }
 
         m_carControl = new StackedControl();
 
@@ -369,16 +377,6 @@ class BalanceFadeControlBox final : public QskGridBox
         addItem( buttons[ Qsk::TopToBottom ], 2, 1 );
 
         addItem( m_carControl, 1, 1 );
-
-        for ( int i = 0; i < 4; i++ )
-        {
-            const auto button = buttons[ i ];
-
-            setAlignment( button, Qt::AlignCenter );
-
-            connect( button, &QskPushButton::pressed,
-                this, [ this, button ]() { shift( button->offset() ); } );
-        }
     }
 
     void shift( const QPointF& offset )

examples/gbenchmark/main.cpp

@@ -48,10 +48,11 @@ int main( int argc, char* argv[] )
         parser.showHelp( 1 );
 
     auto button = new Button( args[ 0 ] );
+    button->setLayoutAlignmentHint( Qt::AlignCenter );
     QObject::connect( button, &Button::clicked, button, &Button::run );
 
     auto box = new QskLinearBox();
-    box->addItem( button, Qt::AlignCenter );
+    box->addItem( button );
 
     QskWindow window;
     window.setColor( Qt::white );

examples/layouts/DynamicConstraintsPage.cpp

@@ -89,6 +89,7 @@ Box::Box( QQuickItem* parent )
     setObjectName( "Box" );
 
     setBackgroundColor( Qt::white );
+    setDefaultAlignment( Qt::AlignCenter );
 
     setMargins( 10 );
     setSpacing( 5 );
@@ -116,7 +117,7 @@ void Box::flip()
 
 void Box::addControl( Control* control )
 {
-    addItem( control, Qt::AlignCenter );
+    addItem( control );
 }
 
 DynamicConstraintsPage::DynamicConstraintsPage( QQuickItem* parent )
@@ -129,9 +130,10 @@ DynamicConstraintsPage::DynamicConstraintsPage( QQuickItem* parent )
 
     auto button = new QskPushButton( "Flip" );
     button->setSizePolicy( Qt::Horizontal, QskSizePolicy::Fixed );
+    button->setLayoutAlignmentHint( Qt::AlignTop | Qt::AlignLeft );
 
     QObject::connect( button, &QskPushButton::clicked, box, &Box::flip );
 
-    addItem( button, Qt::AlignTop | Qt::AlignLeft );
+    addItem( button );
     addItem( box );
 }

examples/layouts/FlowLayoutPage.cpp

@@ -27,6 +27,8 @@ namespace
             setMargins( 10 );
             setSpacing( 5 );
 
+            setDefaultAlignment( Qt::AlignCenter );
+
             addRectangle( "LightSteelBlue" );
             addRectangle( "PowderBlue" );
             addRectangle( "LightBlue" );
@@ -78,7 +80,7 @@ namespace
             auto rect = new TestRectangle( colorName );
             rect->setText( QString::number( count() + 1 ) );
 
-            addItem( rect, Qt::AlignCenter );
+            addItem( rect );
         }
     };
 }
@@ -92,12 +94,13 @@ FlowLayoutPage::FlowLayoutPage( QQuickItem* parent )
     auto box = new Box();
 
     auto buttonBox = new ButtonBox();
+    buttonBox->setLayoutAlignmentHint( Qt::AlignTop | Qt::AlignLeft );
     buttonBox->addButton( "Flip", [ box ]() { box->transpose(); } );
     buttonBox->addButton( "Mirror", [ box ]() { box->mirror(); } );
     buttonBox->addButton( "Rotate", [ box ]() { box->rotate(); } );
     buttonBox->addButton( "Dim+", [ box ]() { box->incrementDimension( +1 ); } );
     buttonBox->addButton( "Dim-", [ box ]() { box->incrementDimension( -1 ); } );
 
-    addItem( buttonBox, Qt::AlignTop | Qt::AlignLeft );
+    addItem( buttonBox );
     addItem( box );
 }

examples/layouts/LinearLayoutPage.cpp

@@ -26,6 +26,8 @@ namespace
             setMargins( 10 );
             setSpacing( 5 );
 
+            setDefaultAlignment( Qt::AlignCenter );
+
             addRectangle( "LightSalmon" );
             addRectangle( "Salmon" );
             addRectangle( "DarkSalmon" );
@@ -71,7 +73,7 @@ namespace
             auto rect = new TestRectangle( colorName );
             rect->setText( QString::number( count() + 1 ) );
 
-            addItem( rect, Qt::AlignCenter );
+            addItem( rect );
         }
     };
 }
@@ -85,12 +87,14 @@ LinearLayoutPage::LinearLayoutPage( QQuickItem* parent )
     auto box = new Box();
 
     auto buttonBox = new ButtonBox();
+
+    buttonBox->setLayoutAlignmentHint( Qt::AlignTop | Qt::AlignLeft );
     buttonBox->addButton( "Flip", [ box ]() { box->transpose(); } );
     buttonBox->addButton( "Mirror", [ box ]() { box->mirror(); } );
     buttonBox->addButton( "Rotate", [ box ]() { box->rotate(); } );
     buttonBox->addButton( "Spacing+", [ box ]() { box->incrementSpacing( +1 ); }, true );
     buttonBox->addButton( "Spacing-", [ box ]() { box->incrementSpacing( -1 ); }, true );
 
-    addItem( buttonBox, Qt::AlignTop | Qt::AlignLeft );
+    addItem( buttonBox );
     addItem( box );
 }

examples/layouts/StackLayoutPage.cpp

@@ -106,6 +106,8 @@ StackLayoutPage::StackLayoutPage( QQuickItem* parent )
     auto* box = new StackBox();
 
     auto* buttonBox = new ButtonBox();
+
+    buttonBox->setLayoutAlignmentHint( Qt::AlignTop | Qt::AlignLeft );
     buttonBox->addButton( "<<", [ box ]() { box->incrementScrolling( Qt::Horizontal, +1 ); } );
     buttonBox->addButton( ">>", [ box ]() { box->incrementScrolling( Qt::Horizontal, -1 ); } );
     buttonBox->addButton( "^", [ box ]() { box->incrementScrolling( Qt::Vertical, -1 ); } );
@@ -115,9 +117,10 @@ StackLayoutPage::StackLayoutPage( QQuickItem* parent )
     auto pageIndicator = new QskPageIndicator();
     pageIndicator->setCount( box->itemCount() );
     pageIndicator->setCurrentIndex( box->currentIndex() );
+    pageIndicator->setLayoutAlignmentHint( Qt::AlignCenter );
 
-    addItem( buttonBox, Qt::AlignTop | Qt::AlignLeft );
+    addItem( buttonBox );
-    addItem( pageIndicator, Qt::AlignCenter );
+    addItem( pageIndicator );
     addItem( box );
 
     connect( box, &QskStackBox::currentIndexChanged,

examples/mycontrols/main.cpp

@@ -77,13 +77,15 @@ class Window : public QskWindow
     Window()
     {
         auto button = new MyToggleButton();
+
         button->setTextAt( 0, "Skin 1" );
         button->setTextAt( 1, "Skin 2" );
+        button->setLayoutAlignmentHint( Qt::AlignRight );
 
         auto box = new QskLinearBox( Qt::Vertical );
 
         box->setMargins( 20 );
-        box->addItem( button, Qt::AlignRight );
+        box->addItem( button );
         box->addSpacer( 10 );
         box->addItem( new ContentBox() );
 

examples/qvgviewer/MainWindow.cpp

@@ -90,10 +90,11 @@ MainWindow::MainWindow()
     auto invertButton = new QskPushButton( "Inverted" );
     invertButton->setSizePolicy( Qt::Horizontal, QskSizePolicy::Fixed );
     invertButton->setCheckable( true );
+    invertButton->setLayoutAlignmentHint( Qt::AlignRight );
 
     auto box = new QskLinearBox( Qt::Vertical );
     box->setMargins( 5 );
-    box->addItem( invertButton, Qt::AlignRight );
+    box->addItem( invertButton );
     box->addItem( m_tabView );
 
     addItem( box );

examples/sliders/main.cpp

@@ -142,7 +142,7 @@ class SliderBox : public QskLinearBox
                 connect( slider, &QskSlider::valueChanged,
                     []( qreal value ) { qDebug() << value; } );
 #endif
-                setAlignment( slider, Qt::AlignCenter );
+                slider->setLayoutAlignmentHint( Qt::AlignCenter );
             }
         }
     }
@@ -203,9 +203,10 @@ int main( int argc, char* argv[] )
         sliderBox, &SliderBox::flip );
 
     auto mainBox = new QskLinearBox( Qt::Vertical );
+    mainBox->setDefaultAlignment( Qt::AlignLeft );
     mainBox->setMargins( 10 );
     mainBox->setSpacing( 10 );
-    mainBox->addItem( buttonFlip, Qt::AlignLeft );
+    mainBox->addItem( buttonFlip );
     mainBox->addItem( sliderBox );
     mainBox->setStretchFactor( sliderBox, 10 );
 

examples/tabview/main.cpp

@@ -87,9 +87,10 @@ int main( int argc, char* argv[] )
     QObject::connect( rotateButton, &QskPushButton::clicked, tabView, &TabView::rotate );
 
     auto layoutBox = new QskLinearBox( Qt::Vertical );
+    layoutBox->setDefaultAlignment( Qt::AlignLeft );
     layoutBox->setMargins( 5 );
     layoutBox->setSpacing( 10 );
-    layoutBox->addItem( rotateButton, Qt::AlignLeft );
+    layoutBox->addItem( rotateButton );
     layoutBox->addItem( tabView );
 
     auto focusIndicator = new QskFocusIndicator();

playground/grids/GridSkinny.cpp

@@ -87,7 +87,7 @@ void GridSkinny::setStretchFactor(
 void GridSkinny::setSizeHintAt( int index, Qt::Orientation orientation,
     Qt::SizeHint which, int hint )
 {
-    if ( auto control = qobject_cast< QskControl* >( m_grid->itemAtIndex( index ) ) )
+    if ( auto control = qskControlCast( m_grid->itemAtIndex( index ) ) )
     {
         auto size = control->explicitSizeHint( which );
 
@@ -103,7 +103,7 @@ void GridSkinny::setSizeHintAt( int index, Qt::Orientation orientation,
 void GridSkinny::setSizePolicyAt(
     int index, Qt::Orientation orientation, int policy )
 {
-    if ( auto control = qobject_cast< QskControl* >( m_grid->itemAtIndex( index ) ) )
+    if ( auto control = qskControlCast( m_grid->itemAtIndex( index ) ) )
     {
         control->setSizePolicy( orientation,
             static_cast< QskSizePolicy::Policy >( policy ) );
@@ -112,14 +112,14 @@ void GridSkinny::setSizePolicyAt(
 
 void GridSkinny::setAlignmentAt( int index, Qt::Alignment alignment )
 {
-    if ( auto item = m_grid->itemAtIndex( index ) )
+    if ( auto control = qskControlCast( m_grid->itemAtIndex( index ) ) )
-        m_grid->setAlignment( item, alignment );
+        control->setLayoutAlignmentHint( alignment );
 }
 
 void GridSkinny::setRetainSizeWhenHiddenAt( int index, bool on )
 {
-    if ( auto item = m_grid->itemAtIndex( index ) )
+    if ( auto control = qskControlCast( m_grid->itemAtIndex( index ) ) )
-        m_grid->setRetainSizeWhenHidden( item, on );
+        control->setLayoutHint( QskControl::RetainSizeWhenHidden, on );
 }
 
 void GridSkinny::setVisibleAt( int index, bool on )

qmlexport/QskLayoutQml.h

@@ -80,16 +80,6 @@ class QskLinearBoxQml : public QskLayoutBoxQml< QskLinearBox >
 
   public:
 
-    Q_INVOKABLE void setAlignment( int index, Qt::Alignment alignment )
-    {
-        QskLinearBox::setAlignment( index, alignment );
-    }
-
-    Q_INVOKABLE Qt::Alignment alignment( int index ) const
-    {
-        return QskLinearBox::alignment( index );
-    }
-
     Q_INVOKABLE void setStretchFactor( QQuickItem* item, int stretchFactor )
     {
         QskLinearBox::setStretchFactor( item, stretchFactor );
@@ -99,16 +89,6 @@ class QskLinearBoxQml : public QskLayoutBoxQml< QskLinearBox >
     {
         return QskLinearBox::stretchFactor( item );
     }
-
-    Q_INVOKABLE void setRetainSizeWhenHidden( QQuickItem* item, bool on )
-    {
-        QskLinearBox::setRetainSizeWhenHidden( item, on );
-    }
-
-    Q_INVOKABLE bool retainSizeWhenHidden( QQuickItem* item ) const
-    {
-        return QskLinearBox::retainSizeWhenHidden( item );
-    }
 };
 
 class QskGridBoxQml : public QskLayoutBoxQml< QskGridBox >
@@ -132,16 +112,6 @@ class QskGridBoxQml : public QskLayoutBoxQml< QskGridBox >
     void resetVerticalSpacing();
     qreal verticalSpacing() const;
 
-    Q_INVOKABLE bool retainSizeWhenHidden( QQuickItem* item ) const
-    {
-        return QskGridBox::retainSizeWhenHidden( item );
-    }
-
-    Q_INVOKABLE void setRetainSizeWhenHidden( QQuickItem* item, bool on )
-    {
-        QskGridBox::setRetainSizeWhenHidden( item, on );
-    }
-
   Q_SIGNALS:
     void verticalSpacingChanged();
     void horizontalSpacingChanged();

src/controls/QskControl.cpp

@@ -341,6 +341,64 @@ QskSizePolicy::Policy QskControl::sizePolicy( Qt::Orientation orientation ) cons
     return d_func()->sizePolicy.policy( orientation );
 }
 
+/*
+    Layout attributes belong more to the layout code, than
+    being parameters of the control. So storing them here is kind of a
+    design flaw ( similar to QWidget/QSizePolicy ).
+    But this way we don't need to add the attributes to all type of
+    layout engines + we can make use of them when doing layouts
+    manually ( f.e autoLayoutChildren ).
+ */
+void QskControl::setLayoutAlignmentHint( Qt::Alignment alignment )
+{
+    Q_D( QskControl );
+
+    if ( d->layoutAlignmentHint != alignment )
+    {
+        d->layoutAlignmentHint = alignment;
+        d->layoutConstraintChanged();
+    }
+}
+
+Qt::Alignment QskControl::layoutAlignmentHint() const
+{
+    return static_cast< Qt::Alignment >( d_func()->layoutAlignmentHint );
+}
+
+void QskControl::setLayoutHint( LayoutHint flag, bool on )
+{
+    Q_D( QskControl );
+    if ( ( d->layoutHints & flag ) != on )
+    {
+        if ( on )
+            d->layoutHints |= flag;
+        else
+            d->layoutHints &= ~flag;
+    
+        d->layoutConstraintChanged();
+    }
+}
+
+bool QskControl::testLayoutHint( LayoutHint hint ) const
+{
+    return d_func()->layoutHints & hint;
+}
+
+void QskControl::setLayoutHints( LayoutHints hints )
+{
+    Q_D( QskControl );
+    if ( hints != layoutHints() )
+    {
+        d->layoutHints = hints;
+        d->layoutConstraintChanged();
+    }
+}
+
+QskControl::LayoutHints QskControl::layoutHints() const
+{
+    return static_cast< LayoutHints >( d_func()->layoutHints );
+}
+
 void QskControl::setPreferredSize( const QSizeF& size )
 {
     setExplicitSizeHint( Qt::PreferredSize, size );

src/controls/QskControl.h

@@ -56,6 +56,15 @@ class QSK_EXPORT QskControl : public QskQuickItem, public QskSkinnable
   public:
     QSK_STATES( Disabled, Hovered, Focused )
 
+    enum LayoutHint
+    {
+        // How to be treated by layouts
+        RetainSizeWhenHidden = 1 << 0
+    };
+
+    Q_ENUM( LayoutHint )
+    Q_DECLARE_FLAGS( LayoutHints, LayoutHint )
+
     QskControl( QQuickItem* parent = nullptr );
     ~QskControl() override;
 
@@ -99,6 +108,16 @@ class QSK_EXPORT QskControl : public QskQuickItem, public QskSkinnable
     QskSizePolicy sizePolicy() const;
     QskSizePolicy::Policy sizePolicy( Qt::Orientation ) const;
 
+    // hints for how to be treated by layouts
+    void setLayoutAlignmentHint( Qt::Alignment );
+    Qt::Alignment layoutAlignmentHint() const;
+
+    void setLayoutHint( LayoutHint, bool on );
+    bool testLayoutHint( LayoutHint ) const;
+
+    void setLayoutHints( LayoutHints );
+    LayoutHints layoutHints() const;
+
     void setMinimumSize( const QSizeF& );
     void setMinimumSize( qreal width, qreal height );
     void setMinimumWidth( qreal width );

src/controls/QskControlPrivate.cpp

@@ -39,6 +39,8 @@ static inline void qskSendEventTo( QObject* object, QEvent::Type type )
 QskControlPrivate::QskControlPrivate()
     : explicitSizeHints( nullptr )
     , sizePolicy( QskSizePolicy::Preferred, QskSizePolicy::Preferred )
+    , layoutHints( 0 )
+    , layoutAlignmentHint( 0 )
     , explicitLocale( false )
     , autoFillBackground( false )
     , autoLayoutChildren( false )

src/controls/QskControlPrivate.h

@@ -8,7 +8,6 @@
 
 #include "QskGlobal.h"
 #include "QskControl.h"
-
 #include "QskQuickItemPrivate.h"
 
 class QskControlPrivate : public QskQuickItemPrivate
@@ -43,7 +42,10 @@ class QskControlPrivate : public QskQuickItemPrivate
     QSizeF* explicitSizeHints;
 
     QLocale locale;
+
     QskSizePolicy sizePolicy;
+    int layoutHints : 4;
+    unsigned int layoutAlignmentHint : 8;
 
     bool explicitLocale : 1;
 

src/dialogs/QskMessageSubWindow.cpp

@@ -85,12 +85,11 @@ QskMessageSubWindow::QskMessageSubWindow( QQuickItem* parent )
     m_data->symbolLabel = new SymbolLabel( this );
     m_data->symbolLabel->hide();
 
-    const auto alignment = Qt::AlignTop | Qt::AlignHCenter;
-
     auto box = new QskLinearBox( Qt::Horizontal );
+    box->setDefaultAlignment( Qt::AlignTop | Qt::AlignHCenter );
     box->setSpacing( 0 );
-    box->addItem( m_data->symbolLabel, alignment );
+    box->addItem( m_data->symbolLabel );
-    box->addItem( m_data->textLabel, alignment );
+    box->addItem( m_data->textLabel );
     box->setStretchFactor( m_data->textLabel, 10 );
 
     setContentItem( box );

src/dialogs/QskMessageWindow.cpp

@@ -89,12 +89,12 @@ QskMessageWindow::QskMessageWindow( QWindow* parent )
     m_data->symbolLabel = new SymbolLabel( this );
     m_data->symbolLabel->hide();
 
-    const auto alignment = Qt::AlignTop | Qt::AlignHCenter;
-
     auto box = new QskLinearBox( Qt::Horizontal );
+
+    box->setDefaultAlignment( Qt::AlignTop | Qt::AlignHCenter );
     box->setSpacing( 0 );
-    box->addItem( m_data->symbolLabel, alignment );
+    box->addItem( m_data->symbolLabel );
-    box->addItem( m_data->textLabel, alignment );
+    box->addItem( m_data->textLabel );
     box->setStretchFactor( m_data->textLabel, 10 );
 
     setDialogContentItem( box );

src/inputpanel/QskInputPanelBox.cpp

@@ -93,9 +93,10 @@ QskInputPanelBox::QskInputPanelBox( QQuickItem* parent )
     m_data->keyboard = new QskVirtualKeyboard();
 
     auto layout = new QskLinearBox( Qt::Vertical, this );
+    layout->setDefaultAlignment( Qt::AlignLeft | Qt::AlignHCenter );
 
-    layout->addItem( m_data->prompt, Qt::AlignLeft | Qt::AlignHCenter );
+    layout->addItem( m_data->prompt );
-    layout->addItem( m_data->inputProxy, Qt::AlignLeft | Qt::AlignHCenter );
+    layout->addItem( m_data->inputProxy );
     layout->addStretch( 10 );
     layout->addItem( m_data->predictionBar );
     layout->addItem( m_data->keyboard );

src/inputpanel/QskInputPredictionBar.cpp

@@ -87,7 +87,7 @@ QskInputPredictionBar::QskInputPredictionBar( QQuickItem* parent )
         if ( i == 0 )
         {
             // to keep the height
-            m_data->layoutBox->setRetainSizeWhenHidden( button, true );
+            button->setLayoutHint( QskControl::RetainSizeWhenHidden, true );
         }
     }
 }

src/layouts/QskGridBox.cpp

@@ -96,8 +96,7 @@ QskGridBox::~QskGridBox()
 }
 
 int QskGridBox::addItem( QQuickItem* item,
-    int row, int column, int rowSpan, int columnSpan,
+    int row, int column, int rowSpan, int columnSpan )
-    Qt::Alignment alignment )
 {
     if ( item == nullptr || row < 0 || column < 0 )
         return -1;
@@ -116,12 +115,7 @@ int QskGridBox::addItem( QQuickItem* item,
         if ( index >= 0 )
         {
             if ( engine.gridAt( index ) == itemGrid )
-            {
-                if ( engine.setAlignmentAt( index, alignment ) )
-                    polish();
-
                 return index;
-            }
         }
     }
 
@@ -134,7 +128,7 @@ int QskGridBox::addItem( QQuickItem* item,
             item->setParentItem( this );
 
         qskSetItemActive( this, item, true );
-        index = engine.insertItem( item, itemGrid, alignment );
+        index = engine.insertItem( item, itemGrid );
     }
 
     if ( engine.count() > 1 )
@@ -311,42 +305,6 @@ void QskGridBox::setColumnFixedWidth( int column, qreal width )
     setColumnSizeHint( column, Qt::MaximumSize, width );
 }
 
-void QskGridBox::setAlignment( const QQuickItem* item, Qt::Alignment alignment )
-{
-    auto& engine = m_data->engine;
-
-    const int index = engine.indexOf( item );
-    if ( index >= 0 )
-    {
-        if ( engine.setAlignmentAt( index, alignment ) )
-            polish();
-    }
-}
-
-Qt::Alignment QskGridBox::alignment( const QQuickItem* item ) const
-{
-    const auto& engine = m_data->engine;
-    return engine.alignmentAt( engine.indexOf( item ) );
-}
-
-void QskGridBox::setRetainSizeWhenHidden( const QQuickItem* item, bool on )
-{
-    auto& engine = m_data->engine;
-
-    const int index = engine.indexOf( item );
-    if ( index >= 0 )
-    {
-        if ( engine.setRetainSizeWhenHiddenAt( index, on ) )
-            invalidate();
-    }
-}
-
-bool QskGridBox::retainSizeWhenHidden( const QQuickItem* item ) const
-{
-    const auto& engine = m_data->engine;
-    return engine.retainSizeWhenHiddenAt( engine.indexOf( item ) );
-}
-
 void QskGridBox::setRowSizeHint( int row, Qt::SizeHint which, qreal height )
 {
     if ( m_data->engine.setRowSizeHint( row, which, height ) )

src/layouts/QskGridBox.h

@@ -24,13 +24,10 @@ class QSK_EXPORT QskGridBox : public QskBox
     explicit QskGridBox( QQuickItem* parent = nullptr );
     ~QskGridBox() override;
 
-    Q_INVOKABLE int addItem(
+    Q_INVOKABLE int addItem( QQuickItem*,
-        QQuickItem*, int row, int column, int rowSpan, int columnSpan,
+        int row, int column, int rowSpan, int columnSpan );
-        Qt::Alignment alignment = Qt::Alignment() );
 
-    Q_INVOKABLE int addItem(
+    Q_INVOKABLE int addItem( QQuickItem*, int row, int column );
-        QQuickItem*, int row, int column,
-        Qt::Alignment alignment = Qt::Alignment() );
 
     Q_INVOKABLE int addSpacer( qreal spacing,
         int row, int column, int columnSpan = 1, int rowSpan = 1 );
@@ -102,14 +99,6 @@ class QSK_EXPORT QskGridBox : public QskBox
     Q_INVOKABLE void setRowFixedHeight( int row, qreal height );
     Q_INVOKABLE void setColumnFixedWidth( int column, qreal width );
 
-    // alignments
-
-    void setAlignment( const QQuickItem* item, Qt::Alignment alignment );
-    Qt::Alignment alignment( const QQuickItem* item ) const;
-
-    bool retainSizeWhenHidden( const QQuickItem* ) const;
-    void setRetainSizeWhenHidden( const QQuickItem*, bool on );
-
     QSizeF contentsSizeHint() const override;
 
     qreal heightForWidth( qreal width ) const override;
@@ -134,10 +123,9 @@ class QSK_EXPORT QskGridBox : public QskBox
     std::unique_ptr< PrivateData > m_data;
 };
 
-inline int QskGridBox::addItem(
+inline int QskGridBox::addItem( QQuickItem* item, int row, int column )
-    QQuickItem* item, int row, int column, Qt::Alignment alignment )
 {
-    return addItem( item, row, column, 1, 1, alignment );
+    return addItem( item, row, column, 1, 1 );
 }
 
 inline bool QskGridBox::isEmpty() const

src/layouts/QskGridLayoutEngine.cpp

@@ -158,7 +158,7 @@ namespace
     class Element
     {
       public:
-        Element( QQuickItem*, const QRect&, Qt::Alignment );
+        Element( QQuickItem*, const QRect& );
         Element( qreal spacing, const QRect& );
 
         Element& operator=( const Element& );
@@ -166,12 +166,6 @@ namespace
         qreal spacer() const;
         QQuickItem* item() const;
 
-        Qt::Alignment alignment() const;
-        void setAlignment( Qt::Alignment );
-
-        bool retainSizeWhenHidden() const;
-        void setRetainSizeWhenHidden( bool );
-
         QRect grid() const;
         void setGrid( const QRect& );
 
@@ -193,29 +187,21 @@ namespace
         };
 
         QRect m_grid;
-
+        bool m_isSpacer;
-        unsigned int m_alignment : 8;
-        bool m_isSpacer : 1;
-        bool m_retainSizeWhenHidden : 1;
     };
 }
 
-Element::Element( QQuickItem* item,
+Element::Element( QQuickItem* item, const QRect& grid )
-        const QRect& grid, Qt::Alignment alignment )
     : m_item( item )
     , m_grid( grid )
-    , m_alignment(alignment)
     , m_isSpacer( false )
-    , m_retainSizeWhenHidden( false )
 {
 }
 
 Element::Element( qreal spacing, const QRect& grid )
     : m_spacer( spacing )
     , m_grid( grid )
-    , m_alignment( 0 )
     , m_isSpacer( true )
-    , m_retainSizeWhenHidden( false )
 {
 }
 
@@ -229,8 +215,6 @@ Element& Element::operator=( const Element& other )
         m_item = other.m_item;
 
     m_grid = other.m_grid;
-    m_alignment = other.m_alignment;
-    m_retainSizeWhenHidden = other.m_retainSizeWhenHidden;
 
     return *this;
 }
@@ -245,26 +229,6 @@ inline QQuickItem* Element::item() const
     return m_isSpacer ? nullptr : m_item;
 }
 
-inline Qt::Alignment Element::alignment() const
-{
-    return static_cast< Qt::Alignment >( m_alignment );
-}
-
-void Element::setAlignment( Qt::Alignment alignment )
-{
-    m_alignment = alignment;
-}
-
-inline bool Element::retainSizeWhenHidden() const
-{
-    return m_retainSizeWhenHidden;
-}
-
-void Element::setRetainSizeWhenHidden( bool on )
-{
-    m_retainSizeWhenHidden = on;
-}
-
 QRect Element::grid() const
 {
     return m_grid;
@@ -283,7 +247,7 @@ QRect Element::minimumGrid() const
 
 bool Element::isIgnored() const
 {
-    if ( !m_isSpacer && !m_retainSizeWhenHidden )
+    if ( !m_isSpacer && !QskLayoutConstraint::retainSizeWhenHidden( m_item ) )
         return !qskIsVisibleToParent( m_item );
 
     return false;
@@ -325,8 +289,7 @@ class QskGridLayoutEngine::PrivateData
         return const_cast< Element* >( &this->elements[index] );
     }
 
-    int insertElement( QQuickItem* item, qreal spacing,
+    int insertElement( QQuickItem* item, qreal spacing, QRect grid )
-        QRect grid, Qt::Alignment alignment )
     {
         // -1 means unlimited, while 0 does not make any sense
         if ( grid.width() == 0 )
@@ -336,7 +299,7 @@ class QskGridLayoutEngine::PrivateData
             grid.setHeight( 1 );
 
         if ( item )
-            elements.push_back( Element( item, grid, alignment ) );
+            elements.push_back( Element( item, grid ) );
         else
             elements.push_back( Element( spacing, grid ) );
 
@@ -452,66 +415,16 @@ qreal QskGridLayoutEngine::columnSizeHint( int column, Qt::SizeHint which ) cons
     return settings.settingAt( column ).hint().size( which );
 }
 
-bool QskGridLayoutEngine::setAlignmentAt( int index, Qt::Alignment alignment )
+int QskGridLayoutEngine::insertItem( QQuickItem* item, const QRect& grid )
-{
-    if ( auto element = m_data->elementAt( index ) )
-    {
-        if ( alignment != element->alignment() )
-            element->setAlignment( alignment );
-
-        return true;
-    }
-
-    return false;
-}
-
-Qt::Alignment QskGridLayoutEngine::alignmentAt( int index ) const
-{
-    if ( const auto element = m_data->elementAt( index ) )
-        return element->alignment();
-
-    return Qt::Alignment();
-}
-
-bool QskGridLayoutEngine::setRetainSizeWhenHiddenAt( int index, bool on )
-{
-    if ( auto element = m_data->elementAt( index ) )
-    {
-        if ( on != element->retainSizeWhenHidden() )
-        {
-            const bool isIgnored = element->isIgnored();
-            element->setRetainSizeWhenHidden( on );
-
-            if ( isIgnored != element->isIgnored() )
-            {
-                invalidate();
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-bool QskGridLayoutEngine::retainSizeWhenHiddenAt( int index ) const
-{
-    if ( const auto element = m_data->elementAt( index ) )
-        return element->retainSizeWhenHidden();
-
-    return false;
-}
-
-int QskGridLayoutEngine::insertItem( QQuickItem* item,
-    const QRect& grid, Qt::Alignment alignment )
 {
     invalidate();
-    return m_data->insertElement( item, -1, grid, alignment );
+    return m_data->insertElement( item, -1, grid );
 }
 
 int QskGridLayoutEngine::insertSpacer( qreal spacing, const QRect& grid )
 {
     spacing = qMax( spacing, 0.0 );
-    return m_data->insertElement( nullptr, spacing, grid, Qt::Alignment() );
+    return m_data->insertElement( nullptr, spacing, grid );
 }
 
 bool QskGridLayoutEngine::removeAt( int index )
@@ -640,7 +553,7 @@ void QskGridLayoutEngine::layoutItems()
             if ( auto item = element.item() )
             {
                 const auto grid = m_data->effectiveGrid( element );
-                layoutItem( item, grid, element.alignment() );
+                layoutItem( item, grid );
             }
         }
     }

src/layouts/QskGridLayoutEngine.h

@@ -33,7 +33,7 @@ class QskGridLayoutEngine : public QskLayoutEngine2D
     bool setColumnSizeHint( int column, Qt::SizeHint, qreal width );
     qreal columnSizeHint( int column, Qt::SizeHint ) const;
 
-    int insertItem( QQuickItem*, const QRect& grid, Qt::Alignment );
+    int insertItem( QQuickItem*, const QRect& grid );
     int insertSpacer( qreal spacing, const QRect& grid );
 
     bool removeAt( int index );
@@ -50,12 +50,6 @@ class QskGridLayoutEngine : public QskLayoutEngine2D
 
     QRect effectiveGridAt( int index ) const;
 
-    bool setRetainSizeWhenHiddenAt( int index, bool on );
-    bool retainSizeWhenHiddenAt( int index ) const;
-
-    bool setAlignmentAt( int index, Qt::Alignment );
-    Qt::Alignment alignmentAt( int index ) const;
-
     void transpose();
 
   private:

src/layouts/QskLayoutConstraint.cpp

@@ -7,6 +7,7 @@
 #include "QskControl.h"
 #include "QskSizePolicy.h"
 #include "QskLayoutHint.h"
+#include "QskQuick.h"
 #include "QskFunctions.h"
 
 #include <functional>
@@ -219,14 +220,11 @@ qreal QskLayoutConstraint::constrainedChildrenMetric(
     const auto children = control->childItems();
     for ( auto child : children )
     {
-        if ( auto control = qskControlCast( child ) )
+        if ( !qskIsTransparentForPositioner( child ) )
         {
-            if ( !control->isTransparentForPositioner() )
+            const auto v = constrainFunction( child, constraint );
-            {
+            if ( v > constrainedValue )
-                const auto v = constrainFunction( control, constraint );
+                constrainedValue = v;
-                if ( v > constrainedValue )
-                    constrainedValue = v;
-            }
         }
     }
 
@@ -425,3 +423,71 @@ QskLayoutHint QskLayoutConstraint::layoutHint(
 
     return QskLayoutHint( minimum, preferred, maximum );
 }
+
+static const char s_alignmentProperty[] = "layoutAlignmentHint";
+static const char s_retainSizeWhenHiddenProperty[] = "layoutRetainSizeWhenHidden";
+
+Qt::Alignment QskLayoutConstraint::layoutAlignmentHint( const QQuickItem* item )
+{
+    if ( auto control = qskControlCast( item ) )
+    {
+        return control->layoutAlignmentHint();
+    }
+    else if ( item )
+    {
+        const QVariant v = item->property( s_alignmentProperty );
+        if ( v.canConvert< Qt::Alignment >() )
+            return v.value< Qt::Alignment >();
+    }
+        
+    return Qt::Alignment();
+}
+
+void QskLayoutConstraint::setLayoutAlignmentHint(
+    QQuickItem* item, Qt::Alignment alignment )
+{
+    if ( auto control = qskControlCast( item ) )
+    {
+        control->setLayoutAlignmentHint( alignment );
+    }
+    else if ( item )
+    {
+        QVariant v;
+        if ( alignment )
+            v.setValue( alignment );
+
+        item->setProperty( s_alignmentProperty, v );
+    }
+}
+
+bool QskLayoutConstraint::retainSizeWhenHidden( const QQuickItem* item )
+{
+    if ( auto control = qskControlCast( item ) )
+    {
+        return control->layoutHints() & QskControl::RetainSizeWhenHidden;
+    }
+    else if ( item )
+    {
+        const QVariant v = item->property( s_retainSizeWhenHiddenProperty );
+        if ( v.canConvert< bool >() )
+            return v.toBool();
+    }
+
+    return false;
+}
+
+void QskLayoutConstraint::setRetainSizeWhenHidden( QQuickItem* item, bool on )
+{
+    if ( auto control = qskControlCast( item ) )
+    {
+        control->setLayoutHint( QskControl::RetainSizeWhenHidden, on );
+    }
+    else if ( item )
+    {
+        QVariant v;
+        if ( on )
+            v.setValue( on );
+
+        item->setProperty( s_retainSizeWhenHiddenProperty, v );
+    }
+}

src/layouts/QskLayoutConstraint.h

@@ -60,6 +60,12 @@ namespace QskLayoutConstraint
     QSK_EXPORT QskLayoutHint layoutHint(
         const QQuickItem*, Qt::Orientation, qreal constraint );
 
+    QSK_EXPORT Qt::Alignment layoutAlignmentHint( const QQuickItem* );
+    QSK_EXPORT void setLayoutAlignmentHint( QQuickItem*, Qt::Alignment );
+
+    QSK_EXPORT bool retainSizeWhenHidden( const QQuickItem* );
+    QSK_EXPORT void setRetainSizeWhenHidden( QQuickItem*, bool );
+
     const qreal unlimited = std::numeric_limits< float >::max();
     const QSizeF defaultSizeHints[] = { { 0, 0 }, { -1, -1 }, { unlimited, unlimited } };
 }

src/layouts/QskLayoutEngine2D.cpp

@@ -252,14 +252,14 @@ void QskLayoutEngine2D::setGeometries( const QRectF& rect )
     m_data->layoutData = nullptr;
 }
 
-void QskLayoutEngine2D::layoutItem( QQuickItem* item,
+void QskLayoutEngine2D::layoutItem( QQuickItem* item, const QRect& grid ) const
-    const QRect& grid, Qt::Alignment alignment ) const
 {
     auto layoutData = m_data->layoutData;
 
     if ( layoutData == nullptr || item == nullptr )
         return;
 
+    auto alignment = QskLayoutConstraint::layoutAlignmentHint( item );
     alignment = m_data->effectiveAlignment( alignment );
 
     QRectF rect = layoutData->geometryAt( grid );

src/layouts/QskLayoutEngine2D.h

@@ -54,8 +54,7 @@ class QskLayoutEngine2D
 
   protected:
 
-    void layoutItem( QQuickItem*,
+    void layoutItem( QQuickItem*, const QRect& grid ) const;
-        const QRect& grid, Qt::Alignment ) const;
 
     enum
     {

src/layouts/QskLinearBox.cpp

@@ -379,13 +379,12 @@ Qt::Edges QskLinearBox::extraSpacingAt() const
     return m_data->engine.extraSpacingAt();
 }
 
-int QskLinearBox::addItem( QQuickItem* item, Qt::Alignment alignment )
+int QskLinearBox::addItem( QQuickItem* item )
 {
-    return insertItem( -1, item, alignment );
+    return insertItem( -1, item );
 }
 
-int QskLinearBox::insertItem(
+int QskLinearBox::insertItem( int index, QQuickItem* item )
-    int index, QQuickItem* item, Qt::Alignment alignment )
 {
     if ( item == nullptr )
         return -1;
@@ -415,7 +414,6 @@ int QskLinearBox::insertItem(
     reparentItem( item );
 
     index = engine.insertItem( item, index );
-    engine.setAlignmentAt( index, alignment );
 
     // Re-ordering the child items to have a a proper focus tab chain
 
@@ -490,30 +488,6 @@ int QskLinearBox::insertStretch( int index, int stretchFactor )
     return insertSpacer( index, 0, stretchFactor );
 }
 
-void QskLinearBox::setAlignment( int index, Qt::Alignment alignment )
-{
-    if ( alignment != m_data->engine.alignmentAt( index ) )
-    {
-        m_data->engine.setAlignmentAt( index, alignment );
-        polish();
-    }
-}
-
-Qt::Alignment QskLinearBox::alignment( int index ) const
-{
-    return m_data->engine.alignmentAt( index );
-}
-
-void QskLinearBox::setAlignment( const QQuickItem* item, Qt::Alignment alignment )
-{
-    setAlignment( indexOf( item ), alignment );
-}
-
-Qt::Alignment QskLinearBox::alignment( const QQuickItem* item ) const
-{
-    return alignment( indexOf( item ) );
-}
-
 void QskLinearBox::setStretchFactor( int index, int stretchFactor )
 {
     auto& engine = m_data->engine;
@@ -540,32 +514,4 @@ int QskLinearBox::stretchFactor( const QQuickItem* item ) const
     return stretchFactor( indexOf( item ) );
 }
 
-void QskLinearBox::setRetainSizeWhenHidden( int index, bool on )
-{
-    auto& engine = m_data->engine;
-
-    if ( engine.retainSizeWhenHiddenAt( index ) != on )
-    {
-        engine.setRetainSizeWhenHiddenAt( index, on );
-
-        resetImplicitSize();
-        polish();
-    }
-}
-
-bool QskLinearBox::retainSizeWhenHidden( int index ) const
-{
-    return m_data->engine.retainSizeWhenHiddenAt( index );
-}
-
-void QskLinearBox::setRetainSizeWhenHidden( const QQuickItem* item, bool on )
-{
-    setRetainSizeWhenHidden( indexOf( item ), on );
-}
-
-bool QskLinearBox::retainSizeWhenHidden( const QQuickItem* item ) const
-{
-    return retainSizeWhenHidden( indexOf( item ) );
-}
-
 #include "moc_QskLinearBox.cpp"

src/layouts/QskLinearBox.h

@@ -75,11 +75,8 @@ class QSK_EXPORT QskLinearBox : public QskIndexedLayoutBox
     void resetSpacing();
     qreal spacing() const;
 
-    Q_INVOKABLE int addItem(
+    Q_INVOKABLE int addItem( QQuickItem* );
-        QQuickItem*, Qt::Alignment alignment = Qt::Alignment() );
+    Q_INVOKABLE int insertItem( int index, QQuickItem* );
-
-    Q_INVOKABLE int insertItem(
-        int index, QQuickItem*, Qt::Alignment alignment = Qt::Alignment() );
 
     Q_INVOKABLE int addSpacer( qreal spacing, int stretchFactor = 0 );
     Q_INVOKABLE int insertSpacer( int index, qreal spacing, int stretchFactor = 0 );
@@ -93,18 +90,6 @@ class QSK_EXPORT QskLinearBox : public QskIndexedLayoutBox
     void setStretchFactor( const QQuickItem*, int stretchFactor );
     int stretchFactor( const QQuickItem* ) const;
 
-    void setAlignment( int index, Qt::Alignment );
-    Qt::Alignment alignment( int index ) const;
-
-    void setAlignment( const QQuickItem*, Qt::Alignment );
-    Qt::Alignment alignment( const QQuickItem* ) const;
-
-    Q_INVOKABLE bool retainSizeWhenHidden( int index ) const;
-    Q_INVOKABLE void setRetainSizeWhenHidden( int index, bool on );
-
-    bool retainSizeWhenHidden( const QQuickItem* ) const;
-    void setRetainSizeWhenHidden( const QQuickItem*, bool on );
-
   public Q_SLOTS:
     void transpose();
     void activate();

src/layouts/QskLinearLayoutEngine.cpp

@@ -47,29 +47,20 @@ namespace
             qreal m_spacer;
         };
 
-        int m_stretch;
+        int m_stretch = -1;
-
+        bool m_isSpacer;
-        unsigned int m_alignment : 8;
-        bool m_isSpacer : 1;
-        bool m_retainSizeWhenHidden : 1;
     };
 }
 
 Element::Element( QQuickItem* item )
     : m_item( item )
-    , m_stretch( -1 )
-    , m_alignment( 0 )
     , m_isSpacer( false )
-    , m_retainSizeWhenHidden( false )
 {
 }
 
 Element::Element( qreal spacing )
     : m_spacer( spacing )
-    , m_stretch( -1 )
-    , m_alignment( 0 )
     , m_isSpacer( true )
-    , m_retainSizeWhenHidden( false )
 {
 }
 
@@ -83,8 +74,6 @@ Element& Element::operator=( const Element& other )
         m_item = other.m_item;
 
     m_stretch = other.m_stretch;
-    m_alignment = other.m_alignment;
-    m_retainSizeWhenHidden = other.m_retainSizeWhenHidden;
 
     return *this;
 }
@@ -99,26 +88,6 @@ inline QQuickItem* Element::item() const
     return m_isSpacer ? nullptr : m_item;
 }
 
-inline Qt::Alignment Element::alignment() const
-{
-    return static_cast< Qt::Alignment >( m_alignment );
-}
-
-inline void Element::setAlignment( Qt::Alignment alignment )
-{
-    m_alignment = alignment;
-}
-
-bool Element::retainSizeWhenHidden() const
-{
-    return m_retainSizeWhenHidden;
-}
-
-void Element::setRetainSizeWhenHidden( bool on )
-{
-    m_retainSizeWhenHidden = on;
-}
-
 inline int Element::stretch() const
 {
     return m_stretch;
@@ -131,7 +100,7 @@ inline void Element::setStretch( int stretch )
 
 bool Element::isIgnored() const
 {
-    if ( !m_isSpacer && !m_retainSizeWhenHidden )
+    if ( !m_isSpacer && !QskLayoutConstraint::retainSizeWhenHidden( m_item ) )
         return !qskIsVisibleToParent( m_item );
 
     return false;
@@ -259,38 +228,6 @@ int QskLinearLayoutEngine::count() const
     return m_data->elements.size();
 }
 
-bool QskLinearLayoutEngine::setRetainSizeWhenHiddenAt( int index, bool on )
-{
-    if ( auto element = m_data->elementAt( index ) )
-    {
-        if ( on != element->retainSizeWhenHidden() )
-        {
-            const bool isIgnored = element->isIgnored();
-
-            element->setRetainSizeWhenHidden( on );
-
-            if ( isIgnored != element->isIgnored() )
-            {
-                if ( m_data->sumIgnored >= 0 )
-                    m_data->sumIgnored += on ? 1 : -1;
-
-                invalidate( LayoutCache );
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-bool QskLinearLayoutEngine::retainSizeWhenHiddenAt( int index ) const
-{
-    if ( const auto element = m_data->elementAt( index ) )
-        return element->retainSizeWhenHidden();
-
-    return false;
-}
-
 bool QskLinearLayoutEngine::setStretchFactorAt( int index, int stretchFactor )
 {
     if ( auto element = m_data->elementAt( index ) )
@@ -318,27 +255,6 @@ int QskLinearLayoutEngine::stretchFactorAt( int index ) const
     return -1;
 }
 
-bool QskLinearLayoutEngine::setAlignmentAt( int index, Qt::Alignment alignment )
-{
-    if ( auto element = m_data->elementAt( index ) )
-    {
-        if ( alignment != element->alignment() )
-            element->setAlignment( alignment );
-
-        return true;
-    }
-
-    return false;
-}
-
-Qt::Alignment QskLinearLayoutEngine::alignmentAt( int index ) const
-{
-    if ( const auto element = m_data->elementAt( index ) )
-        return element->alignment();
-
-    return Qt::Alignment();
-}
-
 int QskLinearLayoutEngine::insertItem( QQuickItem* item, int index )
 {
     auto& elements = m_data->elements;
@@ -440,7 +356,7 @@ void QskLinearLayoutEngine::layoutItems()
         if ( auto item = element.item() )
         {
             const QRect grid( col, row, 1, 1 );
-            layoutItem( item, grid, element.alignment() );
+            layoutItem( item, grid );
         }
 
         if ( m_data->orientation == Qt::Horizontal )

src/layouts/QskLinearLayoutEngine.h

@@ -42,12 +42,6 @@ class QskLinearLayoutEngine : public QskLayoutEngine2D
     QQuickItem* itemAt( int index ) const override final;
     qreal spacerAt( int index ) const override final;
 
-    bool setRetainSizeWhenHiddenAt( int index, bool on );
-    bool retainSizeWhenHiddenAt( int index ) const;
-
-    bool setAlignmentAt( int index, Qt::Alignment );
-    Qt::Alignment alignmentAt( int index ) const;
-
     bool setStretchFactorAt( int index, int stretchFactor );
     int stretchFactorAt( int index ) const;