-Some guidelines for QtQml examples
+Some guidelines for Qt QML examples
Snippets
---
\brief For specifying a role to an XmlListModel
\ingroup qtquick-models
- \sa {QtQml}
+ \sa {Qt QML}
*/
/*!
QML, or enabling a singleton instance of the class to be imported and used
from QML.
-Additionally, the QtQml module provides mechanisms for implementing QML-specific
+Additionally, the \l {Qt QML} module provides mechanisms for implementing QML-specific
features such as \e{attached properties} and \e{default properties} in C++.
(Note that a number of the important concepts covered in this document are
should not be instantiable from QML
\endlist
-The QtQml module provides several methods for registering non-instantiable
+The \l {Qt QML} module provides several methods for registering non-instantiable
types:
\list
initialization is costly, or if the initialization should not be performed until
all property values have been initialized.
-The QtQml module provides the QQmlParserStatus to be subclass for these
+The \l {Qt QML} module provides the QQmlParserStatus to be subclass for these
purposes. It defines a number of virtual methods that are invoked invoked at
various stages during component instantiation. To receive these notifications, a
C++ class should inherit QQmlParserStatus and also notify the Qt meta system
\title Writing QML Extensions with C++
\brief tutorial about extending QML with Qt C++
-The QtQml C++ module provides a set of APIs for extending QML through
+The \l Qt QML} C++ module provides a set of APIs for extending QML through
C++ extensions. You can write extensions to add your own QML types, extend existing
Qt types, or call C/C++ functions that are not accessible from ordinary QML code.
\title Integrating QML and C++
\brief Description of how to integrate QML and C++ code
-QML is designed to be easily extensible through C++ code. The classes in the QtQml C++ module
+QML is designed to be easily extensible through C++ code. The classes in the \l {Qt QML} C++ module
enables QML objects to be loaded and manipulated from C++, and the nature of QML engine's
integration with Qt's \l{Meta Object System}{meta object system} enables C++ functionality to be
invoked directly from QML. This allows the development of hybrid applications which are implemented
C++
\li Use and invoke some C++ functionality from QML (for example, to invoke your application logic,
use a data model implemented in C++, or call some functions in a third-party C++ library)
-\li Access functionality in the QtQml or QtQuick C++ API (for example, to dynamically generate
+\li Access functionality in the \l {Qt QML} or QtQuick C++ API (for example, to dynamically generate
images using QQuickImageProvider)
\li Implement your own \l{qtqml-typesystem-objecttypes.html}{QML object types} from C++
\unicode{0x2014} whether for use within your own specific application, or for distribution to others
These are the most common methods of accessing C++ functionality from QML code; for more options and
details, see the main documentation pages that are described in the sections further below.
-Additionally, aside from the ability to access C++ functionality from QML, the Qt QML module also
+Additionally, aside from the ability to access C++ functionality from QML, the \l {Qt QML} module also
provides ways to do the reverse and manipulate QML objects from C++ code. See
\l{qtqml-cppintegration-interactqmlfromcpp.html}{Interacting with QML Objects from C++} for more
details.
single class instance to be imported by QML code, or it could be registered to enable the
enumeration values of a non-instantiable class to be accessible from QML.
-Additionally, the QtQml module provides mechanisms to define QML types that integrate with QML
+Additionally, the \l {Qt QML} module provides mechanisms to define QML types that integrate with QML
concepts like attached properties and default properties.
For more information on registering and creating custom QML types from C++, see the \l
C++ objects and values can be embedded directly into the context (or \e scope) of loaded QML objects
using \e {context properties} and \e {context objects}. This is achieved through the QQmlContext
-class provided by the QtQml module, which exposes data to the context of a QML component, allowing
+class provided by the \l {Qt QML} module, which exposes data to the context of a QML component, allowing
data to be injected from C++ into QML.
See \l{qtqml-cppintegration-contextproperties.html}{Embedding C++ Objects into QML with Context
implements the QML language supporting infrastructure.
(Prior to Qt 5, this functionality was provided by the QtDeclarative module, which
-has now been replaced by the new QtQml and QtQuick C++ modules. See the
+has now been replaced by the new \l {Qt QML} and QtQuick C++ modules. See the
\l {Porting QML Applications to Qt 5} for more information.)
\section2 QML Engine
}
\endqml
- \sa QtQml
+ \sa {Qt QML}
*/
/*!
If the binding target or binding property is changed, the bound value is
immediately pushed onto the new target.
- \sa QtQml
+ \sa {Qt QML}
*/
QQmlBind::QQmlBind(QObject *parent)
: QObject(*(new QQmlBindPrivate), parent)
}
\endqml
- \sa QtQml
+ \sa {Qt QML}
*/
QQmlConnections::QQmlConnections(QObject *parent) :
QObject(*(new QQmlConnectionsPrivate), parent)
handler. You must call sync() or else the changes made to the list from the external
thread will not be reflected in the list model in the main thread.
- \sa {qml-data-models}{Data Models}, {declarative/threading/threadedlistmodel}{Threaded ListModel example}, QtQml
+ \sa {qml-data-models}{Data Models}, {declarative/threading/threadedlistmodel}{Threaded ListModel example}, {Qt QML}
*/
QQmlListModel::QQmlListModel(QObject *parent)
\snippet quick/views/package/view.qml 0
- \sa {quick/views/package}{Package example}, {quick/demos/photoviewer}{Photo Viewer example}, QtQml
+ \sa {quick/views/package}{Package example}, {quick/demos/photoviewer}{Photo
+ Viewer example}, {Qt QML}
*/
/*!
In Qt 5, all QML applications are rendered with an OpenGL scenegraph architecture rather than the
Graphics View framework used in Qt 4. Due to the scale of this architectural change, the C++ API has
been extensively restructured and the \c QtDeclarative module has been deprecated in favour of two
-new modules: \l QtQml, which implements the QML engine and language infrastructure, and \l QtQuick,
+new modules: \l {Qt QML}, which implements the QML engine and language infrastructure, and \l QtQuick,
which implements the visual canvas and scenegraph backend.
-All classes that were previously in the \c QtDeclarative module have been moved into the \l QtQml
+All classes that were previously in the \c QtDeclarative module have been moved into the \l {Qt QML}
and \l QtQuick modules, and their class names have been changed to reflect their new module
locations. The class name changes are as follows:
\table
\header
- \li QtQml
+ \li Qt QML
\li QtQuick
\row
\li
\endlist
\endtable
-To use the new \c QtQml* and \c QtQuick* classes in Qt 5, link against the approprate module from
-your qmake \c .pro file. For example the following will link against both the QtQml and QtQuick
+To use the new \c QQml* and \c QtQuick* classes in Qt 5, link against the approprate module from
+your qmake \c .pro file. For example the following will link against both the \l {Qt QML} and QtQuick
modules:
\code
For the purposes of porting older applications, the \c QtDeclarative module is still available in Qt
5 but has been renamed to \c QtQuick1. Applications that required QtQuick 1 specific API (e.g.
QDeclarativeView or QDeclarativeItem and the Graphics View integration) can use this module. Note
-that new applications should use the new \l QtQml and \l QtQuick modules instead.
+that new applications should use the new \l {Qt QML} and \l QtQuick modules instead.
To use the \c QtQuick1 module, add “quick1” module to your qmake \c .pro file:
PropertyAction object) so that the rotation animation begins with the
correct transform origin.
- \sa {Animation and Transitions in Qt Quick}, QtQml
+ \sa {Animation and Transitions in Qt Quick}, {Qt QML}
*/
QQuickPropertyAction::QQuickPropertyAction(QObject *parent)
: QQuickAbstractAnimation(*(new QQuickPropertyActionPrivate), parent)
state change. For general advice on using Behaviors to animate state changes, see
\l{Using Qt Quick Behaviors with States}.
- \sa {Animation and Transitions in Qt Quick}, {declarative/animation/behaviors}{Behavior example}, QtQml
+ \sa {Animation and Transitions in Qt Quick}, {declarative/animation/behaviors}{Behavior example}, {Qt QML}
*/
See the PropertyAction documentation for more details.
- \sa {declarative/animation/states}{states example}, {Qt Quick States}{Qt Quick States}, QtQml
+ \sa {declarative/animation/states}{states example}, {Qt Quick States}{Qt Quick States}, {Qt QML}
*/
/*!
not allowed.
\sa {declarative/animation/states}{states example}, {Qt Quick States}{Qt Quick States},
- {Animation and Transitions in Qt Quick}{Transitions}, QtQml
+ {Animation and Transitions in Qt Quick}{Transitions}, {Qt QML}
*/
QQuickState::QQuickState(QObject *parent)
: QObject(*(new QQuickStatePrivate), parent)
}
\endqml
- \sa {Qt Quick States}{Qt Quick States}, {Animation and Transitions in Qt Quick}{Transitions}, {QtQml}
+ \sa {Qt Quick States}{Qt Quick States}, {Animation and Transitions in Qt Quick}{Transitions}, {Qt QML}
*/
QQuickStateGroup::QQuickStateGroup(QObject *parent)
\l Behavior, the Transition animation overrides the \l Behavior for that
state change.
- \sa {Animation and Transitions in Qt Quick}, {declarative/animation/states}{states example}, {Qt Quick States}{Qt Quick States}, {QtQml}
+ \sa {Animation and Transitions in Qt Quick}, {declarative/animation/states}{states example}, {Qt Quick States}{Qt Quick States}, {Qt QML}
*/
//ParallelAnimationWrapper allows us to do a "callback" when the animation finishes, rather than connecting
}
/*
-This test runs all the examples in the QtQml UI source tree and ensures
+This test runs all the examples in the Qt QML UI source tree and ensures
that they start and exit cleanly.
Examples are any .qml files under the examples/ directory that start