Merge remote-tracking branch 'origin/release' into stable

Change-Id: I65967ee732dcf83df3dffae42c854965aec646fe

20 files changed, 452 insertions, 173 deletions

diff --git a/doc/src/classes.qdoc b/doc/src/classes.qdoc
index 62c89f6ec..d0560e9a8 100644
--- a/doc/src/classes.qdoc
+++ b/doc/src/classes.qdoc
@@ -26,6 +26,7 @@
 ****************************************************************************/
 
 /*!
+    \page classesandfunctions.html
     \title Class and Function Documentation
     \brief Lists and Indexes of classes, functions, and types.
 
diff --git a/doc/src/deployment/deployment.qdoc b/doc/src/deployment/deployment.qdoc
index 3d779a2bf..10f338cc8 100644
--- a/doc/src/deployment/deployment.qdoc
+++ b/doc/src/deployment/deployment.qdoc
@@ -431,6 +431,26 @@
     doing.
     \endlist
 
+    \section1 Dependencies detection
+
+    Qt comes with a number of plugins which are loaded at run-time when they are needed. These
+    can handle anything from connecting to SQL databases to loading specific image formats.
+    Detecting plugin dependencies is impossible as the plugins are loaded at run-time, but
+    androiddeployqt tries to guess such dependencies based on the Qt dependencies
+    of your application. If the plugin has any Qt dependencies which are not also dependencies of
+    your application, it will not be included by default. For instance, in order to ensure that
+    the SVG image format plugin is included, you will need to add \c{QT += svg} to your \c .pro file
+    so that the \l{Qt SVG} module becomes a dependency of your application.
+
+    If you are wondering why a particular plugin is not included automatically, you can run androiddeployqt
+    with the \c --verbose option to get the list of missing dependencies for each excluded plugin. You
+    can achieve the same in Qt Creator by ticking the \gui{Verbose output} check box in the
+    \gui{Deployment configurations}. This is located in the \gui{Run} tab of your \gui{Projects}
+    settings.
+
+    It's also possible to manually specify the dependencies of your application. See the documentation
+    for the \c{ANDROID_DEPLOYMENT_DEPENDENCIES} qmake variable below.
+
     \section1 qmake variables
 
     Unless the project has special requirements such as third party libraries, it should be
diff --git a/doc/src/external-resources.qdoc b/doc/src/external-resources.qdoc
index f48af1b9e..145e74953 100644
--- a/doc/src/external-resources.qdoc
+++ b/doc/src/external-resources.qdoc
@@ -36,6 +36,11 @@
 */
 
 /*!
+    \externalpage http://itunes.apple.com/us/app/xcode/id497799835?ls=1&mt=12
+    \title Xcode
+*/
+
+/*!
     \externalpage http://opensource.org/licenses/bsd-license.php
     \title New and Modified BSD Licenses
 */
@@ -98,3 +103,13 @@
     \externalpage http://qt-project.org/doc/qbs/index.html
     \title Qbs Manual
 */
+
+/*!
+    \externalpage https://play.google.com/apps/publish
+    \title Google Play Developer Console
+*/
+
+/*!
+    \externalpage http://qt.digia.com/Try-Qt-Now/
+    \title Try Qt Enterprise
+*/
diff --git a/doc/src/getting-started/gettingstarted.qdoc b/doc/src/getting-started/gettingstarted.qdoc
index 95d144c2f..e124b08fc 100644
--- a/doc/src/getting-started/gettingstarted.qdoc
+++ b/doc/src/getting-started/gettingstarted.qdoc
@@ -34,12 +34,14 @@
 
     The \l{Opensource Downloads}{Downloads} page contains Qt download links,
     where Qt and Qt Creator can be downloaded for different development
-    platforms.
+    platforms. The Qt Enterprise packages are available from the
+    \l{Try Qt Enterprise} page.
 
     \section2 Installing with the Installation Program
 
     The Qt Installation Program can download the Qt libraries and tools as well
-    as the reference documentation and code samples. The \l{Qt Installation
+    as the reference documentation and code samples. The
+    \l{Qt Installation
     Program} page contains information about installation process.
 
     \section2 Installing from the Qt Sources
diff --git a/doc/src/getting-started/installation.qdoc b/doc/src/getting-started/installation.qdoc
index 17667c54b..f5a9d656d 100644
--- a/doc/src/getting-started/installation.qdoc
+++ b/doc/src/getting-started/installation.qdoc
@@ -37,6 +37,8 @@ There are two ways to install Qt:
 project.org/downloads}.
 \endlist
 
+\note Qt Enterprise packages are available from the \l{Try Qt Enterprise} page.
+
 This page lists the relevant information for installing Qt by building the Qt
 sources. The installation procedure is different on each Qt platform. This page
 collects the relevant information for the \l{Supported Platforms}.
diff --git a/doc/src/getting-started/installer-README.qdoc b/doc/src/getting-started/installer-README.qdoc
index 68e72e0e7..ac3415310 100644
--- a/doc/src/getting-started/installer-README.qdoc
+++ b/doc/src/getting-started/installer-README.qdoc
@@ -54,7 +54,8 @@ so on).
 \section1 Installing Qt 5
 
 You can download Qt 5 from \l{http://qt-project.org/downloads}. The site
-provides download links for all supported development platforms.
+provides download links for all supported development platforms. The Qt
+Enterprise packages are available from the \l{Try Qt Enterprise} page.
 
 Start the installation program like any executable on the development platform.
 On Linux, you might first have to make the installation program executable.
diff --git a/doc/src/images/qt5_everywhere_demo.jpg b/doc/src/images/qt5_everywhere_demo.jpg
new file mode 100644
index 000000000..dd17f700c
--- /dev/null
+++ b/doc/src/images/qt5_everywhere_demo.jpg
diff --git a/doc/src/images/qtpositioning_weatherinfo_ex.jpg b/doc/src/images/qtpositioning_weatherinfo_ex.jpg
new file mode 100644
index 000000000..d065bf9d4
--- /dev/null
+++ b/doc/src/images/qtpositioning_weatherinfo_ex.jpg
diff --git a/doc/src/images/qtquickcontrols-example-gallery.jpg b/doc/src/images/qtquickcontrols-example-gallery.jpg
new file mode 100644
index 000000000..979a3caf9
--- /dev/null
+++ b/doc/src/images/qtquickcontrols-example-gallery.jpg
diff --git a/doc/src/images/qtsensors_accelbubble_ex.jpg b/doc/src/images/qtsensors_accelbubble_ex.jpg
new file mode 100644
index 000000000..a512cfa14
--- /dev/null
+++ b/doc/src/images/qtsensors_accelbubble_ex.jpg
diff --git a/doc/src/images/quick_controls_touch_ex.jpg b/doc/src/images/quick_controls_touch_ex.jpg
new file mode 100644
index 000000000..fb334b653
--- /dev/null
+++ b/doc/src/images/quick_controls_touch_ex.jpg
diff --git a/doc/src/platforms/android.qdoc b/doc/src/platforms/android.qdoc
index f0bc7217b..796b9b167 100644
--- a/doc/src/platforms/android.qdoc
+++ b/doc/src/platforms/android.qdoc
@@ -49,9 +49,22 @@ The following list summarizes what you can do with Qt for Android:
  \li Create and deploy Application Package (APK) using Qt Creator.
 \endlist
 
-\section1 Getting Started
+The following topics provide more details about how to use Qt for Android:
+\list
+ \li \l{Getting Started with Qt for Android}{Getting Started}
+ \li \l{Porting to Android}{Porting a Qt Application}
+ \li \l{Adding OpenSSL Support}
+ \li \l{Qt Creator: Deploying Applications to Android Devices}{Deploying to the Device}
+ \li \l{Publishing to Google Play}
+ \li \l{Platform and Compiler Notes - Android}{Platform Notes}
+ \li \l{Android GNU C++ run-time licensing}
+\endlist
+*/
 
-\section2 Requirements
+/*!
+\page androidgs.html
+\title Getting Started with Qt for Android
+\brief Provides instructions to install and configure your development environment.
 
 In order to use Qt for Android, you need the following:
 
@@ -90,7 +103,7 @@ to install:
 ./android update sdk
 \endcode
 
-\section2 Installing Qt for Android
+\section1 Installing Qt for Android
 
 You can install the binary package for Qt 5.1 or later to get
 Qt for Android. The \l{Qt Installation Program}{installer} containing the
@@ -152,7 +165,7 @@ The binaries are installed to the \e{qtbase/bin} directory by default for the
 developer builds. You can check the install paths using the \c{qmake -query}
 command.
 
-\section2 Configuring Qt Creator
+\section1 Configuring Qt Creator
 
 After installing the Qt for Android binaries either using the installer or by
 cross-compiling, Qt Creator must be configured to start developing your first
@@ -170,7 +183,11 @@ to test the setup. Use the \c{android} keyword in the search field under the
 \gui{Examples} tab in Qt Creator \gui{Welcome} mode to list all the examples
 tested for Android.
 
-\section1 Porting a Qt Application
+*/
+/*!
+\page portingtoandroid.html
+\title Porting to Android
+\brief Provides instructions to port your existing Qt application to Android.
 
 In this section, we are going to port an existing Qt Application to Android
 and deploy it to the device.
@@ -251,8 +268,12 @@ Qt Creator deploys your application on the Android device, if the
 device is detected by the PC. Otherwise, it tries to run the application on an
 AVD (Android Virtual Device). You will be prompted to create one if there are no
 AVDs found.
+*/
 
-\section1 Adding OpenSSL Support
+/*!
+\page opensslsupport.html
+\title Adding OpenSSL Support
+\brief Provides instructions to bundle OpenSSL libraries with your Qt application for Android.
 
 The Qt installation package does not ship the OpenSSL libraries due to legal
 restrictions in some countries. If you want to use OpenSSL in your application,
@@ -296,11 +317,62 @@ with the OpenSSL libraries bundled in it. Once the APK is ready, Qt Creator
 prompts you to choose the device to install the APK, and then you should
 see your application running on the device you selected.
 
-\section1 Related Information
-\list
- \li \l{Platform and Compiler Notes - Android}{Platform Notes}
- \li \l{Qt Creator: Deploying Applications to Android Devices}
- \li \l{Android GNU C++ run-time licensing}
- \li \l{Deploying an Application on Android}
+*/
+
+/*!
+\page publishtogoogleplay.html
+\title Publishing to Google Play
+\brief Provides instructions to prepare your application for publishing.
+
+Qt for Android provides a complete solution to develop, build, and package your
+applications for Android. Most of these tasks, especially packaging and
+deployment are handled by Qt Creator providing rich developer experience.
+
+Every time you run the application using Qt Creator, an Android Application
+Package (APK) is created and deployed onto the target (device or emulator) you
+choose. With some minor changes to how the \e .apk is created, you can publish
+your application on Google Play and monetize from it. The following
+step-by-step instructions guide you to create an \e{.apk} that can go live
+on Google Play:
+\list 1
+ \li Open your application project using Qt Creator v3.0 or later and change
+ its \uicontrol Build settings to build release version.
+
+ \li Open \uicontrol Run settings of your project and select
+ \uicontrol {Create AndroidManifest.xml}. Qt Creator adds the manifest XML
+ based on the application's \e .pro file and opens it in \uicontrol General
+ mode.
+
+ \note You can edit the \e AndroidManifest.xml in \uicontrol General or
+ \uicontrol {XML Source} mode.
+
+ \li Check for the following in \e AndroidManifest.xml:
+ \list
+  \li \uicontrol{Minimum required SDK} is set to API 9 or above.
+
+  \note Qt for Android is supported on devices with API 9 and above.
+
+  \li Add \uicontrol{Application name} and \uicontrol{Application icon}.
+
+  \li \uicontrol Permissions list has all the required permissions.
+ \endlist
+
+ \li Set up a \uicontrol keystore to sign the \e .apk. You can create a new
+ keystore if you do not have one.
+
+ \li Select \uicontrol{Open package location after build} and run your
+ application to build the \e .apk. Qt Creator builds the \e .apk and opens the
+ folder containing the \e .apk.
+
+ \li Login into the \l{Google Play Developer Console} and upload the \e .apk
+ file, few screen captures of the application, and a description.
 \endlist
+
+Now your application is available to other Android device users via
+Google Play. You can also choose to publish the application to a smaller
+group, so that you can test and improve the application before publishing it to
+a larger audience.
+
+See \l{Deploying an Application on Android} for more information about how the
+packaging is done and how you can influence it.
 */
diff --git a/doc/src/platforms/ios.qdoc b/doc/src/platforms/ios.qdoc
index 3215ecdc7..457bbfc9b 100644
--- a/doc/src/platforms/ios.qdoc
+++ b/doc/src/platforms/ios.qdoc
@@ -54,25 +54,34 @@
 
     \section2 Setting Up the Development Environment
 
+    You have two options to set up the Qt development environment:
+
+    \list
+        \li \l{Qt Installation Program}{Use an installer}
+        \li \l{Building Qt Sources}{Build from source}
+    \endlist
+
+    Regardless of which approach you choose, you first need to install
+    Xcode. You will find it in the App Store \l{Xcode}{here}. For
+    running Qt applications in the simulator that comes with Xcode,
+    this is all you need. However, for running applications on a
+    device and publishing your applications in the App Store, you must
+    join the iOS Developer Program (see
+    \l{https://developer.apple.com/programs/ios/}), and set up
+    developer certificates and provisioning profiles. The easiest
+    solution is to use a profile that takes any App ID (a \c *).
+
+    Before building Qt or any Qt applications, you should test that Xcode
+    is set up correctly, for example, by running one of the standard
+    Xcode application templates on your device.
+
+    \section3 Building From Source
+
     We assume that you have cloned the Qt 5 repositories (or obtained
     the Qt sources elsewhere) and followed the platform independent
     requirements for building Qt. The requirements are described
     \l{General Qt Requirements}{here}.
 
-    You continue by installing Xcode. You will find it in the App
-    Store. For running Qt applications in the simulator that comes
-    with Xcode, this is all you need. However, for running
-    applications on a device and publishing your applications in the
-    App Store, you must join the iOS Developer Program, see
-    \l{https://developer.apple.com/programs/ios/} for further
-    information. This includes setting up developer certificates and
-    provisioning profiles. The easiest solution is to use a profile
-    that takes any App ID (a \c *).
-
-    Before building Qt or any applications, you should test that Xcode
-    is set up correctly, for example, by running one of the standard
-    Xcode app templates.
-
     We can then build Qt. This is done from the Qt 5 top directory,
     like so:
 
@@ -86,11 +95,13 @@
     libraries. If you want to build for a single target, use the \c
     -sdk argument with either \c iphoneos or \c iphonesimulator.
 
-    \section2 Building Applications
+    \section2 Building Applications From the Command Line
 
     As mentioned previously, the development workflow on iOS consists
     of maintaining a normal \c .pro file project and export it to
-    Xcode. Here is how to build a project:
+    Xcode.
+
+    Here is how to build a project:
 
     \list
         \li run qmake (if you have not done so previously)
@@ -101,16 +112,18 @@
     Note that you must re-import the project if its setup changes, for
     example, when adding or removing source files.
 
-    \section1 Developing with Qt Creator
+    \section1 Building Applications with Qt Creator
+
+    You can find information on how to set up and run iOS applications
+    in Qt Creator's manual:
+
+    \list
+        \li \l{Qt Creator: Connecting iOS devices}{Connecting iOS Devices}.
+    \endlist
+
+    As mentioned previously, you must have Xcode installed.
 
-    After setting up Qt for iOS as described in the previous section
-    or by using an \l{Opensource Downloads}{installer}, you are ready
-    to start developing with Qt Creator. Qt Creator is included in the
-    installer; otherwise, you can build from source
-    (git://gitorious.org/qt-creator/qt-creator.git) or use a separate
-    Qt Creator \l{Opensource Downloads}{installer}. You find info on
-    how to set up and run iOS applications in its \l{Qt Creator:
-    Connecting iOS devices}{manual}.
+    \section2 Examples for iOS
 
     In Qt Creator, tested examples on iOS can be looked up. Use the \c ios
     keyword to search for examples in the Qt Creator Welcome mode. Note that
@@ -119,15 +132,16 @@
     \section1 Using Objective-C Code in Qt Applications
 
     Clang, the compiler used for iOS applications, allows mixing C++
-    and Objective-C code; you only have to suffix files containing
-    both languages with \c .mm. Note that this makes it possible to
-    use frameworks from Apple's iOS Developer Library in Qt
-    applications. Most useful is perhaps the possibility for adding
-    In-App Purchasing with the StoreKit framework.
-
-    We currently have one example that mixes Objective-C and C++ code.
-    You can check it out
-    \l{https://github.com/richardmg/qtdd13_qmlapp}{here}.
+    and Objective-C code. To enable this mode, suffix your source
+    files with \.c mm, and add them to \c OBJECTIVE_SOURCES instead of
+    \c SOURCES in the \c .pro file. This makes it possible to use
+    frameworks from Apple's iOS Developer Library in Qt applications.
+    Most useful is perhaps the possibility for adding In-App
+    Purchasing with the StoreKit framework.
+
+    We currently have one example mixing Objective-C and C++ code. You
+    find it
+    \l{https://qt-project.org/wiki/Mixing_C_and_ObjectiveC_Code}{here}.
 
 */
 
diff --git a/doc/src/platforms/linux.qdoc b/doc/src/platforms/linux.qdoc
index f8e729261..81a4a810f 100644
--- a/doc/src/platforms/linux.qdoc
+++ b/doc/src/platforms/linux.qdoc
@@ -554,10 +554,10 @@
 
     To deploy the application, we must make sure that we copy the
     relevant Qt libraries (corresponding to the Qt modules used in the
-    application) as well as the executable to the same
-    directory. Remember that if your application depends on compiler
-    specific libraries, these must also be redistributed along with
-    your application. For more information, see the \l {Application
+    application), the \l {Qt Plugins}{platform plugin}, and the executable
+    to the same directory tree. Remember that if your application depends
+    on compiler specific libraries, these must also be redistributed along
+    with your application. For more information, see the \l {Application
     Dependencies} section.
 
     We'll cover the plugins shortly, but the main issue with shared
@@ -704,12 +704,19 @@
 
     \section2 Qt Plugins
 
+    All Qt GUI applications require a plugin that implements the \l {Qt
+    Platform Abstraction} (QPA) layer in Qt 5. For Linux/X11, the name of the
+    platform plugin is \c {libqxcb.so}. This file must be located within a
+    specific subdirectory (by default, \c platforms) under your distribution
+    directory. Alternatively, it is possible to adjust the search path Qt
+    uses to find its plugins, as described below.
+
     Your application may also depend on one or more Qt plugins, such
     as the JPEG image format plugin or a SQL driver plugin. Be sure
-    to distribute any Qt plugins that you need with your application,
-    and note that each type of plugin should be located within a
-    specific subdirectory (such as \c imageformats or \c sqldrivers)
-    within your distribution directory, as described below.
+    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 \c imageformats or \c sqldrivers)
+    within your distribution directory.
 
     \note If you are deploying an application that uses \l{Qt WebKit} to display
     HTML pages from the World Wide Web, you should include all text codec
diff --git a/doc/src/platforms/macosx.qdoc b/doc/src/platforms/macosx.qdoc
index 10937c176..17c0a7721 100644
--- a/doc/src/platforms/macosx.qdoc
+++ b/doc/src/platforms/macosx.qdoc
@@ -141,7 +141,7 @@
     can be used as a starting point for app store deployment.
 
     \list
-    \li {Qt for Mac OS X - Deployment}
+    \li \l{Qt for Mac OS X - Deployment}
     \endlist
 
     \section1 Mac OS X Issues
@@ -915,7 +915,8 @@
     best location is to put them under Contents/Plugins. When we built
     the Plug & Paint plugins, based on the \c DESTDIR variable in their \c .pro
     file, the plugins' \c .dylib files are in the \c plugins subdirectory
-    under the \c plugandpaint directory. We just have to move this director.
+    under the \c plugandpaint directory. We just have to move this directory
+    to the correct location.
 
     \snippet snippets/code/doc_src_deployment.qdoc 43
 
@@ -1007,11 +1008,18 @@
 
     \section2 Qt Plugins
 
+    All Qt GUI applications require a plugin that implements the \l {Qt
+    Platform Abstraction} (QPA) layer in Qt 5. For Mac OS X, the name of the
+    platform plugin is \c {libqcocoa.dylib}. This file must be located within a
+    specific subdirectory (by default, \c platforms) under your distribution
+    directory. Alternatively, it is possible to adjust the search path Qt
+    uses to find its plugins, as described below.
+
     Your application may also depend on one or more Qt plugins, such as the JPEG
     image format plugin or a SQL driver plugin. Be sure to distribute any Qt
-    plugins that you need with your application. Each type of plugin must be
-    located within a specific subdirectory (such as \c imageformats or \c
-    sqldrivers) in your distribution directory, as described below.
+    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
+    \c imageformats or \c sqldrivers) in your distribution directory.
 
     When deploying an application that uses Qt WebKit to display HTML pages from
     the World Wide Web, you must include all text codec plugins to support as
@@ -1090,14 +1098,16 @@
     frameworks.
 
     The mac deployment tool also deploys the Qt plugins, according
-    to the following rules:
+    to the following rules (unless \c {-no-plugins} option is used):
     \list
+    \li The platform plugin is always deployed.
     \li Debug versions of the plugins are not deployed.
     \li The designer plugins are not deployed.
-    \li The Image format plugins are always deployed.
+    \li The image format plugins are always deployed.
+    \li The print support plugin is always deployed.
     \li SQL driver plugins are deployed if the application uses the \l{Qt SQL} module.
     \li Script plugins are deployed if the application uses the \l{Qt Script} module.
-    \li The svg icon plugin is deployed if the application uses the \l{Qt SVG} module.
+    \li The SVG icon plugin is deployed if the application uses the \l{Qt SVG} module.
     \li The accessibility plugin is always deployed.
     \endlist
 
@@ -1105,11 +1115,33 @@
     into the bundle manually, after the bundle is created.
 
     \c macdeployqt supports the following options:
-    \list
-    \li \c{-no-plugins}: Skip plugin deployment
-    \li \c{-dmg}       : Create a .dmg disk image
-    \li \c{-no-strip}  : Don't run 'strip' on the binaries
-    \endlist
+    \table
+    \header
+        \li Option
+        \li Description
+    \row
+        \li \c{-verbose=<0-3>}
+        \li 0 = no output, 1 = error/warning (default), 2 = normal, 3 = debug
+    \row
+        \li \c{-no-plugins}
+        \li Skip plugin deployment
+    \row
+        \li \c{-dmg}
+        \li Create a .dmg disk image
+    \row
+        \li \c{-no-strip}
+        \li Don't run 'strip' on the binaries
+    \row
+        \li \c{-use-debug-libs}
+        \li Deploy with debug versions of frameworks and plugins (implies
+            \c{-no-strip})
+    \row
+        \li \c{-executable=<path>}
+        \li Let the given executable also use the deployed frameworks
+    \row
+        \li \c{-qmldir=<path>}
+        \li Deploy imports used by .qml files in the given path
+    \endtable
 */
 
 /*!
diff --git a/doc/src/platforms/platform-notes-android.qdoc b/doc/src/platforms/platform-notes-android.qdoc
index 3cb5b0b3b..011a1a2e6 100644
--- a/doc/src/platforms/platform-notes-android.qdoc
+++ b/doc/src/platforms/platform-notes-android.qdoc
@@ -42,17 +42,18 @@
     The easiest way to develop with Qt for Android is to use
     \l{http://qt-project.org/doc/qtcreator/creator-developing-android.html}{Qt Creator}. When you apply
     a \b{Qt for Android Kit} to a Qt Creator project, it will create and maintain a set of files which
-    are required to make your app run on Android.
+    are required to make your application run on Android.
 
     The files added to your project are:
     \list
-    \li Java files which serve as the entry point into your app and which will automatically load Qt
-        and execute the native code in your app
-    \li AndroidManifest.xml which provides meta-information about your app
-    \li Other XML files detailing the dependencies of your app
+    \li \e .java files will serve as the entry point into your application and
+    automatically load Qt to execute the native code in your application
+    \li \e AndroidManifest.xml which provides meta-information about your
+    application
+    \li Other XML files detailing the dependencies of your application
     \li Resource files
-    \li Depending on the deployment method selected in Qt Creator, additional files like libraries
-    and QML files can be included in the project.
+    \li Depending on the deployment method selected in Qt Creator, additional
+    files like libraries and QML files can be included in the project.
     \endlist
 
     Qt Creator adds these files in a subdirectory of your project called \b android. The contents of
@@ -60,10 +61,11 @@
 
     \section1 Application Package
 
-    On Android, apps are distributed in packages called APK. Qt Creator will manage building the
-    APK for you, but if you for some reason want to do this manually, you must first make sure
-    that the appropriate packaging and build files are in place. As mentioned, Qt Creator will
-    place these files in the \b android subfolder in your project.
+    On Android, apps are distributed in packages called \e APK. Qt Creator
+    builds the \e APK for you, but if you for some reason want to do this
+    manually, you must first make sure that the appropriate packaging and build
+    files are in place. For more detailed information about how the packaging
+    is done, see \l{Deploying an Application on Android}.
 
     \section1 Deployment
 
diff --git a/doc/src/platforms/windows.qdoc b/doc/src/platforms/windows.qdoc
index b4920b8e0..61f8021a3 100644
--- a/doc/src/platforms/windows.qdoc
+++ b/doc/src/platforms/windows.qdoc
@@ -398,13 +398,14 @@
 
     To deploy the application, we must make sure that we copy the
     relevant Qt DLL (corresponding to the Qt modules used in
-    the application) and the windows platform plugin as well as the executable
-    to the same directory in the \c release subdirectory.
+    the application) and the Windows platform plugin, \c {qwindows.dll},
+    as well as the executable to the same directory tree in the \c release
+    subdirectory.
 
     In contrast to user plugins, Qt plugins have to be put into subdirectories
-    matching the plugin type. As we want to deploy the windows platform plugin
-    it has to be put into a "platforms" subdirectory. Additional information
-    about user and Qt plugins will be covered later.
+    matching the plugin type. The correct location for the platform plugin
+    is a subdirectory named \c {platforms}. \l{Qt Plugins} section has
+    additional information about plugins and how Qt searches for them.
 
     Qt relies on the \l{ICU} library for unicode support. Therefore, you must
     include the ICU DLLs that are located in the \c bin directory of your Qt
@@ -681,12 +682,19 @@
 
     \section2 Qt Plugins
 
+    All Qt GUI applications require a plugin that implements the \l {Qt
+    Platform Abstraction} (QPA) layer in Qt 5. For Windows, the name of the
+    platform plugin is \c {qwindows.dll}. This file must be located within a
+    specific subdirectory (by default, \c platforms) under your distribution
+    directory. Alternatively, it is possible to adjust the search path Qt
+    uses to find its plugins, as described below.
+
     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, and note that each type of plugin should be located within a
-    specific subdirectory (such as \c printsupport, \c imageformats or
-    \c sqldrivers) within your distribution directory, as described below.
+    application. Similar to the platform plugin, each type of plugin must
+    be located within a specific subdirectory (such as \c printsupport,
+    \c imageformats or \c sqldrivers) within your distribution directory.
 
     \note 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
diff --git a/doc/src/qmlapp/applicationdevelopers.qdoc b/doc/src/qmlapp/applicationdevelopers.qdoc
index 9a29e5a2f..b4cb72e38 100644
--- a/doc/src/qmlapp/applicationdevelopers.qdoc
+++ b/doc/src/qmlapp/applicationdevelopers.qdoc
@@ -97,6 +97,9 @@ native behavior found in different platforms such as Windows, OS X, and Linux.
 
 \list
 \li \l{Qt Quick Controls Overview}
+\li \l{Qt Quick Controls Styles}{Styles}
+\li \l{Qt Quick Dialogs}{Dialogs}
+\li \l{Qt Quick Layouts}{Layouts}
 \endlist
 
 \section2 Special Effects
@@ -140,9 +143,26 @@ in C++.
     \li \l{Video Overview}
     \li \l{Camera Overview}
     \li \l{Radio Overview}
+    \li \l{Qt Audio Engine QML Types}{Qt Audio Engine} - for 3D positional audio
+    playback and content management.
     \endlist
 \endlist
 
+\section1 Mobile Devices
+
+Several Qt modules provide QML APIs for networked and mobile devices. The QML
+types access Bluetooth, Near-Field Communications (NFC), and GPS-enabled
+devices.
+
+\list
+\li \l{Qt Positioning}
+\li \l{Qt Bluetooth}
+\li \l{Qt NFC}
+\endlist
+
+For more information, visit the \l{Networking and Connectivity} and
+\l{Mobile APIs} pages.
+
 \section1 Code Samples and Demos
 
 To learn more about uses of QML code, there are several code samples which show
diff --git a/doc/src/qt5-intro.qdoc b/doc/src/qt5-intro.qdoc
index 4f491655d..c666074c0 100644
--- a/doc/src/qt5-intro.qdoc
+++ b/doc/src/qt5-intro.qdoc
@@ -57,27 +57,28 @@
     \section1 Qt Everywhere on Mobile
 
     Qt 5.2 introduces the production-ready ports of Qt on Android
-    and iOS. Extensive work has gone into these two platforms and these ports
-    now extend Qt’s multi-platform promise to cover desktop, embedded, and
-    mobile platforms with just one framework, Qt.
+    and iOS. Extensive work has gone into these two platforms and these
+    ports now extend Qt’s multi-platform promise to cover desktop,
+    embedded, and mobile platforms with just one framework, Qt.
 
-    With full support for Android, iOS, and Blackberry 10, Qt 5.2 is a great
-    solution for targeting the mobile markets with one Qt-based mobile
-    application code. It is fast and easy to bring existing desktop or
-    embedded application to mobile, by simply recompiling it.
+    With full support for Android, iOS, and Blackberry 10, Qt 5.2 is a
+    great solution for targeting the mobile markets with one Qt-based
+    mobile application code. It is fast and easy to bring existing
+    desktop or embedded application to mobile, by simply recompiling it.
 
-    You can install several demo applications that show Qt on iOS and Android
-    from the iTunes and Google Play. On Android, we have a new \e{Qt Everywhere}
-    demo as well as the Qt 5 launch demo available in Google Play. For iOS, we
-    have \e SubAttack, a small Qt based game and \e QtQuicksand published in
-    iTunes.
+    You can install several demo applications that show Qt on iOS and
+    Android from the App Store and Google Play. On Android, we have a new
+    \e{Qt Everywhere} demo as well as the Qt 5 launch demo available in
+    Google Play. For iOS, we have \e SubAttack and \e QtQuicksand published
+    in the App Store.
 
     Demo applications:
     \list
-    \li \l{Google Play: Introduction to Qt 5}{Introduction to Qt 5} (Google Play)
+    \li \l{Google Play: Introduction to Qt 5}{Introduction to Qt 5}
+        (Google Play)
     \li \l{Google Play: Qt 5 Everywhere}{Qt 5 Everywhere} (Google Play)
-    \li \l{iTunes: SubAttack}{SubAttack} (iTunes)
-    \li \l{iTunes: QtQuicksand}{QtQuicksand} (iTunes)
+    \li \l{iTunes: SubAttack}{SubAttack} (App Store)
+    \li \l{iTunes: QtQuicksand}{QtQuicksand} (App Store)
     \endlist
 
     Platform pages:
@@ -87,9 +88,16 @@
     \li \l{Qt for iOS}
     \endlist
 
+    \table
+    \header
+    \li Qt Everywhere demo on Nexus 7
+    \row
+    \li \image qt5_everywhere_demo.jpg
+    \endtable
+
     \section1 Amazing Graphics Capability and Performance
 
-    Qt 5 uses an OpenGL based scene graph to accelerate the graphics
+    Qt 5 uses an OpenGL-based scene graph to accelerate the graphics
     of Qt Quick, making it possible to do visually appealing user
     interfaces with animations, impressive graphical effects and
     particle systems, even on the constrained hardware environments of
@@ -97,74 +105,119 @@
 
     \table
     \header
-      \li \l ShaderEffect on an \l Image
-    \row
-      \li \image qt5_shadereffect.jpg
+    \li ShaderEffect on an \l Image
     \row
+    \li \image qt5_shadereffect.jpg
     \endtable
 
-    The benefits of this architectural change in the rendering engine is well
-    demonstrated by the following projects:
+    The benefits of this architectural change in the rendering engine are
+    well demonstrated by the following projects:
     \list
     \li \l{Livecoding video effects with Qt5} - The Big Buck Bunny you
-        never saw before. Video effects created using Qt Quick.
-    \li \l{Pimp my video} - Video effects implemented using the shader language
-        with QML.
+    never saw before. Video effects created using Qt Quick.
+    \li \l{Pimp my video} - Video effects implemented using the shader
+    language with QML.
     \li \l{QtMediaHub} - The power and convenience of Qt Quick.
     \li \l{QtonPi} - Good example of Qt 5 running on the low cost hardware,
-        Raspberry PI.
+    Raspberry PI.
     \endlist
 
-
-
     \section1 Qt Quick in Qt 5
 
-    \l {Qt Quick} provides the necessary infrastructure to develop QML
+    \l{Qt Quick} provides the necessary infrastructure to develop QML
     applications. The latest version (v2.0) of this technology also
     introduces a set of new C++ classes as a replacement for the
     QDeclarative* equivalents in Qt Quick 1. New features in Qt Quick
     include:
     \list
     \li \l Canvas for drawing. Canvas provides an API that is similar to
-        the HTML5 Canvas API, along with some additional features.
-    \li \l {ShaderEffect} {Shader Effects} which enable GLSL shader programs to be
-        integrated directly into QML code and applied to items and
-        images.
-    \li \l {Using the Qt Quick Particle System}{Particle Effects} for creating a variety of 2D particle systems.
-    \li \l {Sprite Animations}{Sprites} can be used in animating 2D graphical objects and as a source
-    for particle systems.
-    \li \l {Qt Quick Local Storage QML Types}{Offline storage} is a HTML5 Web Database API conformant JavaScript API
-    for storing data in Qt Quick applications.
-
-    \li \l {Qt Quick Window QML Types}{Window} provides a
-    top-level window and the Screen type for accessing a screen's
-    resolution and other details. This is useful for desktop
-    applications developed using Qt Quick.
-
-    \li \l {Qt Quick Scene Graph} {New rendering architecture} based on OpenGL for optimal performance.
+    the HTML5 Canvas API, along with some additional features.
+
+    \li \l{ShaderEffect}{Shader Effects} which enable GLSL shader programs
+    to be integrated directly into QML code and applied to items and images.
+
+    \li \l{Using the Qt Quick Particle System}{Particle Effects} for
+    creating a variety of 2D particle systems.
+
+    \li \l{Sprite Animations}{Sprites} can be used in animating 2D
+    graphical objects and as a source for particle systems.
+
+    \li \l{Qt Quick Local Storage QML Types}{Offline storage} is a JavaScript
+    API that conforms with the HTML5 Web Database API for storing data in
+    Qt Quick applications.
+
+    \li \l{Qt Quick Window QML Types}{Window} provides a top-level window
+    and the Screen type for accessing a screen's resolution and other
+    details. This is useful for desktop applications developed using
+    Qt Quick.
+
+    \li \l{Qt Quick Scene Graph}{OpenGL-based rendering architecture} for
+    optimal performance.
     \endlist
 
     \table
     \header
-      \li Qt Quick's \l {Using the Qt Quick Particle System}{Particle System}
+    \li Qt Quick's \l{Qt Quick Particles QML Types}{Particle System}
     \row
-      \li \image qt5_particles.jpg
+    \li \image qt5_particles.jpg
+    \endtable
+
+    Qt Quick's \l {Using the Qt Quick Particle System}{Particle System}
+
+    The \l {qtgraphicaleffects-index.html}{Qt Graphical Effects} module
+    provides a number of ready-made effects for use in Qt Quick
+    applications, including soft drop shadow, blur, glow and colorize.
+
+    \table
+    \header
+    \li Excerpts from the Qt Graphical Effects module
     \row
+    \li \image qt5_graphicaleffects.jpg
     \endtable
 
-    The \l {qtgraphicaleffects-index.html}{Qt Graphical Effects} module provides a number of
-    ready-made effects for use in Qt Quick applications, including
-    soft drop shadow, blur, glow and colorize.
+    \section1 Designing UI Made Simpler
+
+    UI designing can be time consuming if there are not enough tools to help.
+    Qt Quick does reduce the effort considerably compared to the traditional
+    native (C or C++) approach, but the new \l{Qt Quick Controls} and
+    \l{Qt Quick Layouts} take it a step further. These new modules provide
+    ready-to-use UI controls and layouts to enable faster application
+    development and with less code.
+
+    Qt Quick Controls and Qt Quick Layouts provide a vast set of UI controls
+    ranging from the most basic TextField and Button to the more complex
+    TableView and TabView. These controls are also made available in
+    \l{Qt Creator: Using Qt Quick Designer}{Qt Quick Designer}.
 
     \table
     \header
-      \li Excerpts from the Qt Graphical Effects module.
+    \li Controls touch example on Nexus 7
     \row
-      \li \image qt5_graphicaleffects.jpg
+    \li \image quick_controls_touch_ex.jpg
+    \endtable
+
+    \table
+    \header
+    \li Component gallery example on Ubuntu 12.04
     \row
+    \li \image qtquickcontrols-example-gallery.jpg
     \endtable
 
+    \section1 Sensor and Location
 
+    Reacting to sensor value changes and locating a place on the world map
+    are the common use cases supported on most portable devices. Now you
+    can support such use cases in your Qt application using the
+    \l{Qt Sensors} and \l{Qt Positioning} modules.
+
+    \table
+    \header
+    \li Accelerating SVG image
+    \li Location-based weather information
+    \row
+    \li \image qtsensors_accelbubble_ex.jpg
+    \li \image qtpositioning_weatherinfo_ex.jpg
+    \endtable
 
     \section1 WebKit and HTML5
 
@@ -172,27 +225,46 @@
     source WebKit project featuring broad support for standard web
     technologies. The Qt WebKit module provides integration with both
     Qt Quick and traditional widgets. The module brings the latest in
-    HTML5 advancements to Qt 5, including CSS filters and animations
-    and Video, Canvas and WebGL, Canvas support and HTML video.
-
-
+    HTML5 advancements to Qt 5, including CSS filters, animations
+    and video, and Canvas and WebGL.
 
     \section1 Multimedia
 
     \l {Qt Multimedia} provides a rich set of QML types and C++ classes to
-    handle multimedia content. It also provides necessary APIs to
-    access the camera and radio functionality. Qt 5 brings the Qt
-    Multimedia module into the set of essential modules with support
-    on all major platforms.
+    handle multimedia content. It also provides necessary APIs to access
+    the camera and radio functionality. Qt 5 brings the Qt Multimedia
+    module into the set of essential modules with support on all major
+    platforms.
 
     \table
     \header
-      \li \l Video embedded into a Qt Quick application with a displacement effect
+    \li Video embedded into a Qt Quick application with a displacement effect
     \row
-      \li \image qt5_video.jpg
+    \li \image qt5_video.jpg
     \endtable
 
+    \section1 Platform-specific Extras
+
+    Qt is a cross-platform development framework enabling you to target
+    multiple platforms with a single codebase. It provides common APIs across
+    all supported platforms to access a feature without having to worry about
+    how that feature is implemented on a platform. In some applications there
+    will be a need to use a platform-specific feature, and that's
+    when the following modules can be useful:
 
+    \list
+
+    \li \l{Qt Android Extras} enables you to integrate Java code into your Qt
+    application.
+
+    \li \l{Qt Mac Extras} enables you to access specific features on Mac OS X.
+
+    \li \l{Qt Windows Extras} enables you to use Windows-specific features
+    such as jump lists, progress indicator on a taskbar button, and so on.
+
+    \li \l{Qt X11 Extras} enables you to access the display configuration on
+    Linux (X11).
+    \endlist
 
     \section1 Modularized Qt Libraries
 
@@ -205,17 +277,18 @@
 
     \section2 Widgets in Qt 5
 
-    The \l {Qt Widgets} have been separated into their own module in Qt 5,
-    the Qt Widgets module. It is part of the essential modules.
+    The \l {Qt Widgets} have been separated into their own module in
+    Qt 5, the Qt Widgets module. It is part of the essential modules.
 
     \table
     \header
-      \li Screenshots of widget based applications running Qt 5.
+    \li Screen capture of a widget application.
     \row
-      \li \image qt5_widgets.jpg
+    \li \image qt5_widgets.jpg
     \endtable
 
-
+    Designing the UI for widget-based applications can be quick with
+    \l{Qt Designer Manual}{Qt Designer}.
 
     \section1 Qt Platform Abstraction
 
@@ -227,15 +300,15 @@
 
     \list
 
-      \li Centralize the windowing system integration codebase into
-      classes shared for all platforms.
+    \li Centralize the windowing system integration codebase into
+    classes shared for all platforms.
 
-      \li Simplify the work required when porting Qt to new platforms.
+    \li Simplify the work required when porting Qt to new platforms.
 
-      \li Remove the windowing system dependency from Qt, making it
-      possible to have the same Qt binaries run against multiple
-      windowing systems. For instance, the Qt Linux binaries can run
-      against both X11 and Wayland.
+    \li Remove the windowing system dependency from Qt, making it
+    possible to have the same Qt binaries run against multiple
+    windowing systems. For instance, the Qt Linux binaries can run
+    against both X11 and Wayland.
 
     \endlist
 
@@ -274,17 +347,26 @@
     Qt 5 also provides better ways to handle TCP socket-based connections and
     SSL certificates. This means developers can now:
     \list
-      \li bind a TCP socket to an IP address before connecting,
-      \li verify an SSL certificate chain,
-      \li and access legacy systems.
+    \li bind a TCP socket to an IP address before connecting,
+    \li verify an SSL certificate chain,
+    \li and access legacy systems.
     \endlist
 
     Stricter client authentication is one of the primary concerns for many
-    applications handling confidential/critical data. The opaque Private Keys
-    support in Qt 5 enables applications to read private keys from devices such
-    as PKCS#11 dongles for stricter client authentication. The \l{qsslkey
+    applications handling confidential or critical data. The opaque Private
+    Keys support in Qt 5 enables applications to read private keys from devices
+    such as PKCS#11 dongles for stricter client authentication. The \l{qsslkey
     example} illustrates reading private keys from a device.
 
+    \section2 Extended Connectivity
+
+    The connectivity options are endless with Qt 5. We now have
+    \l{Qt Bluetooth}{Bluetooth} and \l{Qt NFC}{NFC} enabling you to connect and
+    and share information in more sophisticated ways such as tap and share,
+    auto-paring two Bluetooth-enabled devices, and so on. These connectivity
+    options are supported on Linux (with BlueZ 4.x) and
+    \l{Qt for BlackBerry}{BlackBerry 10} platforms.
+
     \section1 JSON Support
 
     Qt applications that use simple data structures to store small amount of
@@ -315,11 +397,12 @@
     platforms where this is supported. This comes in handy for gaming
     applications developed using Qt.
 
-   \section1 Related Topics
-   \list
+    \section1 Related Topics
+    \list
     \li \l{What's New in Qt 5.2}
     \li \l{What's New in Qt 5.1}
     \li \l{What's New in Qt 5.0}
     \li \l{Porting Guide}
-   \endlist
+    \endlist
+    \l text
 */
diff --git a/doc/src/whatsnew/whatsnew52.qdoc b/doc/src/whatsnew/whatsnew52.qdoc
index 6fb736419..1e97e70ee 100644
--- a/doc/src/whatsnew/whatsnew52.qdoc
+++ b/doc/src/whatsnew/whatsnew52.qdoc
@@ -53,7 +53,7 @@
 
     \section1 Support for New Platforms
 
-        \section2 Qt for Android
+        \section2 Android
 
         \list
         \li Full support for camera and recording
@@ -65,7 +65,7 @@
 
         For more information, visit the \l{Qt for Android} page.
 
-        \section2 Qt for iOS
+        \section2 iOS
 
         \list
         \li Media player support