/*! \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() */