446 lines
8.5 KiB
Plaintext
446 lines
8.5 KiB
Plaintext
/*!
|
|
\class QskQuickItem QskQuickItem.h
|
|
|
|
\ingroup Framework
|
|
|
|
QskQuickItem completes the C++ API of QQuickItem and implements some
|
|
flags to offer better control over the operations happening in the
|
|
update cycle.
|
|
*/
|
|
|
|
/*!
|
|
\enum QskQuickItem::Flag
|
|
|
|
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
|
|
|
|
Creating of sceme graph nodes is blocked when being invisible.
|
|
( QQuickItem::isVisible() ).
|
|
|
|
\note Some more advanced algorithms have not yet been implemented,
|
|
such as viewport frustrum culling (i.e. hiding items outside of the
|
|
window geometry).
|
|
|
|
\var QskQuickItem::Flag QskQuickItem::DeferredPolish
|
|
|
|
Polishing an item ( QQuickItem::polish() ) is blocked when being invisible.
|
|
F.e for all items being derived from QskControl the layout calculations
|
|
happen during polishing.
|
|
|
|
\var QskQuickItem::Flag QskQuickItem::DeferredLayout
|
|
|
|
Recalculations of the implicitSize are blocked until being explicitely requested by
|
|
QQuickItem::implicitSize().
|
|
|
|
When being enabled the item indicates layout relevant changes by
|
|
sending a QEvent::LayoutRequest ( similar to QWidget ) to its parent item
|
|
without recalculating the actual size hints ( f.e the implicitSize ).
|
|
|
|
When having layout code that relies on binding the implicit width/height
|
|
the QskQuickItem::DeferredLayout flag needs to be disabled.
|
|
|
|
\note All layout classes offered by the Qt/Quick modules of the Qt Company
|
|
( f.e anchors ) do require immediate updates of the implicit size.
|
|
|
|
\sa QskQuickItem::resetImplicitSize()
|
|
|
|
\var QskQuickItem::Flag 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 later.
|
|
|
|
\var QskQuickItem::Flag QskQuickItem::PreferRasterForTextures
|
|
|
|
When creating textures from QskGraphic, prefer the raster paint
|
|
engine over the OpenGL paint engine.
|
|
|
|
\var 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()
|
|
*/
|
|
|
|
/*!
|
|
\var QskQuickItem::geometry
|
|
|
|
This property holds the geometry of the item relative to its parent item.
|
|
When changing the geometry, the item receives a QskEvent::GeometryChange event.
|
|
|
|
\sa geometryChangeEvent(), geometryChange()
|
|
*/
|
|
|
|
/*!
|
|
\var QskQuickItem::transparentForPositioners
|
|
|
|
When transparentForPositioners is set the item indicates, that it should be excluded
|
|
from any layout calculations. This flag is actually a concept of QQuickItem, that
|
|
has not been exposed to its public API.
|
|
|
|
\sa isTransparentForPositioner()
|
|
*/
|
|
|
|
/*!
|
|
\var QskQuickItem::tabFence
|
|
|
|
The tabFence flag can be used to create local tab focus chains. It is usually
|
|
used in combination with QQuickItem::ItemIsFocusScope.
|
|
|
|
QskPopup is an example where the focus tab chain is expected to continue
|
|
with the first child instead of leaving the popup, when reaching its end.
|
|
|
|
\sa isTabFence(), QQuickItem::ItemIsFocusScope
|
|
*/
|
|
|
|
/*!
|
|
\var QskQuickItem::visibleToParent
|
|
|
|
Flag indicating if an item would become visible if its parentItem() is shown.
|
|
The implementation relies on the internal explicitVisible flag, that has not
|
|
been exposed by the public API of QQuickItem.
|
|
|
|
In many situations it is important to know if an item has been explicitly hidden
|
|
because of a setVisible( false ) or it is a child of an item, that is in
|
|
an invisible state. F,e for calculating the size hint for a hidden container
|
|
it is necessary to know which children would stay hidden when the container
|
|
becomes visible.
|
|
|
|
\sa isVisibleToParent(), QQuickItem::setVisible()
|
|
*/
|
|
|
|
/*!
|
|
\var QskQuickItem::polishOnResize
|
|
|
|
When polishOnResize is set QQuickItem::polish() will be called automatically
|
|
whenevent the size of the item has been changed. This is usually necessary
|
|
when the item is a container and the layout of its children depends on the
|
|
size of the container.
|
|
|
|
\sa QskControl::updateLayout(), QskControl::autoLayoutChildren
|
|
*/
|
|
|
|
/*!
|
|
\var QskQuickItem::initiallyPainted
|
|
|
|
Status flag indicating that there has already been a call
|
|
of QQuickItem::updatePaintNode() since the item has become visible.
|
|
|
|
Before each initial call of updatePaintNode() the specific
|
|
hook aboutToShow() is called, that is intended to be overloaded.
|
|
|
|
\sa isInitiallyPainted(), aboutToShow()
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::QskQuickItem
|
|
|
|
Sets the QQuickItem::ItemHasContents flag to true.
|
|
*/
|
|
|
|
*!
|
|
\fn QskQuickItem::~QskQuickItem
|
|
|
|
Sets the componentComplete to false, so that its about-to-delete state is known
|
|
whn detaching it from parent/window.
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::className
|
|
|
|
A convenience wrapper for metaObject()->className()
|
|
\return Class name
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isVisibleTo
|
|
|
|
The true case occurs if neither the item itself nor any parent up to but excluding
|
|
ancestor has been explicitly hidden.
|
|
|
|
\param ancestor Ancestor is the parentItem() hierarchy
|
|
\return true if this item would become visible if ancestor is shown; otherwise returns false.
|
|
|
|
\sa visibleToParent
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isVisibleToParent
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::hasChildItems
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setGeometry( qreal, qreal, qreal, qreal )
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setGeometry( const QRectF& )
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::geometry() const
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::geometryChange
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::rect
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::implicitSize
|
|
|
|
bla
|
|
*/
|
|
|
|
|
|
/*!
|
|
\fn QskQuickItem::setPolishOnResize
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::polishOnResize() const
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setTransparentForPositioner
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isTransparentForPositioner
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setTabFence
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isTabFence
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setLayoutMirroring
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::resetLayoutMirroring
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::layoutMirroring
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setControlFlags
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::resetControlFlags
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::controlFlags
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setControlFlag
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::resetControlFlag
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::testControlFlag
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::controlFlagsChanged
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::classBegin
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::componentComplete
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::releaseResources
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isPolishScheduled
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isUpdateNodeScheduled
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::isInitiallyPainted
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::maybeUnresized
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::itemFlagsChanged
|
|
|
|
bla
|
|
*/
|
|
|
|
|
|
/*!
|
|
\fn QskQuickItem::setGeometry
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::show
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::hide
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::setVisible
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::resetImplicitSize
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::event
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::changeEvent
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::geometryChangeEvent
|
|
|
|
For no known reason QQuickItem propagates changes of position and size
|
|
by calling QQuickItem::geometryChange(), instead of using events.
|
|
|
|
QskQuickItem reestablished the more powerful concept of events by sending/posting
|
|
events, that can be preprocessed by event filtering.
|
|
|
|
\param event Event indicating the geometry change
|
|
|
|
\sa QObject::installEventFilter(), geometryChange()
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::windowChangeEvent
|
|
|
|
*/
|
|
|
|
/*!
|
|
\fn QskQuickItem::itemChange
|
|
|
|
bla
|
|
*/
|
|
|
|
/*!
|
|
void \fn QskQuickItem::aboutToShow
|
|
|
|
A specific hook that is intended to be overloaded by controls that need
|
|
to do some specific operations, when an item is painted the first time
|
|
after becoming visisble.
|
|
|
|
The default implementation is a no operation.
|
|
|
|
\sa initiallyPainted, QQuickItem::setVisible()
|
|
*/
|
|
|