peranger/qskinny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some minor steps towards doxygen docs

Browse Source
This commit is contained in:
Uwe Rathmann 2021-01-25 11:06:01 +01:00
parent 41549a4392
commit a19c4c7878
9 changed files with 661 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/Doxyfile
View File

@ -895,7 +895,7 @@ EXCLUDE_SYMLINKS = NO
# Note that the wildcards are matched against the file with absolute path, so to # 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 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 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the # (namespaces, classes, functions, etc.) that should be excluded from the

209
doc/classes/QskAspect.dox
View File

@ -1,112 +1,92 @@
/*! /*!
\brief Defines a series of enum values for describing particular aspects of controls \class QskAspect QskAspect.h
\ingroup theming
\sa QskSkinHint \brief Lookup key for a QskSkinHintTable
\sa QskControl::skinHint
\sa QskSkin::skinHint
*/
namespace QskAspect
{
/*!
\var Aspect
Used by the \ref qskskinning "skin engine" to determine how a given aspect 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 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 is composed of smaller enum bitfields which can be ORed together to
describe a more specific part of the user interface. 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 defined by combining the State (QskAbstractButton::Pressed) with the
Subcontrol (QskPushButton::Panel), the Primitive (Border), 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 \sa QskSkinnable::effectiveSkinHint(), QskSkin::skinHint()
argument. */
The 64 bits in Aspect are partitioned as follows (Note: flags are /*!
interpreted as single bits, while IDs are interpreted as aggregate integer \enum QskAspect::Type
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)
\note The above structure may change in the future as features are added \brief Represents the type of the Aspect.
and/or sections are be expanded to accommodate wider information types.
*/
/*! Represents a specific "subresource" ID, usually a FontRole or ColorRole. The type categorizes the aspect to be a metric, color or "something else".
In most cases, the default (`0`) is appropriate. */
enum Index : std::uint8_t
{
FirstIndex = 0x00,
LastIndex = 0xFF,
};
/*! Represents the data type of the Aspect. The default is Flag, but Often primitives are related to a specific category. F.e QskAspect::Alignment will
more commonly this will be a Color or Metric. Colors are 32-bit ARGB probably always be a QskAspect::Flag, while QskAspect::Border will usually
values (see QRgb), and Metrics are `float` values typically be combined with QskAspect::Color and QskAspect::Metric.
corresponding to pixel distances. */
enum Type : std::uint16_t
{
Flag = 0x0000, // default, enum / int
Metric = 0x0100, // float
Color = 0x0200, // QRgb (uint)
};
/*! Adds extra information to Type. Currently, the only modifier is Animator, Smooth transitions can be set up depending on these categories. F.e when
which specifies that skinhint corresponds to the animation data for this changing from daylight to darkness color schemem only values of QskAspect::Color
Aspect. */ aspects need to be considered. But when changing the Look&Feel of the
enum Modifier : std::uint16_t application all type of aspects need to be considered.
{
Animator = 0x0800 ///< Denotes that the skin hint affects the animation timing/easing.
};
/*! Used with certain Primitives (such as Border) to specify an edge. Zero or \var QskAspect::Type QskAspect::Flag
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
};
/*! Used with certain Primitives (such as Radius) to specify a corner. Zero or Flags are all sort of attributes that are no metrics or colors - f.e
more Corners can be combined to denote which corner(s) the Aspect is concerned. an alignment. A reasonable subset of possible flags is offered as
The default value of `0` implies AllCorners. */ QskAspect::FlagPrimitive
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
};
/*! The fundamental building blocks of box-like UI components, based on the \var QskAspect::Type QskAspect::Metric
<a>CSS box model</a>. See QskSkinRenderer::updateBox for more information. */
enum Primitive : std::uint32_t
{
Background = 0x00000000, ///< The default primitive, the background color(s)
Margin = 0x00010000, ///< The margin, according to the CSS box model Metrics are related to geometries in most cases corresponding to pixel distances.
Padding = 0x00020000, ///< The padding, according to the CSS box model Examples are the margin/padding. A reasonable subset of possible metrics
RadiusX = 0x00030000, ///< The horizontal corner radius, according to the CSS box model is offered as QskAspect::MetricPrimitive.
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
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 /*! 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 value applies to any control (and can be used as a fallback), specifying a
@ -134,58 +114,3 @@ enum State : std::uint64_t
Automatic = 0x0000000000000000, ///< No specified state (the default) Automatic = 0x0000000000000000, ///< No specified state (the default)
NoState = 0x0000FFFF00000000 ///< Empty state, explicitly specified. Useful in some types of animators. 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).
};
}

60
doc/classes/QskIndexedLayoutBox.dox
View File

@ -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 When autoAddChildren is enabled new children are automatically
appended to the layout. Otherwise items have to be inserted appended to the layout. Otherwise items have to be inserted
manually using addItem() or insertItem(). 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() \fn QskIndexedLayoutBox::~QskIndexedLayoutBox()
\brief Destructor \brief Destructor
*/ */
/*! /*!
\fn void QskIndexedLayoutBox::autoAddChildrenChanged() \fn void QskIndexedLayoutBox::autoAddChildrenChanged()
The autoAddChildren property has changed The autoAddChildren property has changed
\sa setAutoAddChildren(), autoAddChildren() \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 When autoAddChildren() is enabled new children are automatically
appended to the layout. Otherwise items have to be inserted appended to the layout. Otherwise items have to be inserted
manually using addItem() or insertItem(). 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 \note Existing children, that have not been inserted before
remain being not seen by the layout. remain being not seen by the layout.
*/ */
/*! /*!
\fn bool QskIndexedLayoutBox::autoAddChildren() const \fn bool QskIndexedLayoutBox::autoAddChildren() const
\return Value of the \ref autoAddChildren property \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 Checking ItemChildAddedChange/ItemChildRemovedChange changes to
implement the \ref autoAddChildren mode implement the \ref autoAddChildren mode
\sa autoAddChildren \sa autoAddChildren
*/ */

334
doc/classes/QskLinearBox.dox
View File

@ -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 QskLinearBox organizes layout items in vertical or horizontal order
( \ref orientation ). When the number of items for a row/column has ( \ref orientation ). When the number of items for a row/column has
reached an upper limit ( \ref dimension ) the following items will be reached an upper limit ( \ref dimension ) the following items will be
added to a new row/column. added to a new row/column.
When having the \ref dimension being set to unlimited ( or 1 with the When having the \ref dimension being set to unlimited ( or 1 with the
inverted \ref orientation ) the string layout behaves similar to inverted \ref orientation ) the string layout behaves similar to
QBoxLayout, RowLayout/ColumnLayout ( QML ) or what is QBoxLayout, RowLayout/ColumnLayout ( QML ) or what is
sometimes called a linear layout. sometimes called a linear layout.
When not restricting the layout to one row/column only the layout can When not restricting the layout to one row/column only the layout can
be used to set up simple grid formations. be used to set up simple grid formations.
Layout items may be QQuickItem *s or spacers - both having a stretch factor Layout items may be QQuickItem *s or spacers - both having a stretch factor
in the range of [0..10]; in the range of [0..10];
\note All available Qsk layouts are thin layers on top of the same grid \note All available Qsk layouts are thin layers on top of the same grid
based workhorse ( = QGridLayoutEngine ). QskLinearBox offers based workhorse ( = QGridLayoutEngine ). QskLinearBox offers
a reasonable subset of features, tailored for an index based a reasonable subset of features, tailored for an index based
point of view. 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 In case of Qt::Horizontal the elements are organized horizontally
increasing the column index, when appending an item. When the increasing the column index, when appending an item. When the
number of columns exceeds the \ref dimension the next item will be 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 the first column of the next row ( v.v for Qt::Vertical ).
The horizontal layout direction is affected by its state The horizontal layout direction is affected by its state
of QskControl::layoutMirroring(), what might depend on the of QskControl::layoutMirroring(), what might depend on the
QskControl::locale(). QskControl::locale().
\sa transpose(), dimension \sa transpose(), dimension
\accessors orientation(), setOrientation(), orientationChanged() \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 According to the orientation the layout is organized in
rows or columns. The dimension is an upper limit for the number rows or columns. The dimension is an upper limit for the number
of elements in a row/column. of elements in a row/column.
When the number of elements exceeds the dimension the following element When the number of elements exceeds the dimension the following element
will be inserted in the following row/column. will be inserted in the following row/column.
\sa orientation \sa orientation
\accessors dimension(), setDimension(), dimensionChanged() \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 The spacing is the distance between each cell and row
of the layout. Its initial value depend on the current theme. of the layout. Its initial value depend on the current theme.
Beside setting the global spacing it is also possible to add Beside setting the global spacing it is also possible to add
individual spacings at the end of each row and column. 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() \sa setRowSpacing(), setColumnSpacing(), insertSpacer(), QskControl::setMargins()
\accessors spacing(), setSpacing(), spacingChanged() \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 The \ref orientation is set to Qt::Horizontal orientation having
an unlimited \ref dimension. an unlimited \ref dimension.
\param parent Parent item \param parent Parent item
\sa orientation, dimension \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 orientation Qt::Horizontal or Qt::Vertical
\param parent Parent item \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 orientation Qt::Horizontal or Qt::Vertical
\param dimension Upper limit for the number of elements \param dimension Upper limit for the number of elements
in a row or column 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 \brief Set the orientation of the layout
\param orientation Qt::Vertical or Qt::Horizontal \param orientation Qt::Vertical or Qt::Horizontal
\sa orientation \sa orientation
*/ */
/*! /*!
\fn Qt::Orientation QskLinearBox::orientation() const; \fn Qt::Orientation QskLinearBox::orientation() const;
\return Value of the \ref orientation property \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. Qt::Horizontal becomes to Qt::Vertical and v.v.
\sa setOrientation(), orientation(), orientationChanged() \sa setOrientation(), orientation(), orientationChanged()
*/ */
/*! /*!
\fn void QskLinearBox::orientationChanged() \fn void QskLinearBox::orientationChanged()
The orientation of the layout has changed The orientation of the layout has changed
\sa orientation \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 \warning A value of 0 is invalid and will be set to 1
\sa dimension \sa dimension
*/ */
/*! /*!
\fn uint QskLinearBox::dimension(void); \fn uint QskLinearBox::dimension(void);
\return Value of the \ref dimension property const \return Value of the \ref dimension property const
*/ */
/*! /*!
\fn void QskLinearBox::dimensionChanged() \fn void QskLinearBox::dimensionChanged()
The dimension of the layout has changed The dimension of the layout has changed
\sa setDimension(), dimension() \sa setDimension(), dimension()
*/ */
/*! /*!
\fn void QskLinearBox::spacingChanged() \fn void QskLinearBox::spacingChanged()
The spacing of the layout has changed The spacing of the layout has changed
\sa setSpacing(), spacing(), setRowSpacing(), setColumnSpacing() \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 \brief Set the global spacing of the layout
\param spacing Distance between each cell and row \param spacing Distance between each cell and row
\sa spacing \sa spacing
*/ */
/*! /*!
\fn void QskLinearBox::resetSpacing() \fn void QskLinearBox::resetSpacing()
\brief Reset the global spacing to its initial value \brief Reset the global spacing to its initial value
\sa spacing \sa spacing
*/ */
/*! /*!
\fn qreal QskLinearBox::spacing(void) const \fn qreal QskLinearBox::spacing(void) const
\return Value of the \ref spacing property \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 spacing Spacing
\param stretchFactor A value between [0..10]. \param stretchFactor A value between [0..10].
The ratio of the stretch factors of expandable The ratio of the stretch factors of expandable
candidates decides about how to distribute extra space. candidates decides about how to distribute extra space.
\sa insertSpacer() \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 Spacers being inserted to the layout are elements having
an index - like regular QQuickItem *s and participate in the an index - like regular QQuickItem *s and participate in the
calculation of the geometries. calculation of the geometries.
A spacer is treated like being an item with a preferred A spacer is treated like being an item with a preferred
width/height of spacing. In case of having a stretchFactor > 0 width/height of spacing. In case of having a stretchFactor > 0
the width/height might exceed spacing. the width/height might exceed spacing.
\param index Position, where to insert the spacer. If index is < 0 \param index Position, where to insert the spacer. If index is < 0
or beyond QskLayout::itemCount() the spacer will be appended. or beyond QskLayout::itemCount() the spacer will be appended.
\param spacing Spacing Minimum for width/height \param spacing Spacing Minimum for width/height
\param stretchFactor A value between [0..10]. \param stretchFactor A value between [0..10].
The ratio of the stretch factors of expandable The ratio of the stretch factors of expandable
candidates decides about how to distribute extra space. candidates decides about how to distribute extra space.
\note Calling QskLayout::itemAtIndex( index ) will return a nullptr. \note Calling QskLayout::itemAtIndex( index ) will return a nullptr.
\sa insertItem(), QskLayout::itemAtIndex() \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]. \param stretchFactor A value between [0..10].
The ratio of the stretch factors of expandable The ratio of the stretch factors of expandable
candidates decides about how to distribute extra space. 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 \param index Position, where to insert the stretch. If index is < 0
or beyond QskLayout::itemCount() the stretch will be appended. or beyond QskLayout::itemCount() the stretch will be appended.
\param stretchFactor A value between [0..10]. \param stretchFactor A value between [0..10].
The ratio of the stretch factors of expandable The ratio of the stretch factors of expandable
candidates decides about how to distribute extra space. candidates decides about how to distribute extra space.
\note Calling QskLayout::itemAtIndex( index ) will return a nullptr. \note Calling QskLayout::itemAtIndex( index ) will return a nullptr.
\sa insertSpacer(), QskLayout::itemAtIndex() \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 index Position of the element
\param stretchFactor A value between [0..10]. \param stretchFactor A value between [0..10].
The ratio of the stretch factors of expandable The ratio of the stretch factors of expandable
candidates decides about how to distribute extra space. 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 \param index Position of the inserted element
\return Stretch factor of a layout 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 item Inserted item
\param stretchFactor A value between [0..10]. \param stretchFactor A value between [0..10].
The ratio of the stretch factors of expandable The ratio of the stretch factors of expandable
candidates decides about how to distribute extra space. 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 \param item Inserted item
\return Stretch factor of a layout element \return Stretch factor of a layout element
\sa setStretchFactor() \sa setStretchFactor()
*/ */

357
doc/classes/QskQuickItem.dox
View File

@ -1,65 +1,354 @@
/*! /*!
\class QskQuickItem QskQuickItem.h \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 Qt/Quick classes have a tendency to update items too early
and too often. To avoid processing of unwanted operations and too often. To avoid processing of unwanted operations
QskQuickItem implements a couple of modifications, that QskQuickItem implements a couple of modifications, that
can be en/disabled individually. 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 \note Some more advanced algorithms have not yet been implemented,
( QQuickItem::isVisible() ). such as viewport frustrum culling (i.e. hiding items outside of the
window geometry).
\note Some more advanced algorithms have not yet been implemented, \var QskQuickItem::Flag QskQuickItem::DeferredPolish
such as viewport frustrum culling (i.e. hiding items outside of the
window geometry).
\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 \var QskQuickItem::Flag QskQuickItem::DeferredLayout
nodes ( QQuickItem::isVisible() ).
\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() When being enabled the item indicates layout relevant changes by
is explicitly called. When being enabled the implicit size is not recalculated before sending a QEvent::LayoutRequest ( similar to QWidget ) to its parent item
being requested - usually by a QskLayout. 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() ). \note All layout classes offered by the Qt/Quick modules of the Qt Company
Enabling this mode will reduce the memory footprint, but comes at the cost ( f.e anchors ) do require immediate updates of the implicit size.
of having to recreate nodes later.
\var PreferRasterForTextures \sa QskQuickItem::resetImplicitSize()
When creating textures from QskGraphic, prefer the raster paint \var QskQuickItem::Flag QskQuickItem::CleanupOnVisibility
engine over the OpenGL paint engine.
\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. \var QskQuickItem::Flag QskQuickItem::PreferRasterForTextures
\note This flag is useful when analyzing layouts.
\sa controlFlags(), setControlFlags(), resetControlFlags() When creating textures from QskGraphic, prefer the raster paint
testControlFlag(), setControlFlag(), resetControlFlag() 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
bla
*/ */
/*! /*!
\fn void QskQuickItem::resetControlFlag( Flag ); \fn QskQuickItem::isVisibleTo
bla
*/ */
/*! /*!
\fn bool QskQuickItem::testControlFlag( Flag ) const; \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
*/

58
doc/classes/QskSeparator.dox
View File

@ -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. QskSeparator is used to visually distinguish between groups of items.
It can be used in horizontal or vertical direction by setting the It can be used in horizontal or vertical direction by setting the
orientation property to Qt::Vertical or Qt::Horizontal, respectively. orientation property to Qt::Vertical or Qt::Horizontal, respectively.
\subcontrols QskSeparator::Panel \subcontrols QskSeparator::Panel
\skinlet QskSeparatorSkinlet \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. orientation of Qt::Horizontal it might be a vertical line.
\accessors orientation(), setOrientation(), orientationChanged() \accessors orientation(), setOrientation(), orientationChanged()
*/ */
/*! /*!
\var QskSeparator::Panel \var QskSeparator::Panel
\sa QskSeparatorSkinlet \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 Constructs a separator with the given parent. The orientation parameter
determines whether the separator is horizontal or vertical. determines whether the separator is horizontal or vertical.
\sa orientation \sa orientation
*/ */
/*! /*!
\fn QskSeparator::~QskSeparator(); \fn QskSeparator::~QskSeparator();
Destroys this separator. Destroys this separator.
*/ */
/*! /*!
\fn void QskSeparator::setOrientation( Qt::Orientation ); \fn void QskSeparator::setOrientation( Qt::Orientation );
Set the orientation of the separator Set the orientation of the separator
\param orientation Qt::Vertical or Qt::Horizontal \param orientation Qt::Vertical or Qt::Horizontal
\sa orientation \sa orientation
*/ */
/*! /*!
\fn Qt::Orientation QskSeparator::orientation() const; \fn Qt::Orientation QskSeparator::orientation() const;
\return Value of the \ref orientation property \return Value of the \ref orientation property
*/ */
/*! /*!
\fn void QskSeparator::orientationChanged() \fn void QskSeparator::orientationChanged()
The orientation of the layout has changed The orientation of the layout has changed
\sa orientation \sa orientation
*/ */

28
doc/classes/QskSetup.dox
View File

@ -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 \property QskSkin* QskSetup::skin
\accessors skin(), setSkin(), skinChanged() \accessors skin(), setSkin(), skinChanged()
*/ */
/*! /*!
\enum QskSetup::Flag \enum QskSetup::Flag
\var DeferredUpdate \var DeferredUpdate
\var DeferredPolish \var DeferredPolish
\var DeferredLayout \var DeferredLayout
\var CleanupOnVisibility \var CleanupOnVisibility
\var PreferRasterForTextures \var PreferRasterForTextures
\var DebugForceBackground \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* );
*/ */

48
doc/classes/QskSkinnable.dox
View File

@ -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 Allows overriding the QskControl::Skin used by this control to render its
contents. contents.
*/ */
/*! /*!
\fn const QskSkinlet* QskSkinnable::skinlet() const; \fn const QskSkinlet* QskSkinnable::skinlet() const;
\return Skinlet assigned by setSkinlet(). \return Skinlet assigned by setSkinlet().
\sa effectiveSkinlet() \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 Returns the QskSkinHint value for a QskAspect::Aspect. If none is set for
this control, the value for QskSkin::skinHint() is returned. this control, the value for QskSkin::skinHint() is returned.
\note If a QskSkinHintProvider is animating the color when called, the 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 value will be the current value, not the target value, unless a state mask
is requested as part of the aspect. 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 A convenience method equivalent to skinHint( aspect ).metric. The
QskSkinHint::TypeMask is set to QskSkinHint::Metric. 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 This method replaces the QQuickItem::updatePaintNode method as the
preferred paint method to override when subclassing QskControl. This allows preferred paint method to override when subclassing QskControl. This allows
QskControl to perform some additional steps before calling updateNode(), QskControl to perform some additional steps before calling updateNode(),
and provides a consistent parent node which subclasses can rely on. 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. \param parentNode The parent of the nodes to be added in this method.
\return The parent node. \return The parent node.
*/ */

26
doc/qskmodules.dox
View File

@ -39,7 +39,6 @@
\class QskGestureRecognizer \class QskGestureRecognizer
\class QskPanGestureRecognizer \class QskPanGestureRecognizer
\class QskQuick \class QskQuick
\class QskQuickItem
\class QskSetup \class QskSetup
\class QskShortcutMap \class QskShortcutMap
\class QskWindow \class QskWindow
@ -55,7 +54,6 @@
\defgroup Themeing Themeing \defgroup Themeing Themeing
\{ \{
\class QskAspect
\class QskBoxBorderColors \class QskBoxBorderColors
\class QskBoxBorderMetrics \class QskBoxBorderMetrics
\class QskBoxShapeMetrics \class QskBoxShapeMetrics
@ -99,29 +97,7 @@
\class QskTextLabel \class QskTextLabel
\} \}
\defgroup Skinlets Skinlets \defgroup container Container
\{
\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
\{ \{
\class QskScrollArea \class QskScrollArea
\class QskSubWindowArea \class QskSubWindowArea