From 5cb33ad79bd8ae8a6b7a231815a8806512c53165 Mon Sep 17 00:00:00 2001 From: Uwe Rathmann Date: Tue, 9 Feb 2021 08:13:20 +0100 Subject: [PATCH] renamed to QskQuickItem::UpdateFlags --- doc/classes/QskQuickItem.dox | 32 +++++----- examples/automotive/main.cpp | 2 +- examples/mycontrols/main.cpp | 2 +- qmlexport/QskMainQml.cpp | 4 +- qmlexport/QskMainQml.h | 10 ++-- qmlexport/QskQml.cpp | 6 +- src/controls/QskDirtyItemFilter.cpp | 2 +- src/controls/QskQuickItem.cpp | 87 +++++++++++++--------------- src/controls/QskQuickItem.h | 26 ++++----- src/controls/QskQuickItemPrivate.cpp | 39 +++++-------- src/controls/QskQuickItemPrivate.h | 6 +- src/controls/QskSetup.cpp | 60 +++++++++---------- src/controls/QskSetup.h | 42 ++++---------- src/controls/QskSkinlet.cpp | 4 +- src/nodes/QskTextureRenderer.cpp | 2 +- support/SkinnyShortcut.cpp | 2 +- 16 files changed, 142 insertions(+), 184 deletions(-) diff --git a/doc/classes/QskQuickItem.dox b/doc/classes/QskQuickItem.dox index cbdb0056..cd4734a0 100644 --- a/doc/classes/QskQuickItem.dox +++ b/doc/classes/QskQuickItem.dox @@ -9,14 +9,14 @@ */ /*! - \enum QskQuickItem::Flag + \enum QskQuickItem::UpdateFlag Qt/Quick classes have a tendency to update items too early and too often. To avoid processing of unwanted operations QskQuickItem implements a couple of modifications, that 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. @@ -34,7 +34,7 @@ such as viewport frustrum culling (i.e. hiding items outside of the window geometry). - \var QskQuickItem::Flag QskQuickItem::DeferredPolish + \var QskQuickItem::UpdateFlag QskQuickItem::DeferredPolish Polishing an item ( QQuickItem::polish() ) is blocked when being invisible. F.e for all items being derived from QskControl the layout calculations @@ -42,7 +42,7 @@ \sa QQuickItem::updatePolish() - \var QskQuickItem::Flag QskQuickItem::DeferredLayout + \var QskQuickItem::UpdateFlag QskQuickItem::DeferredLayout Recalculations of the implicitSize are blocked until being explicitely requested by QQuickItem::implicitSize(). @@ -59,25 +59,25 @@ \sa QskQuickItem::resetImplicitSize() - \var QskQuickItem::Flag QskQuickItem::CleanupOnVisibility + \var QskQuickItem::UpdateFlag QskQuickItem::CleanupOnVisibility Delete scene graph nodes, when the item becomes hidden ( QQuickItem::isVisible() ). Enabling this mode will reduce the memory footprint, but comes at the cost 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 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. \note This flag is useful when analyzing layouts. - \sa controlFlags(), setControlFlags(), resetControlFlags() - testControlFlag(), setControlFlag(), resetControlFlag() + \sa updateFlags(), setUpdateFlags(), resetUpdateFlags() + testUpdateFlag(), setUpdateFlag(), resetUpdateFlag() */ /*! @@ -372,43 +372,43 @@ */ /*! - \fn QskQuickItem::setControlFlags + \fn QskQuickItem::setUpdateFlags bla */ /*! - \fn QskQuickItem::resetControlFlags + \fn QskQuickItem::resetUpdateFlags bla */ /*! - \fn QskQuickItem::controlFlags + \fn QskQuickItem::updateFlags bla */ /*! - \fn QskQuickItem::setControlFlag + \fn QskQuickItem::setUpdateFlag bla */ /*! - \fn QskQuickItem::resetControlFlag + \fn QskQuickItem::resetUpdateFlag bla */ /*! - \fn QskQuickItem::testControlFlag + \fn QskQuickItem::testUpdateFlag bla */ /*! - \fn QskQuickItem::controlFlagsChanged + \fn QskQuickItem::updateFlagsChanged bla */ diff --git a/examples/automotive/main.cpp b/examples/automotive/main.cpp index 8648e686..ed93e224 100644 --- a/examples/automotive/main.cpp +++ b/examples/automotive/main.cpp @@ -31,7 +31,7 @@ int main( int argc, char** argv ) When going over QPainter for the SVGs we prefer the raster paint engine, simply showing better results. */ - qskSetup->setControlFlag( QskSetup::PreferRasterForTextures, true ); + qskSetup->setItemUpdateFlag( QskQuickItem::PreferRasterForTextures, true ); SkinnyFont::init( &app ); SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts ); diff --git a/examples/mycontrols/main.cpp b/examples/mycontrols/main.cpp index ec59ade8..173a6e93 100644 --- a/examples/mycontrols/main.cpp +++ b/examples/mycontrols/main.cpp @@ -140,7 +140,7 @@ int main( int argc, char* argv[] ) qskSkinManager->registerFactory( QStringLiteral( "MySkinFactory" ), new MySkinFactory() ); - qskSetup->setControlFlag( QskSetup::PreferRasterForTextures, true ); + qskSetup->setItemUpdateFlag( QskQuickItem::PreferRasterForTextures, true ); Window window; window.resize( 480, 360 ); diff --git a/qmlexport/QskMainQml.cpp b/qmlexport/QskMainQml.cpp index 37b268e0..d42487d9 100644 --- a/qmlexport/QskMainQml.cpp +++ b/qmlexport/QskMainQml.cpp @@ -23,8 +23,8 @@ QskMain::QskMain( QObject* parent ) connect( setup(), &QskSetup::skinChanged, this, &QskMain::skinChanged, Qt::QueuedConnection ); - connect( setup(), &QskSetup::controlFlagsChanged, - this, &QskMain::controlFlagsChanged, Qt::QueuedConnection ); + connect( setup(), &QskSetup::itemUpdateFlagsChanged, + this, &QskMain::itemUpdateFlagsChanged, Qt::QueuedConnection ); } QStringList QskMain::skinList() const diff --git a/qmlexport/QskMainQml.h b/qmlexport/QskMainQml.h index 13430a00..581ec723 100644 --- a/qmlexport/QskMainQml.h +++ b/qmlexport/QskMainQml.h @@ -13,14 +13,14 @@ #include #include -class QskSetupFlagsQml : public QskSetup::Flags +class QskSetupFlagsQml : public QskQuickItem::UpdateFlags { Q_GADGET public: template< typename... 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_PRIVATE_PROPERTY( setup(), QskSetupFlagsQml controlFlags - READ controlFlags WRITE setControlFlags NOTIFY controlFlagsChanged ) + Q_PRIVATE_PROPERTY( setup(), QskSetupFlagsQml itemUpdateFlags + READ itemUpdateFlags WRITE setItemUpdateFlags NOTIFY itemUpdateFlagsChanged ) Q_PROPERTY( QQmlListProperty< QObject > data READ data ) Q_CLASSINFO( "DefaultProperty", "data" ) @@ -53,7 +53,7 @@ class QskMain : public QObject void skinListChanged(); // never emitted void skinChanged(); void inputPanelChanged(); - void controlFlagsChanged(); + void itemUpdateFlagsChanged(); private: static inline QskSetup* setup() { return QskSetup::instance(); } diff --git a/qmlexport/QskQml.cpp b/qmlexport/QskQml.cpp index 13d775f6..fd3c0afc 100644 --- a/qmlexport/QskQml.cpp +++ b/qmlexport/QskQml.cpp @@ -169,10 +169,8 @@ void QskQml::registerTypes() qmlRegisterUncreatableType< QskSkin >( "Skinny.Skins", 1, 0, "Skin", QString() ); - QSK_REGISTER_FLAGS( QskControl::Flag ); - QSK_REGISTER_FLAGS( QskControl::Flags ); - QSK_REGISTER_FLAGS( QskSetup::Flag ); - QSK_REGISTER_FLAGS( QskSetup::Flags ); + QSK_REGISTER_FLAGS( QskQuickItem::UpdateFlag ); + QSK_REGISTER_FLAGS( QskQuickItem::UpdateFlags ); QSK_REGISTER_FLAGS( QskSizePolicy::Policy ); QSK_REGISTER_FLAGS( QskDialog::Actions ); diff --git a/src/controls/QskDirtyItemFilter.cpp b/src/controls/QskDirtyItemFilter.cpp index a1b33d86..a41a68f4 100644 --- a/src/controls/QskDirtyItemFilter.cpp +++ b/src/controls/QskDirtyItemFilter.cpp @@ -16,7 +16,7 @@ static inline bool qskIsUpdateBlocked( const QQuickItem* item ) if ( !item->isVisible() ) { if ( const auto control = qskControlCast( item ) ) - return control->testControlFlag( QskControl::DeferredUpdate ); + return control->testUpdateFlag( QskControl::DeferredUpdate ); } #if 0 diff --git a/src/controls/QskQuickItem.cpp b/src/controls/QskQuickItem.cpp index 3004b5b8..4a718ab1 100644 --- a/src/controls/QskQuickItem.cpp +++ b/src/controls/QskQuickItem.cpp @@ -28,17 +28,11 @@ static inline void qskSendEventTo( QObject* object, QEvent::Type type ) QCoreApplication::sendEvent( object, &event ); } -static inline void qskUpdateControlFlags( - QskQuickItem::Flags flags, QskQuickItem* item ) +static inline void qskApplyUpdateFlags( + QskQuickItem::UpdateFlags flags, QskQuickItem* item ) { auto d = static_cast< QskQuickItemPrivate* >( QskQuickItemPrivate::get( item ) ); - d->updateControlFlags( flags ); -} - -static inline quint16 qskControlFlags() -{ - // we are only interested in the first 8 bits - return static_cast< quint16 >( qskSetup->controlFlags() ); + d->applyUpdateFlags( flags ); } static inline void qskFilterWindow( QQuickWindow* window ) @@ -61,7 +55,7 @@ namespace Its faster and saves some memory to have this registry instead of setting up direct connections between qskSetup and each control */ - QObject::connect( qskSetup, &QskSetup::controlFlagsChanged, + QObject::connect( qskSetup, &QskSetup::itemUpdateFlagsChanged, qskSetup, [ this ] { updateControlFlags(); } ); QObject::connect( qskSetup, &QskSetup::skinChanged, @@ -80,10 +74,10 @@ namespace void updateControlFlags() { - const auto flags = static_cast< QskQuickItem::Flags >( qskControlFlags() ); + const auto flags = qskSetup->itemUpdateFlags(); for ( auto item : m_items ) - qskUpdateControlFlags( flags, item ); + qskApplyUpdateFlags( flags, item ); } void updateSkin() @@ -162,7 +156,7 @@ QskQuickItem::QskQuickItem( QskQuickItemPrivate& dd, QQuickItem* parent ) this, &QskQuickItem::sendEnabledChangeEvent ); #endif - if ( dd.controlFlags & QskQuickItem::DeferredUpdate ) + if ( dd.updateFlags & QskQuickItem::DeferredUpdate ) qskFilterWindow( window() ); qskRegistry->insert( this ); @@ -201,7 +195,7 @@ void QskQuickItem::componentComplete() #if defined( QT_DEBUG ) 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" ); } @@ -454,76 +448,73 @@ bool QskQuickItem::maybeUnresized() const 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 ); // set all bits in the mask - d->controlFlagsMask = std::numeric_limits< quint16 >::max(); - d->updateControlFlags( flags ); + d->updateFlagsMask = std::numeric_limits< decltype( d->updateFlagsMask ) >::max(); + d->applyUpdateFlags( flags ); } -void QskQuickItem::resetControlFlags() +void QskQuickItem::resetUpdateFlags() { Q_D( QskQuickItem ); // clear all bits in the mask - d->controlFlagsMask = 0; - d->updateControlFlags( static_cast< Flags >( qskControlFlags() ) ); + d->updateFlagsMask = 0; + d->applyUpdateFlags( qskSetup->itemUpdateFlags() ); } -void QskQuickItem::setControlFlag( Flag flag, bool on ) +void QskQuickItem::setUpdateFlag( UpdateFlag flag, bool on ) { Q_D( QskQuickItem ); - d->controlFlagsMask |= flag; + d->updateFlagsMask |= flag; - if ( ( d->controlFlags & flag ) != on ) + if ( testUpdateFlag( flag ) != on ) { - updateControlFlag( flag, on ); - Q_EMIT controlFlagsChanged(); + applyUpdateFlag( flag, on ); + Q_EMIT updateFlagsChanged( updateFlags() ); } } -void QskQuickItem::resetControlFlag( Flag flag ) +void QskQuickItem::resetUpdateFlag( UpdateFlag flag ) { 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 ); - Q_EMIT controlFlagsChanged(); + applyUpdateFlag( flag, on ); + 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 ); - if ( ( flag > std::numeric_limits< quint16 >::max() ) || - ( bool( d->controlFlags & flag ) == on ) ) - { + if ( testUpdateFlag( flag ) == on ) return; - } if ( on ) - d->controlFlags |= flag; + d->updateFlags |= flag; else - d->controlFlags &= ~flag; + d->updateFlags &= ~flag; switch ( flag ) { @@ -584,7 +575,7 @@ void QskQuickItem::resetImplicitSize() { Q_D( QskQuickItem ); - if ( d->controlFlags & QskQuickItem::DeferredLayout ) + if ( d->updateFlags & QskQuickItem::DeferredLayout ) { d->blockedImplicitSize = true; d->layoutConstraintChanged(); @@ -681,7 +672,7 @@ void QskQuickItem::itemChange( QQuickItem::ItemChange change, if ( value.window ) { Q_D( const QskQuickItem ); - if ( d->controlFlags & QskQuickItem::DeferredUpdate ) + if ( d->updateFlags & QskQuickItem::DeferredUpdate ) qskFilterWindow( value.window ); } @@ -753,7 +744,7 @@ void QskQuickItem::itemChange( QQuickItem::ItemChange change, if ( d->blockedPolish ) polish(); - if ( d->controlFlags & QskQuickItem::DeferredUpdate ) + if ( d->updateFlags & QskQuickItem::DeferredUpdate ) { if ( d->dirtyAttributes && ( d->flags & QQuickItem::ItemHasContents ) ) update(); @@ -761,7 +752,7 @@ void QskQuickItem::itemChange( QQuickItem::ItemChange change, } else { - if ( d->controlFlags & QskQuickItem::CleanupOnVisibility ) + if ( d->updateFlags & QskQuickItem::CleanupOnVisibility ) d->cleanupNodes(); d->initiallyPainted = false; @@ -835,7 +826,7 @@ void QskQuickItem::updatePolish() { Q_D( QskQuickItem ); - if ( d->controlFlags & QskQuickItem::DeferredPolish ) + if ( d->updateFlags & QskQuickItem::DeferredPolish ) { if ( !isVisible() ) { @@ -873,7 +864,7 @@ QSGNode* QskQuickItem::updatePaintNode( QSGNode* node, UpdatePaintNodeData* data Q_D( QskQuickItem ); - Q_ASSERT( isVisible() || !( d->controlFlags & QskQuickItem::DeferredUpdate ) ); + Q_ASSERT( isVisible() || !( d->updateFlags & QskQuickItem::DeferredUpdate ) ); d->initiallyPainted = true; diff --git a/src/controls/QskQuickItem.h b/src/controls/QskQuickItem.h index 7f7b3e5b..f899ee05 100644 --- a/src/controls/QskQuickItem.h +++ b/src/controls/QskQuickItem.h @@ -36,7 +36,7 @@ class QSK_EXPORT QskQuickItem : public QQuickItem using Inherited = QQuickItem; public: - enum Flag + enum UpdateFlag { DeferredUpdate = 1 << 0, DeferredPolish = 1 << 1, @@ -48,8 +48,8 @@ class QSK_EXPORT QskQuickItem : public QQuickItem DebugForceBackground = 1 << 7 }; - Q_ENUM( Flag ) - Q_DECLARE_FLAGS( Flags, Flag ) + Q_ENUM( UpdateFlag ) + Q_DECLARE_FLAGS( UpdateFlags, UpdateFlag ) ~QskQuickItem() override; @@ -82,13 +82,13 @@ class QSK_EXPORT QskQuickItem : public QQuickItem void resetLayoutMirroring(); bool layoutMirroring() const; - void setControlFlags( Flags ); - void resetControlFlags(); - Flags controlFlags() const; + void setUpdateFlags( UpdateFlags ); + void resetUpdateFlags(); + UpdateFlags updateFlags() const; - Q_INVOKABLE void setControlFlag( Flag, bool on = true ); - Q_INVOKABLE void resetControlFlag( Flag ); - Q_INVOKABLE bool testControlFlag( Flag ) const; + Q_INVOKABLE void setUpdateFlag( UpdateFlag, bool on = true ); + Q_INVOKABLE void resetUpdateFlag( UpdateFlag ); + Q_INVOKABLE bool testUpdateFlag( UpdateFlag ) const; void classBegin() override; void componentComplete() override; @@ -102,7 +102,7 @@ class QSK_EXPORT QskQuickItem : public QQuickItem Q_SIGNALS: void itemFlagsChanged(); - void controlFlagsChanged(); + void updateFlagsChanged( UpdateFlags ); public Q_SLOTS: void setGeometry( const QRectF& ); @@ -144,7 +144,7 @@ class QSK_EXPORT QskQuickItem : public QQuickItem */ void childrenRect() = delete; - void updateControlFlag( uint flag, bool on ); + void applyUpdateFlag( UpdateFlag, bool on ); void sendEnabledChangeEvent(); QSGNode* updatePaintNode( QSGNode*, UpdatePaintNodeData* ) override final; @@ -180,7 +180,7 @@ inline QSizeF QskQuickItem::implicitSize() const return QSizeF( implicitWidth(), implicitHeight() ); } -Q_DECLARE_OPERATORS_FOR_FLAGS( QskQuickItem::Flags ) -Q_DECLARE_METATYPE( QskQuickItem::Flags ) +Q_DECLARE_OPERATORS_FOR_FLAGS( QskQuickItem::UpdateFlags ) +Q_DECLARE_METATYPE( QskQuickItem::UpdateFlags ) #endif diff --git a/src/controls/QskQuickItemPrivate.cpp b/src/controls/QskQuickItemPrivate.cpp index 1e1a5d41..412deeb2 100644 --- a/src/controls/QskQuickItemPrivate.cpp +++ b/src/controls/QskQuickItemPrivate.cpp @@ -6,12 +6,6 @@ #include "QskQuickItemPrivate.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 ) { QEvent event( type ); @@ -19,15 +13,15 @@ static inline void qskSendEventTo( QObject* object, QEvent::Type type ) } QskQuickItemPrivate::QskQuickItemPrivate() - : controlFlags( qskControlFlags() ) - , controlFlagsMask( 0 ) + : updateFlags( qskSetup->itemUpdateFlags() ) + , updateFlagsMask( 0 ) , polishOnResize( false ) , blockedPolish( false ) , blockedImplicitSize( true ) , clearPreviousNodes( false ) , initiallyPainted( false ) { - if ( controlFlags & QskQuickItem::DeferredLayout ) + if ( updateFlags & QskQuickItem::DeferredLayout ) { /* In general the geometry of an item should be the job of @@ -57,26 +51,21 @@ void QskQuickItemPrivate::mirrorChange() qskSendEventTo( q_func(), QEvent::LayoutDirectionChange ); } -void QskQuickItemPrivate::updateControlFlags( QskQuickItem::Flags flags ) +void QskQuickItemPrivate::applyUpdateFlags( QskQuickItem::UpdateFlags flags ) { - const auto oldFlags = controlFlags; - const auto newFlags = static_cast< quint16 >( flags ); + if ( flags == updateFlags ) + 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 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(); + const auto flag = static_cast< QskQuickItem::UpdateFlag >( 1 << i ); + q->applyUpdateFlag( flag, flags & flag ); } + + Q_EMIT q->updateFlagsChanged( q->updateFlags() ); } void QskQuickItemPrivate::layoutConstraintChanged() diff --git a/src/controls/QskQuickItemPrivate.h b/src/controls/QskQuickItemPrivate.h index 31336f58..63cae3be 100644 --- a/src/controls/QskQuickItemPrivate.h +++ b/src/controls/QskQuickItemPrivate.h @@ -22,7 +22,7 @@ class QskQuickItemPrivate : public QQuickItemPrivate ~QskQuickItemPrivate() override; public: - void updateControlFlags( QskQuickItem::Flags ); + void applyUpdateFlags( QskQuickItem::UpdateFlags ); protected: virtual void layoutConstraintChanged(); @@ -46,8 +46,8 @@ class QskQuickItemPrivate : public QQuickItemPrivate private: Q_DECLARE_PUBLIC( QskQuickItem ) - quint16 controlFlags; - quint16 controlFlagsMask; + quint8 updateFlags; + quint8 updateFlagsMask; bool polishOnResize : 1; diff --git a/src/controls/QskSetup.cpp b/src/controls/QskSetup.cpp index f7ec5d5d..a4875e3e 100644 --- a/src/controls/QskSetup.cpp +++ b/src/controls/QskSetup.cpp @@ -31,30 +31,30 @@ static inline bool qskHasEnvironment( const char* env ) 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" ) ) - flags |= QskSetup::PreferRasterForTextures; + flags |= QskQuickItem::PreferRasterForTextures; if ( qskHasEnvironment( "QSK_FORCE_BACKGROUND" ) ) - flags |= QskSetup::DebugForceBackground; + flags |= QskQuickItem::DebugForceBackground; return flags; } -static inline QskSetup::Flags qskDefaultControlFlags() +static inline QskQuickItem::UpdateFlags qskDefaultUpdateFlags() { - static QskSetup::Flags flags; + static QskQuickItem::UpdateFlags flags; if ( flags == 0 ) { - flags |= QskSetup::DeferredUpdate; - flags |= QskSetup::DeferredPolish; - flags |= QskSetup::DeferredLayout; - flags |= QskSetup::CleanupOnVisibility; - flags |= qskEnvironmentFlags(); + flags |= QskQuickItem::DeferredUpdate; + flags |= QskQuickItem::DeferredPolish; + flags |= QskQuickItem::DeferredLayout; + flags |= QskQuickItem::CleanupOnVisibility; + flags |= qskEnvironmentUpdateFlags(); } return flags; @@ -115,7 +115,7 @@ class QskSetup::PrivateData { public: PrivateData() - : controlFlags( qskDefaultControlFlags() ) + : itemUpdateFlags( qskDefaultUpdateFlags() ) { } @@ -123,7 +123,7 @@ class QskSetup::PrivateData QPointer< QskSkin > skin; QskGraphicProviderMap graphicProviders; - QskSetup::Flags controlFlags; + QskQuickItem::UpdateFlags itemUpdateFlags; }; QskSetup::QskSetup() @@ -148,46 +148,46 @@ void QskSetup::cleanup() 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; - Q_EMIT controlFlagsChanged(); + m_data->itemUpdateFlags = flags; + 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 ) - m_data->controlFlags |= flag; + m_data->itemUpdateFlags |= flag; 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 ) diff --git a/src/controls/QskSetup.h b/src/controls/QskSetup.h index dc5ceca3..769ee6b1 100644 --- a/src/controls/QskSetup.h +++ b/src/controls/QskSetup.h @@ -4,13 +4,12 @@ *****************************************************************************/ #ifndef QSK_SETUP_H -#define QSK_SETUP_H 1 +#define QSK_SETUP_H #include "QskGlobal.h" +#include "QskQuickItem.h" #include -#include - #include class QskSkin; @@ -30,33 +29,19 @@ class QSK_EXPORT QskSetup : public QObject Q_OBJECT 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(); - Q_INVOKABLE void setControlFlags( Flags ); - Q_INVOKABLE void resetControlFlags(); - Q_INVOKABLE Flags controlFlags() const; + void setItemUpdateFlags( QskQuickItem::UpdateFlags ); + void resetItemUpdateFlags(); + QskQuickItem::UpdateFlags itemUpdateFlags() const; - Q_INVOKABLE void setControlFlag( Flag, bool on = true ); - Q_INVOKABLE void resetControlFlag( Flag ); - Q_INVOKABLE bool testControlFlag( Flag ); + void setItemUpdateFlag( QskQuickItem::UpdateFlag, bool on = true ); + void resetItemUpdateFlag( QskQuickItem::UpdateFlag ); + bool testItemUpdateFlag( QskQuickItem::UpdateFlag ); - Q_INVOKABLE QskSkin* setSkin( const QString& ); - Q_INVOKABLE QString skinName() const; + QskSkin* setSkin( const QString& ); + QString skinName() const; QskSkin* skin(); @@ -73,7 +58,7 @@ class QSK_EXPORT QskSetup : public QObject Q_SIGNALS: void skinChanged( QskSkin* ); - void controlFlagsChanged(); + void itemUpdateFlagsChanged(); private: QskSetup(); @@ -87,15 +72,10 @@ class QSK_EXPORT QskSetup : public QObject std::unique_ptr< PrivateData > m_data; }; -QML_DECLARE_TYPEINFO( QskSetup, QML_HAS_ATTACHED_PROPERTIES ) - inline QskSetup* QskSetup::instance() { Q_ASSERT( s_instance ); return s_instance; } -Q_DECLARE_OPERATORS_FOR_FLAGS( QskSetup::Flags ) -Q_DECLARE_METATYPE( QskSetup::Flags ) - #endif diff --git a/src/controls/QskSkinlet.cpp b/src/controls/QskSkinlet.cpp index c1772044..ac7a6cff 100644 --- a/src/controls/QskSkinlet.cpp +++ b/src/controls/QskSkinlet.cpp @@ -55,7 +55,7 @@ static inline QSGNode* qskUpdateGraphicNode( if ( graphicNode == nullptr ) graphicNode = new QskGraphicNode(); - if ( control->testControlFlag( QskControl::PreferRasterForTextures ) ) + if ( control->testUpdateFlag( QskControl::PreferRasterForTextures ) ) mode = QskTextureRenderer::Raster; /* @@ -187,7 +187,7 @@ void QskSkinlet::updateNode( QskSkinnable* skinnable, QSGNode* parentNode ) cons oldNode = findChildNode( parentNode, DebugRole ); newNode = nullptr; - if ( control->testControlFlag( QskControl::DebugForceBackground ) ) + if ( control->testUpdateFlag( QskControl::DebugForceBackground ) ) newNode = updateDebugNode( control, oldNode ); replaceChildNode( DebugRole, parentNode, oldNode, newNode ); diff --git a/src/nodes/QskTextureRenderer.cpp b/src/nodes/QskTextureRenderer.cpp index 2baa043d..d85328fe 100644 --- a/src/nodes/QskTextureRenderer.cpp +++ b/src/nodes/QskTextureRenderer.cpp @@ -173,7 +173,7 @@ uint QskTextureRenderer::createTexture( #endif if ( renderMode == AutoDetect ) { - if ( qskSetup->controlFlags() & QskSetup::PreferRasterForTextures ) + if ( qskSetup->testItemUpdateFlag( QskQuickItem::PreferRasterForTextures ) ) renderMode = Raster; else renderMode = OpenGL; diff --git a/support/SkinnyShortcut.cpp b/support/SkinnyShortcut.cpp index 01ecf05f..6471628b 100644 --- a/support/SkinnyShortcut.cpp +++ b/support/SkinnyShortcut.cpp @@ -131,7 +131,7 @@ void SkinnyShortcut::showBackground() scengraphDebugMode = sgDebugModes[ id - 2 ]; } - qskSetup->setControlFlag( QskSetup::DebugForceBackground, forceBackground ); + qskSetup->setItemUpdateFlag( QskQuickItem::DebugForceBackground, forceBackground ); const auto windows = QGuiApplication::topLevelWindows(); for ( auto window : windows )