diff --git a/doc/Doxyfile b/doc/Doxyfile index e19e3cd5..8e4ce6ba 100644 --- a/doc/Doxyfile +++ b/doc/Doxyfile @@ -895,7 +895,7 @@ EXCLUDE_SYMLINKS = NO # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* -EXCLUDE_PATTERNS = +EXCLUDE_PATTERNS = *Private.* # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the diff --git a/doc/classes/QskAspect.dox b/doc/classes/QskAspect.dox index 5d113768..97eb1279 100644 --- a/doc/classes/QskAspect.dox +++ b/doc/classes/QskAspect.dox @@ -1,113 +1,93 @@ /*! - \brief Defines a series of enum values for describing particular aspects of controls + \class QskAspect QskAspect.h + \ingroup theming - \sa QskSkinHint - \sa QskControl::skinHint - \sa QskSkin::skinHint -*/ -namespace QskAspect -{ -/*! - \var Aspect + \brief Lookup key for a QskSkinHintTable Used by the \ref qskskinning "skin engine" to determine how a given aspect of a control is drawn. While Aspect is simply a 64-bit unsigned integer, it is composed of smaller enum bitfields which can be ORed together to describe a more specific part of the user interface. - For example, the top border color of a QskPushButton while pressed is + For example, the border colors of a QskPushButton while pressed is defined by combining the State (QskAbstractButton::Pressed) with the Subcontrol (QskPushButton::Panel), the Primitive (Border), - the edge/corner (Top), and the Type (Color) as so: + and the Type (Color) as so: - auto aspect = QskAbstractButton::Pressed | QskPushButton::Panel | QskAspect::Border | QskAspect::Top | QskAspect::Color + auto aspect = QskPushButton::Panel | QskAbstractButton::Pressed | QskAspect::Color | QskAspect::Border - This `aspect` can then be passed to, e.g., QskSkin::setSkinHint as the first - argument. + \sa QskSkinnable::effectiveSkinHint(), QskSkin::skinHint() + */ - The 64 bits in Aspect are partitioned as follows (Note: flags are - interpreted as single bits, while IDs are interpreted as aggregate integer - values): - 0xFFFF000000000000 | 0x0000FFFF00000000 | 0x00000000FFF00000 | 0x00000000000F0000 | 0x000000000000F000 | 0x0000000000000800 | 0x0000000000000700 | 0x00000000000000FF - -------------------| --------------------------- | -------------------------------- | ------------------------------ | -------------------------------------------- | ---------------------------- | ------------------------- | -------------------------- - Unused | QskAspect::State (16 flags) | QskAspect::Subcontrol (4096 IDs) | QskAspect::Primitive (255 IDs) | QskAspect::Corner, QskAspect::Edge (4 flags) | QskAspect::Modifier (1 flag) | QskAspect::Type (128 IDs) | QskAspect::Index (256 IDs) +/*! + \enum QskAspect::Type - \note The above structure may change in the future as features are added - and/or sections are be expanded to accommodate wider information types. -*/ + \brief Represents the type of the Aspect. -/*! Represents a specific "subresource" ID, usually a FontRole or ColorRole. - In most cases, the default (`0`) is appropriate. */ -enum Index : std::uint8_t -{ - FirstIndex = 0x00, - LastIndex = 0xFF, -}; + The type categorizes the aspect to be a metric, color or "something else". -/*! Represents the data type of the Aspect. The default is Flag, but - more commonly this will be a Color or Metric. Colors are 32-bit ARGB - values (see QRgb), and Metrics are `float` values typically - corresponding to pixel distances. */ -enum Type : std::uint16_t -{ - Flag = 0x0000, // default, enum / int - Metric = 0x0100, // float - Color = 0x0200, // QRgb (uint) -}; + Often primitives are related to a specific category. F.e QskAspect::Alignment will + probably always be a QskAspect::Flag, while QskAspect::Border will usually + be combined with QskAspect::Color and QskAspect::Metric. -/*! Adds extra information to Type. Currently, the only modifier is Animator, - which specifies that skinhint corresponds to the animation data for this - Aspect. */ -enum Modifier : std::uint16_t -{ - Animator = 0x0800 ///< Denotes that the skin hint affects the animation timing/easing. -}; + Smooth transitions can be set up depending on these categories. F.e when + changing from daylight to darkness color schemem only values of QskAspect::Color + aspects need to be considered. But when changing the Look&Feel of the + application all type of aspects need to be considered. -/*! Used with certain Primitives (such as Border) to specify an edge. Zero or - more Edges can be combined to denote which edge(s) the Aspect is concerned. - The default value of `0` implies AllEdges. */ -enum Edge : std::uint32_t -{ - Left = 0x00001000, - Top = 0x00002000, - Right = 0x00004000, - Bottom = 0x00008000, - AllEdges = Top | Left | Right | Bottom -}; + \var QskAspect::Type QskAspect::Flag -/*! Used with certain Primitives (such as Radius) to specify a corner. Zero or - more Corners can be combined to denote which corner(s) the Aspect is concerned. - The default value of `0` implies AllCorners. */ -enum Corner : std::uint32_t -{ - TopLeft = 0x00001000, - TopRight = 0x00002000, - BottomRight = 0x00004000, - BottomLeft = 0x00008000, - LeftCorners = TopLeft | BottomLeft, - RightCorners = TopRight | BottomRight, - TopCorners = TopLeft | TopRight, - BottomCorners = BottomLeft | BottomRight, - AllCorners = TopLeft | TopRight | BottomLeft | BottomRight -}; + Flags are all sort of attributes that are no metrics or colors - f.e + an alignment. A reasonable subset of possible flags is offered as + QskAspect::FlagPrimitive -/*! The fundamental building blocks of box-like UI components, based on the - CSS box model. See QskSkinRenderer::updateBox for more information. */ -enum Primitive : std::uint32_t -{ - Background = 0x00000000, ///< The default primitive, the background color(s) + \var QskAspect::Type QskAspect::Metric - Margin = 0x00010000, ///< The margin, according to the CSS box model - Padding = 0x00020000, ///< The padding, according to the CSS box model - RadiusX = 0x00030000, ///< The horizontal corner radius, according to the CSS box model - RadiusY = 0x00040000, ///< The vertical corner radius, according to the CSS box model - Border = 0x00050000, ///< The border thickness/color, according to the CSS box model - Shadow = 0x00060000, ///< The shadow thickness/color, according to the CSS box model - Radius = RadiusX | RadiusY, // 0x70000 ///< Convenience enum for specifying both horizontal and vertical radii + Metrics are related to geometries in most cases corresponding to pixel distances. + Examples are the margin/padding. A reasonable subset of possible metrics + is offered as QskAspect::MetricPrimitive. - Fundamental = 0x00080000 // Disables edge/corner routing -}; + \var QskAspect::Type QskAspect::Color + Colors are all sort of color values, like fill gradients, border colors. + */ + +/*! + \enum QskAspect::FlagPrimitive + + \var QskAspect::FlagPrimitive QskAspect::NoFlagPrimitive + \var QskAspect::FlagPrimitive QskAspect::Alignment + \var QskAspect::FlagPrimitive QskAspect::Direction + \var QskAspect::FlagPrimitive QskAspect::Style + \var QskAspect::FlagPrimitive QskAspect::Decoration + \var QskAspect::FlagPrimitive QskAspect::GraphicRole + \var QskAspect::FlagPrimitive QskAspect::FontRole + */ + +/*! + \enum QskAspect::MetricPrimitive + + \var QskAspect::MetricPrimitive QskAspect::NoMetricPrimitive + \var QskAspect::MetricPrimitive QskAspect::StrutSize + \var QskAspect::MetricPrimitive QskAspect::Size + \var QskAspect::MetricPrimitive QskAspect::Position + \var QskAspect::MetricPrimitive QskAspect::Margin + \var QskAspect::MetricPrimitive QskAspect::Padding + \var QskAspect::MetricPrimitive QskAspect::Shadow + \var QskAspect::MetricPrimitive QskAspect::Spacing + \var QskAspect::MetricPrimitive QskAspect::Shape + \var QskAspect::MetricPrimitive QskAspect::Border + */ + +/*! + \enum QskAspect::ColorPrimitive + + \var QskAspect::ColorPrimitive QskAspect::NoColorPrimitive + \var QskAspect::ColorPrimitive QskAspect::TextColor + \var QskAspect::ColorPrimitive QskAspect::StyleColor + \var QskAspect::ColorPrimitive QskAspect::LinkColor + */ + /*! For use within the rendering of a specific QskSkinnable. While the Default value applies to any control (and can be used as a fallback), specifying a Subcontrol limits the aspect's scope to that sub-component (or \em subcontrol) @@ -134,58 +114,3 @@ enum State : std::uint64_t Automatic = 0x0000000000000000, ///< No specified state (the default) NoState = 0x0000FFFF00000000 ///< Empty state, explicitly specified. Useful in some types of animators. }; - -/*! These Aspects are for convenience, providing commonly combined values - to limit the verbosity of combining Aspects in application code. */ -enum : Aspect -{ - MarginTop = Margin | Top, ///< The top margin - MarginLeft = Margin | Left, ///< The left margin - MarginRight = Margin | Right, ///< The right margin - MarginBottom = Margin | Bottom, ///< The bottom margin - PaddingTop = Padding | Top, ///< The top padding - PaddingLeft = Padding | Left, ///< The left padding - PaddingRight = Padding | Right, ///< The right padding - PaddingBottom = Padding | Bottom, ///< The bottom padding - BorderTop = Border | Top, ///< The top border - BorderLeft = Border | Left, ///< The left border - BorderRight = Border | Right, ///< The right border - BorderBottom = Border | Bottom, ///< The bottom border - ShadowTop = Shadow | Top, ///< The top shadow - ShadowLeft = Shadow | Left, ///< The left shadow - ShadowRight = Shadow | Right, ///< The right shadow - ShadowBottom = Shadow | Bottom, ///< The bottom shadow - - RadiusXTopLeft = RadiusX | TopLeft, ///< The top-left horizontal radius - RadiusXTopRight = RadiusX | TopRight, ///< The top-right horizontal radius - RadiusXBottomLeft = RadiusX | BottomLeft, ///< The bottom-left horizontal radius - RadiusXBottomRight = RadiusX | BottomRight, ///< The bottom-right horizontal radius - RadiusYTopLeft = RadiusY | TopLeft, ///< The top-left vertical radius - RadiusYTopRight = RadiusY | TopRight, ///< The top-right vertical radius - RadiusYBottomLeft = RadiusY | BottomLeft, ///< The bottom-left vertical radius - RadiusYBottomRight = RadiusY | BottomRight, ///< The bottom-right vertical radius - - // Standard metrics - Size = 0x0000000000000000 | Fundamental | Metric, ///< A "size" placeholder, like width or height - Position = 0x0000000000010000 | Fundamental | Metric, ///< A "position" placeholder, like the position of a QskSlider - MinimumWidth = 0x0000000000020000 | Fundamental | Metric, ///< A minimum width hint - MinimumHeight = 0x0000000000030000 | Fundamental | Metric, ///< A minimum height hint - MaximumWidth = 0x0000000000040000 | Fundamental | Metric, ///< A maximum width hint - MaximumHeight = 0x0000000000050000 | Fundamental | Metric, ///< A maximum height hint - Spacing = 0x0000000000060000 | Fundamental | Metric, ///< A spacing hint, such as between rows in a QskListBox - - // Standard flags - Alignment = 0x0000000000000000 | Fundamental | Flag, ///< A flag typically used for storing text alignments (Qt::Alignment) - Style = 0x0000000000010000 | Fundamental | Flag, ///< A flag for storing text style (Qsk::Style) - Decoration = 0x0000000000020000 | Fundamental | Flag, ///< A flag for storing decoration information - ColorRole = 0x0000000000060000 | Fundamental | Flag, ///< A flag for specifying a QRgb value at a given QskAspect::Index - FontRole = 0x0000000000070000 | Fundamental | Flag, ///< A flag for specifying a QFont value at a given QskAspect::Index - - // Standard colors - TextColor = 0x0000000000000000 | Fundamental | Color, ///< A placeholder for text color - StyleColor = 0x0000000000010000 | Fundamental | Color, ///< A placeholder for text style color - LinkColor = 0x0000000000020000 | Fundamental | Color, ///< A placeholder for text link color - - AllAspects = 0xFFFFFFFFFFFFFFFF ///< All possible bits in Aspect (useful for e.g. QskSkinnable::markDirty). -}; -} diff --git a/doc/classes/QskIndexedLayoutBox.dox b/doc/classes/QskIndexedLayoutBox.dox index f1bdb344..786786ac 100644 --- a/doc/classes/QskIndexedLayoutBox.dox +++ b/doc/classes/QskIndexedLayoutBox.dox @@ -4,66 +4,66 @@ */ /*! - \property bool QskIndexedLayoutBox::autoAddChildren + \property bool QskIndexedLayoutBox::autoAddChildren - \brief Flag controlling whether to automatically append children to the layout. + \brief Flag controlling whether to automatically append children to the layout. - When autoAddChildren is enabled new children are automatically - appended to the layout. Otherwise items have to be inserted - manually using addItem() or insertItem(). + When autoAddChildren is enabled new children are automatically + appended to the layout. Otherwise items have to be inserted + manually using addItem() or insertItem(). - \note Children being transparent for positioners are ignored + \note Children being transparent for positioners are ignored - \accessors autoAddChildren(), setAutoAddChildren(), autoAddChildrenChanged() + \accessors autoAddChildren(), setAutoAddChildren(), autoAddChildrenChanged() */ /*! - \fn QskIndexedLayoutBox::QskIndexedLayoutBox( QQuickItem* ) + \fn QskIndexedLayoutBox::QskIndexedLayoutBox( QQuickItem* ) - \brief Constructor + \brief Constructor - Create a layout having autoAddChildren set to false. + Create a layout having autoAddChildren set to false. - \param parent Parent item + \param parent Parent item */ /*! - \fn QskIndexedLayoutBox::~QskIndexedLayoutBox() - \brief Destructor + \fn QskIndexedLayoutBox::~QskIndexedLayoutBox() + \brief Destructor */ /*! - \fn void QskIndexedLayoutBox::autoAddChildrenChanged() + \fn void QskIndexedLayoutBox::autoAddChildrenChanged() - The autoAddChildren property has changed - \sa setAutoAddChildren(), autoAddChildren() + The autoAddChildren property has changed + \sa setAutoAddChildren(), autoAddChildren() */ /*! - \fn void QskIndexedLayoutBox::setAutoAddChildren( bool on ) + \fn void QskIndexedLayoutBox::setAutoAddChildren( bool on ) - \brief En/Disable auto appending of children + \brief En/Disable auto appending of children - When autoAddChildren() is enabled new children are automatically - appended to the layout. Otherwise items have to be inserted - manually using addItem() or insertItem(). + When autoAddChildren() is enabled new children are automatically + appended to the layout. Otherwise items have to be inserted + manually using addItem() or insertItem(). - \param on When true autoAddChildren is enabled + \param on When true autoAddChildren is enabled - \note Existing children, that have not been inserted before - remain being not seen by the layout. + \note Existing children, that have not been inserted before + remain being not seen by the layout. */ /*! - \fn bool QskIndexedLayoutBox::autoAddChildren() const - \return Value of the \ref autoAddChildren property + \fn bool QskIndexedLayoutBox::autoAddChildren() const + \return Value of the \ref autoAddChildren property */ /*! - \fn void QskIndexedLayoutBox::itemChange( QQQuickItem *::ItemChange, const QQQuickItem *::ItemChangeData & ) + \fn void QskIndexedLayoutBox::itemChange( QQQuickItem *::ItemChange, const QQQuickItem *::ItemChangeData & ) - Checking ItemChildAddedChange/ItemChildRemovedChange changes to - implement the \ref autoAddChildren mode + Checking ItemChildAddedChange/ItemChildRemovedChange changes to + implement the \ref autoAddChildren mode - \sa autoAddChildren + \sa autoAddChildren */ diff --git a/doc/classes/QskLinearBox.dox b/doc/classes/QskLinearBox.dox index b32803d5..b3decd66 100644 --- a/doc/classes/QskLinearBox.dox +++ b/doc/classes/QskLinearBox.dox @@ -1,318 +1,318 @@ /*! - \class QskLinearBox QskLinearBox.h + \class QskLinearBox QskLinearBox.h - \brief Layout stringing items in rows and columns + \brief Layout stringing items in rows and columns - QskLinearBox organizes layout items in vertical or horizontal order - ( \ref orientation ). When the number of items for a row/column has - reached an upper limit ( \ref dimension ) the following items will be - added to a new row/column. + QskLinearBox organizes layout items in vertical or horizontal order + ( \ref orientation ). When the number of items for a row/column has + reached an upper limit ( \ref dimension ) the following items will be + added to a new row/column. - When having the \ref dimension being set to unlimited ( or 1 with the - inverted \ref orientation ) the string layout behaves similar to - QBoxLayout, RowLayout/ColumnLayout ( QML ) or what is - sometimes called a linear layout. + When having the \ref dimension being set to unlimited ( or 1 with the + inverted \ref orientation ) the string layout behaves similar to + QBoxLayout, RowLayout/ColumnLayout ( QML ) or what is + sometimes called a linear layout. - When not restricting the layout to one row/column only the layout can - be used to set up simple grid formations. + When not restricting the layout to one row/column only the layout can + be used to set up simple grid formations. - Layout items may be QQuickItem *s or spacers - both having a stretch factor - in the range of [0..10]; + Layout items may be QQuickItem *s or spacers - both having a stretch factor + in the range of [0..10]; - \note All available Qsk layouts are thin layers on top of the same grid - based workhorse ( = QGridLayoutEngine ). QskLinearBox offers - a reasonable subset of features, tailored for an index based - point of view. + \note All available Qsk layouts are thin layers on top of the same grid + based workhorse ( = QGridLayoutEngine ). QskLinearBox offers + a reasonable subset of features, tailored for an index based + point of view. - \sa QskGridBox, QskStackBox + \sa QskGridBox, QskStackBox */ /*! - \property Qt::Orientation QskLinearBox::orientation + \property Qt::Orientation QskLinearBox::orientation - \brief Direction of flow for laying out the items + \brief Direction of flow for laying out the items - In case of Qt::Horizontal the elements are organized horizontally - increasing the column index, when appending an item. When the - number of columns exceeds the \ref dimension the next item will be - in the first column of the next row ( v.v for Qt::Vertical ). + In case of Qt::Horizontal the elements are organized horizontally + increasing the column index, when appending an item. When the + number of columns exceeds the \ref dimension the next item will be + in the first column of the next row ( v.v for Qt::Vertical ). - The horizontal layout direction is affected by its state - of QskControl::layoutMirroring(), what might depend on the - QskControl::locale(). + The horizontal layout direction is affected by its state + of QskControl::layoutMirroring(), what might depend on the + QskControl::locale(). - \sa transpose(), dimension - \accessors orientation(), setOrientation(), orientationChanged() + \sa transpose(), dimension + \accessors orientation(), setOrientation(), orientationChanged() */ /*! - \property uint QskLinearBox::dimension + \property uint QskLinearBox::dimension - \brief Upper limit for the number of elements in a row or column + \brief Upper limit for the number of elements in a row or column - According to the orientation the layout is organized in - rows or columns. The dimension is an upper limit for the number - of elements in a row/column. + According to the orientation the layout is organized in + rows or columns. The dimension is an upper limit for the number + of elements in a row/column. - When the number of elements exceeds the dimension the following element - will be inserted in the following row/column. + When the number of elements exceeds the dimension the following element + will be inserted in the following row/column. - \sa orientation - \accessors dimension(), setDimension(), dimensionChanged() + \sa orientation + \accessors dimension(), setDimension(), dimensionChanged() */ /*! - \property qreal QskLinearBox::spacing + \property qreal QskLinearBox::spacing - \brief Global layout spacing + \brief Global layout spacing - The spacing is the distance between each cell and row - of the layout. Its initial value depend on the current theme. + The spacing is the distance between each cell and row + of the layout. Its initial value depend on the current theme. - Beside setting the global spacing it is also possible to add - individual spacings at the end of each row and column. + Beside setting the global spacing it is also possible to add + individual spacings at the end of each row and column. - \note In opposite to a spacer, the global spacing does not insert elements. + \note In opposite to a spacer, the global spacing does not insert elements. - \sa setRowSpacing(), setColumnSpacing(), insertSpacer(), QskControl::setMargins() - \accessors spacing(), setSpacing(), spacingChanged() + \sa setRowSpacing(), setColumnSpacing(), insertSpacer(), QskControl::setMargins() + \accessors spacing(), setSpacing(), spacingChanged() */ /*! - \fn QskLinearBox::QskLinearBox( QQuickItem* ); + \fn QskLinearBox::QskLinearBox( QQuickItem* ); - \brief Create a row layout + \brief Create a row layout - The \ref orientation is set to Qt::Horizontal orientation having - an unlimited \ref dimension. + The \ref orientation is set to Qt::Horizontal orientation having + an unlimited \ref dimension. - \param parent Parent item - \sa orientation, dimension + \param parent Parent item + \sa orientation, dimension */ /*! - \fn QskLinearBox::QskLinearBox( Qt::Orientation orientation, QQuickItem * parent ); + \fn QskLinearBox::QskLinearBox( Qt::Orientation orientation, QQuickItem * parent ); - \brief Create a row or column layout + \brief Create a row or column layout - The \ref dimension is unlimited. + The \ref dimension is unlimited. - \param orientation Qt::Horizontal or Qt::Vertical - \param parent Parent item + \param orientation Qt::Horizontal or Qt::Vertical + \param parent Parent item - \sa orientation, dimension + \sa orientation, dimension */ /*! - \fn QskLinearBox::QskLinearBox( Qt::Orientation, uint, QQuickItem* ); + \fn QskLinearBox::QskLinearBox( Qt::Orientation, uint, QQuickItem* ); - \brief Constructor + \brief Constructor - \param orientation Qt::Horizontal or Qt::Vertical - \param dimension Upper limit for the number of elements - in a row or column + \param orientation Qt::Horizontal or Qt::Vertical + \param dimension Upper limit for the number of elements + in a row or column - \param parent Parent item + \param parent Parent item - \sa orientation, dimension + \sa orientation, dimension */ /*! - \fn QskLinearBox::~QskLinearBox(); + \fn QskLinearBox::~QskLinearBox(); - Destructor + Destructor */ /*! - \fn void QskLinearBox::setOrientation( Qt::Orientation orientation ); + \fn void QskLinearBox::setOrientation( Qt::Orientation orientation ); - \brief Set the orientation of the layout - \param orientation Qt::Vertical or Qt::Horizontal - \sa orientation + \brief Set the orientation of the layout + \param orientation Qt::Vertical or Qt::Horizontal + \sa orientation */ /*! - \fn Qt::Orientation QskLinearBox::orientation() const; - \return Value of the \ref orientation property + \fn Qt::Orientation QskLinearBox::orientation() const; + \return Value of the \ref orientation property */ /*! - \fn void QskLinearBox::transpose() + \fn void QskLinearBox::transpose() - \brief Invert the orientation of the layout + \brief Invert the orientation of the layout - Qt::Horizontal becomes to Qt::Vertical and v.v. - \sa setOrientation(), orientation(), orientationChanged() + Qt::Horizontal becomes to Qt::Vertical and v.v. + \sa setOrientation(), orientation(), orientationChanged() */ /*! - \fn void QskLinearBox::orientationChanged() + \fn void QskLinearBox::orientationChanged() - The orientation of the layout has changed - \sa orientation + The orientation of the layout has changed + \sa orientation */ /*! - \fn void QskLinearBox::setDimension( uint dimension ); + \fn void QskLinearBox::setDimension( uint dimension ); - \brief Set the dimension of the layout + \brief Set the dimension of the layout - \param dimension Upper limit for the number of elements in a row or column + \param dimension Upper limit for the number of elements in a row or column - \warning A value of 0 is invalid and will be set to 1 - \sa dimension + \warning A value of 0 is invalid and will be set to 1 + \sa dimension */ /*! - \fn uint QskLinearBox::dimension(void); - \return Value of the \ref dimension property const + \fn uint QskLinearBox::dimension(void); + \return Value of the \ref dimension property const */ /*! - \fn void QskLinearBox::dimensionChanged() + \fn void QskLinearBox::dimensionChanged() - The dimension of the layout has changed - \sa setDimension(), dimension() + The dimension of the layout has changed + \sa setDimension(), dimension() */ /*! - \fn void QskLinearBox::spacingChanged() + \fn void QskLinearBox::spacingChanged() - The spacing of the layout has changed - \sa setSpacing(), spacing(), setRowSpacing(), setColumnSpacing() + The spacing of the layout has changed + \sa setSpacing(), spacing(), setRowSpacing(), setColumnSpacing() */ /*! - \fn void QskLinearBox::setSpacing( qreal spacing ) + \fn void QskLinearBox::setSpacing( qreal spacing ) - \brief Set the global spacing of the layout - \param spacing Distance between each cell and row - \sa spacing + \brief Set the global spacing of the layout + \param spacing Distance between each cell and row + \sa spacing */ /*! - \fn void QskLinearBox::resetSpacing() + \fn void QskLinearBox::resetSpacing() - \brief Reset the global spacing to its initial value - \sa spacing + \brief Reset the global spacing to its initial value + \sa spacing */ /*! - \fn qreal QskLinearBox::spacing(void) const - \return Value of the \ref spacing property + \fn qreal QskLinearBox::spacing(void) const + \return Value of the \ref spacing property */ /*! - \fn void QskLinearBox::addSpacer( qreal spacing, int stretchFactor ) + \fn void QskLinearBox::addSpacer( qreal spacing, int stretchFactor ) - \brief Append a spacer to the layout + \brief Append a spacer to the layout - The same as \ref insertSpacer( -1, spacing, stretchFactor ); + The same as \ref insertSpacer( -1, spacing, stretchFactor ); - \param spacing Spacing - \param stretchFactor A value between [0..10]. - The ratio of the stretch factors of expandable - candidates decides about how to distribute extra space. - \sa insertSpacer() + \param spacing Spacing + \param stretchFactor A value between [0..10]. + The ratio of the stretch factors of expandable + candidates decides about how to distribute extra space. + \sa insertSpacer() */ /*! - \fn void QskLinearBox::insertSpacer( int index, qreal spacing, int stretchFactor ) + \fn void QskLinearBox::insertSpacer( int index, qreal spacing, int stretchFactor ) - \brief Insert a spacer at a specific position + \brief Insert a spacer at a specific position - Spacers being inserted to the layout are elements having - an index - like regular QQuickItem *s and participate in the - calculation of the geometries. + Spacers being inserted to the layout are elements having + an index - like regular QQuickItem *s and participate in the + calculation of the geometries. - A spacer is treated like being an item with a preferred - width/height of spacing. In case of having a stretchFactor > 0 - the width/height might exceed spacing. + A spacer is treated like being an item with a preferred + width/height of spacing. In case of having a stretchFactor > 0 + the width/height might exceed spacing. - \param index Position, where to insert the spacer. If index is < 0 - or beyond QskLayout::itemCount() the spacer will be appended. + \param index Position, where to insert the spacer. If index is < 0 + or beyond QskLayout::itemCount() the spacer will be appended. - \param spacing Spacing Minimum for width/height - \param stretchFactor A value between [0..10]. - The ratio of the stretch factors of expandable - candidates decides about how to distribute extra space. + \param spacing Spacing Minimum for width/height + \param stretchFactor A value between [0..10]. + The ratio of the stretch factors of expandable + candidates decides about how to distribute extra space. - \note Calling QskLayout::itemAtIndex( index ) will return a nullptr. - \sa insertItem(), QskLayout::itemAtIndex() + \note Calling QskLayout::itemAtIndex( index ) will return a nullptr. + \sa insertItem(), QskLayout::itemAtIndex() */ /*! - \fn void QskLinearBox::addStretch( int stretchFactor ) + \fn void QskLinearBox::addStretch( int stretchFactor ) - \brief Append a stretch to the layout + \brief Append a stretch to the layout - The same as \ref insertStretch( -1, stretchFactor ); + The same as \ref insertStretch( -1, stretchFactor ); - \param stretchFactor A value between [0..10]. - The ratio of the stretch factors of expandable - candidates decides about how to distribute extra space. + \param stretchFactor A value between [0..10]. + The ratio of the stretch factors of expandable + candidates decides about how to distribute extra space. - \sa insertStretch(), addSpacer() + \sa insertStretch(), addSpacer() */ /*! - \fn void QskLinearBox::insertStretch( int index, int stretchFactor ) + \fn void QskLinearBox::insertStretch( int index, int stretchFactor ) - \brief Insert a stretch at a specific position + \brief Insert a stretch at a specific position - A stretch is simply a spacer with a spacing of 0 + A stretch is simply a spacer with a spacing of 0 - \param index Position, where to insert the stretch. If index is < 0 - or beyond QskLayout::itemCount() the stretch will be appended. - \param stretchFactor A value between [0..10]. - The ratio of the stretch factors of expandable - candidates decides about how to distribute extra space. + \param index Position, where to insert the stretch. If index is < 0 + or beyond QskLayout::itemCount() the stretch will be appended. + \param stretchFactor A value between [0..10]. + The ratio of the stretch factors of expandable + candidates decides about how to distribute extra space. - \note Calling QskLayout::itemAtIndex( index ) will return a nullptr. - \sa insertSpacer(), QskLayout::itemAtIndex() + \note Calling QskLayout::itemAtIndex( index ) will return a nullptr. + \sa insertSpacer(), QskLayout::itemAtIndex() */ /*! - \fn void QskLinearBox::setStretchFactor( int index, int stretchFactor ) + \fn void QskLinearBox::setStretchFactor( int index, int stretchFactor ) - \brief Modify the stretch factor of a layout element + \brief Modify the stretch factor of a layout element - \param index Position of the element - \param stretchFactor A value between [0..10]. - The ratio of the stretch factors of expandable - candidates decides about how to distribute extra space. + \param index Position of the element + \param stretchFactor A value between [0..10]. + The ratio of the stretch factors of expandable + candidates decides about how to distribute extra space. - \sa stretchFactor() + \sa stretchFactor() */ /*! - \fn int QskLinearBox::stretchFactor( int index ) const + \fn int QskLinearBox::stretchFactor( int index ) const - \param index Position of the inserted element - \return Stretch factor of a layout element + \param index Position of the inserted element + \return Stretch factor of a layout element - \sa setStretchFactor() + \sa setStretchFactor() */ /*! - \fn void QskLinearBox::setStretchFactor( const QQuickItem * item, int stretchFactor ) + \fn void QskLinearBox::setStretchFactor( const QQuickItem * item, int stretchFactor ) - \brief Modify the stretch factor of an inserted item + \brief Modify the stretch factor of an inserted item - \param item Inserted item - \param stretchFactor A value between [0..10]. - The ratio of the stretch factors of expandable - candidates decides about how to distribute extra space. + \param item Inserted item + \param stretchFactor A value between [0..10]. + The ratio of the stretch factors of expandable + candidates decides about how to distribute extra space. - \sa stretchFactor() + \sa stretchFactor() */ /*! - \fn int QskLinearBox::stretchFactor( const QQuickItem * item ) const + \fn int QskLinearBox::stretchFactor( const QQuickItem * item ) const - \param item Inserted item - \return Stretch factor of a layout element + \param item Inserted item + \return Stretch factor of a layout element - \sa setStretchFactor() + \sa setStretchFactor() */ diff --git a/doc/classes/QskQuickItem.dox b/doc/classes/QskQuickItem.dox index 275f1069..f5a296c1 100644 --- a/doc/classes/QskQuickItem.dox +++ b/doc/classes/QskQuickItem.dox @@ -1,65 +1,354 @@ /*! \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 + \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. + 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. - The default setting enables all attributes. + \var QskQuickItem::Flag QskQuickItem::DeferredUpdate - \var DeferredUpdate + Creating of sceme graph nodes is blocked when being invisible. + ( QQuickItem::isVisible() ). - Creating of paint nodes is blocked for all invisible nodes - ( 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). - \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 - \var 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. - Calculation of layouts ( updateLayout() ) is blocked for all invisible - nodes ( QQuickItem::isVisible() ). + \var QskQuickItem::Flag QskQuickItem::DeferredLayout - \var DeferredLayout + Recalculations of the implicitSize are blocked until being explicitely requested by + QQuickItem::implicitSize(). - Updates of the implicit size is blocked until effectiveConstraint() or sizeHint() - is explicitly called. When being enabled the implicit size is not recalculated before - being requested - usually by a QskLayout. + 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 ). - \var CleanupOnVisibility + When having layout code that relies on binding the implicit width/height + the QskQuickItem::DeferredLayout flag needs to be disabled. - 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. + \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. - \var PreferRasterForTextures + \sa QskQuickItem::resetImplicitSize() - When creating textures from QskGraphic, prefer the raster paint - engine over the OpenGL paint engine. + \var QskQuickItem::Flag QskQuickItem::CleanupOnVisibility - \var DebugForceBackground + 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. - Always fill the background of thecontrol with a random color. - \note This flag is useful when analyzing layouts. + \var QskQuickItem::Flag QskQuickItem::PreferRasterForTextures - \sa controlFlags(), setControlFlags(), resetControlFlags() - testControlFlag(), setControlFlag(), resetControlFlag() + 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() +*/ + + +/*! + \fn QskQuickItem::QskQuickItem + + bla +*/ + +*! + \fn QskQuickItem::~QskQuickItem + + \bla */ /*! - \fn void QskQuickItem::setControlFlag( Flag, bool on = true ); -*/ + \fn QskQuickItem::className -/*! - \fn void QskQuickItem::resetControlFlag( Flag ); -*/ - -/*! - \fn bool QskQuickItem::testControlFlag( Flag ) const; + bla */ + +/*! + \fn QskQuickItem::isVisibleTo + + bla +*/ + +/*! + \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 + + bla +*/ +/*! + \fn QskQuickItem::windowChangeEvent + + bla +*/ + +/*! + \fn QskQuickItem::itemChange + + bla +*/ + +/*! + void \fn QskQuickItem::aboutToShow + + bla +*/ + diff --git a/doc/classes/QskSeparator.dox b/doc/classes/QskSeparator.dox index c6acab6b..301fc147 100644 --- a/doc/classes/QskSeparator.dox +++ b/doc/classes/QskSeparator.dox @@ -1,68 +1,68 @@ /*! - \class QskSeparator QskSeparator.h + \class QskSeparator QskSeparator.h - \brief Separates a group of items from adjacent items. + \brief Separates a group of items from adjacent items. - QskSeparator is used to visually distinguish between groups of items. - It can be used in horizontal or vertical direction by setting the + QskSeparator is used to visually distinguish between groups of items. + It can be used in horizontal or vertical direction by setting the orientation property to Qt::Vertical or Qt::Horizontal, respectively. - \subcontrols QskSeparator::Panel - \skinlet QskSeparatorSkinlet + \subcontrols QskSeparator::Panel + \skinlet QskSeparatorSkinlet */ /*! - \property Qt::Orientation QskSeparator::orientation + \property Qt::Orientation QskSeparator::orientation - \brief Orientation of the separator - Qt::Horizontal (the default) or Qt::Vertical. + \brief Orientation of the separator - Qt::Horizontal (the default) or Qt::Vertical. - A separator is often represented by some line - for a + A separator is often represented by some line - for a orientation of Qt::Horizontal it might be a vertical line. - \accessors orientation(), setOrientation(), orientationChanged() + \accessors orientation(), setOrientation(), orientationChanged() */ /*! - \var QskSeparator::Panel - \sa QskSeparatorSkinlet + \var QskSeparator::Panel + \sa QskSeparatorSkinlet */ /*! - \fn QskSeparator::QskSeparator( QQuickItem* ) + \fn QskSeparator::QskSeparator( QQuickItem* ) - Constructs a horizontal separator with the given parent. + Constructs a horizontal separator with the given parent. */ /*! - \fn QskSeparator::QskSeparator( Qt::Orientation, QQuickItem* ) + \fn QskSeparator::QskSeparator( Qt::Orientation, QQuickItem* ) - Constructs a separator with the given parent. The orientation parameter - determines whether the separator is horizontal or vertical. + Constructs a separator with the given parent. The orientation parameter + determines whether the separator is horizontal or vertical. - \sa orientation + \sa orientation */ /*! - \fn QskSeparator::~QskSeparator(); - Destroys this separator. + \fn QskSeparator::~QskSeparator(); + Destroys this separator. */ /*! - \fn void QskSeparator::setOrientation( Qt::Orientation ); + \fn void QskSeparator::setOrientation( Qt::Orientation ); - Set the orientation of the separator - \param orientation Qt::Vertical or Qt::Horizontal - \sa orientation + Set the orientation of the separator + \param orientation Qt::Vertical or Qt::Horizontal + \sa orientation */ /*! - \fn Qt::Orientation QskSeparator::orientation() const; - \return Value of the \ref orientation property + \fn Qt::Orientation QskSeparator::orientation() const; + \return Value of the \ref orientation property */ /*! - \fn void QskSeparator::orientationChanged() + \fn void QskSeparator::orientationChanged() - The orientation of the layout has changed - \sa orientation + The orientation of the layout has changed + \sa orientation */ diff --git a/doc/classes/QskSetup.dox b/doc/classes/QskSetup.dox index 3e3950da..266b6be5 100644 --- a/doc/classes/QskSetup.dox +++ b/doc/classes/QskSetup.dox @@ -1,33 +1,33 @@ /*! - \class QskSetup QskSetup.h + \class QskSetup QskSetup.h - \brief Singleton maintaining the global settings of an application using Qsk controls + \brief Singleton maintaining the global settings of an application using Qsk controls */ /*! - \property QskSkin* QskSetup::skin - \accessors skin(), setSkin(), skinChanged() + \property QskSkin* QskSetup::skin + \accessors skin(), setSkin(), skinChanged() */ /*! - \enum QskSetup::Flag + \enum QskSetup::Flag - \var DeferredUpdate - \var DeferredPolish - \var DeferredLayout - \var CleanupOnVisibility - \var PreferRasterForTextures - \var DebugForceBackground + \var DeferredUpdate + \var DeferredPolish + \var DeferredLayout + \var CleanupOnVisibility + \var PreferRasterForTextures + \var DebugForceBackground */ /*! - \fn void QskSetup::setSkin( QskSkin* ); + \fn void QskSetup::setSkin( QskSkin* ); */ /*! - \fn QskSkin* QskSetup::skin(); + \fn QskSkin* QskSetup::skin(); */ /*! - \fn void QskSetup::skinChanged( QskSkin* ); + \fn void QskSetup::skinChanged( QskSkin* ); */ diff --git a/doc/classes/QskSkinnable.dox b/doc/classes/QskSkinnable.dox index 872a61fa..5ef1c550 100644 --- a/doc/classes/QskSkinnable.dox +++ b/doc/classes/QskSkinnable.dox @@ -3,50 +3,50 @@ */ /*! - \fn void QskSkinnable::setSkinlet( QskSkinlet* ) + \fn void QskSkinnable::setSkinlet( QskSkinlet* ) - Allows overriding the QskControl::Skin used by this control to render its - contents. + Allows overriding the QskControl::Skin used by this control to render its + contents. */ /*! - \fn const QskSkinlet* QskSkinnable::skinlet() const; + \fn const QskSkinlet* QskSkinnable::skinlet() const; - \return Skinlet assigned by setSkinlet(). - \sa effectiveSkinlet() + \return Skinlet assigned by setSkinlet(). + \sa effectiveSkinlet() */ /*! - \fn QVariant QskSkinnable::effectiveHint( QskAspect::Aspect, QskSkinHintStatus* ) const + \fn QVariant QskSkinnable::effectiveHint( QskAspect::Aspect, QskSkinHintStatus* ) const - Returns the QskSkinHint value for a QskAspect::Aspect. If none is set for - this control, the value for QskSkin::skinHint() is returned. + Returns the QskSkinHint value for a QskAspect::Aspect. If none is set for + this control, the value for QskSkin::skinHint() is returned. - \note If a QskSkinHintProvider is animating the color when called, the returned - value will be the current value, not the target value, unless a state mask - is requested as part of the aspect. + \note If a QskSkinHintProvider is animating the color when called, the returned + value will be the current value, not the target value, unless a state mask + is requested as part of the aspect. - \param aspect Aspect + \param aspect Aspect */ /*! - \fn qreal QskSkinnable::metric( QskAspect::Aspect, QskSkinHintStatus* ) const + \fn qreal QskSkinnable::metric( QskAspect::Aspect, QskSkinHintStatus* ) const - A convenience method equivalent to skinHint( aspect ).metric. The - QskSkinHint::TypeMask is set to QskSkinHint::Metric. + A convenience method equivalent to skinHint( aspect ).metric. The + QskSkinHint::TypeMask is set to QskSkinHint::Metric. */ /*! - \fn void QskSkinnable::updateNode( QSGNode* ) + \fn void QskSkinnable::updateNode( QSGNode* ) - 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. + 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. - Subclasses should call their Skin's updateNode() method inside this method. + Subclasses should call their Skin's updateNode() method inside this method. - \param parentNode The parent of the nodes to be added in this method. - \return The parent node. + \param parentNode The parent of the nodes to be added in this method. + \return The parent node. */ diff --git a/doc/qskmodules.dox b/doc/qskmodules.dox index b6a90922..af550641 100644 --- a/doc/qskmodules.dox +++ b/doc/qskmodules.dox @@ -39,7 +39,6 @@ \class QskGestureRecognizer \class QskPanGestureRecognizer \class QskQuick - \class QskQuickItem \class QskSetup \class QskShortcutMap \class QskWindow @@ -55,7 +54,6 @@ \defgroup Themeing Themeing \{ - \class QskAspect \class QskBoxBorderColors \class QskBoxBorderMetrics \class QskBoxShapeMetrics @@ -99,29 +97,7 @@ \class QskTextLabel \} - \defgroup Skinlets Skinlets - \{ - \class QskBoxSkinlet - \class QskFocusIndicatorSkinlet - \class QskGraphicLabelSkinlet - \class QskListViewSkinlet - \class QskPageIndicatorSkinlet - \class QskPopupSkinlet - \class QskProgressBarSkinlet - \class QskPushButtonSkinlet - \class QskScrollViewSkinlet - \class QskSeparatorSkinlet - \class QskSliderSkinlet - \class QskStatusIndicatorSkinlet - \class QskSubWindowAreaSkinlet - \class QskSubWindowSkinlet - \class QskTabButtonSkinlet - \class QskTabViewSkinlet - \class QskTextInputSkinlet - \class QskTextLabelSkinlet - \} - - \defgroup Container Container + \defgroup container Container \{ \class QskScrollArea \class QskSubWindowArea