// Copyright (C) 2017 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only

/*!
\qmlmodule QtQuick
\title Qt Quick QML Types
\ingroup qmlmodules
\brief Provides graphical QML types.

The \l{Qt Quick} module provides graphical primitive types. These types are only
available in a QML document if that document imports the \c QtQuick namespace.

To use the module, import the \c QtQuick module with the following statement:

\qml
import QtQuick
\endqml

Visit the \l {Qt Quick} module documentation for more
information about the concepts that are central to \c QtQuick.

\section1 Submodules

    Qt Quick includes several submodules that contain additional types:

    \list
    \li \l{Qt Quick Local Storage QML Types}{Local Storage} - a submodule
    containing a JavaScript interface for an SQLite database
    \li \l{Qt Quick Particles QML Types}{Particles} - provides a particle
    system for QML applications
    \li \l{Qt Quick Controls QML Types}{Controls} - provides a set of reusable
    UI components
    \li \l{Qt Quick Layouts QML Types}{Layouts} - contains types that are used
    to arrange items in the user interface
    \li \l{Qt Quick Test QML Types}{Tests} - types for testing QML applications.
    \li \l{Qt Quick Effects QML Types}{Effects} - provides types for applying
    one or more simple graphical effects to Qt Quick items.
    \li \l{Qt Quick Shapes QML Types}{Shapes} - provides types for rendering vector shapes in
    a Qt Quick scene.
    \li \l{Qt Quick Vector Image QML Types}{Vector Image} - provides types for displaying vector
    image files.
    \endlist

\target value-types
\section1 Value Types

There are a number of value types that are
\l{qtqml-typesystem-valuetypes.html#value-types-provided-by-the-qml-language}
{supported by default in the QML language}.

In addition, the \c QtQuick import provides the following value types:
\annotatedlist qtquickvaluetypes

\section1 Object Types

Most object types provided by the \c QtQuick import are based on the \l{Item}
type, which itself derives from \l{QtQml::QtObject}{QtObject}. \l{Qt Qml QML
Types#Object Types} {QML object types} provided by the Qt QML module (such as
\l{QtQml::QtObject}{QtObject} and \l{QtQml::Component}{Component}) are also
available when you import \c QtQuick.

*/

/*!
    \keyword colorvaluetypedocs
    \qmlvaluetype color
    \ingroup qtquickvaluetypes

    \brief an ARGB color value.

    The \c color type refers to an ARGB color value. It can be specified in a number of ways:

    \list
    \li By a \l{SVG Color Reference}{SVG color name}, such as "red", "green" or "lightsteelblue".
    \li By a hexadecimal triplet or quad in the form \c "#RRGGBB" and \c "#AARRGGBB"
        respectively. For example, the color red corresponds to a triplet of \c "#FF0000"
        and a slightly transparent blue to a quad of \c "#800000FF".
    \li Using the \l{QtQml::Qt::rgba()}{Qt.rgba()}, \l{QtQml::Qt::hsva()}{Qt.hsva()},
        \l{QtQml::Qt::hsla()}{Qt.hsla()}, \l{QtQml::Qt::darker()}{Qt.darker()},
        \l{QtQml::Qt::lighter()}{Qt.lighter()} or \l{QtQml::Qt::tint()}{Qt.tint()} functions.
    \endlist

    Example:

    \div{float-right}
    \inlineimage declarative-colors.png
    \enddiv
    \snippet qml/colors.qml colors


    A color type has \e r, \e g, \e b, and \e a properties that refer to the red,
    green, blue and alpha values of the color, respectively. Additionally, the
    \e hsvHue, \e hsvSaturation, \e hsvValue, \e hslHue, \e hslSaturation, and \e hslLightness
    properties allow access to color values in HSV and HSL color models respectively.

    \qml
    Text {
        color: "red"

        // prints "1 0 0 1"
        Component.onCompleted: console.log(color.r, color.g, color.b, color.a)
    }
    \endqml

    To test color values for equality, use the \l{QtQml::Qt::colorEqual()}{Qt.colorEqual()}
    function.  This allows colors to be accurately compared whether they are in property
    form or in any of the acceptable string specification forms.

    When integrating with C++, note that any QColor value
    \l{qtqml-cppintegration-data.html}{passed into QML from C++} is automatically
    converted into a \c color value, and vice-versa.

    This value type is provided by the QtQuick import.

    \section1 SVG Color Reference

    The following table lists the available
    \l {https://www.w3.org/TR/css-color-3/#svg-color}{SVG colors}:

    \include svg-colors.qdocinc

    \sa {QML Value Types}
*/

/*!
    \qmlproperty real color::r
    The Red color channel of the RGBA model.
*/

/*!
    \qmlproperty real color::g
    The Green color channel of the RGBA model.
*/

/*!
    \qmlproperty real color::b
    The Blue color channel of the RGBA model.
*/

/*!
    \qmlproperty real color::a
    The Alpha color channel of the RGBA model.
    Alpha depicts the opacity of each pixel.
*/

/*!
    \qmlproperty real color::hsvHue
    The HSV Hue color component of the color.
*/

/*!
    \qmlproperty real color::hsvSaturation
    The HSV Saturation color component of the color.
*/

/*!
    \qmlproperty real color::hsvValue
    The HSV Value color component of the color.
*/

/*!
    \qmlproperty real color::hslHue
    The HSL hue color component of the color.
*/

/*!
    \qmlproperty real color::hslSaturation
    The HSL Saturation color component of the color.
*/

/*!
    \qmlproperty real color::hslLightness
    The HSL Lightness color component of the color.
*/

/*!
    \qmlproperty bool  color::valid
    Returns \c True if the color is valid; otherwise returns \c False.
*/

/*!
    \qmlvaluetype font
    \ingroup qtquickvaluetypes
    \brief a font value with the properties of QFont.
    \target fontvaluetypedocs

    The \c font type refers to a font value with the properties of QFont.

    Properties of type \c font default to the application's default
    \l {Application::font} {font}.

    The most commonly used properties are:

    \list
    \li \l string \c font.family
    \li \l bool \c font.bold
    \li \l bool \c font.italic
    \li \l bool \c font.underline
    \li \l real \c font.pointSize
    \li \l int \c font.pixelSize
    \endlist

    If both \c pointSize and a \c pixelSize are specified, \c pixelSize will be used.

    The following properties are also available:

    \list
    \li \l enumeration \c font.weight
    \li \l bool \c font.overline
    \li \l bool \c font.strikeout
    \li \l enumeration \c font.capitalization
    \li \l real \c font.letterSpacing
    \li \l real \c font.wordSpacing
    \li \l bool \c font.kerning
    \li \l bool \c font.preferShaping
    \li \l enumeration \c font.hintingPreference
    \li \c object \l [QML] {QtQuick::Text::}{font.features}
    \li \l string \c font.styleName
    \li \c object \c [QML] {QtQuick::Text::}{font.variableAxes}
    \li \l bool \c font.contextFontMerging
    \li \l bool \c font.preferTypoLineMetrics
    \endlist

    Example:

    \snippet qml/font.qml text

    As \c font is a \l {QML_STRUCTURED_VALUE}{structured value} type, it can
    also be constructed with a JavaScript object:

    \snippet qml/font.qml structured-value-construction

    When integrating with C++, note that any QFont value
    \l{qtqml-cppintegration-data.html}{passed into QML from C++} is automatically
    converted into a \c font value, and vice-versa.

    This value type is provided by the QtQuick import.

    Numerical values for font weights follow the CSS specification, where a
    weight of 100 is extremely light, and 900 is extremely bold.
    The following values are supported:

    \value Font.Thin        100
    \value Font.ExtraLight  200
    \value Font.Light       300
    \value Font.Normal      400
    \value Font.Medium      500
    \value Font.DemiBold    600
    \value Font.Bold        700
    \value Font.ExtraBold   800
    \value Font.Black       900

    Capitalization supports the following values:

    \value Font.MixedCase       No capitalization change is applied.
    \value Font.AllUppercase    Alters the text to be rendered in all uppercase type.
    \value Font.AllLowercase    Alters the text to be rendered in all lowercase type.
    \value Font.SmallCaps       Alters the text to be rendered in small-caps type.
    \value Font.Capitalize      Alters the text to be rendered with the first character of each word as an uppercase character.

    Setting the hinting preference only has an effect when using the "NativeRendering" render type.
    The property supports the following values:

    \value Font.PreferDefaultHinting    Use the default hinting level for the target platform.
    \value Font.PreferNoHinting         If possible, render text without hinting the outlines of the glyphs.
    \value Font.PreferVerticalHinting   If possible, render text with no horizontal hinting,
                                        but align glyphs to the pixel grid in the vertical direction.
    \value Font.PreferFullHinting       If possible, render text with hinting in both horizontal and vertical directions.

    \sa {QML Value Types}
*/

/*!
    \qmlvaluetype vector2d
    \ingroup qtquickvaluetypes

    \brief A vector2d type has x and y attributes.

    A \c vector2d type has \c x and \c y attributes, otherwise
    it is similar to the \c vector3d type.

    Properties of type \c vector2d have a zero vector as their default value.
    This has both \c x and \c y set to \c 0.

    See the documentation about the \c vector3d type for more information.

    To create a \c vector2d value, specify it as a "x,y" string,
    or define the components individually, or compose it with
    the Qt.vector2d() function.

    The vector2d type has the following idempotent functions which can be
    invoked in QML:
    \table 60%
        \header
        \li Function Signature
        \li Description
        \li Example

        \row
        \li real dotProduct(vector2d other)
        \li Returns the scalar real result of the dot product of \c this vector2d with the \c other vector2d
        \li \code
var a = Qt.vector2d(1,2);
var b = Qt.vector2d(3,4);
var c = a.dotProduct(b);
console.log(c); // 11
            \endcode

        \row
        \li vector2d times(vector2d other)
        \li Returns the vector2d result of multiplying \c this vector2d with the \c other vector2d
        \li \code
var a = Qt.vector2d(1,2);
var b = Qt.vector2d(3,4);
var c = a.times(b);
console.log(c.toString()); // QVector2D(3, 8)
            \endcode

        \row
        \li vector2d times(real factor)
        \li Returns the vector2d result of multiplying \c this vector2d with the scalar \c factor
        \li \code
var a = Qt.vector2d(1,2);
var b = 4.48;
var c = a.times(b);
console.log(c.toString()); // QVector2D(4.48, 8.96)
            \endcode

        \row
        \li vector2d plus(vector2d other)
        \li Returns the vector2d result of the addition of \c this vector2d with the \c other vector2d
        \li \code
var a = Qt.vector2d(1,2);
var b = Qt.vector2d(3,4);
var c = a.plus(b);
console.log(c.toString()); // QVector2D(4, 6)
            \endcode

        \row
        \li vector2d minus(vector2d other)
        \li Returns the vector2d result of the subtraction of \c other vector2d from \c this vector2d
        \li \code
var a = Qt.vector2d(1,2);
var b = Qt.vector2d(3,4);
var c = a.minus(b);
console.log(c.toString()); // QVector2D(-2, -2)
            \endcode

        \row
        \li vector2d normalized()
        \li Returns the normalized form of \c this vector
        \li \code
var a = Qt.vector2d(1,2);
var b = a.normalized();
console.log(b.toString()); // QVector2D(0.447214, 0.894427)
            \endcode

        \row
        \li real length()
        \li Returns the scalar real value of the length of \c this vector2d
        \li \code
var a = Qt.vector2d(1,2);
var b = a.length();
console.log(b.toString()); // 2.23606797749979
            \endcode

        \row
        \li vector3d toVector3d()
        \li Returns the vector3d result of converting \c this vector2d to a vector3d
        \li \code
var a = Qt.vector2d(1,2);
var b = a.toVector3d();
console.log(b.toString()); // QVector3D(1, 2, 0)
            \endcode

        \row
        \li vector4d toVector4d()
        \li Returns the vector4d result of converting \c this vector2d to a vector4d
        \li \code
var a = Qt.vector2d(1,2);
var b = a.toVector4d();
console.log(b.toString()); // QVector4D(1, 2, 0, 0)
            \endcode

        \row
        \li bool fuzzyEquals(vector2d other, real epsilon)
        \li Returns true if \c this vector2d is approximately equal to the \c other vector2d.
            The approximation will be true if each attribute of \c this is within \c epsilon
            of \c other.  Note that \c epsilon is an optional argument, the default \c epsilon
            is 0.00001.
        \li \code
var a = Qt.vector2d(1,2);
var b = Qt.vector2d(1.0001, 1.9998);
var c = a.fuzzyEquals(b);        // default epsilon
var d = a.fuzzyEquals(b, 0.005); // supplied epsilon
console.log(c + " " + d); // false true
            \endcode
\endtable

    This value type is provided by the QtQuick import.

    \sa {QML Value Types}
*/

/*!
    \qmlvaluetype vector3d
    \ingroup qtquickvaluetypes
    \brief a value with x, y, and z attributes.

    The \c vector3d type refers to a value with \c x, \c y, and \c z attributes.

    Properties of type \c vector3d have a zero vector by default. This has
    \c x, \c y and \c z set to \c 0.

    To create a \c vector3d value, specify it as a "x,y,z" string:

    \qml
    Rotation { angle: 60; axis: "0,1,0" }
    \endqml

    or with the \l{QtQml::Qt::vector3d()}{Qt.vector3d()} function:

    \qml
    Rotation { angle: 60; axis: Qt.vector3d(0, 1, 0) }
    \endqml

    or as separate \c x, \c y, and \c z components:

    \qml
    Rotation { angle: 60; axis.x: 0; axis.y: 1; axis.z: 0 }
    \endqml

    Each attribute of a vector3d value is stored internally as a
    single-precision floating point number (\c float).

    When integrating with C++, note that any QVector3D value
    \l{qtqml-cppintegration-data.html}{passed into QML from C++} is automatically
    converted into a \c vector3d value, and vice-versa.

    The vector3d type has the following idempotent functions which can be
    invoked in QML:
    \table
        \header
        \li Function Signature
        \li Description
        \li Example

        \row
        \li vector3d crossProduct(vector3d other)
        \li Returns the vector3d result of the cross product of \c this vector3d with the \c other vector3d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.vector3d(4,5,6);
var c = a.crossProduct(b);
console.log(c.toString()); // QVector3D(-3, 6, -3)
            \endcode

        \row
        \li real dotProduct(vector3d other)
        \li Returns the scalar real result of the dot product of \c this vector3d with the \c other vector3d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.vector3d(4,5,6);
var c = a.dotProduct(b);
console.log(c); // 32
            \endcode

        \row
        \li vector3d times(matrix4x4 matrix)
        \li Returns the vector3d result of transforming \c this vector3d with
            the 4x4 \c matrix with the matrix applied post-vector
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.matrix4x4(4,5,6,7,8,9,10,11,
                     12,13,14,15,16,17,18,19);
var c = a.times(b);
console.log(c.toString());
// QVector3D(0.774194, 0.849462, 0.924731)
            \endcode

        \row
        \li vector3d times(vector3d other)
        \li Returns the vector3d result of multiplying \c this vector3d with the \c other vector3d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.vector3d(4,5,6);
var c = a.times(b);
console.log(c.toString()); // QVector3D(4, 10, 18)
            \endcode

        \row
        \li vector3d times(real factor)
        \li Returns the vector3d result of multiplying \c this vector3d with the scalar \c factor
        \li \code
var a = Qt.vector3d(1,2,3);
var b = 4.48;
var c = a.times(b);
console.log(c.toString()); // QVector3D(4.48, 8.96, 13.44)
            \endcode

        \row
        \li vector3d plus(vector3d other)
        \li Returns the vector3d result of the addition of \c this vector3d with the \c other vector3d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.vector3d(4,5,6);
var c = a.plus(b);
console.log(c.toString()); // QVector3D(5, 7, 9)
            \endcode

        \row
        \li vector3d minus(vector3d other)
        \li Returns the vector3d result of the subtraction of \c other vector3d from \c this vector3d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.vector3d(4,5,6);
var c = a.minus(b);
console.log(c.toString()); // QVector3D(-3, -3, -3)
            \endcode

        \row
        \li vector3d normalized()
        \li Returns the normalized form of \c this vector
        \li \code
var a = Qt.vector3d(1,2,3);
var b = a.normalized();
console.log(b.toString());
// QVector3D(0.267261, 0.534522, 0.801784)
            \endcode

        \row
        \li real length()
        \li Returns the scalar real value of the length of \c this vector3d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = a.length();
console.log(b.toString()); // 3.7416573867739413
            \endcode

        \row
        \li vector2d toVector2d()
        \li Returns the vector2d result of converting \c this vector3d to a vector2d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = a.toVector2d();
console.log(b.toString()); // QVector2D(1, 2)
            \endcode

        \row
        \li vector4d toVector4d()
        \li Returns the vector4d result of converting \c this vector3d to a vector4d
        \li \code
var a = Qt.vector3d(1,2,3);
var b = a.toVector4d();
console.log(b.toString()); // QVector4D(1, 2, 3, 0)
            \endcode

        \row
        \li bool fuzzyEquals(vector3d other, real epsilon)
        \li Returns true if \c this vector3d is approximately equal to the \c other vector3d.
            The approximation will be true if each attribute of \c this is within \c epsilon
            of \c other.
            Note that \c epsilon is an optional argument, the default \c epsilon
            is 0.00001.
        \li \code
var a = Qt.vector3d(1,2,3);
var b = Qt.vector3d(1.0001, 1.9998, 2.0001);
var c = a.fuzzyEquals(b);        // default epsilon
var d = a.fuzzyEquals(b, 0.005); // supplied epsilon
console.log(c + " " + d); // false true
            \endcode
\endtable

    This value type is provided by the QtQuick import.

    \sa {QML Value Types}
*/

/*!
    \qmlvaluetype vector4d
    \ingroup qtquickvaluetypes

    \brief A vector4d type has x, y, z and w attributes.

    A \c vector4d type has \c x, \c y, \c z and \c w attributes,
    otherwise it is similar to the \c vector3d type.

    Properties of type \c vector4d have a zero vector by default. This has
    \c x, \c y ,\c z and \c w set to \c 0.

    See the documentation about the \c vector3d type for more information.

    To create a \c vector4d value, specify it as a "x,y,z,w" string,
    or define the components individually, or compose it with
    the Qt.vector4d() function.

    The vector4d type has the following idempotent functions which can be
    invoked in QML:
    \table
        \header
        \li Function Signature
        \li Description
        \li Example

        \row
        \li real dotProduct(vector4d other)
        \li Returns the scalar real result of the dot product of \c this vector4d with the \c other vector4d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = Qt.vector4d(5,6,7,8);
var c = a.dotProduct(b);
console.log(c); // 70
            \endcode

        \row
        \li vector4d times(matrix4x4 matrix)
        \li Returns the vector4d result of transforming \c this vector4d with
            the 4x4 \c matrix with the matrix applied post-vector
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = Qt.matrix4x4(4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
var c = a.times(b);
console.log(c.toString()); // QVector4D(120, 130, 140, 150)
            \endcode

        \row
        \li vector4d times(vector4d other)
        \li Returns the vector4d result of multiplying \c this vector4d with the \c other vector4d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = Qt.vector4d(5,6,7,8);
var c = a.times(b);
console.log(c.toString()); // QVector4D(5, 12, 21, 32)
            \endcode

        \row
        \li vector4d times(real factor)
        \li Returns the vector4d result of multiplying \c this vector4d with the scalar \c factor
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = 4.48;
var c = a.times(b);
console.log(c.toString()); // QVector3D(4.48, 8.96,
                                        13.44, 17.92)
            \endcode

        \row
        \li vector4d plus(vector4d other)
        \li Returns the vector4d result of the addition of \c this vector4d with the \c other vector4d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = Qt.vector4d(5,6,7,8);
var c = a.plus(b);
console.log(c.toString()); // QVector4D(6, 8, 10, 12)
            \endcode

        \row
        \li vector4d minus(vector4d other)
        \li Returns the vector4d result of the subtraction of \c other vector4d from \c this vector4d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = Qt.vector4d(5,6,7,8);
var c = a.minus(b);
console.log(c.toString()); // QVector4D(-4, -4, -4, -4)
            \endcode

        \row
        \li vector4d normalized()
        \li Returns the normalized form of \c this vector
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = a.normalized();
console.log(b.toString());
// QVector4D(0.182574, 0.365148, 0.547723, 0.730297)
            \endcode

        \row
        \li real length()
        \li Returns the scalar real value of the length of \c this vector3d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = a.length();
console.log(b.toString()); // 5.477225575051661
            \endcode

        \row
        \li vector2d toVector2d()
        \li Returns the vector2d result of converting \c this vector4d to a vector2d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = a.toVector2d();
console.log(b.toString()); // QVector2D(1, 2)
            \endcode

        \row
        \li vector3d toVector3d()
        \li Returns the vector3d result of converting \c this vector4d to a vector3d
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = a.toVector3d();
console.log(b.toString()); // QVector3D(1, 2, 3)
            \endcode

        \row
        \li bool fuzzyEquals(vector4d other, real epsilon)
        \li Returns true if \c this vector4d is approximately equal to the \c other vector4d.
            The approximation will be true if each attribute of \c this is within \c epsilon
            of \c other.  Note that \c epsilon is an optional argument, the default \c epsilon
            is 0.00001.
        \li \code
var a = Qt.vector4d(1,2,3,4);
var b = Qt.vector4d(1.0001, 1.9998, 2.0001, 3.9999);
var c = a.fuzzyEquals(b);        // default epsilon
var d = a.fuzzyEquals(b, 0.005); // supplied epsilon
console.log(c + " " + d); // false true
            \endcode
\endtable

    This value type is provided by the QtQuick import.

    \sa {QML Value Types}
*/

/*!
    \qmlvaluetype quaternion
    \ingroup qtquickvaluetypes

    \brief A quaternion type has scalar, x, y, and z attributes.

    A \c quaternion type has \c scalar, \c x, \c y and \c z attributes.

    To create a \c quaternion value, specify it as a "scalar,x,y,z" string,
    or define the components individually, or compose it with
    the Qt.quaternion() function.

    The quaternion type has the following idempotent functions which can be
    invoked in QML:
    \table
        \header
        \li Function Signature
        \li Description
        \li Example

        \row
        \li real dotProduct(quaternion other)
        \li Returns the scalar real result of the dot product of \c this quaternion with
            the \c other quaternion
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = Qt.quaternion(5,6,7,8);
var c = a.dotProduct(b);
console.log(c); // 70
            \endcode

        \row
        \li quaternion times(quaternion other)
        \li Returns the quaternion result of multiplying \c this quaternion with
            the \c other quaternion, which corresponds to applying both of the rotations
        \li \code
var a = Qt.quaternion(1 / Math.sqrt(2), 1 / Math.sqrt(2), 0, 0);
var b = Qt.quaternion(1 / Math.sqrt(2), 0, 1 / Math.sqrt(2), 0);
var c = b.times(a);
console.log(c.toString()); // QQuaternion(0.5, 0.5, 0.5, -0.5)
            \endcode

        \row
        \li vector3d times(vector3d vector)
        \li Returns the vector3d result of rotating the \c vector with \c this quaternion
        \li \code
var a = Qt.quaternion(0.5,0.5,0.5,-0.5);
var b = Qt.vector3d(4,5,6);
var c = a.times(b);
console.log(c.toString()); // QVector3D(5, -6, -4)
            \endcode

        \row
        \li quaternion times(real factor)
        \li Returns the quaternion result of multiplying \c this quaternion with the scalar
            \c factor
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = 4.48;
var c = a.times(b);
console.log(c.toString()); // QQuaternion(4.48, 8.96, 13.44, 17.92)
            \endcode

        \row
        \li quaternion plus(quaternion other)
        \li Returns the quaternion result of the addition of \c this quaternion with
            the \c other quaternion
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = Qt.quaternion(5,6,7,8);
var c = a.plus(b);
console.log(c.toString()); // QQuaternion(6, 8, 10, 12)
            \endcode

        \row
        \li quaternion minus(quaternion other)
        \li Returns the quaternion result of the subtraction of \c other quaternion
            from \c this quaternion
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = Qt.quaternion(5,6,7,8);
var c = a.minus(b);
console.log(c.toString()); // QQuaternion(-4, -4, -4, -4)
            \endcode

        \row
        \li quaternion normalized()
        \li Returns the normalized unit form of \c this quaternion
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = a.normalized();
console.log(b.toString()); // QQuaternion(0.182574, 0.365148, 0.547723, 0.730297)
            \endcode

        \row
        \li quaternion inverted()
        \li Returns the inverse of \c this quaternion
        \li \code
var a = Qt.quaternion(0.5,0.5,0.5,-0.5);
var b = a.inverted();
console.log(b.toString()); // QQuaternion(0.5, -0.5, -0.5, 0.5)
            \endcode

        \row
        \li quaternion conjugated()
        \li Returns the conjugate of \c this quaternion
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = a.conjugated()
console.log(b.toString()); // QQuaternion(1, -2, -3, -4)
            \endcode

        \row
        \li real length()
        \li Returns the scalar real value of the length of \c this quaternion
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = a.length();
console.log(b.toString()); // 5.477225575051661
            \endcode

        \row
        \li vector3d toEulerAngles()
        \li Returns the vector3d Euler angles (in degrees) that corresponds to \c this quaternion
        \li \code
var a = Qt.quaternion(0.933012,0.25,-0.25,0.066987);
var b = a.toEulerAngles();
console.log(b.toString()); // QVector3D(30, -30, -4.28846e-05)
            \endcode

        \row
        \li vector4d toVector4d()
        \li Returns the vector4d result of converting \c this quaternion to a vector4d
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = a.toVector4d();
console.log(b.toString()); // QVector4D(2, 3, 4, 1)
            \endcode

        \row
        \li bool fuzzyEquals(quaternion other, real epsilon)
        \li Returns true if \c this quaternion is approximately equal to the \c other quaternion.
            The approximation will be true if each attribute of \c this is within \c epsilon
            of \c other.
            Note that \c epsilon is an optional argument, the default \c epsilon
            is 0.00001.
        \li \code
var a = Qt.quaternion(1,2,3,4);
var b = Qt.quaternion(1.0001, 1.9998, 2.0001, 3.9999);
var c = a.fuzzyEquals(b);        // default epsilon
var d = a.fuzzyEquals(b, 0.005); // supplied epsilon
console.log(c + " " + d); // false true
            \endcode
    \endtable

    Properties of type \c quaternion have \c {Qt.quaternion(1, 0, 0, 0)} as their
    default value.

    This value type is provided by the QtQuick import.

    \sa {QML Value Types}
*/

/*!
    \qmlvaluetype matrix4x4
    \ingroup qtquickvaluetypes

    \brief A matrix4x4 type is a 4-row and 4-column matrix.

    A \c matrix4x4 type has sixteen values, each accessible via the properties
    \c m11 through \c m44 in QML (in row/column order). Values of this type can
    be composed with the Qt.matrix4x4() function. Each attribute in a matrix4x4
    is stored as a real (single-precision on ARM, double-precision on x86).

    A property of type \c matrix4x4 defaults to the identity matrix, whose
    diagonal entries \c m11, \c m22, \c m33 and \c m44 are all \c 1, with all
    other components \c 0.

    The matrix4x4 type has the following idempotent functions which can be
    invoked in QML:
    \table 70 %
        \header
        \li Function Signature
        \li Description
        \li Example

        \row
        \li translate(vector3d vector)
        \li Multiplies \c this matrix4x4 by another that translates coordinates by the components
            of \c vector
        \li \code
var m = Qt.matrix4x4();
m.translate(Qt.vector3d(1,2,3));
console.log(m.toString());
// QMatrix4x4(1, 0, 0, 1, 0, 1, 0, 2, 0, 0, 1, 3, 0, 0, 0, 1)
            \endcode

        \row
        \li rotate(real angle, vector3d axis)
        \li Multiples \c this matrix4x4 by another that rotates coordinates through
            \c angle degrees about \c axis
        \li \code
var m = Qt.matrix4x4();
m.rotate(180,Qt.vector3d(1,0,0));
console.log(m.toString());
// QMatrix4x4(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1)
            \endcode

        \row
        \li rotate(quaternion quaternion)
        \li Multiples \c this matrix4x4 by another that rotates coordinates according to
            a specified \c quaternion. The \c quaternion is assumed to have been normalized.
        \li \code
var m = Qt.matrix4x4();
m.rotate(Qt.quaternion(0.5,0.5,0.5,-0.5));
console.log(m.toString());
// QMatrix4x4(0, 1, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 1)
            \endcode

        \row
        \li scale(real factor)
        \li Multiplies \c this matrix4x4 by another that scales coordinates by the given \c factor
        \li \code
var m = Qt.matrix4x4();
m.scale(2);
console.log(m.toString());
// QMatrix4x4(2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1)
            \endcode

        \row
        \li scale(real x, real y, real z)
        \li Multiplies \c this matrix4x4 by another that scales coordinates by the components
            \c x, \c y, and \c z
        \li \code
var m = Qt.matrix4x4();
m.scale(1,2,3);
console.log(m.toString());
// QMatrix4x4(1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1)
            \endcode

        \row
        \li scale(vector3d vector)
        \li Multiplies \c this matrix4x4 by another that scales coordinates by the components
            of \c vector
        \li \code
var m = Qt.matrix4x4();
m.scale(Qt.vector3d(1,2,3));
console.log(m.toString());
// QMatrix4x4(1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1)
            \endcode

        \row
        \li lookAt(vector3d eye, vector3d center, vector3d up)
        \li Multiplies \c this matrix4x4 by a viewing matrix derived from an \c eye point.
            The \c center vector3d indicates the center of the view that the \c eye is looking at.
            The \c up vector3d indicates which direction should be considered up with respect to
            the \c eye.
        \li \code
var m = Qt.matrix4x4();
m.lookAt(Qt.vector3d(1,2,3),Qt.vector3d(1,2,0),Qt.vector3d(0,1,0));
console.log(m.toString());
// QMatrix4x4(1, 0, 0, -1, 0, 1, 0, -2, 0, 0, 1, -3, 0, 0, 0, 1)
            \endcode

        \row
        \li matrix4x4 times(matrix4x4 other)
        \li Returns the matrix4x4 result of multiplying \c this matrix4x4 with
            the \c other matrix4x4
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.matrix4x4(4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
var c = a.times(b);
console.log(c.toString());
// QMatrix4x4(120, 130, 140, 150, 280, 306, 332, 358, 440, 482,
//524, 566, 600, 658, 716, 774)
            \endcode

        \row
        \li vector4d times(vector4d vector)
        \li Returns the vector4d result of transforming the \c vector
            according to \c this matrix4x4 with the matrix applied
            pre-vector
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.vector4d(5,6,7,8);
var c = a.times(b);
console.log(c.toString()); // QVector4D(70, 174, 278, 382)
            \endcode

        \row
        \li vector3d times(vector3d vector)
        \li Returns the vector3d result of transforming the \c vector
            according to \c this matrix4x4 with the matrix applied
            pre-vector
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.vector3d(5,6,7);
var c = a.times(b);
console.log(c.toString()); // QVector3D(0.155556, 0.437037, 0.718518)
            \endcode

        \row
        \li matrix4x4 times(real factor)
        \li Returns the matrix4x4 result of multiplying \c this matrix4x4 with the scalar \c factor
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = 4.48;
var c = a.times(b);
console.log(c.toString());
// QMatrix4x4(4.48, 8.96, 13.44, 17.92, 22.4, 26.88, 31.36, 35.84,
// 40.32, 44.8, 49.28, 53.76, 58.24, 62.72, 67.2, 71.68)
            \endcode

        \row
        \li matrix4x4 plus(matrix4x4 other)
        \li Returns the matrix4x4 result of the addition of \c this matrix4x4 with the \c other matrix4x4
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.matrix4x4(5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
var c = a.plus(b);
console.log(c.toString());
// QMatrix4x4(6, 8, 10, 12, 14, 16, 18, 20, 22,
// 24, 26, 28, 30, 32, 34, 36)
            \endcode

        \row
        \li matrix4x4 minus(matrix4x4 other)
        \li Returns the matrix4x4 result of the subtraction of \c other matrix4x4 from \c this matrix4x4
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.matrix4x4(5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
var c = a.minus(b);
console.log(c.toString());
// QMatrix4x4(-4, -4, -4, -4, -4, -4, -4, -4, -4,
// -4, -4, -4, -4, -4, -4, -4)
            \endcode

        \row
        \li vector4d row(int which)
        \li Returns the vector4d row of \c this specified by \c which.
            Note: the \c which is 0-based access into the matrix.
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.vector4d(a.m21, a.m22, a.m23, a.m24);
var c = a.row(2); // zero based access!  so not equal to b
console.log(b.toString() + " " + c.toString());
// QVector4D(5, 6, 7, 8) QVector4D(9, 10, 11, 12)
            \endcode

        \row
        \li vector4d column(int which)
        \li Returns the vector4d column of \c this specified by \c which.
            Note: the \c which is 0-based access into the matrix.
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.vector4d(a.m12, a.m22, a.m32, a.m42);
var c = a.column(2); // zero based access!  so not equal to b
console.log(b.toString() + " " + c.toString());
// QVector4D(2, 6, 10, 14) QVector4D(3, 7, 11, 15)
            \endcode

        \row
        \li real determinant()
        \li Returns the determinant of \c this matrix4x4
        \li \code
var a = Qt.matrix4x4(1,0,0,0,0,2,0,0,0,0,3,0,100,200,300,1);
var b = a.determinant();
console.log(b); // 6
            \endcode

        \row
        \li matrix4x4 inverted()
        \li Returns the inverse of \c this matrix4x4 if it exists, else the identity matrix.
        \li \code
var a = Qt.matrix4x4(1,0,0,0,0,2,0,0,0,0,3,0,100,200,300,1);
var b = a.inverted();
console.log(b.toString());
// QMatrix4x4(1, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 0.333333, 0, -100,
// -100, -100, 1)
            \endcode

        \row
        \li matrix4x4 transposed()
        \li Returns the transpose of \c this matrix4x4
        \li \code
var a = Qt.matrix4x4(1,0,0,0,0,2,0,0,0,0,3,0,100,200,300,1);
var b = a.transposed();
console.log(b.toString());
// QMatrix4x4(1, 0, 0, 100, 0, 2, 0, 200, 0, 0, 3, 300, 0, 0, 0, 1)
            \endcode

        \row
        \li rect mapRect(rect)
        \li Maps the provided rectangle into the coordinate system defined by this matrix.
            If rotation or shearing has been specified, this function returns the bounding rectangle.
            This function was introduced in Qt 6.5.
        \li \code
var a = Qt.matrix4x4(2,0,0,0,0,2,0,0,0,0,1,0,0,0,0,1);
var b = a.mapRect(Qt.rect(10, 20, 30, 40));
console.log(b.toString());
// Qt.rect(20, 40, 60, 80)
            \endcode

        \row
        \li point map(point)
        \li Maps the provided point into the coordinate system defined by this matrix.
            This function was introduced in Qt 6.5.
        \li \code
var a = Qt.matrix4x4(2,0,0,0,0,2,0,0,0,0,1,0,0,0,0,1);
var b = a.map(10, 20);
console.log(b.toString());
// Qt.point(20, 40)
            \endcode

        \row
        \li bool fuzzyEquals(matrix4x4 other, real epsilon)
        \li Returns true if \c this matrix4x4 is approximately equal to the \c other matrix4x4.
            The approximation will be true if each attribute of \c this is within \c epsilon
            of the respective attribute of \c other.  Note that \c epsilon is an optional
            argument, the default \c epsilon is 0.00001.
        \li \code
var a = Qt.matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16);
var b = Qt.matrix4x4(1.0001,2.0001,3.0002,4.0003,5.0001,6.0002,
                     7.0002,8.0004, 9.0001,10.0003,
                     11.0003,12.0004,13.0001,
                     14.0002,15.0003,16.0004);
var c = a.fuzzyEquals(b);        // default epsilon
var d = a.fuzzyEquals(b, 0.005); // supplied epsilon
console.log(c + " " + d); // false true
            \endcode
\endtable

    This value type is provided by the QtQuick import.

    \sa {QML Value Types}
*/
