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

renamed to QskQuickItem::UpdateFlags

Browse Source
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
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
*/

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
engine, simply showing better results.
*/
qskSetup->setControlFlag( QskSetup::PreferRasterForTextures, true );
qskSetup->setItemUpdateFlag( QskQuickItem::PreferRasterForTextures, true );
SkinnyFont::init( &app );
SkinnyShortcut::enable( SkinnyShortcut::AllShortcuts );

2
examples/mycontrols/main.cpp
View File

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

4
qmlexport/QskMainQml.cpp
View File

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

10
qmlexport/QskMainQml.h
View File

@ -13,14 +13,14 @@
#include <qobject.h>
#include <qqmllist.h>
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(); }

6
qmlexport/QskQml.cpp
View File

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

2
src/controls/QskDirtyItemFilter.cpp
View File

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

87
src/controls/QskQuickItem.cpp
View File

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

26
src/controls/QskQuickItem.h
View File

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

39
src/controls/QskQuickItemPrivate.cpp
View File

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

6
src/controls/QskQuickItemPrivate.h
View File

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

60
src/controls/QskSetup.cpp
View File

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

42
src/controls/QskSetup.h
View File

@ -4,13 +4,12 @@
*****************************************************************************/
#ifndef QSK_SETUP_H
#define QSK_SETUP_H 1
#define QSK_SETUP_H
#include "QskGlobal.h"
#include "QskQuickItem.h"
#include <qobject.h>
#include <qqml.h>
#include <memory>
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

4
src/controls/QskSkinlet.cpp
View File

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

2
src/nodes/QskTextureRenderer.cpp
View File

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

2
support/SkinnyShortcut.cpp
View File

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