qskinny/doc/classes/QskQuickItem.dox

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