Doc: Update product name and intro/overview pages

    - Update product name to 'Qt for Device Creation'
    - Update index page and overview docs
    - Separate Boot to Qt section into its own page
    - Update documentation version
    - Link to Qt reference docs under doc.qt.io
    - Link to Android injection blog post

Change-Id: Ib8a35303285930b32b5c33995df8eeba9c1a978c
Reviewed-by: Eirik Aavitsland <eirik.aavitsland@theqtcompany.com>

6 files changed, 179 insertions, 93 deletions

diff --git a/src/doc/config/b2qt.qdocconf b/src/doc/config/b2qt.qdocconf
index 1e499dc..96b0a99 100644
--- a/src/doc/config/b2qt.qdocconf
+++ b/src/doc/config/b2qt.qdocconf
@@ -5,8 +5,8 @@ outputencoding               = UTF-8
 sourceencoding               = UTF-8
 
 project                      = QtEnterpriseEmbedded
-description                  = Qt Enterprise Embedded Documentation
-version                      = 3.2.0
+description                  = Qt for Device Creation
+version                      = 4.0.0
 
 sourcedirs                   = ../src \
                                ../../imports/wifi \
@@ -19,25 +19,26 @@ imagedirs                   += ../images
 indexes                      = $QT_INSTALL_DOCS/qtquick/qtquick.index \
                                $QT_INSTALL_DOCS/qtcore/qtcore.index \
                                $QT_INSTALL_DOCS/qtserialport/qtserialport.index \
-                               $QT_INSTALL_DOCS/emulator/emulator.index
+                               $QT_INSTALL_DOCS/emulator/emulator.index \
+                               $QT_INSTALL_DOCS/qtwebengine/qtwebengine.index
 
 qhp.projects                 = B2Qt
 
 qhp.B2Qt.file                = b2qt.qhp
-qhp.B2Qt.namespace           = com.digia.b2qt.320
+qhp.B2Qt.namespace           = com.digia.b2qt.400
 qhp.B2Qt.virtualFolder       = b2qt
-qhp.B2Qt.indexTitle          = Qt Enterprise Embedded Documentation
+qhp.B2Qt.indexTitle          = Qt for Device Creation
 qhp.B2Qt.indexRoot           =
 
 qhp.B2Qt.subprojects                   = manual
-qhp.B2Qt.subprojects.manual.title      = Qt Enterprise Embedded
-qhp.B2Qt.subprojects.manual.indexTitle = Qt Enterprise Embedded
+qhp.B2Qt.subprojects.manual.title      = Qt for Device Creation
+qhp.B2Qt.subprojects.manual.indexTitle = Qt for Device Creation
 qhp.B2Qt.subprojects.manual.type       = manual
 
 macro.B2Q                    = "Boot to Qt"
-macro.SDK                    = "Qt Enterprise Embedded"
+macro.SDK                    = "Qt for Device Creation"
 macro.B2QA                   = "\\e {Boot to Qt for embedded Android}"
 macro.B2QL                   = "\\e {Boot to Qt for embedded Linux}"
 
-navigation.landingpage = "Qt Enterprise Embedded"
+navigation.landingpage = "Qt for Device Creation"
 navigation.qmltypespage = "Add-On QML Types"
diff --git a/src/doc/images/b2qt-vs-qt-for-android.png b/src/doc/images/b2qt-vs-qt-for-android.png
deleted file mode 100644
index 4c2cf6d..0000000
--- a/src/doc/images/b2qt-vs-qt-for-android.png
+++ /dev/null
diff --git a/src/doc/images/build-your-own-stack.png b/src/doc/images/build-your-own-stack.png
new file mode 100644
index 0000000..6640a09
--- /dev/null
+++ b/src/doc/images/build-your-own-stack.png
diff --git a/src/doc/src/qtee-index.qdoc b/src/doc/src/qtee-index.qdoc
index 7228edf..f4b4757 100644
--- a/src/doc/src/qtee-index.qdoc
+++ b/src/doc/src/qtee-index.qdoc
@@ -18,19 +18,20 @@
 ****************************************************************************/
 
 /*!
-    \contentspage{index.html}{Qt Enterprise Embedded}
+    \contentspage{index.html}{Qt for Device Creation}
     \page index.html
     \nextpage qtee-overview.html
-    \title Qt Enterprise Embedded
+    \title Qt for Device Creation
 
-    \SDK provides a fully-integrated solution to get you started immediately
-    with software development on your embedded device with a tailored user
-    experience for embedded Linux and embedded Android. \SDK contains the tools
-    you need for fast, easy, and fully-integrated embedded device application
-    development. It comes with \B2Q, a light-weight UI stack for embedded
-    systems, and the Qt Creator integrated development environment (IDE) with
-    preconfigured build targets for hardware platforms, as well as an emulator
-    for testing the applications.
+    With commercially licensed Qt for device creation, you get a fully-integrated
+    solution to get you started immediately with software development on your
+    embedded device with a tailored user experience for embedded Linux and
+    embedded Android. Qt libraries can also be manually configured to other
+    operating systems or custom software stacks.
+
+    The Qt development environment for device creation consists of:
+
+    \include common.qdocinc overview-list
 
     \e{\b{IMPORTANT:} Make sure to follow the \l{Installation Guide}
     closely!}
@@ -38,7 +39,7 @@
     \section1 Contents
 
     \list
-        \li \l{About Qt Enterprise Embedded}
+        \li \l{Overview}
         \li \l{Installation Guide}
         \li \l{Supported Platforms}
         \li \l{Preparing Hardware}
@@ -71,66 +72,119 @@
 */
 
 /*!
-    \contentspage{index.html}{Qt Enterprise Embedded}
+    \contentspage{index.html}{Qt for Device Creation}
     \page qtee-overview.html
     \previouspage index.html
-    \nextpage qtee-installation-guide.html
+    \nextpage qtee-about-b2qt.html
 
-    \title About Qt Enterprise Embedded
+    \title Overview
 
-    \SDK has two main parts:
+    The development package that you get with Qt for device creation consists of:
 
-    \list
-        \li Development environment that is installed on a Linux development
-            desktop by using an online installer
-        \li \B2Q
-    \endlist
+    \include common.qdocinc overview-list
+
+    \section1 About Qt Development Libraries
+
+    \l {http://www.qt.io/}{Qt} is a full development framework designed to
+    streamline the creation of applications and user interfaces for desktop,
+    embedded, and mobile platforms. With Qt, you can reuse code efficiently
+    to target multiple platforms with one code base. The modular C++ class
+    library and development tools enable developers to create applications
+    for one platform and easily build and deploy on other platforms as well.
+
+    The Qt libraries provide high-level APIs for a large variety of both
+    non-GUI and GUI related functionality. For UI creation, Qt provides a
+    number of approaches: traditional C++, declarative UI design with
+    \l {Qt Quick} or HTML5/hybrid user interfaces with the \l {Qt WebEngine}
+    module.
+
+    For overview about Qt libraries see the \l {Qt reference documentation}.
 
     \section1 About the Development Environment
 
-    The development is done with the Qt Enterprise libraries and device
-    deployment can be done with one click directly from Qt Creator to a device
-    connected via USB. Alternatively, you can deploy the application locally
-    directly to the \B2Q Emulator that is running the full target software stack
-    as in the device.
+    The development environment is built around the Qt Creator IDE. Qt Creator
+    runs on all desktop platforms, but the embedded development environment is
+    currently supported only on 64-bit Linux desktop.
+
+    Device deployment can be done directly from the Qt Creator IDE to a device
+    connected via USB or local area network. The Qt Creator IDE is
+    pre-configured for devices running \B2Q but can also be manually configured
+    to build and deploy to custom embedded toolchains and devices.
 
-    As with any Qt based application, the same application can be deployed to
-    desktop and mobile OS targets as well.
+    Alternatively, you can deploy the application locally to the Emulator that
+    is running the same, full  software stack as the devices. As with any Qt
+    based application, the same application can be deployed to desktop and
+    mobile OS targets as well.
+*/
+
+/*!
+    \contentspage{index.html}{Qt for Device Creation}
+    \page qtee-about-b2qt.html
+    \previouspage qtee-overview.html
+    \nextpage qtee-installation-guide.html
 
-    \section1 About \B2Q
+    \title About Boot to Qt
 
     \e{\b{\B2Q}} is a light-weight, Qt-optimized, full software stack for
     embedded systems that is installed into the actual target device. This is
     done by flashing the device's memory card or internal memory directly with a
-    pre-built image that comes with the development environment.
+    pre-built image that comes with the online installer.
+    See the \l{Installation Guide} for details.
 
-    \B2Q supports two different operating systems:
+    \B2Q is ideal for the following use cases:
 
     \list
-        \li \b{\B2QA} where the software stack is based on the Android Kernel
-            (version 4.1 or higher) and selected  middleware. It includes a lean
-            software stack where Qt/QML replaces the top Java graphical layer
-            and removes the Zygote process layer as well the Android home screen
-            enabling better and faster development where modern UIs are at the
-            forefront.
-
-        \li \b{\B2QL} where the software stack is using the traditional embedded
-            Linux kernel built with the Yocto Poky reference system (Yocto 1.6
-            \e Daisy release). The Embedded Linux variant is designed for great
-            customization possibilities. It contains only components required in
-            the embedded device, resulting in smaller image sizes while keeping
-            valuable development tools available.
+        \li Evaluating Qt on real embedded environment using one of the provided
+            reference images.
+        \li Getting an immediately working embedded development environment up
+            and running as a starting point to production development. Later,
+            the stack can be customized to production with
+            \e Build-Your-Own-Stack tooling, including proprietary Yocto Project
+            recipes.
+        \li Creating embedded devices from off-the-shelf programmable Android
+            devices using \l {Android injection}.
     \endlist
 
-    Both versions have been tested and verified on a number of different
-    hardware configurations. \B2Q support is not limited to the devices used
-    as reference platforms, it can be made to run on a variety of hardware.
+    \image build-your-own-stack.png
+
+    Boot to Qt supports two different operating systems:
+
+    \b{\B2QL}\br
+    \B2QL is using the traditional embedded Linux
+    kernel built with the Yocto Poky reference system (Yocto 1.6 Daisy release).
+    The embedded Linux variant is designed for great customization possibilities.
+    It contains only components required in the embedded device, resulting in
+    smaller image sizes while keeping valuable development tools available.
+
+    \b{\B2QA}\br
+    The embedded Android stack provides an easy way to create a full embedded
+    device using off-the-shelf programmable Android devices,
+    making the device run stripped-down, Qt-optimized OS and middleware stack.
+    The device will then become an embedded device running Qt applications,
+    instead of running the Android OS with Android applications.
+
+    For just creating applications using the Qt libraries that run on the native
+    Android OS, see \l {Qt for Android} in Qt reference documentation.
+
+    \B2QA tries to strip down the Android stack to the
+    bare minimum, relying only on basic Linux features. The majority of the
+    Android stack, such as Dalvik virtual machine is not running in Boot to Qt,
+    resulting in faster startup times, lower memory consumption and overall
+    better performance.
+
+    The embedded Android stack can be installed into programmable Android
+    devices that are based on Android version 4.2 or higher.
 
-    \section1 Value-Add Components
+    Both versions of \B2Q have been tested and verified on a number of different
+    hardware configurations. Usage of \B2Q is not limited to the devices used as
+    \l {Supported Platforms}{reference platforms}, it can be made to run on a
+    variety of hardware.
 
-    In addition to the \B2Q stack and a comprehensive development environment,
-    \SDK comes with a set of components that bring new features and speed up the
-    creation of high-performing, modern UI embedded applications:
+    \section1 Additional Embedded Libraries and Value-Add Components
+
+    In addition to the Boot to Qt stack and a comprehensive development
+    environment, \SDK comes with a set of components that bring new features and
+    speed up the creation of high-performing, modern UI embedded applications:
 
     \list
         \li \l {Qt Virtual Keyboard} - complete virtual keyboard solution with
@@ -142,46 +196,32 @@
             assets.
         \li \l {Qt Charts} - UI Components for displaying visually pleasing
             charts, driven by static or dynamic data models.
-        \li \l {Qt Data Visualization} - UI Components for creating stunning
-            3D data visualizations.
+        \li \l {Qt Data Visualization} - UI Components for creating stunning 3D
+            data visualizations.
+        \li \l {Qt Quick 2D Renderer} - enables Qt Quick UIs on GPU-less
+            devices.
     \endlist
 
-    \section1 About Qt
+    \section1 Build-Your-Own-Stack Tooling
+
+    \B2QL is built using the tools and resources from the \l {Yocto Project},
+    and is based on Yocto's reference distribution (\e Poky). You can
+    use the same tools to build custom \B2Q images, and have control over
+    which packages are included in the build and how the software stack
+    is configured.
 
-    \l{http://www.qt.io}{Qt} is a full development framework with tools
-    designed to streamline the creation of applications and user interfaces
-    for desktop, embedded, and mobile platforms.
+    The process consist of three parts: Building the \B2Q image and the
+    external toolchain, building Qt libraries and add-ons, and configuring
+    Qt Creator for the new toolchain and custom image:
 
     \list
-        \li \b{Qt Framework} - intuitive APIs for C++
-            and CSS/JavaScript-like programming with
-            \b{Qt Quick} for rapid UI
-            creation
-        \li \b{Qt Creator IDE} - powerful cross-platform integrated development
-            environment, including UI designer tools and on-device debugging
-        \li \b{Tools and toolchains} - internationalization support, embedded
-            toolchains and more.
+        \li \l {Building Your Own Embedded Linux Image}
     \endlist
 
-    With Qt, you can reuse code efficiently to target multiple platforms
-    with one code base. The modular C++ class library and development tools
-    enable developers to create applications for one platform and easily
-    build and run to deploy also on other platforms.
-
-
-    \section1 \B2Q vs Qt for Android
-
-    \image b2qt-vs-qt-for-android.png
-
-    \e{\b{Qt for Android}} is a port of the Qt Framework to be used for application
-    development on the Android platform. Its purpose is to enable development
-    of applications that can run on Android devices. For developers writing
-    applications for the Android ecosystem, Qt for Android is the right choice.
+    \section1 Emulator
 
-    \b{\B2QA} tries to strip down the Android
-    stack to the bare minimum, relying only on basic Linux
-    features. The majority of the Android stack, such as
-    \e{Dalvik virtual machine} is not running in \B2Q,
-    resulting in faster startup times, lower memory consumption and
-    overall better performance.
+    The \l {Emulator Manual}{emulator} running a \B2Q image enables you to
+    test and debug applications in an environment practically identical to
+    that of the device, without having a real device connected to the
+    development host.
 */
diff --git a/src/doc/src/shared/b2qt-external-pages.qdoc b/src/doc/src/shared/b2qt-external-pages.qdoc
index bdbd9b9..2da9463 100644
--- a/src/doc/src/shared/b2qt-external-pages.qdoc
+++ b/src/doc/src/shared/b2qt-external-pages.qdoc
@@ -18,6 +18,16 @@
 ****************************************************************************/
 
 /*!
+    \externalpage http://doc.qt.io/
+    \title Qt reference documentation
+*/
+
+/*!
+    \externalpage http://doc.qt.io/qt-5/android-support.html
+    \title Qt for Android
+*/
+
+/*!
     \externalpage http://www.qt.io/qt-for-device-creation/
     \title product page
 */
@@ -56,3 +66,8 @@
     \externalpage https://www.yoctoproject.org/
     \title Yocto Project
 */
+
+/*!
+    \externalpage http://blog.qt.digia.com/blog/2014/07/04/making-an-android-device-boot-to-qt/
+    \title Android Injection
+*/
diff --git a/src/doc/src/shared/common.qdocinc b/src/doc/src/shared/common.qdocinc
new file mode 100644
index 0000000..a5b9b0a
--- /dev/null
+++ b/src/doc/src/shared/common.qdocinc
@@ -0,0 +1,30 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use the contact form at
+** http://www.qt.io
+**
+** This file is part of Qt Enterprise Embedded.
+**
+** Licensees holding valid Qt Enterprise licenses may use this file in
+** accordance with the Qt Enterprise License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** the contact form at http://www.qt.io
+**
+****************************************************************************/
+/*!
+//! [overview-list]
+    \list
+        \li Qt development libraries and core tools
+        \li Additional embedded libraries and value-add components
+        \li Embedded development environment around Qt Creator IDE
+        \li \B2Q, a light-weight software stack for embedded systems
+        \li Build-Your-Own-Stack tooling for customizing the Boot to Qt stack
+        \li Device emulator for software development and testing without
+            target hardware
+    \endlist
+//! [overview-list]