This file is indexed.

/usr/share/qt5/doc/qtdoc/windows-deployment.html is in qt5-doc-html 5.5.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html>
<html lang="en">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<!-- windows.qdoc -->
  <title>Qt for Windows - Deployment | Qt 5.5 </title>
  <link rel="stylesheet" type="text/css" href="style/offline.css" />
</head>
<body>
<div class="header" id="qtdocheader">
    <div class="main">
    <div class="main-rounded">
        <div class="navigationbar">
        <ul>
<li><a href="index.html">Qt 5.5</a></li>
<li>Qt for Windows - Deployment</li>
<li id="buildversion">Qt 5.5.1 Reference Documentation</li>
    </ul>
    </div>
</div>
<div class="content">
<div class="line">
<div class="content mainContent">
<div class="sidebar">
<div class="toc">
<h3><a name="toc">Contents</a></h3>
<ul>
<li class="level1"><a href="#static-linking">Static Linking</a></li>
<li class="level2"><a href="#linking-the-application-to-the-static-version-of-qt">Linking the Application to the Static Version of Qt</a></li>
<li class="level1"><a href="#shared-libraries">Shared Libraries</a></li>
<li class="level2"><a href="#building-qt-as-a-shared-library">Building Qt as a Shared Library</a></li>
<li class="level2"><a href="#linking-the-application-to-qt-as-a-shared-library">Linking the Application to Qt as a Shared Library</a></li>
<li class="level2"><a href="#creating-the-application-package">Creating the Application Package</a></li>
<li class="level2"><a href="#manifest-files">Manifest files</a></li>
<li class="level2"><a href="#manual-installations-with-visual-studio-2008-and-2010">Manual installations with Visual Studio 2008 and 2010</a></li>
<li class="level1"><a href="#application-dependencies">Application Dependencies</a></li>
<li class="level2"><a href="#additional-libraries">Additional Libraries</a></li>
<li class="level2"><a href="#qt-plugins">Qt Plugins</a></li>
<li class="level1"><a href="#the-windows-deployment-tool">The Windows Deployment Tool</a></li>
</ul>
</div>
<div class="sidebar-content" id="sidebar-content"></div></div>
<h1 class="title">Qt for Windows - Deployment</h1>
<span class="subtitle"></span>
<!-- $$$windows-deployment.html-description -->
<div class="descr"> <a name="details"></a>
<p>This documentation describes deployment issues for <a href="windows-support.html">Windows</a>. We demonstrate the procedures in terms of deploying the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> application that is provided in Qt's examples directory.</p>
<a name="static-linking"></a>
<h2 id="static-linking">Static Linking</h2>
<p>To build static applications, build Qt statically by configuring Qt with <code>-static</code>:</p>
<pre class="cpp">cd C:\path\to\<span class="type"><a href="../qtcore/qt.html">Qt</a></span>
configure <span class="operator">-</span><span class="keyword">static</span> <span class="operator">&lt;</span>any other options you need<span class="operator">&gt;</span></pre>
<p>If you later need to reconfigure and rebuild Qt from the same location, ensure that all traces of the previous configuration are removed by entering the build directory and running <code>nmake distclean</code> or <code>mingw32-make distclean</code> before running <code>configure</code> again.</p>
<a name="linking-the-application-to-the-static-version-of-qt"></a>
<h3 >Linking the Application to the Static Version of Qt</h3>
<p>As an example, this section will build the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> example statically.</p>
<p>Once Qt finishes building, build the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> application. First we must go into the directory that contains the application:</p>
<pre class="cpp">cd examples\tools\plugandpaint</pre>
<p>Run <code>qmake</code> to create a new makefile for the application, and perform a clean build to create the statically linked executable:</p>
<pre class="cpp">nmake clean
qmake <span class="operator">-</span>config release
nmake</pre>
<p>You probably want to link against the release libraries, and you can specify this when invoking <code>qmake</code>. Now, provided that everything compiled and linked without any errors, we should have a <code>plugandpaint.exe</code> file that is ready for deployment. To check that the application has the required libraries, copy the executable to a machine that does not have Qt or any Qt applications installed, and run it on that machine.</p>
<p>Remember that if your application depends on compiler specific libraries, these must still be redistributed along with your application. You can check which libraries your application is linking against by using the <code>depends</code> tool. For more information, read the <a href="windows-deployment.html#application-dependencies">Application Dependencies</a> section.</p>
<p>Since we cannot deploy plugins using the static linking approach, the application we have prepared is incomplete. It will run, but the functionality will be disabled due to the missing plugins. To deploy plugin-based applications we should use the shared library approach.</p>
<a name="shared-libraries"></a>
<h2 id="shared-libraries">Shared Libraries</h2>
<p>We have two challenges when deploying the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> application using the shared libraries approach: The Qt runtime has to be correctly redistributed along with the application executable, and the plugins have to be installed in the correct location on the target system so that the application can find them.</p>
<a name="building-qt-as-a-shared-library"></a>
<h3 >Building Qt as a Shared Library</h3>
<p>For this example, we assume that Qt is installed as a shared library, which is the default when installing Qt, in the <i>C:\path\to\Qt</i> directory.</p>
<a name="linking-the-application-to-qt-as-a-shared-library"></a>
<h3 >Linking the Application to Qt as a Shared Library</h3>
<p>After ensuring that Qt is built as a shared library, we can build the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> application. First, we must go into the directory that contains the application:</p>
<pre class="cpp">cd examples\tools\plugandpaint</pre>
<p>Now run <code>qmake</code> to create a new makefile for the application, and do a clean build to create the dynamically linked executable:</p>
<pre class="cpp">nmake clean
qmake <span class="operator">-</span>config release
nmake</pre>
<p>This builds the core application, the following will build the plugins:</p>
<pre class="cpp">cd <span class="operator">.</span><span class="operator">.</span>\plugandpaintplugins
nmake clean
qmake <span class="operator">-</span>config release
nmake</pre>
<p>If everything compiled and linked without any errors, we will get a <code>plugandpaint.exe</code> executable and the <code>pnp_basictools.dll</code> and <code>pnp_extrafilters.dll</code> plugin files.</p>
<a name="creating-the-application-package"></a>
<h3 >Creating the Application Package</h3>
<p>To deploy the application, we must make sure that we copy the relevant Qt DLLs (corresponding to the Qt modules used in the application) and the Windows platform plugin, <code>qwindows.dll</code>, as well as the executable to the same directory tree in the <code>release</code> subdirectory.</p>
<p>In contrast to user plugins, Qt plugins must be put into subdirectories matching the plugin type. The correct location for the platform plugin is a subdirectory named <code>platforms</code>. <a href="windows-deployment.html#qt-plugins">Qt Plugins</a> section has additional information about plugins and how Qt searches for them.</p>
<p>Qt relies on the <a href="http://site.icu-project.org/">ICU</a> library for unicode support. You must include the ICU DLLs that are located in the <code>bin</code> directory of your Qt installation if Qt was configured to use ICU. The Qt version bundled in the Qt5 package uses ICU, so deployment is needed there. The ICU DLLs are version dependent and have to match the ones your Qt version was linked against.</p>
<p>If <a href="http://code.google.com/p/angleproject/">ANGLE</a> (the default) is used, you additionally need to include both <code>libEGL.dll</code> and <code>libGLESv2.dll</code> from Qt's 'lib' directory as well as the HLSL compiler from DirectX. The HLSL compiler library, d3dcompiler_XX.dll, where XX is the version number that ANGLE (libGLESv2) was linked against.</p>
<p>If your application depends on Qt WebEngine, you must deploy <code>&lt;Qt install path&gt;/bin/QtWebEngineProcess.exe</code> to the application install path. If you chose to deploy the binary to a different path, set the <code>QTWEBENGINEPROCESS_PATH</code> environment variable to the binary's absolute path (including its file name). This enables the application to find the binary and execute it for every instance of QWebEngineView or WebEngineView created. For example, a browser application with two tabs open should have two separate processes of <code>QtWebEngineProcess.exe</code> running. This is a common approach used by most modern web engines to provide a stable browsing experience.</p>
<p><b>Note: </b>To support HTML5 videos, you must additionally deploy <code>ffmpegsumo.dll</code> (WebM codec plugin) into the <code>qtwebengine</code> directory under the application install path or under the path that the <code>PluginsPath</code> variable was set to in <code>&lt;Qt install path&gt;/&lt;Qt version&gt;/msvc2013/qt.conf</code>.</p><p>Remember that if your application depends on compiler specific libraries, these must be redistributed along with your application. You can check which libraries your application is linking against by using the <code>depends</code> tool. For more information, see the <a href="windows-deployment.html#application-dependencies">Application Dependencies</a> section.</p>
<p>We'll cover the plugins shortly, but first we'll check that the application will work in a deployed environment: Either copy the executable and the Qt DLLs to a machine that doesn't have Qt or any Qt applications installed, or if you want to test on the build machine, ensure that the machine doesn't have Qt in its environment.</p>
<p>If the application starts without any problems, then we have successfully made a dynamically linked version of the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> application. But the application's functionality will still be missing since we have not yet deployed the associated plugins.</p>
<p>Plugins work differently to normal DLLs, so we can't just copy them into the same directory as our application's executable as we did with the Qt DLLs. When looking for plugins, the application searches in a <code>plugins</code> subdirectory inside the directory of the application executable.</p>
<p>So to make the plugins available to our application, we have to create the <code>plugins</code> subdirectory and copy over the relevant DLLs:</p>
<pre class="cpp">plugins\pnp_basictools<span class="operator">.</span>dll
plugins\pnp_extrafilters<span class="operator">.</span>dll</pre>
<p>An archive distributing all the Qt DLLs and application specific plugins required to run the <a href="../qtwidgets/qtwidgets-tools-plugandpaint-example.html">Plug &amp; Paint</a> application, would have to include the following files:</p>
<div class="table"><table class="generic" width="100%">
 <thead><tr class="qt-style"><th >Component</th><th  colspan="2" rowspan=" 1">File Name</th></tr></thead>
<tr valign="top" class="odd"><td >The executable</td><td  colspan="2" rowspan=" 1"><code>plugandpaint.exe</code></td></tr>
<tr valign="top" class="even"><td >The Basic Tools plugin</td><td  colspan="2" rowspan=" 1"><code>plugins\pnp_basictools.dll</code></td></tr>
<tr valign="top" class="odd"><td >The ExtraFilters plugin</td><td  colspan="2" rowspan=" 1"><code>plugins\pnp_extrafilters.dll</code></td></tr>
<tr valign="top" class="even"><td >The Qt Windows platform plugin</td><td  colspan="2" rowspan=" 1"><code>platforms\qwindows.dll</code></td></tr>
<tr valign="top" class="odd"><td >The Qt Core module</td><td  colspan="2" rowspan=" 1"><code>Qt5Core.dll</code></td></tr>
<tr valign="top" class="even"><td >The Qt GUI module</td><td  colspan="2" rowspan=" 1"><code>Qt5Gui.dll</code></td></tr>
<tr valign="top" class="odd"><td >The Qt Widgets module</td><td  colspan="2" rowspan=" 1"><code>Qt5Widgets.dll</code></td></tr>
</table></div>
<p>In addition, the archive must contain the following compiler specific libraries depending on your version of Visual Studio:</p>
<div class="table"><table class="generic" width="100%">
 <thead><tr class="qt-style"><th ></th><th >VC++ 8.0 (2005)</th><th >VC++ 9.0 (2008)</th><th >VC++ 10.0 (2010)</th></tr></thead>
<tr valign="top" class="odd"><td >The C run-time</td><td ><code>msvcr80.dll</code></td><td ><code>msvcr90.dll</code></td><td ><code>msvcr100.dll</code></td></tr>
<tr valign="top" class="even"><td >The C++ run-time</td><td ><code>msvcp80.dll</code></td><td ><code>msvcp90.dll</code></td><td ><code>msvcp100.dll</code></td></tr>
</table></div>
<p>If ICU was used, the archive must contain:</p>
<div class="table"><table class="generic" width="100%">
 <thead><tr class="qt-style"><th  colspan="3">File Name</th></tr></thead>
<tr valign="top" class="odd"><td >icudtXX.dll</td><td >icuinXX.dll</td><td >icuucXX.dll</td></tr>
</table></div>
<p>Finally, if ANGLE was used, then the archive must additionally contain:</p>
<div class="table"><table class="generic" width="100%">
 <thead><tr class="qt-style"><th  colspan="3">File Name</th></tr></thead>
<tr valign="top" class="odd"><td >libEGL.dll</td><td >libGLESv2.dll</td><td >d3dcompiler_XX.dll</td></tr>
</table></div>
<p>To verify that the application now can be successfully deployed, you can extract this archive on a machine without Qt and without any compiler installed, and try to run it.</p>
<p>An alternative to putting the plugins in the plugins subdirectory is to add a custom search path when you start your application using <a href="../qtcore/qcoreapplication.html#addLibraryPath">QApplication::addLibraryPath</a>() or <a href="../qtcore/qcoreapplication.html#setLibraryPaths">QApplication::setLibraryPaths</a>().</p>
<pre class="cpp">qApp<span class="operator">-</span><span class="operator">&gt;</span>addLibraryPath(<span class="string">&quot;C:\some\other\path&quot;</span>);</pre>
<p>One benefit of using plugins is that they can easily be made available to a whole family of applications.</p>
<p>It's often most convenient to add the path in the application's <code>main()</code> function, right after the <a href="../qtwidgets/qapplication.html">QApplication</a> object is created. Once the path is added, the application will search it for plugins, in addition to looking in the <code>plugins</code> subdirectory in the application's own directory. Any number of additional paths can be added.</p>
<a name="manifest-files"></a>
<h3 >Manifest files</h3>
<p>When deploying an application compiled with Visual Studio 2005 onwards, there are some additional steps to be taken.</p>
<p>First, we need to copy the manifest file created when linking the application. This manifest file contains information about the application's dependencies on side-by-side assemblies, such as the runtime libraries.</p>
<p>The manifest file needs to be copied into the <b>same</b> folder as the application executable. You do not need to copy the manifest files for shared libraries (DLLs), since they are not used.</p>
<p>If the shared library has dependencies that are different from the application using it, the manifest file needs to be embedded into the DLL binary. Since Qt 4.1&#x2e;3, the following <code>CONFIG</code> options are available for embedding manifests:</p>
<pre class="cpp">embed_manifest_dll
embed_manifest_exe</pre>
<p>To use the options, add</p>
<pre class="cpp">CONFIG += embed_manifest_exe</pre>
<p>to your .pro file. The <code>embed_manifest_dll</code> option is enabled by default. The <code>embed_manifest_exe</code> option is NOT enabled by default.</p>
<p>You can find more information about manifest files and side-by-side assemblies at the <a href="http://msdn.microsoft.com/en-us/library/aa376307.aspx">MSDN website</a>.</p>
<p>The correct way to include the runtime libraries with your application is to ensure that they are installed on the end-user's system.</p>
<p>To install the runtime libraries on the end-user's system, you need to include the appropriate Visual C++ Redistributable Package (VCRedist) executable with your application and ensure that it is executed when the user installs your application.</p>
<p>For example, on an 32-bit x86-based system, you would include the <a href="http://www.microsoft.com/downloads/details.aspx?FamilyId=32BC1BEE-A3F9-4C13-9C99-220B62A191EE">vcredist_x86.exe</a> executable. The <a href="http://www.microsoft.com/downloads/details.aspx?familyid=526BF4A7-44E6-4A91-B328-A4594ADB70E5">vcredist_IA64.exe</a> and <a href="http://www.microsoft.com/downloads/details.aspx?familyid=90548130-4468-4BBC-9673-D6ACABD5D13B">vcredist_x64.exe</a> executables provide the appropriate libraries for the IA64 and 64-bit x86 architectures, respectively.</p>
<p><b>Note: </b>The application you ship must be compiled with exactly the same compiler version against the same C runtime version. This prevents deploying errors caused by different versions of the C runtime libraries.</p><a name="manual-installations-with-visual-studio-2008-and-2010"></a>
<h3 >Manual installations with Visual Studio 2008 and 2010</h3>
<p>As well as the above details for VS 2005 and onwards, Visual Studio 2008/2010 applications may have problems when deploying manually, say to a USB stick.</p>
<p>The recommended procedure is to configure Qt with the <code>-plugin-manifests</code> option using the 'configure' tool. Then follow the <a href="http://msdn.microsoft.com/en-us/library/ms235291(VS.80).aspx">guidelines</a> for manually deploying private assemblies.</p>
<p>In brief the steps are</p>
<ol class="1">
<li>create a folder structure on the development computer that will match the target USB stick directory structure, for example '\app' and for your dlls, '\app\lib'.</li>
<li>on the development computer, from the appropriate 'redist' folder copy over Microsoft.VC80.CRT and Microsoft.VC80.MFC to the directories '\app' and '\app\lib' on the development PC.</li>
<li>xcopy the \app folder to the target USB stick.</li>
</ol>
<p>Your application should now run. Also be aware that even with a service pack installed the Windows DLLs that are linked to will be the defaults. See the information on <a href="http://msdn.microsoft.com/en-us/library/cc664727.aspx">how to select the appropriate target DLLs</a>.</p>
<a name="application-dependencies"></a>
<h2 id="application-dependencies">Application Dependencies</h2>
<a name="additional-libraries"></a>
<h3 >Additional Libraries</h3>
<p>Depending on configuration, compiler specific libraries must be redistributed along with your application.</p>
<p>For example, if Qt is built using <a href="http://code.google.com/p/angleproject/">ANGLE</a>, its shared libraries and the required shared libraries of the <a href="http://msdn.microsoft.com/en-us/directx/default.aspx">Direct X SDK</a> need to be shipped as well.</p>
<p>You can check which libraries your application is linking against by using the <a href="http://www.dependencywalker.com/">Dependency Walker</a> tool. All you need to do is to run it like this:</p>
<pre class="cpp">depends <span class="operator">&lt;</span>application executable<span class="operator">&gt;</span></pre>
<p>This will provide a list of the libraries that your application depends on and other information.</p>
<p class="centerAlign"><img src="images/deployment-windows-depends.png" alt="" /></p><p>When looking at the release build of the Plug &amp; Paint executable (<code>plugandpaint.exe</code>) with the <code>depends</code> tool, the tool lists the following immediate dependencies to non-system libraries:</p>
<div class="table"><table class="generic" width="100%">
 <thead><tr class="qt-style"><th >Qt</th><th >VC++ 10.0 (2010)</th><th >VC++ 11.0 (2012)</th><th >VC++ 12.0 (2013)</th><th ><a href="http://www.mingw.org/">MinGW</a></th></tr></thead>
<tr valign="top" class="odd"><td ><ul>
<li>QT5CORE.DLL - The <a href="../qtcore/qtcore-module.html">QtCore</a> runtime</li>
<li>QT5GUI.DLL - The <a href="../qtgui/qtgui-module.html">QtGui</a> runtime</li>
<li>QT5WIDGETS.DLL - The <a href="../qtgui/qtwidgets-module.html">QtWidgets</a> runtime</li>
</ul>
</td><td ><ul>
<li>MSVCR100.DLL - The C runtime</li>
<li>MSVCP100.DLL - The C++ runtime</li>
</ul>
</td><td ><ul>
<li>MSVCR110.DLL - The C runtime</li>
<li>MSVCP110.DLL - The C++ runtime</li>
</ul>
</td><td ><ul>
<li>MSVCR120.DLL - The C runtime</li>
<li>MSVCP120.DLL - The C++ runtime</li>
</ul>
</td><td ><ul>
<li>LIBWINPTHREAD-1.DLL</li>
<li>LIBGCC_S_DW2-1.DLL</li>
<li>LIBSTDC++-6.DLL</li>
</ul>
</td></tr>
</table></div>
<p>When looking at the plugin DLLs the exact same dependencies are listed.</p>
<a name="qt-plugins"></a>
<h3 >Qt Plugins</h3>
<p>All Qt GUI applications require a plugin that implements the <a href="qpa.html">Qt Platform Abstraction</a> (QPA) layer in Qt 5. For Windows, the name of the platform plugin is <code>qwindows.dll</code>. This file must be located within a specific subdirectory (by default, <code>platforms</code>) under your distribution directory. Alternatively, it is possible to adjust the search path Qt uses to find its plugins, as described below.</p>
<p>Your application may also depend on one or more Qt plugins, such as the print support plugin, the JPEG image format plugin or a SQL driver plugin. Be sure to distribute any Qt plugins that you need with your application. Similar to the platform plugin, each type of plugin must be located within a specific subdirectory (such as <code>printsupport</code>, <code>imageformats</code> or <code>sqldrivers</code>) within your distribution directory.</p>
<p><b>Note: </b>If you are deploying an application that uses Qt WebKit to display HTML pages from the World Wide Web, you should include all text codec plugins to support as many HTML encodings possible.</p><p>The search path for Qt plugins is hard-coded into the <a href="../qtcore/qtcore-module.html">QtCore</a> library. By default, the plugins subdirectory of the Qt installation is the first plugin search path. However, pre-determined paths like the default one have certain disadvantages. For example, they may not exist on the target machine. For that reason, you need to examine various alternatives to make sure that the Qt plugins are found:</p>
<ul>
<li><a href="qt-conf.html">Using <code>qt.conf</code></a>. This approach is the recommended if you have executables in different places sharing the same plugins.</li>
<li>Using <a href="../qtcore/qcoreapplication.html#addLibraryPath">QApplication::addLibraryPath</a>() or <a href="../qtcore/qcoreapplication.html#setLibraryPaths">QApplication::setLibraryPaths</a>(). This approach is recommended if you only have one executable that will use the plugin.</li>
<li>Using a third party installation utility to change the hard-coded paths in the <a href="../qtcore/qtcore-module.html">QtCore</a> library.</li>
</ul>
<p>If you add a custom path using <a href="../qtcore/qcoreapplication.html#addLibraryPath">QApplication::addLibraryPath</a> it could look like this:</p>
<pre class="cpp">qApp<span class="operator">-</span><span class="operator">&gt;</span>addLibraryPath(<span class="string">&quot;C:/customPath/plugins&quot;</span>);</pre>
<p>Then <a href="../qtwidgets/qapplication.html#qApp">qApp</a>-&gt;libraryPaths() would return something like this:</p>
<ul>
<li><code>C:/customPath/plugins</code></li>
<li><code>C:/Qt/5.5&#x2e;1/plugins</code></li>
<li><code>E:/myApplication/directory</code></li>
</ul>
<p>The executable will look for the plugins in these directories and the same order as the <a href="../qtcore/qstringlist.html">QStringList</a> returned by <a href="../qtwidgets/qapplication.html#qApp">qApp</a>-&gt;libraryPaths(). The newly added path is prepended to the <a href="../qtwidgets/qapplication.html#qApp">qApp</a>-&gt;libraryPaths() which means that it will be searched through first. However, if you use <a href="../qtwidgets/qapplication.html#qApp">qApp</a>-&gt;setLibraryPaths(), you will be able to determine which paths and in which order they will be searched.</p>
<p>The <a href="plugins-howto.html">How to Create Qt Plugins</a> document outlines the issues you need to pay attention to when building and deploying plugins for Qt applications.</p>
<a name="the-windows-deployment-tool"></a>
<h2 id="the-windows-deployment-tool">The Windows Deployment Tool</h2>
<a name="windeployqt"></a><p>The Windows deployment tool can be found in QTDIR/bin/windeployqt. It is designed to automate the process of creating a deployable folder that contains all libraries, QML imports, plugins, translations that are required to run the application from that folder. This is used to create the sandbox for <a href="winrt-support.html">Windows Runtime</a> or an installation tree for Windows desktop applications that can be easily bundled by an installer.</p>
<pre class="cpp">Usage: windeployqt [options] [files]
Qt Deploy Tool 5.4&#x2e;0

The simplest way to use windeployqt is to add the bin directory of your Qt
installation (e.g&#x2e; &lt;QT_DIR\bin&gt;) to the PATH variable and then run:
  windeployqt &lt;path-to-app-binary&gt;
If ICU, ANGLE, etc. are not in the bin directory, they need to be in the PATH
variable. If your application uses Qt Quick, run:
  windeployqt --qmldir &lt;path-to-app-qml-files&gt; &lt;path-to-app-binary&gt;

Options:
  -?, -h, --help             Displays this help.
  -v, --version              Displays version information.
  --dir &lt;directory&gt;          Use directory instead of binary directory.
  --libdir &lt;path&gt;            Copy libraries to path.
  --debug                    Assume debug binaries.
  --release                  Assume release binaries.
  --release-with-debug-info  Assume release binaries with debug information.
  --force                    Force updating files.
  --dry-run                  Simulation mode. Behave normally, but do not
                             copy/update any files.
  --no-plugins               Skip plugin deployment.
  --no-libraries             Skip library deployment.
  --qmldir &lt;directory&gt;       Scan for QML-imports starting from directory.
  --no-quick-import          Skip deployment of Qt Quick imports.
  --no-translations          Skip deployment of translations.
  --no-system-d3d-compiler   Skip deployment of the system D3D compiler.
  --compiler-runtime         Deploy compiler runtime (Desktop only).
  --no-compiler-runtime      Do not deploy compiler runtime (Desktop only).
  --webkit2                  Deployment of WebKit2 (web process).
  --no-webkit2               Skip deployment of WebKit2.
  --json                     Print to stdout in JSON format.
  --angle                    Force deployment of ANGLE.
  --no-angle                 Disable deployment of ANGLE.
  --list &lt;option&gt;            Print only the names of the files copied.
                             Available options:
                              source:   absolute path of the source files
                              target:   absolute path of the target files
                              relative: paths of the target files, relative
                                        to the target directory
                              mapping:  outputs the source and the relative
                                        target, suitable for use within an
                                        Appx mapping file
  --verbose &lt;level&gt;          Verbose level.

Qt libraries can be added by passing their name (-xml) or removed by passing
the name prepended by --no- (--no-xml). Available libraries:
bluetooth clucene concurrent core declarative designer designercomponents
enginio gui qthelp multimedia multimediawidgets multimediaquick network nfc
opengl positioning printsupport qml qmltooling quick quickparticles quickwidgets
script scripttools sensors serialport sql svg test webkit webkitwidgets
websockets widgets winextras xml xmlpatterns webenginecore webengine
webenginewidgets

Arguments:
  [files]                    Binaries or directory containing the binary.</pre>
</div>
<!-- @@@windows-deployment.html -->
        </div>
       </div>
   </div>
   </div>
</div>
<div class="footer">
   <p>
   <acronym title="Copyright">&copy;</acronym> 2015 The Qt Company Ltd.
   Documentation contributions included herein are the copyrights of
   their respective owners.<br>    The documentation provided herein is licensed under the terms of the    <a href="http://www.gnu.org/licenses/fdl.html">GNU Free Documentation    License version 1.3</a> as published by the Free Software Foundation.<br>    Qt and respective logos are trademarks of The Qt Company Ltd.     in Finland and/or other countries worldwide. All other trademarks are property
   of their respective owners. </p>
</div>
</body>
</html>