168492376
/
qskinny
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moving alignment/retainSizeWhenHidden from layouts to QskControl

This commit is contained in:
Uwe Rathmann 2019-09-05 10:46:42 +02:00
parent ab5dc1924e
commit 6a588dc95a
32 changed files with 249 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
examples/automotive/SoundControl.cpp
View File

@ -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 )

3
examples/gbenchmark/main.cpp
View File

@ -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 );

6
examples/layouts/DynamicConstraintsPage.cpp
View File

@ -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 );
}

7
examples/layouts/FlowLayoutPage.cpp
View File

@ -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 );
}

8
examples/layouts/LinearLayoutPage.cpp
View File

@ -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 );
}

7
examples/layouts/StackLayoutPage.cpp
View File

@ -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( pageIndicator, Qt::AlignCenter );
addItem( buttonBox );
addItem( pageIndicator );
addItem( box );
connect( box, &QskStackBox::currentIndexChanged,

4
examples/mycontrols/main.cpp
View File

@ -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() );

3
examples/qvgviewer/MainWindow.cpp
View File

@ -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 );

5
examples/sliders/main.cpp
View File

@ -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 );

3
examples/tabview/main.cpp
View File

@ -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();

12
playground/grids/GridSkinny.cpp
View File

@ -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 ) )
m_grid->setAlignment( item, alignment );
if ( auto control = qskControlCast( m_grid->itemAtIndex( index ) ) )
control->setLayoutAlignmentHint( alignment );
}
void GridSkinny::setRetainSizeWhenHiddenAt( int index, bool on )
{
if ( auto item = m_grid->itemAtIndex( index ) )
m_grid->setRetainSizeWhenHidden( item, on );
if ( auto control = qskControlCast( m_grid->itemAtIndex( index ) ) )
control->setLayoutHint( QskControl::RetainSizeWhenHidden, on );
}
void GridSkinny::setVisibleAt( int index, bool on )

30
qmlexport/QskLayoutQml.h
View File

@ -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();

58
src/controls/QskControl.cpp
View File

@ -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 );

19
src/controls/QskControl.h
View File

@ -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 );

2
src/controls/QskControlPrivate.cpp
View File

@ -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 )

4
src/controls/QskControlPrivate.h
View File

@ -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;

7
src/dialogs/QskMessageSubWindow.cpp
View File

@ -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->textLabel, alignment );
box->addItem( m_data->symbolLabel );
box->addItem( m_data->textLabel );
box->setStretchFactor( m_data->textLabel, 10 );
setContentItem( box );

8
src/dialogs/QskMessageWindow.cpp
View File

@ -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->textLabel, alignment );
box->addItem( m_data->symbolLabel );
box->addItem( m_data->textLabel );
box->setStretchFactor( m_data->textLabel, 10 );
setDialogContentItem( box );

5
src/inputpanel/QskInputPanelBox.cpp
View File

@ -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->inputProxy, Qt::AlignLeft | Qt::AlignHCenter );
layout->addItem( m_data->prompt );
layout->addItem( m_data->inputProxy );
layout->addStretch( 10 );
layout->addItem( m_data->predictionBar );
layout->addItem( m_data->keyboard );

2
src/inputpanel/QskInputPredictionBar.cpp
View File

@ -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 );
}
}
}

46
src/layouts/QskGridBox.cpp
View File

@ -96,8 +96,7 @@ QskGridBox::~QskGridBox()
}
int QskGridBox::addItem( QQuickItem* item,
int row, int column, int rowSpan, int columnSpan,
Qt::Alignment alignment )
int row, int column, int rowSpan, int columnSpan )
{
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 ) )

22
src/layouts/QskGridBox.h
View File

@ -24,13 +24,10 @@ class QSK_EXPORT QskGridBox : public QskBox
explicit QskGridBox( QQuickItem* parent = nullptr );
~QskGridBox() override;
Q_INVOKABLE int addItem(
QQuickItem*, int row, int column, int rowSpan, int columnSpan,
Qt::Alignment alignment = Qt::Alignment() );
Q_INVOKABLE int addItem( QQuickItem*,
int row, int column, int rowSpan, int columnSpan );
Q_INVOKABLE int addItem(
QQuickItem*, int row, int column,
Qt::Alignment alignment = Qt::Alignment() );
Q_INVOKABLE int addItem( QQuickItem*, int row, int column );
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(
QQuickItem* item, int row, int column, Qt::Alignment alignment )
inline int QskGridBox::addItem( QQuickItem* item, int row, int column )
{
return addItem( item, row, column, 1, 1, alignment );
return addItem( item, row, column, 1, 1 );
}
inline bool QskGridBox::isEmpty() const

107
src/layouts/QskGridLayoutEngine.cpp
View File

@ -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;
unsigned int m_alignment : 8;
bool m_isSpacer : 1;
bool m_retainSizeWhenHidden : 1;
bool m_isSpacer;
};
}
Element::Element( QQuickItem* item,
const QRect& grid, Qt::Alignment alignment )
Element::Element( QQuickItem* item, const QRect& grid )
: 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,
QRect grid, Qt::Alignment alignment )
int insertElement( QQuickItem* item, qreal spacing, QRect grid )
{
// -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 )
{
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 )
int QskGridLayoutEngine::insertItem( QQuickItem* item, const QRect& grid )
{
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 );
}
}
}

8
src/layouts/QskGridLayoutEngine.h
View File

@ -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:

80
src/layouts/QskLayoutConstraint.cpp
View File

@ -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( control, constraint );
if ( v > constrainedValue )
constrainedValue = v;
}
const auto v = constrainFunction( child, constraint );
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 );
}
}

6
src/layouts/QskLayoutConstraint.h
View File

@ -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 } };
}

4
src/layouts/QskLayoutEngine2D.cpp
View File

@ -252,14 +252,14 @@ void QskLayoutEngine2D::setGeometries( const QRectF& rect )
m_data->layoutData = nullptr;
}
void QskLayoutEngine2D::layoutItem( QQuickItem* item,
const QRect& grid, Qt::Alignment alignment ) const
void QskLayoutEngine2D::layoutItem( QQuickItem* item, const QRect& grid ) 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 );

3
src/layouts/QskLayoutEngine2D.h
View File

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

60
src/layouts/QskLinearBox.cpp
View File

@ -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 index, QQuickItem* item, Qt::Alignment alignment )
int QskLinearBox::insertItem( int index, QQuickItem* item )
{
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"

19
src/layouts/QskLinearBox.h
View File

@ -75,11 +75,8 @@ class QSK_EXPORT QskLinearBox : public QskIndexedLayoutBox
void resetSpacing();
qreal spacing() const;
Q_INVOKABLE int addItem(
QQuickItem*, Qt::Alignment alignment = Qt::Alignment() );
Q_INVOKABLE int insertItem(
int index, QQuickItem*, Qt::Alignment alignment = Qt::Alignment() );
Q_INVOKABLE int addItem( QQuickItem* );
Q_INVOKABLE int insertItem( int index, QQuickItem* );
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();

92
src/layouts/QskLinearLayoutEngine.cpp
View File

@ -47,29 +47,20 @@ namespace
qreal m_spacer;
};
int m_stretch;
unsigned int m_alignment : 8;
bool m_isSpacer : 1;
bool m_retainSizeWhenHidden : 1;
int m_stretch = -1;
bool m_isSpacer;
};
}
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 )

6
src/layouts/QskLinearLayoutEngine.h
View File

@ -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;