Add space between Qt and name/number when mentioning Qt products

Fix qmlbook#56

docs/ch01-meetqt/intro.md

@@ -1,8 +1,8 @@
-# Qt6 Introduction
+# Qt 6 Introduction
 
 ## Qt Quick
 
-Qt Quick is the umbrella term for the user interface technology used in Qt6. It was introduced in Qt5 and now expanded for Qt6. Qt Quick itself is a collection of several technologies:
+Qt Quick is the umbrella term for the user interface technology used in Qt 6. It was introduced in Qt 5 and now expanded for Qt 6. Qt Quick itself is a collection of several technologies:
 
 * QML - Markup language for user interfaces
 * JavaScript - The dynamic scripting language

docs/ch01-meetqt/meet-qt.md

@@ -1,33 +1,33 @@
-# Qt and QtQuick
+# Qt and Qt Quick
 
-This book provides you with a walk through of the different aspects of application development using the new Qt6. It focuses on the Qt Quick technology, but also provides necessary information about writing C++ back-ends and extension for Qt Quick.
+This book provides you with a walk through of the different aspects of application development using the new Qt 6. It focuses on the Qt Quick technology, but also provides necessary information about writing C++ back-ends and extension for Qt Quick.
 
-This chapter shall provide a high-level overview of Qt6. It shows the different application models available for developers, as well as a showcase application, as a sneak preview of things to come. Additionally, the chapter aims to provide a wide overview of the Qt content and how to get in touch with the makers of Qt the Qt Company.
+This chapter shall provide a high-level overview of Qt 6. It shows the different application models available for developers, as well as a showcase application, as a sneak preview of things to come. Additionally, the chapter aims to provide a wide overview of the Qt content and how to get in touch with the makers of Qt the Qt Company.
 
 
-## Qt6 Focus
+## Qt 6 Focus
 
-Qt5 was released many years ago and introduced a new declarative way of writing stunning user interfaces. Since then a lot has changed in the world around us. The
+Qt 5 was released many years ago and introduced a new declarative way of writing stunning user interfaces. Since then a lot has changed in the world around us. The
 
-Qt6 will be a continuation of what has been done with Qt5 and should not be disruptive to the majority of users. What make Qt valuable to the users?
+Qt 6 will be a continuation of what has been done with Qt 5 and should not be disruptive to the majority of users. What make Qt valuable to the users?
 
 * It's cross-platform nature
 * It's scalability
 * World class APIs and documentation
 * Maintainability, stability and compatibility
 * A large developer ecosystem
 
-Qt6 adjust the Qt product to new markets while keeping close to the users values.
+Qt 6 adjust the Qt product to new markets while keeping close to the users values.
 
 The desktop market is the root of Qts offering. It is where most users get the first contact with Qt and it forms the base for the Qt tools and its success.
 
-It is expected that Qt6 will grow most in the embedded and connected devices market from high-end near desktop performing devices to low-end devices like microcontrollers. Touch screens will come to an exponential increasing number to these devices. Many of these devices will have relatively simple functionality but require a polished and smooth user interface.
+It is expected that Qt 6 will grow most in the embedded and connected devices market from high-end near desktop performing devices to low-end devices like microcontrollers. Touch screens will come to an exponential increasing number to these devices. Many of these devices will have relatively simple functionality but require a polished and smooth user interface.
 
 At the other end of the spectrum there is a demand for more complex and 2D/3D integrated user interfaces. These 3D content with 2D elements based interfaces will be common, as will be the usage of augmented and virtual reality.
 
-The growth of connected devices and the higher demand for smooth user interfaces require a simpler workflow to create applications and devices. Integrating UX designers into the development workflow and is one of the goals of the Qt6 series.
+The growth of connected devices and the higher demand for smooth user interfaces require a simpler workflow to create applications and devices. Integrating UX designers into the development workflow and is one of the goals of the Qt 6 series.
 
-## Qt6 does bring us:
+## Qt 6 does bring us:
 
 * Next generation QML
 * Next generation graphics

docs/ch03-qtcreator/debugging.md

@@ -1,6 +1,6 @@
 # Debugging
 
-Qt Creator is an easy to use and well designed IDE to code your Qt C++ and Q<: projects. It has world class `CMake` support and is pre-configured for QtC++ development. Due to it's excellent C++ support it can also be used for any other vanilla C++ projects.
+Qt Creator is an easy to use and well designed IDE to code your Qt C++ and Q<: projects. It has world class `CMake` support and is pre-configured for Qt C++ development. Due to it's excellent C++ support it can also be used for any other vanilla C++ projects.
 
 ::: tip
 Hmm, I just realized I have not used debugging a lot. I hope this is a good sign. Need to ask someone to help me out here. In the meantime have a look at the [Qt Creator documentation](http://http://doc.qt.io/qtcreator/index.html).

docs/ch03-qtcreator/kit-registry.md

@@ -1,6 +1,6 @@
 # Registering your Qt Kit
 
-The Qt Kit is probably the most difficult aspect when it comes to working with Qt Creator initially. A Qt Kit is a set of a Qt version, compiler and device and some other settings. It is used to uniquely identify the combination of tools for your project build. A typical kit for the desktop would contain a C++ compiler and a Qt version (e.g. Qt 6.xx.yy) and a device (“Desktop”). After you have created a project you need to assign a kit to a project before Qt Creator can build the project. Before you are able to create a kit first you need to have a compiler installed and have a Qt version registered. A Qt version is registered by specifying the path to the `qmake` executable. Qt Creator then queries `qmake` for information required to identify the Qt version. This is also true for Qt6 where CMake is the preferred build tool.
+The Qt Kit is probably the most difficult aspect when it comes to working with Qt Creator initially. A Qt Kit is a set of a Qt version, compiler and device and some other settings. It is used to uniquely identify the combination of tools for your project build. A typical kit for the desktop would contain a C++ compiler and a Qt version (e.g. Qt 6.xx.yy) and a device (“Desktop”). After you have created a project you need to assign a kit to a project before Qt Creator can build the project. Before you are able to create a kit first you need to have a compiler installed and have a Qt version registered. A Qt version is registered by specifying the path to the `qmake` executable. Qt Creator then queries `qmake` for information required to identify the Qt version. This is also true for Qt 6 where CMake is the preferred build tool.
 
 Adding a kit and registering a Qt version is done in the `Settings ‣ Build & Run` entry. There you can also see which compilers are registered.
 

docs/ch03-qtcreator/projects.md

@@ -6,13 +6,13 @@ Qt Creator manages your source code in projects. You can create a new project by
 
 * **Applications (Qt Quick) / Qt Quick Application (Empty)**: Creates a bare C++ project with cmake support and a QML main document to render an empty window. This is the typical default starting point for all native QML application. 
 
-* **Libraries / Qt Quick 2.0 Extension Plug-in**: Use this wizard to create a stub for a plug-in for your Qt Quick UI. A plug-in is used to extend Qt Quick with native elements. This is ideally to create a re-usable QtQuick library. 
+* **Libraries / Qt Quick 2.0 Extension Plug-in**: Use this wizard to create a stub for a plug-in for your Qt Quick UI. A plug-in is used to extend Qt Quick with native elements. This is ideally to create a re-usable Qt Quick library. 
 
-* **Applications (Qt) / Qt Widgets Application**: Creates a starting point for a desktop application using QtWidgets. This would be your starting point if you plan to create a traditional C++ widgets based application.
+* **Applications (Qt) / Qt Widgets Application**: Creates a starting point for a desktop application using Qt Widgets. This would be your starting point if you plan to create a traditional C++ widgets based application.
 
 * **Applications (Qt) / Qt Console Application**: Creates a starting point for a desktop application without any user interface. This would be your starting point if you plan to create a traditional C++ command line tool using Qt C++.
 
 
 ::: tip
-During the first parts of the book, we will mainly use the **QtQuick UI Prototype** type or the **Qt Quick Application**, depending on whether we also use some C++ code with QtQuick. Later to describe some c++ aspects we will use the **Qt Console Application** type. For extending Qt Quick with our own native plug-ins we will use the *Qt Quick 2.0 Extension Plug-in* wizard type.
+During the first parts of the book, we will mainly use the **QtQuick UI Prototype** type or the **Qt Quick Application**, depending on whether we also use some C++ code with Qt Quick. Later to describe some c++ aspects we will use the **Qt Console Application** type. For extending Qt Quick with our own native plug-ins we will use the *Qt Quick 2.0 Extension Plug-in* wizard type.
 :::

docs/ch06-controls/controls2.md

@@ -1,6 +1,6 @@
 # UI Controls
 
-This chapter shows how to use the Qt Quick Controls module. QtQuick Controls are used to create advanced user interfaces built from standard components such as buttons, labels, sliders and so on. 
+This chapter shows how to use the Qt Quick Controls module. Qt Quick Controls are used to create advanced user interfaces built from standard components such as buttons, labels, sliders and so on. 
 
-QtQuick Controls can be arranged using the layout module and are easy to style. Also we will look into the various styles for the different plaforms before diving into custom styling.
+Qt Quick Controls can be arranged using the layout module and are easy to style. Also we will look into the various styles for the different plaforms before diving into custom styling.
 

docs/ch11-multimedia/multimedia.md

@@ -1,8 +1,8 @@
 # Multimedia
 
-The multimedia elements in the QtMultimedia makes it possible to playback and record media such as sound, video or pictures. Decoding and encoding are handled through platform-specific backends. For instance, the popular GStreamer framework is used on Linux, WMF is used on Windows, AVFramework on OS X and iOS and the Android multimedia APIs are used on Android.
+The multimedia elements in the Qt Multimedia makes it possible to playback and record media such as sound, video or pictures. Decoding and encoding are handled through platform-specific backends. For instance, the popular GStreamer framework is used on Linux, WMF is used on Windows, AVFramework on OS X and iOS and the Android multimedia APIs are used on Android.
 
-The multimedia elements are not a part of the Qt Quick core API. Instead, they are provided through a separate API made available by importing QtMultimedia as shown below:
+The multimedia elements are not a part of the Qt Quick core API. Instead, they are provided through a separate API made available by importing Qt Multimedia as shown below:
 
 ```qml
 import QtMultimedia

docs/ch12-networking/serve-qml.md

@@ -28,7 +28,7 @@ curl http://localhost:8080/Remote.qml
 
 Or just point your browser to the location. Your browser does not understand QML and will not be able to render the document through. 
 
-Hopefully, Qt6 provides such a browser in the form of the `qml` binary. You can directly load a remote QML document by using the following command:
+Hopefully, Qt 6 provides such a browser in the form of the `qml` binary. You can directly load a remote QML document by using the following command:
 
 ```sh
 qml -f http://localhost:8080/Remote.qml

docs/ch15-javascript/html-qml.md

@@ -1,4 +1,4 @@
-# Browser/HTML vs QtQuick/QML
+# Browser/HTML vs Qt Quick/QML
 
 The browser is the runtime to render HTML and execute the Javascript associated with the HTML. Nowadays modern web applications contain much more JavaScript than HTML. The Javascript inside the browser is a standard ECMAScript environment with some additional browser APIs. A typical JS environment inside the browser has a global object named `window` which is used to interact with the browser window (title, location URL, DOM tree etc.) Browsers provide functions to access DOM nodes by their id, class etc. (which were used by jQuery to provide the CSS selectors) and recently also by CSS selectors (`querySelector`, `querySelectorAll`). Additionally, there is a possibility to call a function after a certain amount of time (`setTimeout`) and to call it repeatedly (`setInterval`). Besides these (and other browser APIs), the environment is similar to QML/JS.
 

docs/ch15-javascript/javascript.md

@@ -3,7 +3,7 @@
 JavaScript is the lingua-franca on web client development. It also starts to get traction on web server development mainly by node js. As such it is a well-suited addition as an imperative language onto the side of declarative QML language. QML itself as a declarative language is used to express the user interface hierarchy but is limited to express operational code. Sometimes you need a way to express operations, here JavaScript comes into play.
 
 ::: tip
-There is an open question in the Qt community about the right mixture about QML/JS/QtC++ in a modern Qt application. The commonly agreed recommended mixture is to limit the JS part of your application to a minimum and do your business logic inside QtC++ and the UI logic inside QML/JS.
+There is an open question in the Qt community about the right mixture about QML/JS/Qt C++ in a modern Qt application. The commonly agreed recommended mixture is to limit the JS part of your application to a minimum and do your business logic inside Qt C++ and the UI logic inside QML/JS.
 :::
 
 This book pushes the boundaries, which is not always the right mix for a product development and not for everyone. It is important to follow your team skills and your personal taste. In doubt follow the recommendation.

docs/ch15-javascript/js-console.md

@@ -1,6 +1,6 @@
 # Creating a JS Console
 
-As a little example, we will create a JS console. We need an input field where the user can enter his JS expressions and ideally there should be a list of output results. As this should more look like a desktop application we use the QtQuick Controls module.
+As a little example, we will create a JS console. We need an input field where the user can enter his JS expressions and ideally there should be a list of output results. As this should more look like a desktop application we use the Qt Quick Controls module.
 
 ::: tip
 A JS console inside your next project can be really beneficial for testing. Enhanced with a Quake-Terminal effect it is also good to impress customers. To use it wisely you need to control the scope the JS console evaluates in, e.g. the currently visible screen, the main data model, a singleton core object or all together.
@@ -10,7 +10,7 @@ A JS console inside your next project can be really beneficial for testing. Enha
 
 ![image](./assets/jsconsole.png)
 
-We use Qt Creator to create a Qt Quick UI project using QtQuick controls. We call the project JSConsole. After the wizard has finished we have already a basic structure for the application with an application window and a menu to exit the application.
+We use Qt Creator to create a Qt Quick UI project using Qt Quick controls. We call the project JSConsole. After the wizard has finished we have already a basic structure for the application with an application window and a menu to exit the application.
 
 For the input, we use a TextField and a Button to send the input for evaluation. The result of the expression evaluation is displayed using a ListView with a ListModel as the model and two labels to display the expression and the evaluated result.
 

docs/ch16-qtcpp/boilerplate.md

@@ -42,7 +42,7 @@ The example demonstrates the use of file access and the how to write text to a a
 
 You build the application using CMake and make. CMake reads a project file, `CMakeLists.txt` and generates a Makefile which is used to build the application. CMake supports other build systems too, for example ninja. The project file is platform independent and CMake has some rules to apply the platform specific settings to the generated makefile. The project can also contain platform scopes for platform-specific rules, which are required in some specific cases. 
 
-Here is an example of a simple project file generated by QtCreator. Notice that Qt attempts to create a file that is compatible with both Qt 5 and Qt 6, as well as various platforms such as Android, OS X and such.
+Here is an example of a simple project file generated by Qt Creator. Notice that Qt attempts to create a file that is compatible with both Qt 5 and Qt 6, as well as various platforms such as Android, OS X and such.
 
 ```sh
 cmake_minimum_required(VERSION 3.14)

docs/ch16-qtcpp/build-system.md

@@ -33,7 +33,7 @@ When you are using Qt Creator it does these things behind the scenes for you and
 
 CMake is a tool created by Kitware. Kitware is very well known for their 3D visualization software VTK and also CMake, the cross-platform makefile generator. It uses a series of `CMakeLists.txt` files to generate platform-specific makefiles. CMake is used by the KDE project and as such has a special relationship with the Qt community and since version 6, it is the preferred way to build Qt projects.
 
-The `CMakeLists.txt` is the file used to store the project configuration. For a simple hello world using QtCore the project file would look like this:
+The `CMakeLists.txt` is the file used to store the project configuration. For a simple hello world using Qt Core the project file would look like this:
 
 ```cmake
 // ensure cmake version is at least 3.16.0
@@ -71,7 +71,7 @@ CMake is a powerful, a complex, tool and it takes some time to get used to the s
 ## References
 
 
-* [CMake Help](http://www.cmake.org/documentation/) - available online but also as QtHelp format
+* [CMake Help](http://www.cmake.org/documentation/) - available online but also as Qt Help format
 
 
 * [Running CMake](http://www.cmake.org/runningcmake/)
@@ -96,7 +96,7 @@ QMake is the tool which reads your project file and generates the build file. A
 SOURCES += main.cpp
 ```
 
-Here we build an executable application which will have the name `myproject` based on the project file name. The build will only contain the `main.cpp` source file. And by default, we will use the QtCore and QtGui module for this project. If our project were a QML application we would need to add the QtQuick and QtQml module to the list:
+Here we build an executable application which will have the name `myproject` based on the project file name. The build will only contain the `main.cpp` source file. And by default, we will use the `QtCore` and `QtGui` module for this project. If our project were a QML application we would need to add the `QtQuick` and `QtQml` module to the list:
 
 ```js
 // myproject.pro
@@ -106,7 +106,7 @@ QT += qml quick
 SOURCES += main.cpp
 ```
 
-Now the build file knows to link against the QtQml and QtQuick Qt modules. QMake uses the concept of `=`, `+=` and `-=` to assign, add, remove elements from a list of options, respectively. For a pure console build without UI dependencies you would remove the QtGui module:
+Now the build file knows to link against the `QtQml` and `QtQuick` Qt modules. QMake uses the concept of `=`, `+=` and `-=` to assign, add, remove elements from a list of options, respectively. For a pure console build without UI dependencies you would remove the `QtGui` module:
 
 ```js
 // myproject.pro