843 lines
20 KiB
C++
843 lines
20 KiB
C++
/******************************************************************************
|
|
* QSkinny - Copyright (C) 2016 Uwe Rathmann
|
|
* This file may be used under the terms of the QSkinny License, Version 1.0
|
|
*****************************************************************************/
|
|
|
|
#include "QskQuickItem.h"
|
|
#include "QskQuickItemPrivate.h"
|
|
#include "QskQuick.h"
|
|
#include "QskEvent.h"
|
|
#include "QskSetup.h"
|
|
#include "QskSkin.h"
|
|
#include "QskDirtyItemFilter.h"
|
|
|
|
#include <qglobalstatic.h>
|
|
#include <qquickwindow.h>
|
|
|
|
#if defined( QT_DEBUG )
|
|
QSK_QT_PRIVATE_BEGIN
|
|
#include <private/qquickpositioners_p.h>
|
|
QSK_QT_PRIVATE_END
|
|
#endif
|
|
|
|
#include <unordered_set>
|
|
|
|
static inline void qskSendEventTo( QObject* object, QEvent::Type type )
|
|
{
|
|
QEvent event( type );
|
|
QCoreApplication::sendEvent( object, &event );
|
|
}
|
|
|
|
static inline void qskUpdateControlFlags(
|
|
QskQuickItem::Flags 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() );
|
|
}
|
|
|
|
static inline void qskFilterWindow( QQuickWindow* window )
|
|
{
|
|
if ( window == nullptr )
|
|
return;
|
|
|
|
static QskDirtyItemFilter itemFilter;
|
|
itemFilter.addWindow( window );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class QskQuickItemRegistry
|
|
{
|
|
public:
|
|
QskQuickItemRegistry()
|
|
{
|
|
/*
|
|
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,
|
|
qskSetup, [ this ] { updateControlFlags(); } );
|
|
|
|
QObject::connect( qskSetup, &QskSetup::skinChanged,
|
|
qskSetup, [ this ] { updateSkin(); } );
|
|
}
|
|
|
|
inline void insert( QskQuickItem* item )
|
|
{
|
|
m_items.insert( item );
|
|
}
|
|
|
|
inline void remove( QskQuickItem* item )
|
|
{
|
|
m_items.erase( item );
|
|
}
|
|
|
|
void updateControlFlags()
|
|
{
|
|
const auto flags = static_cast< QskQuickItem::Flags >( qskControlFlags() );
|
|
|
|
for ( auto item : m_items )
|
|
qskUpdateControlFlags( flags, item );
|
|
}
|
|
|
|
void updateSkin()
|
|
{
|
|
QEvent event( QEvent::StyleChange );
|
|
|
|
for ( auto item : m_items )
|
|
{
|
|
event.setAccepted( true );
|
|
QCoreApplication::sendEvent( item, &event );
|
|
}
|
|
}
|
|
|
|
private:
|
|
std::unordered_set< QskQuickItem* > m_items;
|
|
};
|
|
}
|
|
|
|
namespace
|
|
{
|
|
/*
|
|
A helper class to store the released window to be able to
|
|
put it later into the WindowChange event.
|
|
*/
|
|
class QskWindowStore
|
|
{
|
|
public:
|
|
QskWindowStore()
|
|
: m_refCount( 0 )
|
|
, m_window( nullptr )
|
|
{
|
|
}
|
|
|
|
void setWindow( QQuickWindow* window )
|
|
{
|
|
if ( m_window != window )
|
|
{
|
|
m_window = window;
|
|
m_refCount = 0;
|
|
}
|
|
|
|
if ( m_window )
|
|
m_refCount++;
|
|
}
|
|
|
|
QQuickWindow* window()
|
|
{
|
|
QQuickWindow* w = m_window;
|
|
|
|
if ( m_window )
|
|
{
|
|
if ( --m_refCount == 0 )
|
|
m_window = nullptr;
|
|
}
|
|
|
|
return w;
|
|
}
|
|
|
|
private:
|
|
int m_refCount;
|
|
QQuickWindow* m_window;
|
|
};
|
|
}
|
|
|
|
Q_GLOBAL_STATIC( QskQuickItemRegistry, qskRegistry )
|
|
Q_GLOBAL_STATIC( QskWindowStore, qskReleasedWindowCounter )
|
|
|
|
QskQuickItem::QskQuickItem( QskQuickItemPrivate& dd, QQuickItem* parent )
|
|
: QQuickItem( dd, parent )
|
|
{
|
|
setFlag( QQuickItem::ItemHasContents, true );
|
|
|
|
// since Qt 5.10 we have QQuickItem::ItemEnabledHasChanged
|
|
#if QT_VERSION < QT_VERSION_CHECK( 5, 10, 0 )
|
|
/*
|
|
Setting up this connections slows down the time needed
|
|
for construction by almost 100%. Would be nice to
|
|
avoid this penalty also for earlier Qt versions.
|
|
*/
|
|
connect( this, &QQuickItem::enabledChanged,
|
|
[ this ] { qskSendEventTo( this, QEvent::EnabledChange ); } );
|
|
#endif
|
|
|
|
Q_D( QskQuickItem );
|
|
if ( d->controlFlags & QskQuickItem::DeferredUpdate )
|
|
qskFilterWindow( window() );
|
|
|
|
qskRegistry->insert( this );
|
|
}
|
|
|
|
QskQuickItem::~QskQuickItem()
|
|
{
|
|
/*
|
|
We set componentComplete to false, so that operations
|
|
that are triggered by detaching the item from its parent
|
|
can be aware of the about-to-delete state.
|
|
*/
|
|
d_func()->componentComplete = false;
|
|
|
|
if ( qskRegistry )
|
|
qskRegistry->remove( this );
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 5, 10, 0 )
|
|
disconnect( this, &QQuickItem::enabledChanged, nullptr, nullptr );
|
|
#endif
|
|
}
|
|
|
|
const char* QskQuickItem::className() const
|
|
{
|
|
return metaObject()->className();
|
|
}
|
|
|
|
void QskQuickItem::classBegin()
|
|
{
|
|
Inherited::classBegin();
|
|
}
|
|
|
|
void QskQuickItem::componentComplete()
|
|
{
|
|
#if defined( QT_DEBUG )
|
|
if ( qobject_cast< const QQuickBasePositioner* >( parent() ) )
|
|
{
|
|
if ( d_func()->controlFlags & QskQuickItem::DeferredLayout )
|
|
{
|
|
qWarning( "QskQuickItem in DeferredLayout mode under control of a positioner" );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
Inherited::componentComplete();
|
|
}
|
|
|
|
void QskQuickItem::releaseResources()
|
|
{
|
|
Inherited::releaseResources();
|
|
|
|
// QQuickItem::derefWindow runs over the children between
|
|
// calling releaseResources and itemChange. So we need to have
|
|
// a reference count to know, when we have processed all
|
|
// sequences to be able to provide the correct "oldWindow"
|
|
// in the WindowChange event.
|
|
|
|
qskReleasedWindowCounter->setWindow( window() );
|
|
}
|
|
|
|
void QskQuickItem::setVisible( bool on )
|
|
{
|
|
// QQuickItem::setVisible is no slot
|
|
Inherited::setVisible( on );
|
|
}
|
|
|
|
void QskQuickItem::show()
|
|
{
|
|
Inherited::setVisible( true );
|
|
}
|
|
|
|
void QskQuickItem::hide()
|
|
{
|
|
Inherited::setVisible( false );
|
|
}
|
|
|
|
bool QskQuickItem::isVisibleTo( const QQuickItem* ancestor ) const
|
|
{
|
|
return qskIsVisibleTo( this, ancestor );
|
|
}
|
|
|
|
void QskQuickItem::setGeometry( qreal x, qreal y, qreal width, qreal height )
|
|
{
|
|
// QQuickItem does not even offer changing the geometry
|
|
// in one call - what leads to 2 calls of the updateGeometry
|
|
// hook. Grmpf ...
|
|
|
|
Q_D( QQuickItem );
|
|
|
|
d->heightValid = true;
|
|
d->widthValid = true;
|
|
|
|
const QRectF oldRect( d->x, d->y, d->width, d->height );
|
|
|
|
int dirtyType = 0;
|
|
|
|
if ( d->x != x || d->y != y )
|
|
{
|
|
d->x = x;
|
|
d->y = y;
|
|
|
|
dirtyType |= QQuickItemPrivate::Position;
|
|
}
|
|
|
|
if ( d->width != width || d->height != height )
|
|
{
|
|
d->height = height;
|
|
d->width = width;
|
|
|
|
dirtyType |= QQuickItemPrivate::Size;
|
|
}
|
|
|
|
if ( dirtyType )
|
|
{
|
|
if ( dirtyType & QQuickItemPrivate::Position )
|
|
d->dirty( QQuickItemPrivate::Position );
|
|
|
|
if ( dirtyType & QQuickItemPrivate::Size )
|
|
d->dirty( QQuickItemPrivate::Size );
|
|
|
|
/*
|
|
Unfortunately geometryChanged is protected and we can't implement
|
|
this code as qskSetItemGeometry - further hacking required: TODO ...
|
|
*/
|
|
|
|
geometryChanged( QRectF( d->x, d->y, d->width, d->height ), oldRect );
|
|
}
|
|
}
|
|
|
|
QRectF QskQuickItem::rect() const
|
|
{
|
|
Q_D( const QQuickItem );
|
|
return QRectF( 0, 0, d->width, d->height );
|
|
}
|
|
|
|
QRectF QskQuickItem::geometry() const
|
|
{
|
|
Q_D( const QQuickItem );
|
|
return QRectF( d->x, d->y, d->width, d->height );
|
|
}
|
|
|
|
void QskQuickItem::setTransparentForPositioner( bool on )
|
|
{
|
|
Q_D( QQuickItem );
|
|
if ( on != d->isTransparentForPositioner() )
|
|
{
|
|
d->setTransparentForPositioner( on );
|
|
Q_EMIT itemFlagsChanged();
|
|
}
|
|
}
|
|
|
|
bool QskQuickItem::isTransparentForPositioner() const
|
|
{
|
|
return d_func()->isTransparentForPositioner();
|
|
}
|
|
|
|
void QskQuickItem::setTabFence( bool on )
|
|
{
|
|
Q_D( QQuickItem );
|
|
if ( on != d->isTabFence )
|
|
{
|
|
d->isTabFence = on;
|
|
Q_EMIT itemFlagsChanged();
|
|
}
|
|
}
|
|
|
|
bool QskQuickItem::isTabFence() const
|
|
{
|
|
return d_func()->isTabFence;
|
|
}
|
|
|
|
void QskQuickItem::setPolishOnResize( bool on )
|
|
{
|
|
Q_D( QskQuickItem );
|
|
if ( on != d->polishOnResize )
|
|
{
|
|
d->polishOnResize = on;
|
|
polish();
|
|
|
|
Q_EMIT itemFlagsChanged();
|
|
}
|
|
}
|
|
|
|
bool QskQuickItem::polishOnResize() const
|
|
{
|
|
return d_func()->polishOnResize;
|
|
}
|
|
|
|
bool QskQuickItem::layoutMirroring() const
|
|
{
|
|
return d_func()->effectiveLayoutMirror;
|
|
}
|
|
|
|
void QskQuickItem::setLayoutMirroring( bool on, bool recursive )
|
|
{
|
|
// Again we have to deal with an existing API made for QML,
|
|
// that is weired for C++: LayoutMirroring/QQuickLayoutMirroringAttached
|
|
// Internally it is managed by 5(!) different flags - condolences
|
|
// to the poor guy who has been sentenced to maintain this.
|
|
|
|
// Anyway, the code below might achieve the desired behavior without
|
|
// breaking the QML path.
|
|
|
|
Q_D( QQuickItem );
|
|
|
|
if ( recursive != d->inheritMirrorFromItem )
|
|
{
|
|
d->inheritMirrorFromItem = recursive;
|
|
d->resolveLayoutMirror();
|
|
}
|
|
|
|
d->isMirrorImplicit = false;
|
|
|
|
if ( on != d->effectiveLayoutMirror )
|
|
{
|
|
d->setLayoutMirror( on );
|
|
if ( recursive )
|
|
d->resolveLayoutMirror();
|
|
}
|
|
}
|
|
|
|
void QskQuickItem::resetLayoutMirroring()
|
|
{
|
|
Q_D( QQuickItem );
|
|
|
|
if ( d && !d->isMirrorImplicit )
|
|
{
|
|
d->isMirrorImplicit = true;
|
|
// d->inheritMirrorFromItem = false;
|
|
d->resolveLayoutMirror();
|
|
}
|
|
}
|
|
|
|
bool QskQuickItem::isPolishScheduled() const
|
|
{
|
|
return d_func()->polishScheduled;
|
|
}
|
|
|
|
bool QskQuickItem::isUpdateNodeScheduled() const
|
|
{
|
|
Q_D( const QskQuickItem );
|
|
|
|
return ( d->dirtyAttributes & QQuickItemPrivate::ContentUpdateMask ) &&
|
|
( d->flags & QQuickItem::ItemHasContents );
|
|
}
|
|
|
|
bool QskQuickItem::isInitiallyPainted() const
|
|
{
|
|
return d_func()->isInitiallyPainted;
|
|
}
|
|
|
|
bool QskQuickItem::maybeUnresized() const
|
|
{
|
|
Q_D( const QskQuickItem );
|
|
|
|
if ( d->width <= 0.0 && d->height <= 0.0 )
|
|
{
|
|
/*
|
|
Unfortunately the list of items to-be-polished is not processed
|
|
in top/down order and we might run into updatePolish() before
|
|
having a proper size. But when the parentItem() is waiting
|
|
for to-be-polished, we assume, that we will be resized then
|
|
and run into another updatePolish() then.
|
|
*/
|
|
if ( d->polishOnResize && qskIsPolishScheduled( parentItem() ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QskQuickItem::Flags QskQuickItem::controlFlags() const
|
|
{
|
|
return QskQuickItem::Flags( d_func()->controlFlags );
|
|
}
|
|
|
|
void QskQuickItem::setControlFlags( Flags flags )
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
// set all bits in the mask
|
|
d->controlFlagsMask = std::numeric_limits< quint16 >::max();
|
|
d->updateControlFlags( flags );
|
|
}
|
|
|
|
void QskQuickItem::resetControlFlags()
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
// clear all bits in the mask
|
|
d->controlFlagsMask = 0;
|
|
d->updateControlFlags( static_cast< Flags >( qskControlFlags() ) );
|
|
}
|
|
|
|
void QskQuickItem::setControlFlag( Flag flag, bool on )
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
d->controlFlagsMask |= flag;
|
|
|
|
if ( ( d->controlFlags & flag ) != on )
|
|
{
|
|
updateControlFlag( flag, on );
|
|
Q_EMIT controlFlagsChanged();
|
|
}
|
|
}
|
|
|
|
void QskQuickItem::resetControlFlag( Flag flag )
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
d->controlFlagsMask &= ~flag;
|
|
|
|
const bool on = qskSetup->testControlFlag( static_cast< QskSetup::Flag >( flag ) );
|
|
|
|
if ( ( d->controlFlags & flag ) != on )
|
|
{
|
|
updateControlFlag( flag, on );
|
|
Q_EMIT controlFlagsChanged();
|
|
}
|
|
}
|
|
|
|
bool QskQuickItem::testControlFlag( Flag flag ) const
|
|
{
|
|
return d_func()->controlFlags & flag;
|
|
}
|
|
|
|
void QskQuickItem::updateControlFlag( uint flag, bool on )
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
if ( ( flag > std::numeric_limits< quint16 >::max() ) ||
|
|
( bool( d->controlFlags & flag ) == on ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( on )
|
|
d->controlFlags |= flag;
|
|
else
|
|
d->controlFlags &= ~flag;
|
|
|
|
switch ( flag )
|
|
{
|
|
case QskQuickItem::DeferredUpdate:
|
|
{
|
|
if ( on )
|
|
{
|
|
qskFilterWindow( window() );
|
|
}
|
|
else
|
|
{
|
|
if ( !isVisible() )
|
|
update();
|
|
}
|
|
|
|
break;
|
|
}
|
|
case QskQuickItem::DeferredPolish:
|
|
{
|
|
if ( !on && d->blockedPolish )
|
|
polish();
|
|
|
|
break;
|
|
}
|
|
case QskQuickItem::DeferredLayout:
|
|
{
|
|
if ( !on )
|
|
{
|
|
// Update the implicitSize and rebind the size to it.
|
|
// Having set the size explicitly gets lost.
|
|
|
|
d->widthValid = d->heightValid = false;
|
|
d->updateImplicitSize( false );
|
|
}
|
|
|
|
break;
|
|
}
|
|
case QskQuickItem::CleanupOnVisibility:
|
|
{
|
|
if ( on && !isVisible() )
|
|
d->cleanupNodes();
|
|
|
|
break;
|
|
}
|
|
case QskQuickItem::DebugForceBackground:
|
|
{
|
|
// no need to mark it dirty
|
|
if ( flags() & QQuickItem::ItemHasContents )
|
|
update();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void QskQuickItem::resetImplicitSize()
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
if ( d->controlFlags & QskQuickItem::DeferredLayout )
|
|
{
|
|
d->blockedImplicitSize = true;
|
|
d->layoutConstraintChanged();
|
|
}
|
|
else
|
|
{
|
|
d->updateImplicitSize( true );
|
|
}
|
|
}
|
|
|
|
bool QskQuickItem::event( QEvent* event )
|
|
{
|
|
const int eventType = event->type();
|
|
|
|
switch( eventType )
|
|
{
|
|
case QEvent::StyleChange:
|
|
{
|
|
d_func()->clearPreviousNodes = true;
|
|
|
|
resetImplicitSize();
|
|
polish();
|
|
|
|
if ( flags() & QQuickItem::ItemHasContents )
|
|
update();
|
|
|
|
changeEvent( event );
|
|
return true;
|
|
}
|
|
case QEvent::ContentsRectChange:
|
|
{
|
|
if ( polishOnResize() )
|
|
polish();
|
|
|
|
changeEvent( event );
|
|
return true;
|
|
}
|
|
case QEvent::EnabledChange:
|
|
case QEvent::FontChange:
|
|
case QEvent::PaletteChange:
|
|
case QEvent::LocaleChange:
|
|
case QEvent::ReadOnlyChange:
|
|
case QEvent::ParentChange:
|
|
{
|
|
changeEvent( event );
|
|
return true;
|
|
}
|
|
case QskEvent::GeometryChange:
|
|
{
|
|
geometryChangeEvent( static_cast< QskGeometryChangeEvent* >( event ) );
|
|
return true;
|
|
}
|
|
case QskEvent::WindowChange:
|
|
{
|
|
windowChangeEvent( static_cast< QskWindowChangeEvent* >( event ) );
|
|
return true;
|
|
}
|
|
case QEvent::LayoutRequest:
|
|
{
|
|
if ( d_func()->polishOnResize )
|
|
polish();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return Inherited::event( event );
|
|
}
|
|
|
|
void QskQuickItem::windowChangeEvent( QskWindowChangeEvent* )
|
|
{
|
|
}
|
|
|
|
void QskQuickItem::geometryChangeEvent( QskGeometryChangeEvent* )
|
|
{
|
|
}
|
|
|
|
void QskQuickItem::changeEvent( QEvent* )
|
|
{
|
|
}
|
|
|
|
void QskQuickItem::itemChange( QQuickItem::ItemChange change,
|
|
const QQuickItem::ItemChangeData& value )
|
|
{
|
|
switch ( change )
|
|
{
|
|
case QQuickItem::ItemSceneChange:
|
|
{
|
|
if ( value.window )
|
|
{
|
|
Q_D( const QskQuickItem );
|
|
if ( d->controlFlags & QskQuickItem::DeferredUpdate )
|
|
qskFilterWindow( value.window );
|
|
}
|
|
|
|
#if 1
|
|
auto oldWindow = qskReleasedWindowCounter->window();
|
|
if ( oldWindow && ( oldWindow->activeFocusItem() == this ) )
|
|
{
|
|
/*
|
|
Removing an item from the scene might result in
|
|
changes of the active focus item. Unfortunately the corresponding
|
|
FocusIn/Out events are sent, while the item tree is in an
|
|
invalid state.
|
|
When having event handlers, that do modifications of the focus
|
|
( f.e. assigning the local focus, inside of a focus scope )
|
|
we might end up with having a dangling pointer for
|
|
oldWindow->activeFocusItem().
|
|
*/
|
|
QQuickWindowPrivate::get( oldWindow )->clearFocusInScope(
|
|
qskNearestFocusScope( this ), this, Qt::OtherFocusReason );
|
|
}
|
|
#endif
|
|
|
|
QskWindowChangeEvent event( oldWindow, value.window );
|
|
QCoreApplication::sendEvent( this, &event );
|
|
|
|
break;
|
|
}
|
|
#if QT_VERSION >= QT_VERSION_CHECK( 5, 10, 0 )
|
|
case QQuickItem::ItemEnabledHasChanged:
|
|
{
|
|
qskSendEventTo( this, QEvent::EnabledChange );
|
|
break;
|
|
}
|
|
#endif
|
|
case QQuickItem::ItemVisibleHasChanged:
|
|
{
|
|
Q_D( QskQuickItem );
|
|
#if 1
|
|
/*
|
|
~QQuickItem sends QQuickItem::ItemVisibleHasChanged recursively
|
|
to all childItems. When being a child ( not only a childItem() )
|
|
we are short before being destructed too and any updates
|
|
done here are totally pointless. TODO ...
|
|
*/
|
|
#endif
|
|
if ( value.boolValue )
|
|
{
|
|
if ( d->blockedPolish )
|
|
polish();
|
|
|
|
if ( d->controlFlags & QskQuickItem::DeferredUpdate )
|
|
{
|
|
if ( d->dirtyAttributes && ( d->flags & QQuickItem::ItemHasContents ) )
|
|
update();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( d->controlFlags & QskQuickItem::CleanupOnVisibility )
|
|
d->cleanupNodes();
|
|
|
|
d->isInitiallyPainted = false;
|
|
}
|
|
|
|
if ( parentItem() && parentItem()->isVisible() )
|
|
{
|
|
/*
|
|
Layout code might consider the visiblility of the children
|
|
and therefore needs to be updated. Posting a statement about
|
|
changed layout constraints has this effect, but is not correct.
|
|
The right way to go would be to create show/hide events and to
|
|
handle them, where visibility of the children matters.
|
|
TODO ...
|
|
*/
|
|
|
|
d->layoutConstraintChanged();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
case QQuickItem::ItemParentHasChanged:
|
|
case QQuickItem::ItemChildAddedChange:
|
|
case QQuickItem::ItemChildRemovedChange:
|
|
case ItemOpacityHasChanged:
|
|
case ItemActiveFocusHasChanged:
|
|
case ItemRotationHasChanged:
|
|
case ItemAntialiasingHasChanged:
|
|
case ItemDevicePixelRatioHasChanged:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
Inherited::itemChange( change, value );
|
|
}
|
|
|
|
void QskQuickItem::geometryChanged(
|
|
const QRectF& newGeometry, const QRectF& oldGeometry )
|
|
{
|
|
Inherited::geometryChanged( newGeometry, oldGeometry );
|
|
|
|
Q_D( const QskQuickItem );
|
|
if ( !d->polishScheduled && d->polishOnResize )
|
|
{
|
|
if ( newGeometry.size() != oldGeometry.size() )
|
|
polish();
|
|
}
|
|
|
|
QskGeometryChangeEvent event( newGeometry, oldGeometry );
|
|
QCoreApplication::sendEvent( this, &event );
|
|
}
|
|
|
|
void QskQuickItem::updatePolish()
|
|
{
|
|
Q_D( QskQuickItem );
|
|
|
|
if ( d->controlFlags & QskQuickItem::DeferredPolish )
|
|
{
|
|
if ( !isVisible() )
|
|
{
|
|
d->blockedPolish = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
d->blockedPolish = false;
|
|
|
|
if ( !d->isInitiallyPainted )
|
|
{
|
|
/*
|
|
We should find a better way for identifying, when
|
|
an item is about to be shown, than making it dependend
|
|
from polishing and the existence of scene graph nodes. TODO ...
|
|
*/
|
|
aboutToShow();
|
|
}
|
|
|
|
updateItemPolish();
|
|
}
|
|
|
|
void QskQuickItem::aboutToShow()
|
|
{
|
|
}
|
|
|
|
void QskQuickItem::updateItemPolish()
|
|
{
|
|
}
|
|
|
|
QSGNode* QskQuickItem::updatePaintNode( QSGNode* node, UpdatePaintNodeData* data )
|
|
{
|
|
Q_UNUSED( data );
|
|
|
|
Q_D( QskQuickItem );
|
|
|
|
Q_ASSERT( isVisible() || !( d->controlFlags & QskQuickItem::DeferredUpdate ) );
|
|
|
|
d->isInitiallyPainted = true;
|
|
|
|
if ( d->clearPreviousNodes )
|
|
{
|
|
delete node;
|
|
node = nullptr;
|
|
|
|
d->clearPreviousNodes = false;
|
|
}
|
|
|
|
return updateItemPaintNode( node );
|
|
}
|
|
|
|
QSGNode* QskQuickItem::updateItemPaintNode( QSGNode* node )
|
|
{
|
|
return node;
|
|
}
|
|
|
|
#include "moc_QskQuickItem.cpp"
|