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

renamed to QskQuickItem::UpdateFlags

This commit is contained in:
Uwe Rathmann 2021-02-09 08:13:20 +01:00
parent 40b257a36f
commit 5cb33ad79b
16 changed files with 142 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
doc/classes/QskQuickItem.dox
View File

@ -9,14 +9,14 @@
*/ */
/*! /*!
\enum QskQuickItem::Flag \enum QskQuickItem::UpdateFlag
Qt/Quick classes have a tendency to update items too early Qt/Quick classes have a tendency to update items too early
and too often. To avoid processing of unwanted operations and too often. To avoid processing of unwanted operations
QskQuickItem implements a couple of modifications, that QskQuickItem implements a couple of modifications, that
can be en/disabled individually. can be en/disabled individually.
\var QskQuickItem::Flag QskQuickItem::DeferredUpdate \var QskQuickItem::UpdateFlag QskQuickItem::DeferredUpdate
Creating of sceme graph nodes is blocked when being invisible. Creating of sceme graph nodes is blocked when being invisible.
@ -34,7 +34,7 @@
such as viewport frustrum culling (i.e. hiding items outside of the such as viewport frustrum culling (i.e. hiding items outside of the
window geometry). window geometry).
\var QskQuickItem::Flag QskQuickItem::DeferredPolish \var QskQuickItem::UpdateFlag QskQuickItem::DeferredPolish
Polishing an item ( QQuickItem::polish() ) is blocked when being invisible. Polishing an item ( QQuickItem::polish() ) is blocked when being invisible.
F.e for all items being derived from QskControl the layout calculations F.e for all items being derived from QskControl the layout calculations
@ -42,7 +42,7 @@
\sa QQuickItem::updatePolish() \sa QQuickItem::updatePolish()
\var QskQuickItem::Flag QskQuickItem::DeferredLayout \var QskQuickItem::UpdateFlag QskQuickItem::DeferredLayout
Recalculations of the implicitSize are blocked until being explicitely requested by Recalculations of the implicitSize are blocked until being explicitely requested by
QQuickItem::implicitSize(). QQuickItem::implicitSize().
@ -59,25 +59,25 @@
\sa QskQuickItem::resetImplicitSize() \sa QskQuickItem::resetImplicitSize()
\var QskQuickItem::Flag QskQuickItem::CleanupOnVisibility \var QskQuickItem::UpdateFlag QskQuickItem::CleanupOnVisibility
Delete scene graph nodes, when the item becomes hidden ( QQuickItem::isVisible() ). Delete scene graph nodes, when the item becomes hidden ( QQuickItem::isVisible() ).
Enabling this mode will reduce the memory footprint, but comes at the cost Enabling this mode will reduce the memory footprint, but comes at the cost
of having to recreate nodes once the item gets shown again. of having to recreate nodes once the item gets shown again.
\var QskQuickItem::Flag QskQuickItem::PreferRasterForTextures \var QskQuickItem::UpdateFlag QskQuickItem::PreferRasterForTextures
When creating textures from QskGraphic, prefer the raster paint When creating textures from QskGraphic, prefer the raster paint
engine over the OpenGL paint engine. engine over the OpenGL paint engine.
\var QskQuickItem::Flag QskQuickItem::DebugForceBackground \var QskQuickItem::UpdateFlag QskQuickItem::DebugForceBackground
Always fill the background of the item with a random color. Always fill the background of the item with a random color.
\note This flag is useful when analyzing layouts. \note This flag is useful when analyzing layouts.
\sa controlFlags(), setControlFlags(), resetControlFlags() \sa updateFlags(), setUpdateFlags(), resetUpdateFlags()
testControlFlag(), setControlFlag(), resetControlFlag() testUpdateFlag(), setUpdateFlag(), resetUpdateFlag()
*/ */
/*! /*!
@ -372,43 +372,43 @@
*/ */
/*! /*!
\fn QskQuickItem::setControlFlags \fn QskQuickItem::setUpdateFlags
bla bla
*/ */
/*! /*!
\fn QskQuickItem::resetControlFlags \fn QskQuickItem::resetUpdateFlags
bla bla
*/ */
/*! /*!
\fn QskQuickItem::controlFlags \fn QskQuickItem::updateFlags
bla bla
*/ */
/*! /*!
\fn QskQuickItem::setControlFlag \fn QskQuickItem::setUpdateFlag
bla bla
*/ */
/*! /*!
\fn QskQuickItem::resetControlFlag \fn QskQuickItem::resetUpdateFlag
bla bla
*/ */
/*! /*!
\fn QskQuickItem::testControlFlag \fn QskQuickItem::testUpdateFlag
bla bla
*/ */
/*! /*!
\fn QskQuickItem::controlFlagsChanged \fn QskQuickItem::updateFlagsChanged
bla bla
*/ */

2
examples/automotive/main.cpp
View File

@ -31,7 +31,7 @@ int main( int argc, char** argv )
When going over QPainter for the SVGs we prefer the raster paint When going over QPainter for the SVGs we prefer the raster paint
engine, simply showing better results. engine, simply showing better results.
*/ */
qskSetup->setControlFlag( QskSetup::PreferRasterForTextures, true ); qskSetup->setItemUpdateFlag( QskQuickItem::PreferRasterForTextures, true );
SkinnyFont::init( &app ); SkinnyFont::init( &app );
SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts ); SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts );

2
examples/mycontrols/main.cpp
View File

@ -140,7 +140,7 @@ int main( int argc, char* argv[] )
qskSkinManager->registerFactory( qskSkinManager->registerFactory(
QStringLiteral( "MySkinFactory" ), new MySkinFactory() ); QStringLiteral( "MySkinFactory" ), new MySkinFactory() );
qskSetup->setControlFlag( QskSetup::PreferRasterForTextures, true ); qskSetup->setItemUpdateFlag( QskQuickItem::PreferRasterForTextures, true );
Window window; Window window;
window.resize( 480, 360 ); window.resize( 480, 360 );

4
qmlexport/QskMainQml.cpp
View File

@ -23,8 +23,8 @@ QskMain::QskMain( QObject* parent )
connect( setup(), &QskSetup::skinChanged, connect( setup(), &QskSetup::skinChanged,
this, &QskMain::skinChanged, Qt::QueuedConnection ); this, &QskMain::skinChanged, Qt::QueuedConnection );
connect( setup(), &QskSetup::controlFlagsChanged, connect( setup(), &QskSetup::itemUpdateFlagsChanged,
this, &QskMain::controlFlagsChanged, Qt::QueuedConnection ); this, &QskMain::itemUpdateFlagsChanged, Qt::QueuedConnection );
} }
QStringList QskMain::skinList() const QStringList QskMain::skinList() const

10
qmlexport/QskMainQml.h
View File

@ -13,14 +13,14 @@
#include <qobject.h> #include <qobject.h>
#include <qqmllist.h> #include <qqmllist.h>
class QskSetupFlagsQml : public QskSetup::Flags class QskSetupFlagsQml : public QskQuickItem::UpdateFlags
{ {
Q_GADGET Q_GADGET
public: public:
template< typename... Args > template< typename... Args >
QskSetupFlagsQml( Args&&... args ) QskSetupFlagsQml( Args&&... args )
: QskSetup::Flags( std::forward< Args >( args )... ) : QskQuickItem::UpdateFlags( std::forward< Args >( args )... )
{ {
} }
@ -37,8 +37,8 @@ class QskMain : public QObject
Q_PROPERTY( QStringList skinList READ skinList NOTIFY skinListChanged ) Q_PROPERTY( QStringList skinList READ skinList NOTIFY skinListChanged )
Q_PRIVATE_PROPERTY( setup(), QskSetupFlagsQml controlFlags Q_PRIVATE_PROPERTY( setup(), QskSetupFlagsQml itemUpdateFlags
READ controlFlags WRITE setControlFlags NOTIFY controlFlagsChanged ) READ itemUpdateFlags WRITE setItemUpdateFlags NOTIFY itemUpdateFlagsChanged )
Q_PROPERTY( QQmlListProperty< QObject > data READ data ) Q_PROPERTY( QQmlListProperty< QObject > data READ data )
Q_CLASSINFO( "DefaultProperty", "data" ) Q_CLASSINFO( "DefaultProperty", "data" )
@ -53,7 +53,7 @@ class QskMain : public QObject
void skinListChanged(); // never emitted void skinListChanged(); // never emitted
void skinChanged(); void skinChanged();
void inputPanelChanged(); void inputPanelChanged();
void controlFlagsChanged(); void itemUpdateFlagsChanged();
private: private:
static inline QskSetup* setup() { return QskSetup::instance(); } static inline QskSetup* setup() { return QskSetup::instance(); }

6
qmlexport/QskQml.cpp
View File

@ -169,10 +169,8 @@ void QskQml::registerTypes()
qmlRegisterUncreatableType< QskSkin >( "Skinny.Skins", 1, 0, "Skin", QString() ); qmlRegisterUncreatableType< QskSkin >( "Skinny.Skins", 1, 0, "Skin", QString() );
QSK_REGISTER_FLAGS( QskControl::Flag ); QSK_REGISTER_FLAGS( QskQuickItem::UpdateFlag );
QSK_REGISTER_FLAGS( QskControl::Flags ); QSK_REGISTER_FLAGS( QskQuickItem::UpdateFlags );
QSK_REGISTER_FLAGS( QskSetup::Flag );
QSK_REGISTER_FLAGS( QskSetup::Flags );
QSK_REGISTER_FLAGS( QskSizePolicy::Policy ); QSK_REGISTER_FLAGS( QskSizePolicy::Policy );
QSK_REGISTER_FLAGS( QskDialog::Actions ); QSK_REGISTER_FLAGS( QskDialog::Actions );

2
src/controls/QskDirtyItemFilter.cpp
View File

@ -16,7 +16,7 @@ static inline bool qskIsUpdateBlocked( const QQuickItem* item )
if ( !item->isVisible() ) if ( !item->isVisible() )
{ {
if ( const auto control = qskControlCast( item ) ) if ( const auto control = qskControlCast( item ) )
return control->testControlFlag( QskControl::DeferredUpdate ); return control->testUpdateFlag( QskControl::DeferredUpdate );
} }
#if 0 #if 0

87
src/controls/QskQuickItem.cpp
View File

@ -28,17 +28,11 @@ static inline void qskSendEventTo( QObject* object, QEvent::Type type )
QCoreApplication::sendEvent( object, &event ); QCoreApplication::sendEvent( object, &event );
} }
static inline void qskUpdateControlFlags( static inline void qskApplyUpdateFlags(
QskQuickItem::Flags flags, QskQuickItem* item ) QskQuickItem::UpdateFlags flags, QskQuickItem* item )
{ {
auto d = static_cast< QskQuickItemPrivate* >( QskQuickItemPrivate::get( item ) ); auto d = static_cast< QskQuickItemPrivate* >( QskQuickItemPrivate::get( item ) );
d->updateControlFlags( flags ); d->applyUpdateFlags( flags );
}
static inline quint16 qskControlFlags()
{
// we are only interested in the first 8 bits
return static_cast< quint16 >( qskSetup->controlFlags() );
} }
static inline void qskFilterWindow( QQuickWindow* window ) static inline void qskFilterWindow( QQuickWindow* window )
@ -61,7 +55,7 @@ namespace
Its faster and saves some memory to have this registry instead Its faster and saves some memory to have this registry instead
of setting up direct connections between qskSetup and each control of setting up direct connections between qskSetup and each control
*/ */
QObject::connect( qskSetup, &QskSetup::controlFlagsChanged, QObject::connect( qskSetup, &QskSetup::itemUpdateFlagsChanged,
qskSetup, [ this ] { updateControlFlags(); } ); qskSetup, [ this ] { updateControlFlags(); } );
QObject::connect( qskSetup, &QskSetup::skinChanged, QObject::connect( qskSetup, &QskSetup::skinChanged,
@ -80,10 +74,10 @@ namespace
void updateControlFlags() void updateControlFlags()
{ {
const auto flags = static_cast< QskQuickItem::Flags >( qskControlFlags() ); const auto flags = qskSetup->itemUpdateFlags();
for ( auto item : m_items ) for ( auto item : m_items )
qskUpdateControlFlags( flags, item ); qskApplyUpdateFlags( flags, item );
} }
void updateSkin() void updateSkin()
@ -162,7 +156,7 @@ QskQuickItem::QskQuickItem( QskQuickItemPrivate& dd, QQuickItem* parent )
this, &QskQuickItem::sendEnabledChangeEvent ); this, &QskQuickItem::sendEnabledChangeEvent );
#endif #endif
if ( dd.controlFlags & QskQuickItem::DeferredUpdate ) if ( dd.updateFlags & QskQuickItem::DeferredUpdate )
qskFilterWindow( window() ); qskFilterWindow( window() );
qskRegistry->insert( this ); qskRegistry->insert( this );
@ -201,7 +195,7 @@ void QskQuickItem::componentComplete()
#if defined( QT_DEBUG ) #if defined( QT_DEBUG )
if ( qobject_cast< const QQuickBasePositioner* >( parent() ) ) if ( qobject_cast< const QQuickBasePositioner* >( parent() ) )
{ {
if ( d_func()->controlFlags & QskQuickItem::DeferredLayout ) if ( d_func()->updateFlags & QskQuickItem::DeferredLayout )
{ {
qWarning( "QskQuickItem in DeferredLayout mode under control of a positioner" ); qWarning( "QskQuickItem in DeferredLayout mode under control of a positioner" );
} }
@ -454,76 +448,73 @@ bool QskQuickItem::maybeUnresized() const
return false; return false;
} }
QskQuickItem::Flags QskQuickItem::controlFlags() const QskQuickItem::UpdateFlags QskQuickItem::updateFlags() const
{ {
return QskQuickItem::Flags( d_func()->controlFlags ); return UpdateFlags( d_func()->updateFlags );
} }
void QskQuickItem::setControlFlags( Flags flags ) void QskQuickItem::setUpdateFlags( UpdateFlags flags )
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
// set all bits in the mask // set all bits in the mask
d->controlFlagsMask = std::numeric_limits< quint16 >::max(); d->updateFlagsMask = std::numeric_limits< decltype( d->updateFlagsMask ) >::max();
d->updateControlFlags( flags ); d->applyUpdateFlags( flags );
} }
void QskQuickItem::resetControlFlags() void QskQuickItem::resetUpdateFlags()
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
// clear all bits in the mask // clear all bits in the mask
d->controlFlagsMask = 0; d->updateFlagsMask = 0;
d->updateControlFlags( static_cast< Flags >( qskControlFlags() ) ); d->applyUpdateFlags( qskSetup->itemUpdateFlags() );
} }
void QskQuickItem::setControlFlag( Flag flag, bool on ) void QskQuickItem::setUpdateFlag( UpdateFlag flag, bool on )
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
d->controlFlagsMask |= flag; d->updateFlagsMask |= flag;
if ( ( d->controlFlags & flag ) != on ) if ( testUpdateFlag( flag ) != on )
{ {
updateControlFlag( flag, on ); applyUpdateFlag( flag, on );
Q_EMIT controlFlagsChanged(); Q_EMIT updateFlagsChanged( updateFlags() );
} }
} }
void QskQuickItem::resetControlFlag( Flag flag ) void QskQuickItem::resetUpdateFlag( UpdateFlag flag )
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
d->controlFlagsMask &= ~flag; d->updateFlagsMask &= ~flag;
const bool on = qskSetup->testControlFlag( static_cast< QskSetup::Flag >( flag ) ); const bool on = qskSetup->testItemUpdateFlag( flag );
if ( ( d->controlFlags & flag ) != on ) if ( testUpdateFlag( flag ) != on )
{ {
updateControlFlag( flag, on ); applyUpdateFlag( flag, on );
Q_EMIT controlFlagsChanged(); Q_EMIT updateFlagsChanged( updateFlags() );
} }
} }
bool QskQuickItem::testControlFlag( Flag flag ) const bool QskQuickItem::testUpdateFlag( UpdateFlag flag ) const
{ {
return d_func()->controlFlags & flag; return d_func()->updateFlags & flag;
} }
void QskQuickItem::updateControlFlag( uint flag, bool on ) void QskQuickItem::applyUpdateFlag( UpdateFlag flag, bool on )
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
if ( ( flag > std::numeric_limits< quint16 >::max() ) || if ( testUpdateFlag( flag ) == on )
( bool( d->controlFlags & flag ) == on ) )
{
return; return;
}
if ( on ) if ( on )
d->controlFlags |= flag; d->updateFlags |= flag;
else else
d->controlFlags &= ~flag; d->updateFlags &= ~flag;
switch ( flag ) switch ( flag )
{ {
@ -584,7 +575,7 @@ void QskQuickItem::resetImplicitSize()
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
if ( d->controlFlags & QskQuickItem::DeferredLayout ) if ( d->updateFlags & QskQuickItem::DeferredLayout )
{ {
d->blockedImplicitSize = true; d->blockedImplicitSize = true;
d->layoutConstraintChanged(); d->layoutConstraintChanged();
@ -681,7 +672,7 @@ void QskQuickItem::itemChange( QQuickItem::ItemChange change,
if ( value.window ) if ( value.window )
{ {
Q_D( const QskQuickItem ); Q_D( const QskQuickItem );
if ( d->controlFlags & QskQuickItem::DeferredUpdate ) if ( d->updateFlags & QskQuickItem::DeferredUpdate )
qskFilterWindow( value.window ); qskFilterWindow( value.window );
} }
@ -753,7 +744,7 @@ void QskQuickItem::itemChange( QQuickItem::ItemChange change,
if ( d->blockedPolish ) if ( d->blockedPolish )
polish(); polish();
if ( d->controlFlags & QskQuickItem::DeferredUpdate ) if ( d->updateFlags & QskQuickItem::DeferredUpdate )
{ {
if ( d->dirtyAttributes && ( d->flags & QQuickItem::ItemHasContents ) ) if ( d->dirtyAttributes && ( d->flags & QQuickItem::ItemHasContents ) )
update(); update();
@ -761,7 +752,7 @@ void QskQuickItem::itemChange( QQuickItem::ItemChange change,
} }
else else
{ {
if ( d->controlFlags & QskQuickItem::CleanupOnVisibility ) if ( d->updateFlags & QskQuickItem::CleanupOnVisibility )
d->cleanupNodes(); d->cleanupNodes();
d->initiallyPainted = false; d->initiallyPainted = false;
@ -835,7 +826,7 @@ void QskQuickItem::updatePolish()
{ {
Q_D( QskQuickItem ); Q_D( QskQuickItem );
if ( d->controlFlags & QskQuickItem::DeferredPolish ) if ( d->updateFlags & QskQuickItem::DeferredPolish )
{ {
if ( !isVisible() ) if ( !isVisible() )
{ {
@ -873,7 +864,7 @@ QSGNode* QskQuickItem::updatePaintNode( QSGNode* node, UpdatePaintNodeData* data
Q_D( QskQuickItem ); Q_D( QskQuickItem );
Q_ASSERT( isVisible() || !( d->controlFlags & QskQuickItem::DeferredUpdate ) ); Q_ASSERT( isVisible() || !( d->updateFlags & QskQuickItem::DeferredUpdate ) );
d->initiallyPainted = true; d->initiallyPainted = true;

26
src/controls/QskQuickItem.h
View File

@ -36,7 +36,7 @@ class QSK_EXPORT QskQuickItem : public QQuickItem
using Inherited = QQuickItem; using Inherited = QQuickItem;
public: public:
enum Flag enum UpdateFlag
{ {
DeferredUpdate = 1 << 0, DeferredUpdate = 1 << 0,
DeferredPolish = 1 << 1, DeferredPolish = 1 << 1,
@ -48,8 +48,8 @@ class QSK_EXPORT QskQuickItem : public QQuickItem
DebugForceBackground = 1 << 7 DebugForceBackground = 1 << 7
}; };
Q_ENUM( Flag ) Q_ENUM( UpdateFlag )
Q_DECLARE_FLAGS( Flags, Flag ) Q_DECLARE_FLAGS( UpdateFlags, UpdateFlag )
~QskQuickItem() override; ~QskQuickItem() override;
@ -82,13 +82,13 @@ class QSK_EXPORT QskQuickItem : public QQuickItem
void resetLayoutMirroring(); void resetLayoutMirroring();
bool layoutMirroring() const; bool layoutMirroring() const;
void setControlFlags( Flags ); void setUpdateFlags( UpdateFlags );
void resetControlFlags(); void resetUpdateFlags();
Flags controlFlags() const; UpdateFlags updateFlags() const;
Q_INVOKABLE void setControlFlag( Flag, bool on = true ); Q_INVOKABLE void setUpdateFlag( UpdateFlag, bool on = true );
Q_INVOKABLE void resetControlFlag( Flag ); Q_INVOKABLE void resetUpdateFlag( UpdateFlag );
Q_INVOKABLE bool testControlFlag( Flag ) const; Q_INVOKABLE bool testUpdateFlag( UpdateFlag ) const;
void classBegin() override; void classBegin() override;
void componentComplete() override; void componentComplete() override;
@ -102,7 +102,7 @@ class QSK_EXPORT QskQuickItem : public QQuickItem
Q_SIGNALS: Q_SIGNALS:
void itemFlagsChanged(); void itemFlagsChanged();
void controlFlagsChanged(); void updateFlagsChanged( UpdateFlags );
public Q_SLOTS: public Q_SLOTS:
void setGeometry( const QRectF& ); void setGeometry( const QRectF& );
@ -144,7 +144,7 @@ class QSK_EXPORT QskQuickItem : public QQuickItem
*/ */
void childrenRect() = delete; void childrenRect() = delete;
void updateControlFlag( uint flag, bool on ); void applyUpdateFlag( UpdateFlag, bool on );
void sendEnabledChangeEvent(); void sendEnabledChangeEvent();
QSGNode* updatePaintNode( QSGNode*, UpdatePaintNodeData* ) override final; QSGNode* updatePaintNode( QSGNode*, UpdatePaintNodeData* ) override final;
@ -180,7 +180,7 @@ inline QSizeF QskQuickItem::implicitSize() const
return QSizeF( implicitWidth(), implicitHeight() ); return QSizeF( implicitWidth(), implicitHeight() );
} }
Q_DECLARE_OPERATORS_FOR_FLAGS( QskQuickItem::Flags ) Q_DECLARE_OPERATORS_FOR_FLAGS( QskQuickItem::UpdateFlags )
Q_DECLARE_METATYPE( QskQuickItem::Flags ) Q_DECLARE_METATYPE( QskQuickItem::UpdateFlags )
#endif #endif

39
src/controls/QskQuickItemPrivate.cpp
View File

@ -6,12 +6,6 @@
#include "QskQuickItemPrivate.h" #include "QskQuickItemPrivate.h"
#include "QskSetup.h" #include "QskSetup.h"
static inline quint16 qskControlFlags()
{
// we are only interested in the first 8 bits
return static_cast< quint16 >( qskSetup->controlFlags() );
}
static inline void qskSendEventTo( QObject* object, QEvent::Type type ) static inline void qskSendEventTo( QObject* object, QEvent::Type type )
{ {
QEvent event( type ); QEvent event( type );
@ -19,15 +13,15 @@ static inline void qskSendEventTo( QObject* object, QEvent::Type type )
} }
QskQuickItemPrivate::QskQuickItemPrivate() QskQuickItemPrivate::QskQuickItemPrivate()
: controlFlags( qskControlFlags() ) : updateFlags( qskSetup->itemUpdateFlags() )
, controlFlagsMask( 0 ) , updateFlagsMask( 0 )
, polishOnResize( false ) , polishOnResize( false )
, blockedPolish( false ) , blockedPolish( false )
, blockedImplicitSize( true ) , blockedImplicitSize( true )
, clearPreviousNodes( false ) , clearPreviousNodes( false )
, initiallyPainted( false ) , initiallyPainted( false )
{ {
if ( controlFlags & QskQuickItem::DeferredLayout ) if ( updateFlags & QskQuickItem::DeferredLayout )
{ {
/* /*
In general the geometry of an item should be the job of In general the geometry of an item should be the job of
@ -57,26 +51,21 @@ void QskQuickItemPrivate::mirrorChange()
qskSendEventTo( q_func(), QEvent::LayoutDirectionChange ); qskSendEventTo( q_func(), QEvent::LayoutDirectionChange );
} }
void QskQuickItemPrivate::updateControlFlags( QskQuickItem::Flags flags ) void QskQuickItemPrivate::applyUpdateFlags( QskQuickItem::UpdateFlags flags )
{ {
const auto oldFlags = controlFlags; if ( flags == updateFlags )
const auto newFlags = static_cast< quint16 >( flags ); return;
if ( oldFlags != newFlags ) Q_Q( QskQuickItem );
Q_STATIC_ASSERT( sizeof( updateFlags ) == 1 );
for ( uint i = 0; i < 8; i++ )
{ {
Q_Q( QskQuickItem ); const auto flag = static_cast< QskQuickItem::UpdateFlag >( 1 << i );
q->applyUpdateFlag( flag, flags & flag );
const auto numBits = qCountTrailingZeroBits(
static_cast< quint32 >( QskQuickItem::DebugForceBackground ) );
for ( quint32 i = 0; i <= numBits; ++i )
{
const quint32 flag = ( 1 << i );
q->updateControlFlag( flag, flags & flag );
}
Q_EMIT q->controlFlagsChanged();
} }
Q_EMIT q->updateFlagsChanged( q->updateFlags() );
} }
void QskQuickItemPrivate::layoutConstraintChanged() void QskQuickItemPrivate::layoutConstraintChanged()

6
src/controls/QskQuickItemPrivate.h
View File

@ -22,7 +22,7 @@ class QskQuickItemPrivate : public QQuickItemPrivate
~QskQuickItemPrivate() override; ~QskQuickItemPrivate() override;
public: public:
void updateControlFlags( QskQuickItem::Flags ); void applyUpdateFlags( QskQuickItem::UpdateFlags );
protected: protected:
virtual void layoutConstraintChanged(); virtual void layoutConstraintChanged();
@ -46,8 +46,8 @@ class QskQuickItemPrivate : public QQuickItemPrivate
private: private:
Q_DECLARE_PUBLIC( QskQuickItem ) Q_DECLARE_PUBLIC( QskQuickItem )
quint16 controlFlags; quint8 updateFlags;
quint16 controlFlagsMask; quint8 updateFlagsMask;
bool polishOnResize : 1; bool polishOnResize : 1;

60
src/controls/QskSetup.cpp
View File

@ -31,30 +31,30 @@ static inline bool qskHasEnvironment( const char* env )
return !result.isEmpty() && result != "false"; return !result.isEmpty() && result != "false";
} }
static inline const QskSetup::Flags qskEnvironmentFlags() static inline const QskQuickItem::UpdateFlags qskEnvironmentUpdateFlags()
{ {
QskSetup::Flags flags; QskQuickItem::UpdateFlags flags;
if ( qskHasEnvironment( "QSK_PREFER_RASTER" ) ) if ( qskHasEnvironment( "QSK_PREFER_RASTER" ) )
flags |= QskSetup::PreferRasterForTextures; flags |= QskQuickItem::PreferRasterForTextures;
if ( qskHasEnvironment( "QSK_FORCE_BACKGROUND" ) ) if ( qskHasEnvironment( "QSK_FORCE_BACKGROUND" ) )
flags |= QskSetup::DebugForceBackground; flags |= QskQuickItem::DebugForceBackground;
return flags; return flags;
} }
static inline QskSetup::Flags qskDefaultControlFlags() static inline QskQuickItem::UpdateFlags qskDefaultUpdateFlags()
{ {
static QskSetup::Flags flags; static QskQuickItem::UpdateFlags flags;
if ( flags == 0 ) if ( flags == 0 )
{ {
flags |= QskSetup::DeferredUpdate; flags |= QskQuickItem::DeferredUpdate;
flags |= QskSetup::DeferredPolish; flags |= QskQuickItem::DeferredPolish;
flags |= QskSetup::DeferredLayout; flags |= QskQuickItem::DeferredLayout;
flags |= QskSetup::CleanupOnVisibility; flags |= QskQuickItem::CleanupOnVisibility;
flags |= qskEnvironmentFlags(); flags |= qskEnvironmentUpdateFlags();
} }
return flags; return flags;
@ -115,7 +115,7 @@ class QskSetup::PrivateData
{ {
public: public:
PrivateData() PrivateData()
: controlFlags( qskDefaultControlFlags() ) : itemUpdateFlags( qskDefaultUpdateFlags() )
{ {
} }
@ -123,7 +123,7 @@ class QskSetup::PrivateData
QPointer< QskSkin > skin; QPointer< QskSkin > skin;
QskGraphicProviderMap graphicProviders; QskGraphicProviderMap graphicProviders;
QskSetup::Flags controlFlags; QskQuickItem::UpdateFlags itemUpdateFlags;
}; };
QskSetup::QskSetup() QskSetup::QskSetup()
@ -148,46 +148,46 @@ void QskSetup::cleanup()
s_instance = nullptr; s_instance = nullptr;
} }
void QskSetup::setControlFlags( QskSetup::Flags flags ) void QskSetup::setItemUpdateFlags( QskQuickItem::UpdateFlags flags )
{ {
if ( m_data->controlFlags != flags ) if ( m_data->itemUpdateFlags != flags )
{ {
m_data->controlFlags = flags; m_data->itemUpdateFlags = flags;
Q_EMIT controlFlagsChanged(); Q_EMIT itemUpdateFlagsChanged();
} }
} }
QskSetup::Flags QskSetup::controlFlags() const QskQuickItem::UpdateFlags QskSetup::itemUpdateFlags() const
{ {
return m_data->controlFlags; return m_data->itemUpdateFlags;
} }
void QskSetup::resetControlFlags() void QskSetup::resetItemUpdateFlags()
{ {
setControlFlags( qskDefaultControlFlags() ); setItemUpdateFlags( qskDefaultUpdateFlags() );
} }
void QskSetup::setControlFlag( QskSetup::Flag flag, bool on ) void QskSetup::setItemUpdateFlag( QskQuickItem::UpdateFlag flag, bool on )
{ {
if ( m_data->controlFlags.testFlag( flag ) != on ) if ( m_data->itemUpdateFlags.testFlag( flag ) != on )
{ {
if ( on ) if ( on )
m_data->controlFlags |= flag; m_data->itemUpdateFlags |= flag;
else else
m_data->controlFlags &= ~flag; m_data->itemUpdateFlags &= ~flag;
Q_EMIT controlFlagsChanged(); Q_EMIT itemUpdateFlagsChanged();
} }
} }
void QskSetup::resetControlFlag( QskSetup::Flag flag ) void QskSetup::resetItemUpdateFlag( QskQuickItem::UpdateFlag flag )
{ {
setControlFlag( flag, flag & qskDefaultControlFlags() ); setItemUpdateFlag( flag, flag & qskDefaultUpdateFlags() );
} }
bool QskSetup::testControlFlag( QskSetup::Flag flag ) bool QskSetup::testItemUpdateFlag( QskQuickItem::UpdateFlag flag )
{ {
return m_data->controlFlags.testFlag( flag ); return m_data->itemUpdateFlags.testFlag( flag );
} }
QskSkin* QskSetup::setSkin( const QString& skinName ) QskSkin* QskSetup::setSkin( const QString& skinName )

42
src/controls/QskSetup.h
View File

@ -4,13 +4,12 @@
*****************************************************************************/ *****************************************************************************/
#ifndef QSK_SETUP_H #ifndef QSK_SETUP_H
#define QSK_SETUP_H 1 #define QSK_SETUP_H
#include "QskGlobal.h" #include "QskGlobal.h"
#include "QskQuickItem.h"
#include <qobject.h> #include <qobject.h>
#include <qqml.h>
#include <memory> #include <memory>
class QskSkin; class QskSkin;
@ -30,33 +29,19 @@ class QSK_EXPORT QskSetup : public QObject
Q_OBJECT Q_OBJECT
public: public:
enum Flag
{
DeferredUpdate = 1 << 0,
DeferredPolish = 1 << 1,
DeferredLayout = 1 << 2,
CleanupOnVisibility = 1 << 3,
PreferRasterForTextures = 1 << 4,
DebugForceBackground = 1 << 7
};
Q_ENUM( Flag )
Q_DECLARE_FLAGS( Flags, Flag )
static QskSetup* instance(); static QskSetup* instance();
Q_INVOKABLE void setControlFlags( Flags ); void setItemUpdateFlags( QskQuickItem::UpdateFlags );
Q_INVOKABLE void resetControlFlags(); void resetItemUpdateFlags();
Q_INVOKABLE Flags controlFlags() const; QskQuickItem::UpdateFlags itemUpdateFlags() const;
Q_INVOKABLE void setControlFlag( Flag, bool on = true ); void setItemUpdateFlag( QskQuickItem::UpdateFlag, bool on = true );
Q_INVOKABLE void resetControlFlag( Flag ); void resetItemUpdateFlag( QskQuickItem::UpdateFlag );
Q_INVOKABLE bool testControlFlag( Flag ); bool testItemUpdateFlag( QskQuickItem::UpdateFlag );
Q_INVOKABLE QskSkin* setSkin( const QString& ); QskSkin* setSkin( const QString& );
Q_INVOKABLE QString skinName() const; QString skinName() const;
QskSkin* skin(); QskSkin* skin();
@ -73,7 +58,7 @@ class QSK_EXPORT QskSetup : public QObject
Q_SIGNALS: Q_SIGNALS:
void skinChanged( QskSkin* ); void skinChanged( QskSkin* );
void controlFlagsChanged(); void itemUpdateFlagsChanged();
private: private:
QskSetup(); QskSetup();
@ -87,15 +72,10 @@ class QSK_EXPORT QskSetup : public QObject
std::unique_ptr< PrivateData > m_data; std::unique_ptr< PrivateData > m_data;
}; };
QML_DECLARE_TYPEINFO( QskSetup, QML_HAS_ATTACHED_PROPERTIES )
inline QskSetup* QskSetup::instance() inline QskSetup* QskSetup::instance()
{ {
Q_ASSERT( s_instance ); Q_ASSERT( s_instance );
return s_instance; return s_instance;
} }
Q_DECLARE_OPERATORS_FOR_FLAGS( QskSetup::Flags )
Q_DECLARE_METATYPE( QskSetup::Flags )
#endif #endif

4
src/controls/QskSkinlet.cpp
View File

@ -55,7 +55,7 @@ static inline QSGNode* qskUpdateGraphicNode(
if ( graphicNode == nullptr ) if ( graphicNode == nullptr )
graphicNode = new QskGraphicNode(); graphicNode = new QskGraphicNode();
if ( control->testControlFlag( QskControl::PreferRasterForTextures ) ) if ( control->testUpdateFlag( QskControl::PreferRasterForTextures ) )
mode = QskTextureRenderer::Raster; mode = QskTextureRenderer::Raster;
/* /*
@ -187,7 +187,7 @@ void QskSkinlet::updateNode( QskSkinnable* skinnable, QSGNode* parentNode ) cons
oldNode = findChildNode( parentNode, DebugRole ); oldNode = findChildNode( parentNode, DebugRole );
newNode = nullptr; newNode = nullptr;
if ( control->testControlFlag( QskControl::DebugForceBackground ) ) if ( control->testUpdateFlag( QskControl::DebugForceBackground ) )
newNode = updateDebugNode( control, oldNode ); newNode = updateDebugNode( control, oldNode );
replaceChildNode( DebugRole, parentNode, oldNode, newNode ); replaceChildNode( DebugRole, parentNode, oldNode, newNode );

2
src/nodes/QskTextureRenderer.cpp
View File

@ -173,7 +173,7 @@ uint QskTextureRenderer::createTexture(
#endif #endif
if ( renderMode == AutoDetect ) if ( renderMode == AutoDetect )
{ {
if ( qskSetup->controlFlags() & QskSetup::PreferRasterForTextures ) if ( qskSetup->testItemUpdateFlag( QskQuickItem::PreferRasterForTextures ) )
renderMode = Raster; renderMode = Raster;
else else
renderMode = OpenGL; renderMode = OpenGL;

2
support/SkinnyShortcut.cpp
View File

@ -131,7 +131,7 @@ void SkinnyShortcut::showBackground()
scengraphDebugMode = sgDebugModes[ id - 2 ]; scengraphDebugMode = sgDebugModes[ id - 2 ];
} }
qskSetup->setControlFlag( QskSetup::DebugForceBackground, forceBackground ); qskSetup->setItemUpdateFlag( QskQuickItem::DebugForceBackground, forceBackground );
const auto windows = QGuiApplication::topLevelWindows(); const auto windows = QGuiApplication::topLevelWindows();
for ( auto window : windows ) for ( auto window : windows )