1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** GNU Free Documentation License
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of
** this file.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms
** and conditions contained in a signed written agreement between you
** and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
/*!
\page qmlruntime.html
\title Qt Declarative UI Runtime
QML documents are loaded and executed by the QML runtime. This includes the
Declarative UI engine along with the built-in QML elements and plugin modules,
and it also provides access to third-party QML elements and modules.
Applications that use QML need to invoke the QML runtime in order to
execute QML documents. This can be done by creating a QDeclarativeView
or a QDeclarativeEngine, as described below. In addition, the Declarative UI
package includes the \QQV tool, which loads \c .qml files. This tool is
useful for developing and testing QML code without the need to write
a C++ application to load the QML runtime.
\section1 Deploying QML-based applications
To deploy an application that uses QML, the QML runtime must be invoked by
the application. This is done by writing a Qt C++ application that loads the
QDeclarativeEngine by either:
\list
\li Loading the QML file through a QDeclarativeView instance, or
\li Creating a QDeclarativeEngine instance and loading QML files with QDeclarativeComponent
\endlist
\section2 Deploying with QDeclarativeView
QDeclarativeView is a QWidget-based class that is able to load QML files.
For example, if there is a QML file, \c application.qml, like this:
\qml
import QtQuick 1.0
Rectangle { width: 100; height: 100; color: "red" }
\endqml
It can be loaded in a Qt application's \c main.cpp file like this:
\code
#include <QApplication>
#include <QDeclarativeView>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QDeclarativeView view;
view.setSource(QUrl::fromLocalFile("application.qml"));
view.show();
return app.exec();
}
\endcode
This creates a QWidget-based view that displays the contents of
\c application.qml.
The application's \c .pro \l{qmake Project Files}{project file} must specify
the \c declarative module for the \c QT variable. For example:
\code
TEMPLATE += app
QT += gui declarative
SOURCES += main.cpp
\endcode
\section2 Creating a QDeclarativeEngine directly
If \c application.qml does not have any graphical components, or if it is
preferred to avoid QDeclarativeView for other reasons, the QDeclarativeEngine
can be constructed directly instead. In this case, \c application.qml is
loaded as a QDeclarativeComponent instance rather than placed into a view:
\code
#include <QApplication>
#include <QDeclarativeEngine>
#include <QDeclarativeContext>
#include <QDeclarativeComponent>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QDeclarativeEngine engine;
QDeclarativeContext *objectContext = new QDeclarativeContext(engine.rootContext());
QDeclarativeComponent component(&engine, "application.qml");
QObject *object = component.create(objectContext);
// ... delete object and objectContext when necessary
return app.exec();
}
\endcode
See \l {Using QML Bindings in C++ Applications} for more information about using
QDeclarativeEngine, QDeclarativeContext and QDeclarativeComponent, as well
as details on including QML files through \l{The Qt Resource System}{Qt's Resource system}.
\section1 Developing and prototyping with QML Viewer
The Declarative UI package includes a QML runtime tool, the \QQV, which loads
and displays QML documents. This is useful during the application development
phase for prototyping QML-based applications without writing your own C++
applications to invoke the QML runtime.
See the \l{QML Viewer} documentation for more details.
*/
|
