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

Doc: move projects mode topics to a separate folder

Browse Source 
Change-Id: I031e1f488c4923baea0bddbd24da804f3bb01c95
Reviewed-on: http://codereview.qt-project.org/5611
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Eike Ziller <eike.ziller@nokia.com>
This commit is contained in:
Leena Miettinen
2011-09-27 11:55:44 +02:00
parent 44c107c267
commit c78528dce8
23 changed files with 2616 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
doc/src/projects/creator-projects-build-run-tutorial.qdoc Normal file
View File

@@ -0,0 +1,92 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-getting-started.html
\page creator-build-example-application.html
\nextpage creator-qml-application.html
\title Building and Running an Example Application
You can test that your installation is successful by opening an existing
example application project.
\list 1
\o On the \gui Welcome page, select the \gui {Show Examples and Demos}
check box, and then search for \gui {Toys: Clocks Example} in the
list of examples.
\image qtcreator-gs-build-example-open.png "Selecting an example"
\o Select targets for the project. Select at least Qt Simulator
and one of the mobile targets, Symbian Device, Maemo 5, or
MeeGo Harmattan, depending on the device you develop for.
\image qtcreator-gs-build-example-targets.png "Selecting targets"
\note You can add targets later in the \gui Projects mode.
\o To test the application in Qt Simulator, click the \gui {Target
Selector} and select \gui {Qt Simulator}.
\image {qtcreator-gs-build-example-select-qs.png} "Selecting Qt Simulator as target"
\o Click
\inlineimage{qtcreator-run.png}
to build the application and run it in Qt Simulator.
\o To see the compilation progress, press \key{Alt+4} to open the
\gui {Compile Output} pane.
The \gui Build progress bar on the toolbar turns green when the
project is successfully built. The application opens in
Qt Simulator.
\image {qt-simulator.png} "Qt Simulator"
\o Change the settings in the \gui Model view. For example, rotate the
device by clicking the \gui {Orientation} buttons or choose from the
various mobile device configurations in the \gui {Device} field. You
can also simulate various mobile functions and create your own
scripts.
\if defined(qcmanual)
\o To test the application on a Symbian device, check that the required
Qt libraries and a debugging agent are installed on the device. For
more information, see \l{Connecting Symbian Devices}.
\o Click the \gui {Target Selector} and select \gui {Symbian Device}.
\o Click \gui Run to build the application and run it on the Symbian
device.
\endif
\endlist
*/

66
doc/src/projects/creator-projects-building-running.qdoc Normal file
View File

@@ -0,0 +1,66 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-usability.html
\page creator-building-running.html
\nextpage creator-building-targets.html
\title Building and Running Applications
\QC provides support for building, running, and deploying Qt applications
for different \l{glossary-development-target}{targets}.
You can set up the following configurations:
\list
\o \e {Build configuration}, which contains everything you need to
compile the sources into binaries.
\o \e {Deploy configuration}, which handles the packaging and copying
of the necessary files to a location you want to run the executable
at. The files can be copied to a location in the file system of the
development PC or a mobile device.
\o \e {Run configuration}, which starts the application in the location
where it was stored by the deploy configuration.
\endlist
By default, when you select the \gui Run function, \QC builds, deploys, and
runs the project. To specify the relationship between the release, build,
and deploy configurations, select \gui {Tools > Options > Project}. By
default, the \gui {Always build project before deploying it} and the
\gui {Always deploy project before running it} options are enabled.
Therefore, when you select the \gui Run function, \QC builds, deploys, and
runs the project.
\image qtcreator-project-options-deploy.png "Project General Options"
*/

65
doc/src/projects/creator-projects-building.qdoc Normal file
View File

@@ -0,0 +1,65 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-building-running.html
\page creator-building-targets.html
\nextpage creator-running-targets.html
\title Building Applications for Multiple Targets
You can build applications for multiple \l{glossary-development-target}
{targets}. By default, when you run the application on a target, you
automatically build it for the target and deploy it to the target first.
However, you can also perform each operation separately.
To check that the application code can be compiled and linked for a target,
you can build the project. The build errors and warnings are displayed in
the \gui {Build Issues} output pane. More detailed information is displayed
in the \gui {Compile Output} pane.
To build an application:
\list 1
\o Select a target for the project.
\image qtcreator-target-selector.png "Target selector"
\o Choose \gui {Build > Build Project} or press \key {Ctrl+B}.
\endlist
For more information on the options you have, see
\l{Specifying Build Settings}.
\if defined(qcmanual)
\input symbian/creator-projects-building-symbian.qdocinc
\endif
*/

133
doc/src/projects/creator-projects-cmake.qdoc Normal file
View File

@@ -0,0 +1,133 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-project-wizards.html
\page creator-project-cmake.html
\nextpage creator-project-generic.html
\title Setting Up a CMake Project
CMake is an alternative to qmake for automating the generation of build
configurations. It controls the software compilation process by using simple
configuration files, called \c{CMakeLists.txt} files. CMake generates native
build configurations and workspaces that you can use in the compiler
environment of your choice.
Since \QC 1.1, CMake configuration files are supported. Since \QC 1.3, the
Microsoft tool chain is supported if the CMake version is at least 2.8.
\section1 Setting the Path for CMake
You can set the path for the \c CMake executable in \gui{Tools} >
\gui{Options > Projects > CMake}.
\image qtcreator-cmakeexecutable.png
\note Before you open a \c CMake project, you must modify the \c{PATH}
environment variable to include the bin folders of \c mingw and \QC in
the \QSDK.
For instance, if the \QSDK is installed in \c {C:\SDK}, you would use the
following command to set the environment variables in the command line
prompt:
\code
set PATH=C:\sdk\mingw\bin;C:\sdk\qt\bin;
\endcode
Then start \QC by typing:
\code
C:\sdk\bin\qtcreator.exe
\endcode
\section1 Opening CMake Projects
To open a \c CMake project:
\list 1
\o Select \gui{File} > \gui{Open File or Project}.
\o Select the \c{CMakeLists.txt} file from your \c CMake project.
\endlist
A wizard guides you through the rest of the process.
\note If the \c CMake project does not have an in-place build, \QC
lets you specify the directory in which the project is built
(\l{glossary-shadow-build}{shadow build}).
\image qtcreator-cmake-import-wizard1.png
The screenshot below shows how you can specify command line arguments to
\c CMake for your project.
\image qtcreator-cmake-import-wizard2.png
Normally, there is no need to pass any command line arguments for projects
that are already built, as \c CMake caches that information.
\section1 Building CMake Projects
\QC builds \c CMake projects by running \c make, \c mingw32-make, or
\c nmake depending on your platform. The build errors and warnings are
parsed and displayed in the \gui{Build Issues} output pane.
By default, \QC builds the \bold{all} target. You can specify which
targets to build in \gui{Project} mode, under \gui{Build Settings}.
\image qtcreator-cmake-build-settings.png
\QC supports multiple build configurations. You can change the build
directory after the initial import.
\section1 Running CMake Projects
\QC automatically adds \gui{Run Configurations} for all targets specified
in the \c CMake project file.
For more information about known issues for the current version, see
\l{Known Issues}.
\section1 Adding External Libraries to CMake Projects
Through external libraries, \QC can support code completion and syntax
highlighting as if they were part of the current project or the Qt library.
\QC detects the external libraries using the \c FIND_PACKAGE()
macro. Some libraries come with the CMake installation. You can find those
in the \c {Modules} directory of your CMake installation.
\note If you provide your own libraries, you also need to provide your own
\c FindFoo.cmake file. For more information, see
\l{http://vtk.org/Wiki/CMake_FAQ#Writing_FindXXX.cmake_files}{CMake FAQ}.
Syntax completion and highlighting work once your project successfully
builds and links against the external library.
*/

213
doc/src/projects/creator-projects-creating.qdoc Normal file
View File

@@ -0,0 +1,213 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-project-managing.html
\page creator-project-creating.html
\nextpage creator-project-opening.html
\title Creating Projects
\image qtcreator-new-project.png
You can use wizards to create following types of projects:
\list
\o Qt Quick Project
Use QML elements or Qt Quick Components to define the user interface
and, optionally, C++ or JavaScript to define the application logic.
\if defined(qcmanual)
\o Qt Widget Project
Use \QD forms to define a Qt widget based user interface and C++ to
define the application logic
\endif
\o Other Project
\list
\o HTML5 based applications
\o Qt console applications
\o Shared or static C++ libraries
\o Qt unit tests
\if defined(qcmanual)
\o Qt Custom Designer Widgets
\endif
\o Subprojects
\endlist
\o Project from Version Control
Import a project from a supported version control system. For more
information on how version control systems are integrated in
\QC, see \l{Using Version Control Systems}.
\endlist
To create a new project, select \gui File > \gui{New File or Project} and
select the type of your project. The contents of the wizard dialogs depend
on the project type and the build targets that you select in the
\gui {Target Setup} dialog. Follow the instructions of the wizard.
For examples of creating different types of projects, see
\l{Getting Started}.
For more information about creating Qt Quick projects, see
\l {Creating Qt Quick Projects}.
To change the location of the project directory, and to specify settings
for building and running projects, select \gui{Tools} > \gui{Options} >
\gui{Projects} > \gui{General}.
To specify build and run settings for different target platforms, select
\gui Projects.
\section1 Adding Files to Projects
You can use wizards also to add individual files to your projects.
You can create the following types of files:
\list
\o Qt resource files, which allow you to store binary files in the
application executable
\if defined(qcmanual)
\o \QD forms and \QD form classes, which specify parts of user
interfaces in Qt widget based projects
\endif
\o QML files, which specify elements in Qt Quick projects
\o GLSL files that define fragment and vertex shaders in both Qt Quick
projects and Qt widget based projects
\o C++ class, source, or header files that you can use to write the
application logic in both Qt Quick projects and
\if defined(qcmanual)
Qt widget based projects
\endif
\o JavaScript files that you can use to write the application logic in
Qt Quick projects
\o Text files
\endlist
\section2 Creating C++ Classes
The \gui {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
name, base class, and header and source files for the class.
The wizard supports namespaces. To use a namespace, enter a qualified
class name in the \gui {Class name} field. For example:
MyNamespace::MySubNamespace::MyClass.
\image qtcreator-cpp-class-wizard.png "Enter Class Name dialog"
The names of the header and source file are based on the class name. To
change the default suffix of a file, click \gui Configure.
You can create your own project and class wizards. For more information,
see \l{Adding New Custom Wizards}.
\section2 Creating OpenGL Fragment and Vertex Shaders
Qt provides support for integration with OpenGL implementations on all
platforms, which allows you to display hardware accelerated 3D graphics
alongside a more conventional user interface. For more information, see
\l{http://doc.qt.nokia.com/4.7/qtopengl.html}{QtOpenGL Module}.
You can use the QGLShader class to compile OpenGL shaders written in the
OpenGL Shading Language (GLSL) and in the OpenGL/ES Shading Language
(GLSL/ES). QGLShader and QGLShaderProgram shelter you from the details of
compiling and linking vertex and fragment shaders.
You can use \QC code editor to write fragment and vertex shaders
in GLSL or GLSL/ES. The code editor provides syntax highlighting and code
completion for the files.
\image qtcreator-new-opengl-file.png "New OpenGL file wizard"
\section2 Displaying Additional File Types in Projects Pane
\QC determines whether to display files from the project folder
in the \gui Projects pane depending on the file type (.pro, .pri, .cpp,
.h, .qrc, and so on). To display other types of files, edit the
project file. Add filenames as values of the \c {OTHER_FILES} variable.
You can also use wildcards.
For example, the following code specifies that text files are displayed
in the \gui Projects pane:
\code
OTHER_FILES += *.txt
\endcode
This also makes the files available in the \gui Locator.
\section1 Adding Subprojects to Projects
When you create a new project, you can add it to another project as a
subproject in the \gui{Project Management} dialog. However, the root project
must specify that qmake uses the \c subdirs template to build the project.
To create a root project, select \gui {File > New File or Project >
Other Project > Subdirs Project > Choose}.
On the \gui Summary page, select \gui {Finish & Add Subproject} to create
the root project and to add another project, such as a C++ library.
The wizard creates a project file (.pro) that defines a \c subdirs template
and the subproject that you add as a value of the
\l{http://doc.qt.nokia.com/4.7/qmake-variable-reference.html#subdirs}
{SUBDIRS variable}. It also adds all the necessary files for the subproject.
To add more subprojects, right-click the project name in the \gui Projects
pane, and select \gui {New Subproject} in the context menu.
To remove subprojects, right-click the project name in the \gui Projects
pane, and select \gui {Remove Subproject} in the context menu.
To specify dependencies, use the \gui{Add Library} wizard. For more
information, see \l{Adding Libraries to Projects}.
*/

513
doc/src/projects/creator-projects-custom-wizards.qdoc Normal file
View File

@@ -0,0 +1,513 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-os-supported-platforms.html
\page creator-project-wizards.html
\nextpage creator-project-cmake.html
\title Adding New Custom Wizards
If you have a team working on a large application or several applications,
you might want to standardize the way the team members create projects
and classes.
You can copy the wizard templates in the template folders to create your own
project and class wizards. They are displayed in the \gui New dialog that
opens when you choose \gui {File > New File or Project}.
In a project wizard, you can specify the files needed in a project.
You can add wizard pages to allow developers to specify settings for the
project.
In a class wizard, you can allow developers to specify the class name, base
class, and header and source files for the class.
To see how this works, rename wizard_sample.xml as wizard.xml in the
\c {\share\qtcreator\templates\wizards\listmodel\helloworld} and
\c {\share\qtcreator\templates\wizards\listmodel\listmodels} folders. After
you restart \QC, the \gui {Custom Classes}
and \gui {Custom Projects} categories appear in the \gui New dialog.
\image qtcreator-custom-project-wizards.png "The New dialog with custom projects and classes"
\section1 Overview of Custom Wizards
A custom wizard defines the user interface of a wizard page. The values the
user enters in the wizard are assigned field names. Field name and value
pairs are then passed to the file creation process. File creation can happen
in the following ways:
\list 1
\o Template-based, where source files that contain placeholders for
the field names are provided. During processing, the placeholders
are replaced by the values from the wizard page. Optionally,
modifier characters are applied. For more information, see
\l{Processing Template Files}.
\o Generator script, where a script is called to create the files.
\note This option mainly exists to accommodate existing generator
scripts or cases where complicated algorithmic logic is required
when generating files. Writing cross-platform scripts is inherently
difficult, and therefore, it is not recommended for new wizards. For
more information, see \l{Using Generator Scripts}.
\endlist
Custom wizards are located in subdirectories of the following directories:
\list
\o \c{share/qtcreator/templates/wizards}
\o the local user's configuration folder,
\c{$HOME/.config/Nokia/qtcreator/templates/wizards}
\o \c{%APPDATA%\Nokia\qtcreator\templates\wizards}
\endlist
They contain an XML configuration file called wizard.xml, the template
source files, and optionally, the generator script.
\section1 Creating Project Wizards
To create a project wizard:
\list 1
\o Make a copy of the \c {share/qtcreator/templates/wizards/helloworld}
or \c {share/qtcreator/templates/wizards/listmodel} folder.
\o Modify the wizard_example.xml file.
\o The following code determines the type of the wizard and its place
in the \gui New dialog:
\code
<wizard version="1" kind="project"
class="qt4project" firstpage="10"
id="A.HelloWorld" category="B.CustomProjects">
\endcode
\list
\o \c version is the version of the file contents. Do not modify
this value.
\o \c kind specifies the type of the wizard: \c project or
\c class.
\o \c class specifies the type of the project. Currently the only
available type is \c qt4project, which specifies a Qt console
project.
\o \c firstpage specifies the place of the new page in the standard
project wizard. The value 10 ensures that the custom page
appears after the standard pages, as the last page of the
wizard.
\o \c id is the unique identifier for your wizard. The letter
specifies the position of the wizard within the \c category. The
HelloWorld wizard appears as the first wizard in the second
category in the \gui New dialog.
\o \c category is the category in which to place the wizard in the
list. The letter specifies the position of the category in the
list in the \gui New dialog.
\endlist
\o The following code specifies the icon and text that appear in the
\gui New dialog:
\code
<icon>console.png</icon>
<description>Creates a hello-world-project with custom message.</description>
<description xml:lang="de">Erzeugt ein Hello-Welt-Projekt mit einer Nachricht.</description>
<displayname>Hello World</displayname>;
<displayname xml:lang="de">Hallo Welt</displayname>;
<displaycategory>Custom Projects</displaycategory>
<displaycategory xml:lang="de">Benutzerdefinierte Projekte</displaycategory>
\endcode
\list
\o \c icon appears next to the \c displayName.
\o \c description appears at the bottom of the \gui New dialog when
you select the display name.
\o \c displayName appears in the \gui New dialog, under the
\c displayCategory.
You can add translations as values for the text elements. Specify the target
language as an attribute for the element. Use locale names (QLocale).
For example, \c {xml:lang="de"}.
\endlist
\o Files to be added to the project:
\list
\o Template-based: The following code specifies the files to add to
the project:
\code
<files>
<file source="main.cpp" openeditor="true" />
<file source="project.pro" target="%ProjectName%.pro" openproject="true" />
<file source="icon.png" target="%ProjectName%.png" binary="true" />
\endcode
\list
\o \c source specifies the file to copy to the project. The
files must be located in the wizard folder.
\o \c openeditor indicates that the file is to be opened in an
editor after the wizard has finished.
\o \c binary indicates that the file is a binary file (for
example, an image file). It is to be copied to the target
folder as is. Placeholders are not replaced with values.
\o \c target specifies the new filename for the file. The
\c {%ProjectName%} variable is replaced with the string that
users specify in the \gui Name field on the first page of
the wizard.
\o \c openproject indicates that the file is a project file
which is to be opened after the wizard has finished.
\endlist
See also \l{Processing Template Files}.
\o Generator-script: The following code specifies that the script
\c generate.pl is to be used to create the files:
\code
<generatorscript binary="generate.pl">
<argument value="--class-name=%ClassName%"/>
<argument value="--project-name=%ProjectName%"/>
<argument value="--header-suffix=%CppHeaderSuffix%" omit-empty="true"/>
<argument value="--source-suffix=%CppSourceSuffix%" omit-empty="true"/>
<argument value="--description=%Description%" omit-empty="true" write-file="true"/>
</generatorscript>
\endcode
In each argument, the field placeholders are replaced by the
field values. There are additional boolean attributes which give
fine-grained control:
\list
\o \c omit-empty specifies that complete argument is to be
omitted when all placeholders expand to empty values. In
the above example, the option \c --source-suffix will
not be passed to the script if the value is empty.
\o \c write-file indicates that instead of the expanded
value, the value will be written to a temporary file and
its file name will be passed to the script instead. This
is useful for multi-line text fields.
\endlist
See also \l{Using Generator Scripts}.
\endlist
\o The following code creates a page that specifies settings for the project:
\code
<!-- Create a 2nd wizard page with parameters -->
<fieldpagetitle>Hello World Parameters</fieldpagetitle>
<fieldpagetitle xml:lang="de">Hallo Welt Parameter</fieldpagetitle>
<fields>
<field mandatory="true" name="MESSAGE">
<fieldcontrol class="QLineEdit" validator='^[^"]+$' defaulttext="Hello world!" />
<fielddescription>Hello world message:</fielddescription>
<fielddescription xml:lang="de">Hallo-Welt-Nachricht:</fielddescription>
</field>
</fields>
\endcode
\list
\o \c fieldpagetitle specifies the title of the page.
\o \c field specifies whether the field is mandatory (\c true or
\c false). You can use the value of the \c name field as a
variable in other files (for example, \c {%MESSAGE%}.
\o \c fieldcontrol specifies the field. \c class specifies the
field type. You can use interface objects from the QWidget class
to create fields. This example uses QLineEdit to create an input
field.
\o \c validator specifies a regular expression to check the
characters allowed in the field.
\o \c defaulttext specifies text that appears in the field by
default.
\o \c fielddescription specifies the field name that appears on the
wizard page.
\endlist
\endlist
\section1 Creating Class Wizards
The widget.xml file for a class wizard is very similar to that for a project
wizard. The differences are discussed below.
To create a class wizard:
\list 1
\o The following code specifies settings for the wizard:
\code
<wizard version="1" kind="class" id="A.ListModel" category="B.CustomClasses">
<description>Creates a QAbstractListModel implementation.</description>
<description xml:lang="de">Erzeugt eine Implementierung von QAbstractListModel.</description>
<displayname>QAbstractListModel implementation</displayname>
<displayname xml:lang="de">Implementierung von QAbstractListModel</displayname>
<displaycategory>Custom Classes</displaycategory>
<displaycategory xml:lang="de">Benutzerdefinierte Klassen</displaycategory>
\endcode
For more information about the elements and their values, see
\l {Creating Project Wizards}.
\o The following code specifies the files to add to the project:
\code
<files>
<file source="listmodel.cpp" target="%ClassName:l%.%CppSourceSuffix%" openeditor="true" />
<file source="listmodel.h" target="%ClassName:l%.%CppHeaderSuffix%" openeditor="true" />
</files>
\endcode
Here, \c target contains the following variables that are used to
construct the filename:
\list
\o \c {%ClassName:l%} is replaced with the value of the
\c ClassName field. The modifier \c l converts the string to
lower case, to observe Qt conventions.
\o \c {%CppSourceSuffix%} and \c {%CppHeaderSuffix%} are
pre-defined. For more information, see
\l{Pre-defined Standard Variables}.
\endlist
\code
<!-- Create parameter wizard page -->
<fieldpagetitle>ListModel parameters</fieldpagetitle>
<fieldpagetitle xml:lang="de">Parameter des ListModel</fieldpagetitle>
<fields>
<field name="ClassName">
<fieldcontrol class="QLineEdit" validator="^[a-zA-Z0-9_]+$" defaulttext="MyListModel" />
<fielddescription>Class name:</fielddescription>
<fielddescription xml:lang="de">Klassenname:</fielddescription>
</field>
<field name="Datatype">
<fieldcontrol class="QComboBox" combochoices="QString,int" defaultindex="0" />
<fielddescription>Data type:</fielddescription>
<fielddescription xml:lang="de">Datentyp:</fielddescription>
</field>
</fields>
\endcode
In addition to QLineEdit, QComboBox is used in the class wizard to
create a field. \c combochoices specifies the options in the combobox
and \c defaultindex specifies that QString is the default value.
\endlist
\section1 Processing Template Files
When processing a template source file, placeholders specifying the field
names in the format \c{%FIELDNAME%} are replaced by the values entered by
the user. In addition, modifier characters are supported. For example,
\c{%FIELDNAME:u%} specifies that the value is converted to upper case. This
enables generating header guards for C++ header files.
The following modifier characters are supported:
\list
\o \c{l} for lower case.
\o \c{u} for upper case.
\o \c{c} for upper case initial letter ("project" > "Project").
\endlist
You can use conditions to add sections of the file depending on field
values. Use a syntax that is similar to C++ preprocessing, as demonstrated
in the profile of the \c{helloworld} example:
\code
@if "%SCRIPT%" == "true"
QT += script
@endif
\endcode
The value of the Boolean (QCheckBox) field labeled \c{SCRIPT} determines
whether the script module is added. The expressions must expand to valid
Javascript expressions after field replacement.
\section1 Pre-defined Standard Variables
In addition to the field values entered by the user, you can use
the following pre-defined standard values:
\list
\o \c {%ProjectName%} is replaced by the name of the project in the
case of project wizards.
\o \c {%Path%} is replaced by the path to the target directory. For
classes, this is the directory, where the files are created. For
project wizards, an additional subdirectory named after the project
is created.
\o \c {%TargetPath%} is replaced by the path to the directory where the
actual files are created. For non-project wizards, it is identical
to \c %Path%. For project wizards, it is \c %Path%/%ProjectName%.
\o \c {%CppSourceSuffix%} is replaced by the default source suffix,
which is defined in \QC in \gui {Tools > Options > C++ >
File Naming}. For example, if users enter \bold MyClass, the
filename becomes myclass.cpp when the project is created.
\o \c {%CppHeaderSuffix%} is replaced by the default header suffix,
which is also defined in \gui {File Naming}.
\endlist
\section1 Validating User Input
You can specify validation rules for user input. The rules consist of a
Boolean JavaScript expression and an error message. The placeholders in them
are replaced with values before they are evaluated or displayed.
Consider the following rule used in the \l{Creating Class Wizards} example:
\code
<validationrules>
<validationrule condition='"%ClassName%" != "QAbstractListModel"'>
<message>%ClassName% cannot be used as class name.</message>
<message xml:lang="de">%ClassName% kann nicht als Klassenname verwendet werden.</message>
</validationrule>
</validationrules>
\endcode
It ensures that the class name entered by the user does not match the name
of the base class. If the validation fails, a red label displaying the
message appears at the bottom of the wizard page.
\section1 Using Generator Scripts
The values entered in the wizard page are passed to the script
as command line arguments as defined by the wizard configuration file.
In addition, the script must implement a \c{--dry-run} command line option.
\QC needs to know the file names before the files are created to check
whether files with identical names already exist, for example. Therefore,
script file generation is a two-step process:
\list 1
\o Determine file names and attributes: The script is called with the
command line \c{--dry-run} option and the field values. It then prints
the relative path names of the files it intends to create, followed by
comma-separated attributes matching those of the \c{<file>} element, for
example:
\code
myclass.cpp,openeditor
myclass.h,openeditor
myproject.pro,openproject
\endcode
\o Create files: The script is called with the parameters only in the
working directory. It then actually creates the files. If directories
are needed, the script should create them, too.
\endlist
The \c{scriptgeneratedproject} sample wizard illustrates the usage.
A typical script invocation for this example (obtained by running \QC with
\c{--customwizard-verbose}) looks as follows:
\code
generate.pl --class-name=TestClass --project-name=TestProject --header-suffix=h --source-suffix=cpp --description=/tmp/qtcreatorj26629.txt
\endcode
By default, the scripts are run in the directory corresponding to
\c %TargetPath%. This can be overriden by specifying the attribute
\c workingdirectory on the element \c generatorscript. For example, if the
script creates the project directory by itself, %Path% can be specified. In
that case, \c --dry-run should output the correct relative paths or absolute
paths constructed using the value of \c %Path%.
*/

144
doc/src/projects/creator-projects-generic.qdoc Normal file
View File

@@ -0,0 +1,144 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-project-cmake.html
\page creator-project-generic.html
\nextpage creator-version-control.html
\title Setting Up a Generic Project
\QC supports generic projects, so you can import existing projects
that do not use qmake or CMake and \QC ignores your build system.
Generic project support allows you to use \QC as a code editor. You
can change the way your project is built by modifying the \c make command
in the \gui{Projects} mode under \gui{Build Settings}.
When you import a project, \QC creates the following files that
allow you to specify which files belong to your project and which include
directories or defines you want to pass to your compiler:
\tt{.files}, \tt{.includes}, and \tt{.config}.
\section1 Importing a Generic Project
To import an existing generic project:
\list 1
\o Select \gui File > \gui{New File or Project} > \gui{Other Project}
> \gui{Import Existing Project}.
\o In \gui{Import Existing Project}, enter the project name
and select the location of the project file you want to import.
\QC automatically generates the following files in the
project directory:
\list
\o \l{Specifying Files}{.files}
\o \l{Specifying Include Paths}{.includes}
\o \l{Specifying Defines}{.config}
\o .creator
\endlist
\endlist
When the project is successfully imported, \QC creates the project
tree in the sidebar.
After importing a generic project into \QC, open it by selecting the
\tt{.creator} file.
\section1 Working with Generic Project Files
For a generic project, you have to manually specify which files belong to
your project and which include directories or defines you want to pass to
your compiler.
\section1 Specifying Files
The list of files for a generic project is specified in the \tt{.files}
file. When you first create a generic project, \QC adds any files it
recognizes to your project.
To add or remove files, edit the \tt{.files} file in \QC.
\QC recreates your project tree when you save the \tt{.files} file.
Alternatively, you can add and remove files using the context menu in the
project tree.
If you frequently need to update the \tt{.files} file, you can do so
efficiently by using a script that updates the file for you. If the file
is modified externally, you have to restart \QC for the changes to
take effect.
To update the \tt{.files} on the \gui Git repository use the following
script:
\code
git ls-files "*.cpp" "*.h" > MyProject.files
\endcode
\section1 Specifying Include Paths
The include paths are specified in the \tt{.includes} file, one include
path per line. The paths can be either absolute or relative to the
\tt{.includes} file.
\section1 Specifying Defines
The defines are specified in the \tt{.config} file. The \tt{.config} file is
a regular C++ file, prepended to all your source files when they are parsed.
Only use the \tt{.config} file to add lines as in the example below:
\code
#define NAME value
\endcode
\section1 Creating a Run Configuration
\QC cannot automatically determine which executable to run.
In the \gui{Projects} mode under \gui{Run Settings}, define the executable
file to run:
\list 1
\o Click \gui Add and select \gui{Custom Executable}.
\o Define the configuration name, the location of the executable, any
additional arguments and the working directory.
\endlist
*/

148
doc/src/projects/creator-projects-libraries.qdoc Normal file
View File

@@ -0,0 +1,148 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-project-opening.html
\page creator-project-qmake-libraries.html
\nextpage creator-developing-meego.html
\title Adding Libraries to Projects
In addition to Qt libraries, you can add other libraries to your projects.
The way the library is added depends on whether it is a system library or
your own library or a 3rd party library located in the build tree of the
current project or in another build tree.
\image qtcreator-add-library-wizard.png "Add Library wizard"
Because system libraries do not typically change and are often found by
default, you do not need to specify the path to the library or to its
includes when you add it.
For your own libraries and 3rd party libraries, you need to specify
the paths. \QC tries to guess the include path for an external library,
but you need to check it and modify it if necessary. \QC automatically
adds the include path for an internal library.
For all libraries, select the target platforms for the application, library,
or plugin.
Specify whether the library is statically or dynamically linked. For a
statically linked internal library, \QC adds dependencies
(PRE_TARGETDEPS) in the project file.
Depending on the development platform, some options might be detected
automatically. For example, on Mac OS, the library type (\gui Library or
\gui Framework) is detected automatically and the option is hidden. However,
if you develop on another platform than Mac OS and want to build your
project for the Mac OS, you must specify the library type.
The default convention on Windows is that the debug and release versions
of a library have the same name, but are placed in different subdirectories,
usually called \e debug and \e release. If the library path does not contain
either of these folders, you cannot select the option to place the libraries
in separate folders.
Alternatively, the letter \e d can be added to the library name for the
debug version. For example, if the release version is called example.lib,
the debug version is called exampled.lib. You can specify that the letter
is added for the debug version and removed for the release version.
If the library name ends in \e d, deselect the \gui {Remove "d" suffix
for release version} option.
\QC supports code completion and syntax highlighting for the added
libraries once your project successfully builds and links to them.
\section1 To Add Libraries
\list 1
\o In the \gui Projects pane, open the project file (.pro).
\o Right-click in the code editor to open the context menu and select
\gui {Add Library}.
\o Follow the instructions of the wizard.
\endlist
For more information about the project file settings, see
\l{http://doc.qt.nokia.com/4.7/qmake-project-files.html#declaring-other-libraries}
{Declaring Other Libraries}.
\section1 Example of Adding Internal Libraries
The following example describes how to add a statically linked internal
library to your project.
\list 1
\o Choose \gui {File > New File or Project > Other Projects >
C++ Library} to create the library.
The \gui {Introduction and Product Location} dialog opens.
\image qtcreator-add-library-wizard-ex-1.png "Introduction and Product Location dialog"
\o In the \gui Type field, select \gui {Statically Linked Library}.
\o In the \gui Name field, give a name for the library. For example,
\bold mylib.
\o Follow the instructions of the wizard until you get to the
\gui {Project Management} dialog. In the \gui {Add to project}
list, select a project. For example, \bold myapp.
\o In the \gui Projects pane, open the project file (.pro).
For example, \bold myapp.pro.
\o Right-click in the code editor to open the context menu and select
\gui {Add Library > Internal Library > Next}.
\o In the \gui Library field, select \bold mylib and click \gui Next.
\o Click \gui Finish to add the following library declaration to the
project file:
\code
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../../../projects/mylib/release/ -lmylib
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../../../projects/mylib/debug/ -lmylib
else:symbian: LIBS += -lmylib
else:unix: LIBS += -L$$OUT_PWD/../../../projects/mylib/ -lmylib
INCLUDEPATH += $$PWD/../../../projects/mylib
DEPENDPATH += $$PWD/../../../projects/mylib
win32:CONFIG(release, debug|release): PRE_TARGETDEPS += $$OUT_PWD/../../../projects/mylib/release/mylib.lib
else:win32:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$OUT_PWD/../../../projects/mylib/debug/mylib.lib
else:unix:!symbian: PRE_TARGETDEPS += $$OUT_PWD/../../../projects/mylib/libmylib.a
\endcode
\endlist
*/

102
doc/src/projects/creator-projects-opening.qdoc Normal file
View File

@@ -0,0 +1,102 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-project-creating.html
\page creator-project-opening.html
\nextpage creator-project-qmake-libraries.html
\title Opening Projects
\QC stores information that it needs to build projects in a .user file. If
\QC cannot find the file when you open an existing project, it prompts you
to enter the information. If you created the project by using another \QC
instance, \QC asks whether you want to use the old settings. The settings
are specific to the development environment, and should not be copied from
one environment to another. Therefore, we recommend that you click \gui No
and enter the information again in the \gui {Project Setup} dialog.
The \gui {Project Setup} dialog displays a list of development environments
for target platforms that are installed on the development PC. Select the Qt
versions that you want to use to build the project for each target.
\image qtcreator-open-project-targets.png "Target Setup dialog"
If \QC cannot find an existing build for a particular development
environment (Qt version) and target, it starts out from a clean slate, and
creates a new build in the specified directory. \QC suggests a name
and location for the directory that you can change.
By default, \QC does a \l{glossary-shadow-build}{shadow build} and also
creates the directory. However, shadow building is not supported for the
following targets on Windows:
\list
\o Maemo5
\o MeeGo Harmattan
\if defined(qcmanual)
\o Symbian Devices
\endif
\endlist
If you have built the project before, \QC can use the existing build
configuration to make the exact same build as found in the directory
available to \QC.
If you know you have a build, but it is not listed, click \gui {Add Build}
to locate it. Select a directory, and \QC scans it (including
subdirectories) for additional builds of the project. \QC adds the found
builds to the target list.
You can edit the build configuration later. For more information, see
\l{Editing Build Configurations}.
To open a project:
\list 1
\o Select \gui File > \gui{Open File or Project} and select the project
to open.
\o In the \gui {Project Setup} dialog, select the Qt versions to use as
build targets for your project, and click \gui{Finish}.
\note If you have only one development environment installed, this
dialog is skipped.
\endlist
\QC parses all the source files in the project and performs a semantic
analysis to build up the information that it needs for functions such as
navigation and finding usages. A progress bar is displayed during parsing.
*/

134
doc/src/projects/creator-projects-overview.qdoc Normal file
View File

@@ -0,0 +1,134 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-mobile-example.html
\page creator-project-managing.html
\nextpage creator-project-creating.html
\title Managing Projects
To set up a project, you first have to decide what kind of an application
you want to develop. Do you want a user interface based on:
\list
\o Qt Quick
\o HTML5
\if defined(qcmanual)
\o Qt widgets
\endif
\endlist
For a Qt Quick or HTML5 project, you also have a choice of the language to
implement the application logic: C++ or JavaScript.
You can also create other kinds of projects, such as Qt console
applications, shared or static C++ libraries, or subprojects.
You can use wizards to create and import projects. The wizards prompt you
to enter the settings needed for that particular type of project and create
the necessary files for you. You can add your own custom wizards to
standardize the way subprojects and classes are added to a project.
The wizards set up projects to use the Qt build tool, qmake. It 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 only a few lines
of information are needed to create each configuration. For more
information about qmake, see the
\l{http://qt.nokia.com/doc/4.7/qmake-manual.html}{qmake Manual}.
You can modify the build and run settings for qmake projects in the
\gui Projects mode.
Alternatively, you can use the CMake build automation system and set up the
projects manually. In addition, you can import generic projects that do not
use qmake or CMake. This allows you to use \QC as a code editor. For
generic projects, \QC ignores your build system.
\if defined(qcmanual)
To develop applications for Symbian devices, you use qmake and the local
Symbian compiler (on Windows) or qmake and a compilation service at
Nokia Developer (on Linux and Mac OS) to build the applications for the
Symbian devices target. The interface to the compilation service,
Remote Compiler, is installed as a part of the \QSDK. For more information,
see \l{Building with Remote Compiler}.
\endif
You can install mobile device \l{glossary-development-target}{targets}
as part of the \QSDK. The build and run settings for the
installed targets are set up automatically. 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.
You can use sessions to store personal data, such as bookmarks and
breakpoints that are usually not of interest to other developers working on
the same projects. Sessions allow you to quickly switch between projects
when you work on several projects.
The following sections describe how to manage projects:
\list
\o \l{Creating Projects}
\o \l{Opening Projects}
\o \l{Adding Libraries to Projects}
\o \l{Configuring Projects}
\list
\o \l{Specifying Build Settings}
\list
\o \l{Adding Qt Versions}
\o \l{Adding Tool Chains}
\endlist
\o \l{Specifying Run Settings}
\o \l{Specifying Editor Settings}
\o \l{Specifying Code Style Settings}
\o \l{Specifying Dependencies}
\endlist
\if defined(qcmanual)
\o \l{Connecting Maemo Devices}
\o \l{Connecting MeeGo Harmattan Devices}
\o \l{Connecting Generic Linux Devices}
\o \l{Connecting Symbian Devices}
\endif
\o \l{Managing Sessions}
\endlist
For advanced options, see the following topics:
\list
\o \l{Adding New Custom Wizards}
\o \l{Setting Up a CMake Project}
\o \l{Setting Up a Generic Project}
\endlist
*/

90
doc/src/projects/creator-projects-qt-versions.qdoc Normal file
View File

@@ -0,0 +1,90 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-build-settings.html
\page creator-project-qmake.html
\nextpage creator-tool-chains.html
\title Adding Qt Versions
\QC allows you to have multiple versions of Qt installed on your development
PC and use different versions to build your projects for different targets.
For example, \QSDK contains special Qt versions for developing applications
for mobile devices.
\QC checks the directories listed in the \c{PATH} environment
variable for the qmake executable. If a qmake executable is found, it is
referred to as \bold{Qt in PATH} and selected as the Qt version to use
in the \gui Projects mode in the \gui {Build Settings}. If \QC
cannot find qmake, the value in the \gui {Qt version} field might be
invalid and you might need to change it.
\QC automatically detects the Qt versions that are registered by
your system or by \QSDK. To view the settings for each Qt version, move the
mouse pointer over it in the list. To add Qt versions, select
\gui {Tools > Options > Qt4 > Qt Versions}.
Typically, you select the Qt versions for a project when you use project
wizards to create the project. You can add Qt versions for a project in
\gui {Build Settings}.
\section2 Setting Up New Qt Versions
To add a Qt version:
\list 1
\o Select \gui Tools > \gui Options > \gui Qt4 > \gui Add.
\image qtcreator-qt4-qtversions-add.png
\o In the \gui{qmake location} field, enter the path to the
directory where the qmake executable is located.
\o In the \gui{Version name} field, edit the name that \QC
suggests for the Qt version.
\QC automatically determines the path to the binaries in
the Qt installation and displays it in the dialog.
\o In the \gui Helpers section, you can build the debugging
helpers that are available for the Qt version. This is
necessary, because the internal data structures of Qt can
change between versions. For more information, see
\l{Using Debugging Helpers}.
\endlist
\if defined(qcmanual)
\input symbian/creator-projects-qt-versions-symbian.qdocinc
\endif
*/

11
doc/src/projects/creator-projects-running-desktop.qdocinc Normal file
View File

@@ -0,0 +1,11 @@
\section1 Running on Desktop
\list 1
\o Select \gui Desktop as the target.
\image qtcreator-target-selector.png "Target selector"
\o Click the \gui Run button.
\endlist

17
doc/src/projects/creator-projects-running-simulator.qdocinc Normal file
View File

@@ -0,0 +1,17 @@
\section1 Running on Qt Simulator
You can use the Qt Simulator to test Qt applications that are intended
for mobile devices in an environment similar to that of the device. You
can change the information that the device has about its configuration
and environment.
\list 1
\o Select \gui {Qt Simulator} as the target.
\o Click the \gui Run button.
\endlist
For more information about using the Qt Simulator, see the
\l{http://doc.qt.nokia.com/qtsimulator/index.html}{Qt Simulator Manual}.

60
doc/src/projects/creator-projects-running.qdoc Normal file
View File

@@ -0,0 +1,60 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-building-targets.html
\page creator-running-targets.html
\nextpage creator-build-settings.html
\title Running Applications on Multiple Targets
By default, running an application also builds it and deploys it to a
location from where it can be run on the desktop, in Qt Simulator, or
on a mobile device that is connected to the development PC.
To run executable files without deploying them first, deselect the
\gui {Tools > Options > Project > Always deploy project before running it}
option. This allows you to test SIS files that you receive from Ovi
Publishing or Symbian Signed after you have them signed, for example.
For more information on the options you have, see
\l{Specifying Run Settings}.
\if defined(qcmanual)
\input projects/creator-projects-running-desktop.qdocinc
\endif
\input projects/creator-projects-running-simulator.qdocinc
\if defined(qcmanual)
\input linux-mobile/creator-projects-running-madde.qdocinc
\input linux-mobile/creator-projects-running-generic-linux.qdocinc
\input symbian/creator-projects-running-symbian.qdocinc
\endif
*/

217
doc/src/projects/creator-projects-settings-build.qdoc Normal file
View File

@@ -0,0 +1,217 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-running-targets.html
\page creator-build-settings.html
\nextpage creator-project-qmake.html
\title Specifying Build Settings
Different build configurations allow you to quickly switch between
different build settings. By default, \QC creates \bold debug
and \bold release build configurations. A debug build contains additional
debug symbols that you need for debugging the application but that you
can leave out from the release version. Generally, you use the debug
configuration for testing and the release configuration for creating
the final installation file.
You specify build settings in the \gui Projects mode.
\image qtcreator-projectpane.png
To add a new build configuration, click \gui Add and select the type of
configuration you would like to add. You can add as many build
configurations as you need.
To delete the build configuration currently selected, click \gui Remove.
\section1 Editing Build Configurations
To edit a build configuration:
\list 1
\o Select the build configuration you want to edit in
\gui{Edit Build Configuration}.
\o In the \gui {Qt version} field, select the Qt version to use for
building project. You can add Qt versions to the list if they are
installed on the development PC, but were not detected
automatically. For more information, see \l{Adding Qt Versions}.
\o In the \gui {Tool chain} field, select the tool chain required
to build the project. The tool chains that are compatible with the
selected Qt version are listed. You can add tool chains to the list
if they are not automatically detected. For more information, see
\l{Adding Tool Chains}.
\o In the \gui {Build directory} field, specify the build directory for
the project. By default, projects are built in a separate directory
from the source directory, as \l{glossary-shadow-build}
{shadow builds}. This keeps the files generated for each
\l{glossary-development-target}{target} platform separate.
If you only build for one target platform, you can deselect the
\gui{Shadow build} checkbox.
\if defined(qcmanual)
\note Shadow building is not supported for Maemo or MeeGo Harmattan
on Windows. Also, shadow building is not supported by the Symbian
build system.
\endif
\endlist
\if defined(qcmanual)
\note The build configuration for the \gui{Symbian Device} target
uses the GCCE tool chain by default. If you want to build
for the device using RVCT, install the RVCT tool chain, and then
select it in the \gui {Tool chain} field. RVCT 2.2 is supported on Symbian^3
and earlier. RVCT 4.0 b902 or later is required for Symbian Belle.
\endif
\section1 Starting External Processes
\QC executes external processes to accomplish tasks such as building
and running applications. To execute the processes, \QC uses shell
commands that are native to the system. It constructs the commands from
an executable name and optional command line arguments.
The executable name is specified in the executable fields: \gui qmake,
\gui Make, \gui Command, or \gui Executable. It is either derived from the
project or specified manually. When you specify executables manually, you
can reference environment variables and \QC variables. However, no
quoting rules
apply.
You can specify command-line arguments in the arguments fields:
\gui {Additional arguments}, \gui {Command arguments},
\gui {Make arguments}, or \gui Arguments. You can create shell command lines
that can contain redirection and other advanced constructs. However, some
more complex use cases, such as piping test data into the application being
tested or grouping commands, are not supported because the value of the
\gui Executable field is always placed first when constructing the command.
\section2 Using Environment Variables
You can use any environment variables as values in the fields. For a list
of variable names, click \gui {Build Environment > Details} in the
\gui {Build Settings}. Environment variables are referenced using the native
syntax: $VARNAME or ${VARNAME} on Unix and %VARNAME% on Windows.
\section2 Using Qt Creator Variables
You can use \QC variables in arguments, executable paths, and working
directories. The variables take care of quoting their expansions, so you do
not need to put them in quotes.
The following \QC variables are available:
\list
\o %{buildDir}
\o %{sourceDir}
\endlist
\section1 Build Steps
The build system of \QC is built on qmake and make. In \gui{Build Steps} you
can change the settings for qmake and make. \QC runs the make command using
the Qt version defined for the current build configuration.
\image qtcreator-build-steps.png "Build steps"
To override the shell command that \QC constructs by default, remove
the build step and add a custom build step that specifies another shell
command.
\section2 Adding Custom Build Steps
To add custom steps to the build settings, select \gui {Add Build Step >
Custom Process Step}.
By default, custom steps are disabled. To activate a custom step, select
the \gui{Enable custom process step} check-box.
\image qtcreator-build-steps-custom.png "Custom Process Step"
\section1 Clean Steps
You can use the cleaning process to remove intermediate files. This process
might help you to fix obscure issues during the process of building a
project.
\image qtcreator-clean-steps.png "Clean steps"
You can define the cleaning steps for your builds in the \gui{Clean Steps}:
\list
\o To add a clean step using make or a custom process, click
\gui{Add Clean Step} and select the type of step you want to add.
By default, custom steps are disabled. To activate a custom step,
select the \gui{Enable custom process step} check-box.
\o To remove a clean step, click \gui{Remove Item}.
\o To change the order of steps, click
\inlineimage qtcreator-movestep.png
.
\endlist
\section1 Build Environment
You can specify the environment you want to use for building in the
\bold{Build Environment} section. By default, the environment in which \QC
was started is used and modified to include the Qt version.
Depending on the selected Qt version, \QC automatically sets the
necessary environment variables. You can edit existing environment
variables or add, reset and unset new variables based on your project
requirements.
\image qtcreator-build-environment.png "Build Environment"
\note The changes are stored in the local project specific \c{.pro.user}
file. Therefore, they are not suitable for sharing between developers or
development PCs. To share settings, incorporate them into the build system.
For example, if you use qmake, make the changes in the \c{.pro} file.
\section2 Clearing the System Environment
To build with a clean system environment, select the \gui {Clear system
environment} check box. \QC discards the current environment, and
populates a clean system environment with the environment variables that the
compilers and tools need. Therefore, the environment is never totally empty,
even after you clear it.
*/

70
doc/src/projects/creator-projects-settings-code-style.qdoc Normal file
View File

@@ -0,0 +1,70 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-editor-settings.html
\page creator-code-style-settings.html
\nextpage creator-build-dependencies.html
\title Specifying Code Style Settings
\QC uses the \l{Editing MIME Types}{MIME type} of the file to
determine which mode and editor to use for opening the file.
\QC opens C++ files in \gui Edit mode in the C++ code editor and
QML files in the Qt Quick editor.
You can configure the code style according to your needs. You can specify
code style either globally for all projects or separately for each
project. To specify global code style for C++ files, select \gui {Tools >
Options > C++}.
To specify global code style for QML files, select \gui {Tools > Options
> Qt Quick}.
To configure the editor behavior for the current project:
\list
\o Select \gui {Projects > Code Style Settings}.
\o In the \gui Language field, select \gui C++ or \gui Qt Quick.
\o Deselect the \gui {Use global settings} check box.
\o In the \gui Settings field, select \gui Custom.
\o Specify code style settings for the project. Only \gui General
settings are available for QML files.
\endlist
\image qtcreator-code-style-settings.png "Code Style Settings view"
For more information about the settings, see \l{Indenting Code}.
*/

66
doc/src/projects/creator-projects-settings-dependencies.qdoc Normal file
View File

@@ -0,0 +1,66 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-code-style-settings.html
\page creator-build-dependencies.html
\nextpage creator-debugging.html
\title Specifying Dependencies
If you have multiple projects loaded in a session, you can define the
order in which they are built. For example, if project A depends on project
B, project B must be built first.
\note The build order is stored as a property of a session, not a project.
You must open the session for these settings to take effect. For more
information, see \l{Managing Sessions}.
\image qtcreator-build-dependencies.png "Dependencies view"
To define the build order of projects within a session:
\list 1
\o In \gui Projects, select a project.
\o Click \gui Dependencies.
\o Select projects that must be built before the current project is
built.
\endlist
\QC calculates the build order based on the dependencies that you
specify for the projects loaded in the session.
\note You cannot use this view to specify subprojects for projects.
For more information on how to add subprojects, see \l{Adding Subprojects
to Projects}.
*/

73
doc/src/projects/creator-projects-settings-editor.qdoc Normal file
View File

@@ -0,0 +1,73 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-run-settings.html
\page creator-editor-settings.html
\nextpage creator-code-style-settings.html
\title Specifying Editor Settings
\QC uses the \l{Editing MIME Types}{MIME type} of the file to
determine which mode and editor to use for opening the file. For example,
\QC opens .txt files in \gui Edit mode in the text editor.
You can configure the text editor according to your needs. You can specify
editor behavior either globally for all projects or separately for each
project. To specify global editor behavior, select \gui {Tools > Options
> Text Editor > Behavior}.
To configure the text editor behavior for the current project:
\list
\o Select \gui {Projects > Editor Settings}.
\o Deselect the \gui {Use global settings} check box.
\o Specify text editor settings for the project.
\endlist
\image qtcreator-editor-settings.png "Editor Settings view"
For more information about the settings, see:
\list
\o \l{Indenting Code}
\o \l{File Encoding}
\o \l{Moving to Symbol Definition or Declaration}
\o \l{Configuring Fonts}
\endlist
*/

82
doc/src/projects/creator-projects-settings-overview.qdoc Normal file
View File

@@ -0,0 +1,82 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-usability.html
\page creator-configuring-projects.html
\nextpage creator-building-targets.html
\title Configuring Projects
When you install the \QSDK, the build and run settings for the tool chains
delivered with the \QSDK are set up automatically.
To view and modify the settings for currently open projects, switch to the
\gui Projects mode by pressing \key Ctrl+5.
\image qtcreator-projectpane.png
You can add a target if the development environment for the target platform
is installed on the development PC and the Qt version is configured. Click
\inlineimage qtcreator-qt4-addbutton.png "Add Target button"
and select from a list of available targets. To remove a target, select it
and click
\inlineimage qtcreator-target-remove.png "Remove Target button"
.
You can select the targets and use the \gui Build menu commands to build,
deploy, and run projects.
The project pane consists of the following tabs:
\list
\o \l{Running Applications on Multiple Targets}{Targets}
(If you have installed the development environment for only one
target, the \gui Targets tab is replaced by a \gui Build tab and a
\gui Run tab.)
\o \l{Specifying Build Settings}{Build Settings}
\o \l{Specifying Run Settings}{Run Settings}
\o \l{Specifying Editor Settings}{Editor Settings}
\o \l{Specifying Code Style Settings}{Code Style Settings}
\o \l{Specifying Dependencies}{Dependencies}
\endlist
Use the \gui Build and \gui Run buttons to switch between the build and
run settings for the active project.
If you have multiple projects open in \QC, use the tabs at the top of the
window to navigate between their settings.
*/

15
doc/src/projects/creator-projects-settings-run-desktop.qdocinc Normal file
View File

@@ -0,0 +1,15 @@
\section2 Specifying Run Settings for Desktop Targets
You can specify command line arguments to be passed to the executable
and the working directory to use. The working directory defaults to
the directory of the build result.
For console applications, check the \gui{Run in Terminal} check box.
If you need to run with special environment variables set up, you
also do it in the run configuration settings.
\image qtcreator-pprunsettings.png
You can also create custom executable run configurations where you
can set the executable to be run. For more information, see
\l{Specifying a Custom Executable to Run}.

71
doc/src/projects/creator-projects-settings-run.qdoc Normal file
View File

@@ -0,0 +1,71 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-tool-chains.html
\page creator-run-settings.html
\nextpage creator-editor-settings.html
\title Specifying Run Settings
\QC automatically creates run configurations for your project.
To view and modify the settings, select \gui {Projects > Run}.
The settings to specify depend on the type of the project and on the build
target for the project.
Click \gui Add to add run settings for a project and \gui Remove to remove
the current settings.
\section1 Specifying Run Settings for qmake Projects
The run configurations for qmake projects derive their executable from the
parsed .pro files. For more information on how the commands are constructed,
see \l{Starting External Processes}.
\if defined(qcmanual)
\input projects/creator-projects-settings-run-desktop.qdocinc
\input symbian/creator-projects-settings-run-symbian.qdocinc
\input linux-mobile/creator-projects-settings-run-madde.qdocinc
\input linux-mobile/creator-projects-settings-run-generic-linux.qdocinc
\endif
\section1 Specifying a Custom Executable to Run
If you use CMake or the generic project type in \QC, or want
to run a custom desktop executable, create a \gui {Custom Executable}
run configuration for your project. For example, when working on a library,
you can run a test application that links against the library.
Specify the executable to run, command line arguments, working directory,
and environment variables to use.
\image qmldesigner-run-custom-exe.png "Run settings for custom executables"
\input qtquick/creator-projects-settings-run-qtquick.qdocinc
*/

148
doc/src/projects/creator-projects-tool-chains.qdoc Normal file
View File

@@ -0,0 +1,148 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-project-qmake.html
\page creator-tool-chains.html
\nextpage creator-run-settings.html
\title Adding Tool Chains
A \e {tool chain} specifies a compiler and a debugger and other necessary
tools for building an application that is \l{glossary-development-target}
{targeted} for a particular platform. \QC automatically detects the tool
chains that are registered by your system or by \QSDK.
You can add tool chains to build applications by using other compilers or
with different versions of the automatically detected compilers:
\list
\o GNU Compiler Collection (GCC) is a compiler for Linux and
Mac OS X.
\o MinGW (Minimalist GNU for Windows) is a native software port of GCC
and GNU Binutils for use in the development of native Microsoft
Windows applications on Windows. MinGW is
distributed together with \QC and Qt SDK for Windows.
\o Linux ICC (Intel C++ Compiler) is a group of C and C++ compilers
for Linux.
\o Clang is a C, C++, Objective C, and Objective C++ front-end for the
LLVM compiler for Windows, Linux, Mac OS X, and Symbian.
\o GCCE (GNU Compiler Collection for Embedded) is an ARM-based
compiler used in Symbian OS 9 and distributed together with \QSDK.
\if defined(qcmanual)
\o RVCT is an ARM-based compiler for building applications for Symbian
devices (requires a license).
\o WINSCW is a compiler for building applications that can be run or
debugged on the Symbian Emulator. It is distributed together with
Symbian SDKs (but not with the \QSDK).
\endif
\endlist
To build an application using GCC, MinGW, GCCE, or Clang, specify the paths
to the directories where the compiler and debugger are located and select
the application binary interface (ABI) version from the list of available
versions. You can also create a custom ABI definition.
\QC allows you to select a tool chain that matches the Qt version
in the \gui Projects mode \gui {Build Settins}.
To add tool chains:
\list 1
\o Select \gui {Tools > Options Tool Chains > Add} and select a
compiler in the list.
\image qtcreator-toolchains.png
To clone the selected tool chain, select \gui {Clone}.
\o In the \gui Name column, double-click the name to change it.
\o In the \gui{Compiler path} field, enter the path to the directory
where the compiler is located.
\if defined(qcmanual)
For WINSCW, enter the path to the Carbide C++ installation directory
here.
\endif
The other settings to specify depend on the tool chain.
\if defined(qcmanual)
\o For RVCT, select the ARM version to use in the \gui {ARM version}
field. RVCT 2.2 is supported on Symbian^3 and earlier. RVCT 4.0 b902
or later is required for Symbian Belle.
\endif
\endlist
\section2 Troubleshooting MinGW Compilation Errors
If error messages displayed in the \gui {Compile Output} pane contain
paths where slashes are missing (for example, C:QtSDK),
check your PATH variable. At the command line, enter the following commands:
\code
where sh.exe
where make.exe
where mingw32-make.exe
\endcode
If these commands show paths, they have been added to the global PATH
variable during the installation of a tool chain based on Cygwin or MinGW,
even though this is against Windows conventions.
To keep working with the third-party tool chain, create a new shell link
that adds the required paths (as Visual Studio and Qt do). The shell link
must point to cmd.exe, as illustrated by the following example:
\c {C:\Windows\System32\cmd.exe /K C:\path_to\myenv.bat}
where the /K parameter carries out the command specified in the bat file.
Create the myenv.bat file at \e path_to, which should be in a convenient
location. In the file, specify the paths to the tool chains. For example,
\c {set PATH=C:\path1;C:\path2;%PATH%}
where \e path1 and \e path2 are paths to the tool chains.
Finally, remove the paths from the global PATH, reboot the computer, and
run the \c where commands again to verify that the global PATH is now clean.
You can use the shell link to run the tools in the third-party tool chains.
*/

86
doc/src/projects/creator-remote-compiler.qdoc Normal file
View File

@@ -0,0 +1,86 @@
/****************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (info@qt.nokia.com)
**
**
** GNU Free Documentation License
**
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at info@qt.nokia.com.
**
****************************************************************************/
// **********************************************************************
// NOTE: the sections are not ordered by their logical order to avoid
// reshuffling the file each time the index order changes (i.e., often).
// Run the fixnavi.pl script to adjust the links to the index order.
// **********************************************************************
/*!
\contentspage index.html
\previouspage creator-publish-ovi.html
\page creator-remote-compiler.html
\nextpage creator-help.html
\title Building with Remote Compiler
The \gui {Remote Compiler} target is an interface to a compilation service
at Nokia Developer. It provides a simple, standardized environment for
building Qt applications and creating installation packages for mobile
device targets when you do not have the necessary tool chains and SDKs
installed or they are not supported on the development PC. You can choose
from a set of supported devices.
You need a Nokia Developer user account to use the Remote Compiler. You can
create an account for free at \l{http://www.developer.nokia.com/}
{Nokia Developer}.
\note Remote Compiler is an experimental component that is installed as
part of \QSDK.
\list 1
\o Select \gui {Start > \QSDK > Maintain \QSDK} to open the
\gui {Maintain \QSDK} tool.
\o In the \gui {Package Manager}, select \gui {Experimental >
Remote Compiler} to install Remote Compiler.
\o In \QC, choose \gui {Tools > Options > Projects > Remote Compiler}
to log on to Nokia Developer.
\image remotecompiler-fn-logon.png "Remote Compiler options"
\o Choose \gui {Projects}.
\o Click
\inlineimage qtcreator-qt4-addbutton.png "Add Target button"
and select \gui {Remote Compiler} to add Remote Compiler as a
target.
\o Click \gui Add to add mobile device platforms as build
configurations.
\o Click the \gui {Target Selector} and select a build configuration.
\o Choose \gui {Build > Build All}.
\endlist
The installation package is generated in the \gui {Build directory} on
the development PC.
For more information about Remote Compiler, choose \gui {Help > Contents >
Remote Compiler Manual}. The document is added during the installation of
Remote Compiler.
*/