| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the documentation of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:FDL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Free Documentation License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Free |
| ** Documentation License version 1.3 as published by the Free Software |
| ** Foundation and appearing in the file included in the packaging of |
| ** this file. Please review the following information to ensure |
| ** the GNU Free Documentation License version 1.3 requirements |
| ** will be met: https://www.gnu.org/licenses/fdl-1.3.html. |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| /*! |
| \page qtquickcontrols-texteditor.html |
| \title Qt Quick Text Editor Guide |
| \nextpage Qt Quick Text Editor Guide - UI |
| \brief Walkthrough of an application built with Qt Quick Controls. |
| |
| \section1 Application Design |
| |
| The \e{Text Editor} example is a simple example of creating an application |
| with Qt. Specifically, the example uses QML to set up the user interface, |
| C++ to implement the file operations, and the Qt tools to manage the project |
| files and build environment. |
| |
| We will use Qt Quick Designer to add QML controls onto our application and set |
| up the controls and resources. We will also implement the logic and connect |
| the user interface to a C++ backend that will handle the saving and loading of |
| text files. |
| |
| This guide assumes that you have downloaded Qt and are able to install, open, |
| and run the basic examples found in Qt Creator's \uicontrol{Welcome Mode}. If |
| not, here are the pages that will help you: |
| |
| \list |
| \li \l{Getting Started with Qt} |
| \endlist |
| |
| The guide attempts to be self-contained but will refer to topics in the Qt |
| reference documentation. Feel free to click on the links, but it is not |
| necessary to leave the guide to find the information necessary to develop |
| the application. |
| |
| The files are part of the Qt package and are available when searched for |
| \uicontrol{Qt Quick Text Editor} in Qt Creator's \uicontrol{Welcome mode}. |
| All files used in the application are listed for viewing in the |
| \l{Qt Quick Controls 1 - Text Editor Example} page. |
| |
| \section1 Setting Up the Environment and Project |
| |
| We can start by creating the project in Qt Creator. Our application has the |
| name \e{Text Editor} and it is a Qt Quick Application. Qt Creator has a wizard |
| that can create the project for you. |
| |
| \list 1 |
| \li Select \uicontrol File > \uicontrol {New File or Project} > \uicontrol Applications > |
| \uicontrol {Qt Quick Application} > \uicontrol Choose. |
| \li In the \uicontrol Name field, enter \uicontrol TextEditor and select \uicontrol Next. |
| \li In the \uicontrol {Qt Quick component set} field, select |
| \uicontrol{Qt Quick Controls 1.2} > \uicontrol Next. |
| \li In the \uicontrol{Kit Selection} page, select \uicontrol Next. |
| \li In the \uicontrol{Summary} page, select \uicontrol Finish. |
| \endlist |
| |
| The wizard creates the project and you can run it by clicking on the run button, |
| \inlineimage{qtcreator/qtcreator-run.png} |
| . The application is an empty shell but it contains the basic window and layout |
| on which we can build. Make sure that you can run the basic application and if |
| not, make sure that your build environment and Qt version are configured. |
| |
| \section2 Project Files |
| |
| The wizard creates the project files used to build the project. To view them, |
| select the \uicontrol{Edit mode}. The following project files are modified |
| later in the guide: |
| |
| \list |
| \li \uicontrol TextEdit.pro - the project file used to create the build files. |
| Also sets the paths that are visible to the project. |
| \li \uicontrol Sources - contains the C++ implementation files (\c{.cpp}). |
| \li \uicontrol Resources - contains a resource file that configures the application |
| assets and how the application resolves the location of the assets. The QML |
| file is also found here. |
| \li \uicontrol Headers - contains the C++ header files (\c{.h}). The default |
| project does not have any header files, therefore this is not visible. |
| \endlist |
| |
| \section2 Resource Files |
| |
| The text editor uses several icons to represent various actions. The icons are |
| in the \e images directory which is directly under the \e TextEditor project |
| directory. The images as well as the project files are also listed in the |
| reference documentation on the \l{Qt Quick Controls 1 - Text Editor Example} page. |
| |
| We first need to register the image files into the project's resource file, |
| \e qml.qrc. The resource files compact the images into the binary packages. |
| The resource files provide a streamlined directory structure, which is |
| cross-platform. It is beneficial especially on mobile platforms, where each |
| platform manages the application resources differently. |
| |
| \list |
| \li To register the image files, in the \uicontrol Edit mode, right-click the |
| \e qml.qrc file and select \uicontrol{Open in Editor}. |
| \li Click the \uicontrol Add button and select \uicontrol{Add Files}. |
| \li In the file manager, select the files to be added. You can select |
| all the images in the \e images directory at once. |
| \endlist |
| |
| You can refer to the images from QML by referring directly to the filename. |
| For example, \c{images/editcopy.png} is the name of the \e editcopy.png file. |
| We will use these images later in the guide. |
| |
| Qt Creator then packages the images alongside your application in a single |
| binary. For more information about resource files, see the |
| \l{Managing Resource Files with the Qt Resource System} and the |
| \l{The Qt Resource System} pages. |
| |
| \section1 Example Files |
| |
| The accompanying examples files are listed in the following page: |
| \list |
| \li \l{Qt Quick Controls 1 - Text Editor Example} |
| \endlist |
| |
| */ |
| |
| /*! |
| \page qtquickcontrols-texteditor-ui.html |
| \title Qt Quick Text Editor Guide - UI |
| \previouspage Qt Quick Text Editor Guide |
| \nextpage Qt Quick Text Editor Guide - Logic |
| \brief Walkthrough of an application built with Qt Quick Controls. |
| |
| Qt Quick Designer is integrated into Qt Creator, allowing you to switch between |
| \uicontrol Edit and \uicontrol Design modes. To start using Qt Quick Designer, |
| select the QML file, \e main.qml, and click the \uicontrol Design button on the |
| left panel. |
| |
| It is important to familiarize yourself with the windows in Qt Quick Designer. |
| This guide uses Qt Quick Designer to add and set up the layout. |
| |
| \image controlstexteditor/controlstexteditor_designer.png |
| |
| \note The default kit for the project must be a Desktop kit, as Qt Quick |
| Designer cannot yet emulate the styles for a mobile platform. |
| |
| To start, we can customize the default application created by the wizard. You |
| can delete the \uicontrol MainForm.ui.qml file and remove the following lines |
| from the \uicontrol main.qml file: |
| \qml |
| MainForm { |
| anchors.fill: parent |
| button1.onClicked: messageDialog.show(qsTr("Button 1 pressed")) |
| button2.onClicked: messageDialog.show(qsTr("Button 2 pressed")) |
| button3.onClicked: messageDialog.show(qsTr("Button 3 pressed")) |
| } |
| |
| MessageDialog { |
| id: messageDialog |
| title: qsTr("May I have your attention, please?") |
| |
| function show(caption) { |
| messageDialog.text = caption; |
| messageDialog.open(); |
| } |
| } |
| \endqml |
| |
| The default dimension of the \c ApplicationWindow may remain but |
| you can change the \c title property to a relevant name such as: |
| |
| \qml |
| title: qsTr("Text Editor Example") |
| \endqml |
| |
| \note The example uses the \c qsTr() function to facilitate translation. For |
| more information, visit the \l{Internationalization and Localization with Qt Quick} |
| page. |
| |
| Make sure that \uicontrol Resources tab contains the images from the |
| \l{Resource Files}{previous page}. |
| |
| \section1 Defining the Application Layout |
| |
| Our application has a simple layout, which consists of a \e{tool bar} and a |
| \e{text area}. The tool bar contains the \e{tool buttons} that the user can |
| choose to manipulate the text area contents. At the top, there are menus, which |
| perform actions such as saving and opening files to edit. |
| |
| \section1 Adding the Controls |
| |
| To add a control, you have the following options: |
| |
| \list 1 |
| \li Drag and drop a control from the \uicontrol{QML Types} window onto the |
| main design window. This allows you to drop the control onto a specific |
| area of the layout. |
| \li Drag and drop a control from the \uicontrol{QML Types} window onto the |
| \uicontrol Navigator window. This allows you to set the layout hierarchy. |
| \endlist |
| |
| Both these actions give you several options to quickly set up the layout. |
| Whichever method you use, designer gives you a more direct way of setting up a |
| particular aspect of the control, such as the scene hierarchy or the position |
| of the control. |
| |
| Afterwards, the various properties are set from within the |
| \uicontrol Properties window on the right side of Qt Creator window. |
| |
| \section1 Setting Up the Tool Bar |
| |
| First, we need to add the tool bar. We can do this in the |
| \e Edit mode and typing in a \l ToolBar type inside the ApplicationWindow type. |
| This configures the ApplicationWindow object as the tool bar's parent. |
| |
| \badcode |
| ApplicationWindow { |
| |
| ToolBar { |
| id: toolBar |
| } |
| } |
| \endcode |
| |
| In the \uicontrol Design mode, the \uicontrol Properties window lets us set the |
| tool bar \uicontrol id to \c toolbar. |
| |
| In the \uicontrol Navigator window, make sure that the tool bar is a child of the |
| application window. To make the tool bar a child of the window, simply drag the tool bar |
| underneath the application window. |
| |
| Within the tool bar, we need a \e{row} layout. Drag the \e{row} layout into the |
| \uicontrol Navigator window and set it to be a child of the tool bar. |
| |
| Similarly, set these layout properties: |
| \list |
| \li \uicontrol id - set it to \c rowToolbar |
| \li click on the fill area button to set the fill area to \e parent. The parent should |
| be the tool bar. |
| \endlist |
| |
| \image controlstexteditor/controlstexteditor_rowproperties.png |
| |
| \section2 Adding the Tool Buttons |
| |
| \e{Tool buttons} exist within a tool bar and specifically use the layout within the tool bar. |
| \e{Text Editor} has six tool buttons, each performing a specific action, such as |
| \e copy and \e paste to and from the clipboard. |
| |
| The steps for adding the six tool buttons are mainly the same: |
| \list |
| \li Drag and drop the \uicontrol{Tool Button} type as a child of the row layout. |
| \li The \uicontrol id should be set to a unique name that is related to the |
| tool button's action. |
| The parent is set to \uicontrol parent and set the \uicontrol margin to \c 0. |
| |
| \image controlstexteditor/controlstexteditor_newproperties.png |
| \li The first tool button, for example \uicontrol New, should have the left anchor |
| set to the row layout. |
| \li The subsequent tool buttons should have the left anchor set to their previous |
| sibling and the \uicontrol margin to \c 0. These settings makes sure that |
| the tool buttons are adjacent to each other. |
| \li Set the \uicontrol iconName and \uicontrol iconSource properties in the |
| \uicontrol ToolButton tab. The \uicontrol iconName should be set to a unique name |
| identifying the icon name while the \uicontrol iconSource property should |
| be set to the name of the icon for the tool button. |
| \endlist |
| |
| For example, the \uicontrol New tool button has \c newIcon set as its \uicontrol iconName and |
| \c images/filenew.png set to the \uicontrol iconSource property. The icons are also viewable in the |
| \uicontrol Resources inside the \uicontrol Library window. |
| |
| Similarly for the \uicontrol Open tool button, the margins are set to \c 0 |
| but the left anchor is set to the \uicontrol New tool button. |
| |
| \image controlstexteditor/controlstexteditor_openproperties.png |
| |
| \note Dragging and dropping the images from the \uicontrol Resources onto |
| the scene adds the image into the scene as an \l Image object, instead |
| of setting the iconSource property. |
| |
| \section1 Setting Up the Text Area |
| |
| Next, add a \uicontrol{Text Area} onto the scene as a child of the application |
| window and a sibling of \c toolBar. The tool bar should be above the text area. |
| Similarly, set the following text area properties: |
| |
| \list |
| \li \uicontrol id - set it to \c textArea |
| \li set the left, right, and bottom margin to the parent and the top margin |
| to \c toolBar.bottom and set the margins to \c 0. |
| \qml |
| anchors.top: toolBar.bottom |
| anchors.right: parent.right |
| anchors.bottom: parent.bottom |
| anchors.left: parent.left |
| \endqml |
| \endlist |
| |
| Verify that you have the parent, margins, and icons set up. Your |
| \uicontrol Navigator should look similar to: |
| |
| \image controlstexteditor/controlstexteditor_navigator.png |
| |
| Running the application should result in this layout: |
| \image controlstexteditor/controlstexteditor_main.png |
| |
| We are now ready to go back to \uicontrol Edit and set the handlers and |
| actions. A QML \e handler is called when the buttons are pressed and |
| triggers the necessary action associated with the tool buttons. An |
| \e action collects various QML logic into one code block so it may be |
| reused by several handlers. For more information, visit the \l Action |
| QML type and \l{Signal and Handler Event System}. |
| |
| \section1 Example Files |
| |
| The accompanying examples files are found in the following page: |
| \list |
| \li \l{Qt Quick Controls 1 - Text Editor Example} |
| \endlist |
| |
| */ |
| |
| /*! |
| \page qtquickcontrols-texteditor-logic.html |
| \title Qt Quick Text Editor Guide - Logic |
| \previouspage Qt Quick Text Editor Guide - UI |
| \nextpage qtquickcontrols-texteditor-action.html |
| \brief Walkthrough of an application built with Qt Quick Controls. |
| |
| This part of the guide is about adding logic and backend to the |
| text editor example. At this stage, the user interface is |
| set up from the \l{Qt Quick Text Editor Guide - Logic}{previous} stage. |
| |
| \section1 Implementing the Logic and C++ Backend |
| |
| \e{Text Editor} has a QML user interface and a C++ backend to |
| implement the document handling. To connect QML and C++, |
| we need to create \e actions associated to the tool buttons, |
| which will call the document handling logic in C++. |
| |
| \section1 Creating the Document Handler |
| |
| The document handler implements the file loading and file |
| saving logic with Qt's C++ APIs. First, we need to create the |
| header file and the implementation file in Qt Creator's |
| \uicontrol Edit mode. |
| |
| \list |
| \li Right-click a folder, and select \uicontrol{Add New}. |
| \li Follow the wizard and create a new \uicontrol{C++ Class}. |
| \li Create a class called \uicontrol DocumentHandler and select |
| \uicontrol{Inherits QObject} in the \uicontrol{Type information}. |
| \li You can use default values for the rest and finish the wizard. |
| \endlist |
| |
| The wizard creates a \uicontrol DocumentHandler class in two files, |
| \e documenthandler.h and \e documenthandler.cpp. |
| |
| There are two functionalities we can expose to QML, the file loading and |
| saving. We can do this by creating \e properties and binding them to C++ |
| functions through the \l{The Property System}{Qt Property System}. |
| |
| In the \e documenthandler.h header file, add the following functions with their |
| respective access modifier: |
| |
| \code |
| Q_PROPERTY(QUrl fileUrl READ fileUrl WRITE setFileUrl NOTIFY fileUrlChanged) |
| Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged) |
| Q_PROPERTY(QString documentTitle READ documentTitle WRITE setDocumentTitle NOTIFY documentTitleChanged) |
| |
| public: |
| QUrl fileUrl() const; |
| QString text() const; |
| QString documentTitle() const; |
| |
| public slots: |
| void setFileUrl(const QUrl &arg); |
| void setText(const QString &arg); |
| void setDocumentTitle(QString arg); |
| |
| signals: |
| void fileUrlChanged(); |
| void textChanged(); |
| void documentTitleChanged(); |
| \endcode |
| |
| The lines with \c Q_PROPERTY() macro declares the \e property and its \e write |
| and \e read methods as well as its \e notify signal. For example, setting the |
| \c fileUrl property calls \c setFileUrl() and reading the property calls the |
| \c fileUrl() function. Similarly, when the value of fileUrl changes the |
| \c fileUrlChanged() function is called. |
| |
| Internally, the properties are represented by private member variables. For our |
| needs, here are the three variables in \e documenthandler.h which correspond to the properties: |
| \code |
| private: |
| QUrl m_fileUrl; |
| QString m_text; |
| QString m_documentTitle; |
| \endcode |
| |
| Implementing the read functions is straightforward. They simply return |
| the private member variables. For example, the implementation of |
| \c documentTitle() in \e documenthandler.cpp is: |
| \code |
| QString DocumentHandler::documentTitle() const |
| { |
| return m_documentTitle; |
| } |
| \endcode |
| |
| Implementing the write (\c setText(), for example) functions is also straightforward as they simply |
| assign a value to a private member variable. They also handle basic error handling |
| and they emit their respective notify signals. For example, the \c setDocumentTitle() function |
| is implemented in \e documenthandler.cpp as: |
| |
| \code |
| void DocumentHandler::setDocumentTitle(QString arg) |
| { |
| if (m_documentTitle != arg) { |
| m_documentTitle = arg; |
| emit documentTitleChanged(); |
| } |
| } |
| \endcode |
| |
| The opening of the file is done in the \c setFileUrl() function: |
| \code |
| void DocumentHandler::setFileUrl(const QUrl &arg) |
| { |
| if (m_fileUrl != arg) { |
| m_fileUrl = arg; |
| QString fileName = arg.fileName(); |
| QFile file(arg.toLocalFile()); |
| if (file.open(QFile::ReadOnly)) { |
| setText(QString(file.readAll())); |
| if (fileName.isEmpty()) |
| m_documentTitle = QStringLiteral("untitled"); |
| else |
| m_documentTitle = fileName; |
| emit textChanged(); |
| emit documentTitleChanged(); |
| } |
| emit fileUrlChanged(); |
| } |
| } |
| \endcode |
| |
| Note how the function emits the notify signals with the \c emit keyword. |
| |
| Similarly, we use QFile and text streams to save files. The function signature in |
| \e documenthandler.h is placed under \c{public slots} because that is one |
| way to expose functions to the QML engine. \c saveFile() is called from the |
| QML file during saving. |
| \code |
| public slots: |
| |
| Q_INVOKABLE void saveFile(const QUrl &arg) const; |
| \endcode |
| |
| The implementation of \c saveFile() is in documenthandler.cpp: |
| \code |
| void DocumentHandler::saveFile(const QUrl &arg) const |
| { |
| QFile file(arg.toLocalFile()); |
| if (file.open(QFile::WriteOnly | QFile::Truncate)) { |
| QTextStream out(&file); |
| out << text(); |
| } |
| } |
| \endcode |
| |
| For information about reading files and data storage, visit the QFile |
| and the \l{Data Storage} documentation. |
| |
| \section1 Registering the DocumentHandler Class |
| |
| We now need to let the QML engine know about the \c DocumentHandler and its |
| type. The \c qmlRegisterType() function is called in the application's \c main() |
| function in \e main.cpp: |
| |
| \code |
| qmlRegisterType<DocumentHandler>("org.qtproject.example", 1, 0, "DocumentHandler"); |
| \endcode |
| |
| The \c org.qtproject.example is the library with the version \c 1.0 and the |
| QML type registered is \c DocumentHandler. The import statement for the |
| DocumentHandler QML type is then |
| \code |
| import org.qtproject.example 1.0 |
| \endcode |
| |
| \note The \c qmlRegisterType() function should be called before the engine loads the QML file. |
| |
| \section1 Using the DocumentHandler QML type |
| |
| With the basic loading implemented, we can use the functionalities in the |
| QML file by creating an instance of the DocumentHandler class and by accessing |
| its properties. |
| |
| The \l{Qt Quick Text Editor - Connecting Actions}{next page} is about using |
| these C++ functions in QML files. |
| |
| \section1 Example Files |
| |
| The accompanying examples files are found in the following page: |
| \list |
| \li \l{Qt Quick Controls 1 - Text Editor Example} |
| \endlist |
| |
| */ |
| |
| /*! |
| \page qtquickcontrols-texteditor-action.html |
| \title Qt Quick Text Editor - Connecting Actions |
| \previouspage Qt Quick Text Editor Guide - Logic |
| |
| Earlier in the \l{Qt Quick Text Editor Guide}, we created a \e main.qml file |
| containing the description of our user interface in QML. The user interface |
| contains tool buttons in a tool bar on top of a text area. Afterwards, we |
| created a DocumentHandler class in C++ that will handle the file loading |
| and saving. |
| |
| Now we shall use the DocumentHandler in the QML file through \e actions. There |
| is an \l Action QML type that we can connect to the tool buttons which in turn |
| calls the DocumentHandler functions. |
| |
| \section1 Importing the DocumentHandler QML Type |
| |
| With the \c qmlRegisterType() function, we declared that the DocumentHandler |
| QML type is imported from the \c org.qtproject.example library. |
| |
| The following code is taken from the \e main.cpp file from the previous stage. |
| \code |
| qmlRegisterType<DocumentHandler>("org.qtproject.example", 1, 0, "DocumentHandler"); |
| \endcode |
| |
| In the \e main.qml file, enter the following import statement: |
| \qml |
| import org.qtproject.example 1.0 |
| \endqml |
| The DocumentHandler type is then available and we can create an object directly by adding it at |
| the bottom of the application window. |
| \qml |
| DocumentHandler { |
| id: document |
| } |
| \endqml |
| |
| \section1 Assigning Actions |
| |
| As mentioned, the tool buttons are associated with an \e action, for example, the cut button |
| is associated with the cut action. The cut action embodies the events that define the action, |
| for example, the calling of the appropriate function in the text area. |
| |
| For our application, we have six actions, which may be placed inside the application window. |
| |
| \qml |
| Action { |
| id: cutaction |
| text: "Cut" |
| shortcut: "ctrl+x" |
| iconSource: "images/editcut.png" |
| iconName: "edit-cut" |
| onTriggered: textarea.cut() |
| } |
| |
| Action { |
| id: copyaction |
| text: "Copy" |
| shortcut: "Ctrl+C" |
| iconSource: "images/editcopy.png" |
| iconName: "edit-copy" |
| onTriggered: textarea.copy() |
| } |
| |
| Action { |
| id: pasteaction |
| text: "Paste" |
| shortcut: "ctrl+v" |
| iconSource: "qrc:images/editpaste.png" |
| iconName: "edit-paste" |
| onTriggered: textarea.paste() |
| } |
| |
| Action { |
| id: fileopenaction |
| iconSource: "images/fileopen.png" |
| iconName: "document-open" |
| text: "Open" |
| onTriggered: fileDialog.open() |
| } |
| \endqml |
| |
| These actions call the appropriate function and assign a specific icon and name to the |
| action. To connect the \c cutaction to the cut tool button, add the following to the |
| tool button |
| |
| \qml |
| ToolButton { |
| id: cut_toolbutton |
| iconSource: "images/editcut.png" |
| iconName: "cut_icon" |
| anchors.left: save_toolbutton.right |
| action: cutaction; |
| } |
| \endqml |
| |
| For the open and save actions, we require that the user choose an existing file |
| or create a new file. To do this, we can pop up a file dialog and ask the user |
| to select the file to open from or save onto. We can create two file dialogs, |
| one for opening a file and one for saving the file, each setting their own |
| titles. |
| |
| \qml |
| FileDialog { |
| id: fileOpenDialog |
| title: "Please choose a file to open" |
| nameFilters: ["Text files (*.txt)"] |
| onAccepted: document.fileUrl = fileUrl |
| } |
| |
| FileDialog { |
| id: fileSaveDialog |
| title: "Please enter the file to save" |
| nameFilters: ["Text files (*.txt)"] |
| selectExisting: false |
| onAccepted: document.saveFile(fileUrl) |
| } |
| \endqml |
| |
| Setting the FileDialog's \c selectExisting property to \c false allows us to |
| save new files. |
| |
| The \l FileDialog type is from the \l{Qt Quick Dialogs} and is imported with |
| \qml |
| import QtQuick.Dialogs 1.2 |
| \endqml |
| |
| \section1 Deploying TextEditor |
| |
| Deploying the TextEditor depends on the platform on which the application is run. The process is simple |
| and Qt provides several tools for packaging applications for a given platform. The |
| \l{Deploying Qt Applications} page lists the instructions for the supported platforms. |
| For this guide, we will deploy on Windows desktop platform with the |
| \c windeploytool to create a directory with the required dependent libraries. |
| |
| To package TextEditor, |
| \list 1 |
| \li Copy the \e texteditor.exe file from the release directory to another directory which |
| serves as the destination folder. |
| \li Run the \e windeployqt.exe file which resolves and copies the Qt libraries into |
| the destination folder. \e windeployqt.exe is found in the \e bin directory of the installation. |
| \code |
| C:\Qt\5.3\msvc2012_opengl\bin>windeployqt.exe <path to destination folder> |
| \endcode |
| \endlist |
| |
| The destination folder can now be packaged and the binary file is executable. The images |
| and QML file are already packaged into the binary file. |
| |
| \section1 Example Files |
| |
| The accompanying examples files are found in the following page: |
| \list |
| \li \l{Qt Quick Controls 1 - Text Editor Example} |
| \endlist |
| |
| */ |