feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Doc: Remove detailed info about wizard templates

Browse Source 
Improve descriptions of some wizard templates.

Task-number: QTCREATORBUG-28996
Change-Id: Ib53fa38918120af60a03f3850fed7db1e6f0c391
Reviewed-by: Eike Ziller <eike.ziller@qt.io>
This commit is contained in:
Leena Miettinen
2023-04-25 16:12:45 +02:00
parent eb41e98b00
commit e7b5e64a70
17 changed files with 99 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/qtcreator/images/qtcreator-new-file.webp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 17 KiB

2
doc/qtcreator/src/howto/creator-keyboard-shortcuts.qdoc
View File

@@ -438,7 +438,7 @@
Works with namespaces, classes, functions, variables, include
statements, and macros. Also, opens URLs in the default browser
and Qt resource files (.qrc) in the \l{Creating Resource Files}
and Qt resource files (.qrc) in the \l{Resource Files}
{resource editor}
\li F2
\row

145
doc/qtcreator/src/projects/creator-only/creator-files-creating.qdoc
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
/*!
@@ -8,122 +8,33 @@
\title Creating Files
You can use wizard templates to add individual files to your
\l{Creating Projects}{projects}.
The following table lists the wizard templates for creating files.
\image qtcreator-new-file.webp {New File wizard}
\table
\header
\li Category
\li Wizard Template
\li Purpose
\row
\li {1,3} C/C++
\li C++ Class
\li C++ header and source file for a new class that you can add to
a C++ project.
\row
\li C/C++ Source File
\li C++ source file that you can add to a C++ project.
\row
\li C/C++ Header File
\li C++ header file that you can add to a C++ project.
\row
\li {1,3} Modeling
\li State Chart
\li State Chart XML (SCXML) file that has boilerplate
code for state machines. You can use the classes in the
\l {Qt SCXML} module to embed state machines created from
the files in Qt applications.
\row
\li Model
\li Universal Modeling Language (UML) style model with a structured
diagram. However, the model editor uses a variant of UML and
has only a subset of properties for specifying the
appearance of model elements. For more information, see
\l {Modeling}.
\row
\li Scratch Model
\li Scratch model using a temporary file.
\row
\li {1,7} Qt
\li Qt Item Model
\li Source and header files that you can use to create classes
derived from QAbstractItemModel, QAbstractTableModel, or
QAbstractListModel.
\row
\li \QD Form Class
\li \QD form and a matching class for implementing a UI based
on Qt widgets.
\row
\li \QD Form
\li \QD form for Qt widget based projects. This is useful
if you already have an existing class for the UI logic.
\row
\li Qt Resource File
\li Resource file for storing binary files in the application
executable.
\row
\li QML File (Qt Quick 2)
\li QML file that imports Qt Quick 2.0 for use in Qt Quick projects.
\row
\li Qt Quick UI File
\li \l{UI Files}{UI file} (\e .ui.qml) and the corresponding
implementation file (\e .qml) for use in Qt Quick projects.
\row
\li JS File
\li JavaScript file that you can use to write the application logic
in Qt Quick projects.
\row
\li {1,4} GLSL
\li Fragment Shader (OpenGL/ES 2.0)
\li Fragment shader that generates the final pixel colors for
triangles, points, and lines rendered with OpenGL. You can use
it in both Qt Quick projects and Qt widget based projects.
\row
\li Vertex Shader (OpenGL/ES 2.0)
\li Vertex shader that transforms the positions, normals, and
texture coordinates of triangles, points, and lines rendered
with OpenGL. You can use it in both Qt Quick projects and Qt
widget based projects.
\row
\li Fragment Shader (Desktop OpenGL)
\li Fragment shader for use in both Qt Quick projects and Qt
widget based projects.
\row
\li Vertex Shader (Desktop OpenGL)
\li Vertex shader for use in both Qt Quick projects and Qt
widget based projects.
\row
\li {1,2} General
\li Empty File
\li Empty file that you can save with any filename extension.
\row
\li Scratch Buffer
\li Scratch buffer that uses temporary files. You can
create this type of files for temporarily storing information
that you do not intend to save
\row
\li Java
\li Java File
\li Java class files that you can use to create Java classes.
\row
\li {1,2} Python
\li Python Class
\li Python class file.
\row
\li Python File
\li Python script file using UTF-8 encoding.
\row
\li {1,2} Nim (experimental)
\li Nim Script File
\li Empty Nim script file using UTF-8 encoding.
\row
\li Nim File
\li Empty Nim source file using UTF-8 encoding.
\endtable
Use wizard templates to add individual files to your \l{Creating Projects}
{projects}:
\section1 Creating C++ Classes
\list
\li \uicontrol {C/C++}: header and source files for new classes.
\li \uicontrol {Modeling}: State Chart XML (SCXML) files,
Universal Modeling Language (UML) style \l {Modeling}{models},
and scratch models that use a temporary file.
\li \uicontrol {Qt}: source and header files for item, table,
or list models, \QD forms and a matching classes for Qt Widgets
projects, Qt resource files, as well as QML and JavaScript files
for Qt Quick projects.
\li \uicontrol {GLSL}: fragment and vertex shaders.
\li \uicontrol {General}: markdown files, empty files that you can save
with any filename extension, and scratch buffers that use temporary
files.
\li \uicontrol {Java}: class files.
\li \uicontrol {Python}: class and script files for Python projects.
\li \uicontrol {Nim} (experimental): empty Nim source and script files.
\endlist
The \uicontrol {New File} dialog shows detailed information about each file
wizard template.
\section1 C++ Classes
The \uicontrol {C++ Class Wizard} allows you to create a C++ header and source
file for a new class that you can add to a C++ project. Specify the class
@@ -149,7 +60,7 @@
You can create your own project and class wizards. For more information,
see \l{Adding New Custom Wizards}.
\section1 Creating Resource Files
\section1 Resource Files
\QC supports the \l{The Qt Resource System}{Qt Resource System}, which is a
platform-independent mechanism for storing files in the application's
@@ -187,7 +98,7 @@
The above functions are also available in the context menu in the
\uicontrol Projects view.
\section1 Creating OpenGL Fragment and Vertex Shaders
\section1 OpenGL Fragment and Vertex Shaders
Qt supports integration with OpenGL implementations on all
platforms, which allows you to display hardware accelerated 3D graphics

16
doc/qtcreator/src/projects/creator-only/creator-projects-build-systems.qdocinc
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2020 The Qt Company Ltd.
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
// **********************************************************************
@@ -12,29 +12,33 @@
\section1 Selecting the Build System
You can use several build systems to build your projects.
You can use several build systems to build your projects:
\l{qmake Manual}{qmake} is a cross-platform system for build automation
\list
\li \l{qmake Manual}{qmake} is a cross-platform system for build automation
that helps simplify the build process for development projects across
different platforms. qmake automates the generation of build configurations
so that you need only a few lines of information to create each
configuration. Qt installers install and configure qmake.
To use one of the other supported build systems, you need to set it up.
\l {Build with CMake}{CMake} is an alternative to qmake for automating the
\li \l {Build with CMake}{CMake} is an alternative to qmake for automating the
generation of build configurations. For more information, see
\l {Setting Up CMake}.
\l {https://mesonbuild.com/}{Meson} Meson is a fast and user-friendly
\li \l {https://mesonbuild.com/}{Meson} is a fast and user-friendly
open-source build system that aims to minimize the time developers spend
writing or debugging build definitions and waiting for the build system
to start compiling code. For more information, see \l {Setting Up Meson}.
\l{Qbs Manual}{Qbs} is an all-in-one build tool that generates a build graph
\li \l{Qbs Manual}{Qbs} is an all-in-one build tool that generates a build graph
from a high-level project description (like qmake or CMake do) and executes
the commands in the low-level build graph (like make does). For more
information, see \l{Setting Up Qbs}.
\endlist
To export a project to some other build system, such as Microsoft Visual
Studio, select \uicontrol Build > \uicontrol {Run Generator}, and select
a generator in the list. \QC generates the build files, such as .vcxproj,

163
doc/qtcreator/src/projects/creator-only/creator-projects-creating.qdoc
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
// **********************************************************************
@@ -49,7 +49,7 @@
The installers create \l{glossary-buildandrun-kit}{kits} and specify build
and run settings for the installed device types. However, you might need to
install and configure some additional software on the devices to be able to
connect to them from the development PC.
\l{Connecting Devices}{connect} to them from the development PC.
\include creator-projects-build-systems.qdocinc build systems
@@ -71,146 +71,49 @@
\section1 Selecting Project Type
The following table lists the wizard templates for creating projects.
The following table lists the types of wizard templates that you can use
for creating projects. The \uicontrol {New Project} dialog shows detailed
information about each project wizard template.
\table
\header
\li Category
\li Wizard Template
\li Purpose
\row
\li Application (Qt for MCU)
\li MCU Support Application
\li Creates an application that uses a subset of Qt QML and
Qt Quick Controls types (as supported by Qt for MCUs) that
you can deploy, run, and debug on MCU boards. For more
information, see \l {Connecting MCUs}.
\li Application
\li Use many UI technologies (Qt Widgets and Qt Quick) and
programming languages (C++, QML, and Python) to create
applications for different purposes that you can run on
many target platforms (desktop, mobile, and embedded).
\row
\li {1,3} Application (Qt)
\li Qt Widgets Application
\li Uses \QD forms to design a Qt widget based user interface for
the desktop and C++ to implement the application logic.
\li Library or plugin
\li Create a shared or static C++ library, a C++ plugin for Qt Quick
application extensions, or a \QC plugin.
\row
\li Qt Console Application
\li Uses a single main.cpp file.
\li Other project
\li Create custom \l{Developing Widget Based Applications}{\QD}
widgets or widget collections,
\l{Qt Quick UI Projects}{Qt Quick UI projects},
\l {Creating Tests}{auto-test projects},
\l{Adding Subprojects to Projects}{subprojects},
empty qmake projects, or qmake projects for testing
code snippets.
\row
\li Qt Quick Application
\li Creates a Qt Quick application project that can have both
QML and C++ code. You can build the application and deploy it
to desktop, embedded, and mobile target platforms.
\li Non-Qt project
\li Create plain C or C++ applications or \l {Setting Up Nimble}
{Nim or Nimble} applications (experimental)
\row
\li Imported project
\li Import projects from a supported \l{Using Version Control Systems}
{version control system}, such as Bazaar, CVS, Git, Mercurial, or
Subversion.
You can select an option to create a project that you can open
in \QDS, which has a visual editor for Qt Quick UIs.
\row
\li {1,4} Application (Qt for Python)
\li Empty Application
\li Creates a \l{https://doc.qt.io/qtforpython/index.html}
{Qt for Python} application that has only the main
code for a QApplication.
\row
\li Empty Window
\li Creates a Qt for Python application that has an empty
window.
\row
\li Window UI
\li Creates a Qt for Python application that has an empty
window with a widget-based UI. Preferred approach that requires
you to generate a Python file from the .ui file, to import
it directly into your application.
\row
\li Qt Quick Application - Empty
\li Creates a Python project that has an empty Qt Quick
Application.
\row
\li {1,3} Library
\li C++ Library
\li A shared or static C++ library based on qmake.
\row
\li Qt Quick 2 Extension Plugin
\li Creates a C++ plugin that makes it possible to offer extensions
that the QQmlEngine class can load dynamically into Qt Quick
applications.
\row
\li \QC Plugin
\li Creates a \QC plugin.
\row
\li {1,6} Other Project
\li Qt Custom Designer Widget
\li Creates a custom \QD widget or widget collection.
\row
\li Qt Quick UI Prototype
\li Creates a \l{Creating Qt Quick UI Projects}{Qt Quick UI project}
with a single QML file that has the main view. You can
preview Qt Quick UI projects in the
\l{Validating with Target Hardware}{QML Scene preview tool}.
You do not need to build them because they do not have any
C++ code.
Use this template only if you are prototyping. You cannot create
a full application by using this template.
You cannot deploy Qt Quick UI projects to embedded or mobile
target platforms. For those platforms, create a Qt Quick
application instead.
\row
\li Auto Test Project
\li Creates a project with boilerplate code for a Qt or Google
test. For more information, see \l {Creating Tests}.
\row
\li Subdirs Project
\li Creates a subproject that enables you to structure your qmake
projects as a tree hierarchy.
\row
\li Empty qmake Project
\li Creates an empty qmake project that uses qmake as the build
system but does not use any default classes.
\row
\li Code Snippet
\li Creates a qmake project from a code snippet. When working on
bug reports that have a code snippet, you can place the code
snippet into a project to compile and check it.
\row
\li {1,4} Non-Qt Project
\li Plain C Application
\li Creates a plain C application that uses qmake, Qbs, or CMake
but does not use the Qt library.
\row
\li Plain C++ Application
\li Creates a plain C++ application that uses qmake, Qbs, or CMake
but does not use the Qt library.
\row
\li Nim Application (experimental)
\li Creates a Nim application that uses Nimble, but does not use the
Qt library. For more information, see \l {Setting Up Nimble}.
\row
\li Nimble Application (experimental)
\li Creates a Nimble application that uses Nimble, but does not use
the Qt library. For more information, see
\l {Setting Up Nimble}.
\row
\li {1,3} Import Project
\li Project from version control
\li Imports a project from a supported version control system, such
as Bazaar, CVS, Git, Mercurial, or Subversion. For more
information about how \QC integrates version control systems,
see \l{Using Version Control Systems}.
\row
\li Import as qmake or CMake Project (Limited Functionality)
\li Imports an existing project that does not use any of the
supported build systems: qmake, Qbs, CMake, or Autotools. The
template creates a project file, which enables you to use
\QC as a code editor and as a launcher for debugging and
analysis tools. However, if you want to build the project,
you might need to edit the generated project file.
\row
\li Import Existing Project
\li Imports an existing project that does not use any of the
supported build systems: qmake, Qbs, CMake, or Autotools.
This enables you to use \QC as a code editor.
You can also import existing projects that do not use any of the
supported build systems to use \QC as a code editor and as a
launcher for debugging and analysis tools.
\row
\li Squish
\li Squish Test Suite
\li Creates a new \l {Using Squish}{Squish test suite}.
\li Create new \l {Using Squish}{Squish test suites}.
\endtable

4
doc/qtcreator/src/python/creator-python-project.qdocinc
View File

@@ -140,7 +140,7 @@
For more information about the
\uicontrol {Qt for Python - Qt Quick Application - Empty} wizard, see
\l {Creating Qt Quick Based Python Applications}.
\l {Qt Quick Based Python Applications}.
For examples of creating Qt for Python applications, see
\l {https://doc.qt.io/qtforpython/tutorials/index.html}
@@ -151,7 +151,7 @@
//! [python qml project wizards]
\section1 Creating Qt Quick Based Python Applications
\section1 Qt Quick Based Python Applications
The \uicontrol {Qt for Python - Qt Quick Application - Empty} wizard enables
you to create a Python project that has a main QML file. Specify the

2
doc/qtcreator/src/qtquick/creator-only/qt-design-viewer.qdoc
View File

@@ -19,7 +19,7 @@
However, the actual performance of the application once started is
indistinguishable from the same application running on the desktop.
You can run \l{Creating Qt Quick UI Projects}{Qt Quick UI projects}, which
You can run \l{Qt Quick UI Projects}{Qt Quick UI projects}, which
have a .qmlproject file that define the main QML file and the import paths.
Compress the project folder into a ZIP file that you upload to \QDV.

60
doc/qtcreator/src/qtquick/creator-only/qtquick-creating.qdoc
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
// **********************************************************************
@@ -14,58 +14,28 @@
\title Creating Qt Quick Projects
The following table lists the wizard templates for creating a new
Qt Quick project from scratch.
Use the following wizard templates to create new Qt Quick projects:
\table
\header
\li Category
\li Wizard Template
\li Purpose
\row
\li Application (Qt)
\li Qt Quick Application
\li Creates a Qt Quick application project that can have both
QML and C++ code. You can build the application and deploy it
to desktop, embedded, and mobile target platforms.
\list
\li \uicontrol {Application (Qt)} > \uicontrol {Qt Quick Application}
\li \uicontrol {Application (Qt for Python)} >
\uicontrol {Qt for Python - Qt Quick Application}
\li \uicontrol {Other Project} > \uicontrol {Qt Quick UI Prototype}
\li \uicontrol {Library} > \uicontrol {Qt Quick 2 Extension Plugin}
\endlist
You can select an option to create a project that you can open
in \QDS.
\row
\li Application (Qt for Python)
\li Qt for Python - Qt Quick Application
\li Creates a Python project that has an empty Qt Quick
Application.
\row
\li Other Project
\li Qt Quick UI Prototype
\li Creates a Qt Quick UI project with a single QML file that
has the main view. You can preview Qt Quick UI projects
in the QML Scene preview tool. You do not need to build them
because they do not have any C++ code.
This project type is compatible with \QDS. However, use this
template only if you are prototyping. You cannot create
a full application by using this template.
You cannot deploy Qt Quick UI projects to embedded or
mobile target platforms. For those platforms, create a Qt Quick
application instead.
\row
\li Library
\li Qt Quick 2 Extension Plugin
\li Creates C++ plugins that make it possible to offer extensions
that can be loaded dynamically into Qt Quick applications.
\endtable
The \uicontrol {New Project} dialog shows detailed information about each
project wizard template.
\note The SDK for a particular target platform might install additional
templates for that platform. For example, the QNX templates are installed
as part of the QNX SDK.
\QC creates the necessary boilerplate files. Some of the files are
specific to a particular target platform.
specific to a particular target platform. You can use wizard templates
also to \l{Creating Files}{add files} to the projects.
\section1 Creating Qt Quick Applications
\section1 Qt Quick Applications
\list 1
@@ -138,7 +108,7 @@
\include creator-python-project.qdocinc python qml project wizards
\section1 Creating Qt Quick UI Projects
\section1 Qt Quick UI Projects
Qt Quick UI Prototype projects are useful for testing or prototyping user
interfaces,

2
doc/qtcreator/src/qtquick/creator-only/qtquick-tutorial-create-empty-project.qdocinc
View File

@@ -69,7 +69,7 @@
\endlist
For more information about the settings that you skipped and the other
wizard templates available, see \l{Creating Qt Quick Applications}.
wizard templates available, see \l{Qt Quick Applications}.
//! [qtquick empty application]
*/

2
doc/qtcreator/src/qtquick/qtquick-live-preview.qdoc
View File

@@ -22,7 +22,7 @@
In addition, you can use \QDV to run
\if defined(qtcreator)
\l{Creating Qt Quick UI Projects}{Qt Quick UI projects}
\l{Qt Quick UI Projects}{Qt Quick UI projects}
\else
applications
\endif

2
share/qtcreator/templates/wizards/codesnippet/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "CMakeProjectManager.CMakeProject" ],
"id": "Z.Snippet",
"category": "H.Project",
"trDescription": "Creates a CMake-based test project for which a code snippet can be entered.",
"trDescription": "Creates a CMake-based test project where you can enter a code snippet to compile and check it.",
"trDisplayName": "Code Snippet",
"trDisplayCategory": "Other Project",
"featuresRequired": [ "QtSupport.Wizards.FeatureQt" ],

2
share/qtcreator/templates/wizards/projects/consoleapp/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "MesonProjectManager.MesonProject", "CMakeProjectManager.CMakeProject", "Qbs.QbsProject", "Qt4ProjectManager.Qt4Project" ],
"id": "E.QtCore",
"category": "D.ApplicationQt",
"trDescription": "Creates a project containing a single main.cpp file with a stub implementation.\n\nPreselects a desktop Qt for building the application if available.",
"trDescription": "Creates a project containing a single main.cpp file with a stub implementation and no graphical UI.\n\nPreselects a desktop Qt for building the application if available.",
"trDisplayName": "Qt Console Application",
"trDisplayCategory": "Application (Qt)",
"icon": "../../global/consoleapplication.png",

2
share/qtcreator/templates/wizards/projects/cpplibrary/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "MesonProjectManager.MesonProject", "CMakeProjectManager.CMakeProject", "Qbs.QbsProject", "Qt4ProjectManager.Qt4Project" ],
"id": "H.CppLibrary",
"category": "G.Library",
"trDescription": "Creates a C++ library. This can be used to create:<ul><li>a shared C++ library for use with <tt>QPluginLoader</tt> and runtime (Plugins)</li><li>a shared or static C++ library for use with another project at linktime</li></ul>",
"trDescription": "Creates a C++ library. You can create:<ul><li>a shared C++ library for use with <tt>QPluginLoader</tt> and runtime (Plugins)</li><li>a shared or static C++ library for use with another project at linktime</li></ul>",
"trDisplayName": "C++ Library",
"trDisplayCategory": "Library",
"icon": "../../global/lib.png",

2
share/qtcreator/templates/wizards/projects/qtquickapplication/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "CMakeProjectManager.CMakeProject", "QbsProjectManager.QbsProject" ],
"id": "U.QtQuickApplicationEmpty",
"category": "D.ApplicationQt",
"trDescription": "Creates a Qt Quick application that contains an empty window. Optionally, you can create a Qt Design Studio project.",
"trDescription": "Creates a Qt Quick application that can have both QML and C++ code. You can build the application and deploy it to desktop, embedded, and mobile target platforms.\n\nYou can select an option to create a project that you can open in Qt Design Studio, which has a visual editor for Qt Quick UIs.",
"trDisplayName": "Qt Quick Application",
"trDisplayCategory": "Application (Qt)",
"icon": "icon.png",

2
share/qtcreator/templates/wizards/projects/qtquickuiprototype/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "QmlProjectManager.QmlProject" ],
"id": "QA.QtQuickUi",
"category": "H.Project",
"trDescription": "Creates a Qt Quick 2 UI project with a QML entry point. To use it, you need to have a QML runtime environment.\n\nUse this only if you are prototyping. You cannot create a full application with this. Consider using a Qt Quick Application project instead.",
"trDescription": "Creates a Qt Quick UI project for previewing and prototyping designs.\n\nTo develop a full application, create a Qt Quick Application project instead.",
"trDisplayName": "Qt Quick UI Prototype",
"trDisplayCategory": "Other Project",
"icon": "qtquickuiprototype.png",

2
share/qtcreator/templates/wizards/projects/qtwidgetsapplication/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "MesonProjectManager.MesonProject","CMakeProjectManager.CMakeProject", "Qt4ProjectManager.Qt4Project", "Qbs.QbsProject" ],
"id": "C.QtWidgets",
"category": "D.ApplicationQt",
"trDescription": "Creates a widget-based Qt application that contains a Qt Designer-based main window.\n\nPreselects a desktop Qt for building the application if available.",
"trDescription": "Creates a widget-based Qt application that contains a Qt Designer-based main window and C++ source and header files to implement the application logic.\n\nPreselects a desktop Qt for building the application if available.",
"trDisplayName": "Qt Widgets Application",
"trDisplayCategory": "Application (Qt)",
"icon": "../../global/guiapplication.png",

2
src/plugins/mcusupport/wizards/qmlproject/wizard.json
View File

@@ -3,7 +3,7 @@
"supportedProjectTypes": [ "CMakeProjectManager.CMakeProject" ],
"id": "M.McuSupportApplication",
"category": "D.ApplicationMCU",
"trDescription": "Suitable for Qt for MCUs versions 2.4 and later. Creates a Qt for MCUs application with a simple UI, based on qmlproject.",
"trDescription": "Suitable for Qt for MCUs versions 2.4 and later. Creates an application that uses a subset of Qt QML and Qt Quick Controls types (as supported by Qt for MCUs) that you can deploy, run, and debug on MCU boards.",
"trDisplayName": "Qt for MCUs Application",
"trDisplayCategory": "QmlProject Application (Qt for MCUs)",
"icon": "../icon.png",