qskinny/doc/classes/QskSkinnable.dox

/*!
    \class QskSkinnable QskSkinnable.h

	\ingroup Framework

	QskSkinnable is the base for all objects, that can be configured by skin hints
	and are displayed by a skinlet. The configuration from the skin can be overwritten by
    adding values to the local skin hint table - it is even possible to replace the
    skinlet individually.

	In most cases a skinnable is a QskControl, but conceptually it is
    possible to have controls, that consist of many skinnables.

	\sa QskSkin, QskSkinlet, QskControl, QskSkinHintTable
*/

/*! \fn QskSkinnable::QskSkinnable()

	Constructs a skinnable where all settings will be resolved from the skin

	\sa effectiveSkin(), effectiveSkinlet, effectiveSkinHint
*/

/*! \fn QskSkinnable::~QskSkinnable()

	Called when the skinnable is destroyed.
*/

/*!
    \fn void QskSkinnable::setSkinlet

	\brief Set an individual skinlet to render/display the content

	Usually all skinnables of the same type are rendered by the same instance
    of a skinlet. For rare situations it can be useful to assign a different skinlet.

	When QskSkinlet::isOwnedBySkinnable() is true, the skinlet will be deleted,
    when the skinnable is deleted or a different skinlet gets assigned.

	\param skinlet Skinlet to render/layout the skinnable.
    
	\sa skinlet(), effectiveSkinlet(), resetSkinlet(),
        QskSkin::declareSkinlet, QskSkinlet::isOwnedBySkinnable()

	\note Overriding the skinlet that has been registered in the skin
          breaks the themeabilty of the skinnable.
*/

/*!
    \fn QskSkinnable::skinlet

    \return Skinlet, that has been assigned by setSkinlet(). Usually the skinnable
            is coupled to a default skinlet from the skin and the result is a nullptr.

    \sa setSkinlet(), effectiveSkinlet(), effectiveSkin()
*/

/*!
    \fn QskSkinnable::updateNode

    This method replaces the QQuickItem::updatePaintNode method as the
    preferred paint method to override when subclassing QskControl. This allows
    QskControl to perform some additional steps before calling updateNode(),
    and provides a consistent parent node which subclasses can rely on.

	The default implementation simply forwards the operation to the skinlet,

    \param parentNode The parent of the nodes to be added in this method.

    \note Overriding updateNode() might break the themeability and the usual
          strategy to implement custom painting is to customize or replace
          the skinlet.

	\sa QskSkinlet::updateSubNode()
*/

/*!
    \fn QskSkinnable::effectiveSkinHint

	\brief Find the value for a specific aspect

	\param aspect Initial aspect, to feed the skin hint lookup algorithm.

	\param status Optional status information, that indicates how the aspect has been
                  resolved and where the result has been found

	\sa effectiveSubcontrol(), effectivePlacement()
*/

/*! \fn QskSkinnable::effectiveFont

	Finds the font role for the given aspect and returns
    the corrsponding font from the font table of the skin.

	\param aspect Unresolved aspect
	\return Font, corresponding to the resolved aspect 

	\sa fontRoleHint(), effectiveSkinHint(), QskSkin::font()
*/

/*! \fn QskSkinnable::effectiveGraphicFilter

	Finds the graphic role for the given aspect and returns
	the corrsponding color filter from the skin

	\param aspect Unresolved aspect
	\return Color filter, corresponding to the resolved aspect 

	\sa graphicRoleHint(), effectiveSkinHint(), QskSkin::graphicFilter()
*/

/*! \fn QskSkinnable::setAnimationHint

	Insert an animation hint into the local hint table

	\param aspect Unresolved aspect
	\param hint Animation hint

	\sa animationHint(), effectiveAnimation()
*/

/*! \fn QskSkinnable::animationHint
*/

/*! \fn QskSkinnable::effectiveAnimation

	Retrieve the configuration of the animator for reaching
	a specific state.

	\param type Metric, color or something else
	\param subControl Unsubstituted subControl
	\param state State bits
	\param status If status != nullptr additional informations
                  about where the hint has been found is returned

	\return Value from the hint tables
	\sa animationHint()
*/

/*! \fn QskSkinnable::setSkinHint

	Insert a hint into the local hint table

	\param aspect Unresolved aspect
	\param hint Hint, might be anything that fits into a QVariant
                and is understood by the skinlet consuming it.

	\sa effectiveSkinHint(), resetSkinHint(), QskSkinHintTable::setHint()
*/

/*! \fn QskSkinnable::resetSkinHint

	Remove a hint from the local hint table

	After removing the hint from the local table the hint will
    be resolved fro the hint table of the skin.

	\param aspect Unresolved aspect

	\sa setSkinHint(), effectiveSkinHint()
*/

/*! \fn QskSkinnable::effectivePlacement
*/

/*! \fn QskSkinnable::hintStatus

	\param aspect Unresolved aspect
	\return Informations about how the aspect would be resolved

	\sa effectiveSkinHint()
*/

/*! \fn QskSkinnable::skinState

	\return Current state
	\sa setSkinStateFlag(), setSkinState()
*/

/*! \fn QskSkinnable::skinStateAsPrintable() const

	\return Current state as printable for debugging purposes
	\sa skinStateAsPrintable( QskAspect::State ) const
*/

/*! \fn QskSkinnable::skinStateAsPrintable( QskAspect::State ) const

	\param state State bits
    \return state as printable for debugging purposes

    \note A pointer to an internal buffer is returned, that might be
          overwritten by subsequent calls.
*/

/*! \fn QskSkinnable::subControlRect

	The same as
	\code effectiveSkinlet()->subControlRect( this, contentsRect, subControl ); \endcode

	\param contentsRect Bounding contents rectangle
	\param subControl Subcontrol

	\sa effectiveSkinlet(), QskSkinlet::subControlRect(), QskControl::contentsRect()
*/

/*! \fn QskSkinnable::subControlContentsRect
*/

/*! \fn QskSkinnable::outerBoxSize
*/

/*! \fn QskSkinnable::innerBoxSize
*/

/*! \fn QskSkinnable::innerBox
*/

/*! \fn QskSkinnable::outerBox
*/

/*! \fn QskSkinnable::innerPadding
*/

/*! \fn QskSkinnable::effectiveSkinlet

	\return Skinlet that has been set with setSkinlet() - or the default
            skinlet from the skin, that had been registered for metaObject()
*/

/*! \fn QskSkinnable::effectiveSkin

	\return Almost always the current skin. The only exception is when manually
            setting a skinlet being created from a different skin.

	\sa QskSetup::skin(), QskSkinlet::skin()
*/

/*! \fn QskSkinnable::startTransition
*/

/*! \fn QskSkinnable::effectiveSubcontrol
*/

/*! \fn QskSkinnable::controlCast()
	
	Safe casting of the skinnable to a QskControl

	The operation is based on comparing metaObject()
	with QskControl::staticMetaObject() ( similar to what qobject_cast() does )

	\return Control if successful, or a nullptr otherwise
*/

/*! \fn QskSkinnable::controlCast() const

	Safe casting of the skinnable to a QskControl

    The operation is based on comparing metaObject()
    with QskControl::staticMetaObject() ( similar to what qobject_cast() does )
    
    \return Control if successful, or a nullptr otherwise
*/

/*! \fn QskSkinnable::owningControl

	In most cases a skinnable is one of the base classes of QskControl and
	the owning control is the derived control. But in case of a control, that
    is built from several skinnables this pure virtual method needs to be implemented.

	\return QskControl, that is owner of the skinnable. In most
            cases the skinnable is inherited 
*/

/*! \fn QskSkinnable::metaObject
*/

/*! \fn QskSkinnable::debug( QskAspect ) const
*/

/*! \fn QskSkinnable::debug( QskAspect::State ) const
*/

/*! \fn QskSkinnable::debug( QDebug, QskAspect ) const
*/

/*! \fn QskSkinnable::debug( QDebug, QskAspect::State ) const
*/

/*! \fn QskSkinnable::setSkinState
*/

/*! \fn QskSkinnable::setSkinStateFlag
*/

/*! \fn QskSkinnable::setColor( QskAspect, Qt::GlobalColor )
*/

/*! \fn QskSkinnable::setColor( QskAspect, QRgb )
*/

/*! \fn QskSkinnable::setColor( QskAspect, const QColor& )
*/

/*! \fn QskSkinnable::resetColor
*/

/*! \fn QskSkinnable::color
*/

/*! \fn QskSkinnable::setMetric
*/

/*! \fn QskSkinnable::resetMetric
*/

/*! \fn QskSkinnable::metric
*/

/*! \fn QskSkinnable::setFlagHint
*/

/*! \fn QskSkinnable::resetFlagHint
*/

/*! \fn QskSkinnable::flagHint( QskAspect ) const
*/

/*! \fn template< typename T > T QskSkinnable::flagHint( QskAspect, T ) const
*/

/*! \fn QskSkinnable::setStrutSizeHint( QskAspect, const QSizeF& )
*/

/*! \fn QskSkinnable::setStrutSizeHint( QskAspect, qreal width, qreal height )
*/

/*! \fn QskSkinnable::resetStrutSizeHint
*/

/*! \fn QskSkinnable::strutSizeHint
*/

/*! \fn QskSkinnable::setMarginHint( QskAspect, qreal )
*/

/*! \fn QskSkinnable::setMarginHint( QskAspect, const QMarginsF& )
*/

/*! \fn QskSkinnable::resetMarginHint
*/

/*! \fn QskSkinnable::marginHint
*/

/*! \fn QskSkinnable::setPaddingHint( QskAspect, qreal )
*/

/*! \fn QskSkinnable::setPaddingHint( QskAspect, const QMarginsF& )
*/

/*! \fn QskSkinnable::resetPaddingHint
*/

/*! \fn QskSkinnable::paddingHint
*/

/*! \fn QskSkinnable::setGradientHint
*/

/*! \fn QskSkinnable::gradientHint
*/

/*! \fn QskSkinnable::setBoxShapeHint
*/

/*! \fn QskSkinnable::resetBoxShapeHint
*/

/*! \fn QskSkinnable::boxShapeHint
*/

/*! \fn QskSkinnable::setBoxBorderMetricsHint
*/

/*! \fn QskSkinnable::resetBoxBorderMetricsHint
*/

/*! \fn QskSkinnable::boxBorderMetricsHint
*/

/*! \fn QskSkinnable::setBoxBorderColorsHint
*/

/*! \fn QskSkinnable::resetBoxBorderColorsHint
*/

/*! \fn QskSkinnable::boxBorderColorsHint
*/

/*! \fn QskSkinnable::setSpacingHint
*/

/*! \fn QskSkinnable::resetSpacingHint
*/

/*! \fn QskSkinnable::spacingHint
*/

/*! \fn QskSkinnable::setAlignmentHint
*/

/*! \fn QskSkinnable::resetAlignmentHint
*/

/*! \fn QskSkinnable::alignmentHint
*/

/*! \fn QskSkinnable::setFontRoleHint
*/

/*! \fn QskSkinnable::resetFontRoleHint
*/

/*! \fn QskSkinnable::fontRoleHint
*/

/*! \fn QskSkinnable::setGraphicRoleHint
*/

/*! \fn QskSkinnable::resetGraphicRoleHint
*/

/*! \fn QskSkinnable::graphicRoleHint
*/

/*! \fn QskSkinnable::isTransitionAccepted
*/

/*! \fn QskSkinnable::hintTable()
*/

/*! \fn QskSkinnable::hintTable() const
*/