qtcreator.qdoc

           A list of files containing the searched text is displayed in the
           \gui{Search Results} pane.
           \list
            \o To see all occurrences in a file, double-click the file name in
               the list.
            \o To go to an occurrence, double-click it.
           \endlist
    \endlist
*/


/*!
    \contentspage index.html
    \previouspage creator-editor-finding.html
    \page creator-editor-refactoring.html
    \nextpage creator-editor-locator.html

    \title Refactoring

    Code refactoring is the process of changing the code without modifying the
    existing functionality of your application. By refactoring your code you
    can:
    \list
        \o Improve internal quality of your application
        \o Improve performance and extensibility
        \o Improve code readability and maintainability
        \o Simplify code structure
    \endlist

    \section1 Finding Symbols

    To find the use of a specific symbol in your project:
    \list 1
        \o In the editor place the cursor on the symbol and select \gui Tools
           > \gui C++ > \gui{Find Usages} or press
           \key Ctrl+Shift+U.

           Qt Creator looks for the symbol in the following locations:
           \list
            \o Files listed as a part of the project
            \o Files directly used by the project files (for example, generated
               files)
            \o Header files of used frameworks and libraries
           \endlist
        \o The \gui{Search Results} pane opens and shows the location and
           number of instances of the symbol in the current project.

           \image qtcreator-refactoring-find.png
    \endlist

    You can browse the search results in the following ways:
    \list
        \o To go directly to an instance, double-click the instance in the
           \gui{Search Results} pane.
        \o To move between instances, click
           \inlineimage qtcreator-forward.png
           and
           \inlineimage qtcreator-back.png
           in the \gui{Search Results} pane.
        \o To expand and collapse the list of all instances, click
           \inlineimage qtcreator-expand.png
           .
        \o To clear the search results, click \inlineimage qtcreator-clear.png
           .
    \endlist

    \section1 Renaming Symbols

    To rename a specific symbol in your project:
    \list 1
        \o In the editor, place the cursor on the symbol you would like to
           change and select \gui Tools > \gui C++ >
           \gui{Rename Symbol Under Cursor} or press \key Ctrl+Shift+R.

           The \gui{Search Results} pane opens and shows the location and
           number of instances of the symbol in the current project.

           \image qtcreator-refactoring-replace.png
        \o To replace all selected instances, enter the name of the new symbol
           in the \gui{Replace with} text box and click \gui Replace.

           To omit an instance, uncheck the check-box next to the instance.

           \note This action replaces all selected instances of the symbol in
           all files listed in the \gui{Search Results} pane. You cannot
           undo this action.
    \endlist

    \note Renaming local symbols does not open the \gui{Search Results} pane.
    The instances of the symbol are highlighted in code and you can edit the
    symbol. All instances of the local symbol are changed as you type.
*/

/*!
    \contentspage index.html
    \previouspage creator-editor-locator.html
    \page creator-project-managing.html
    \nextpage creator-project-creating.html

    \title Managing Projects

    One of the major advantages of Qt Creator is that it allows a team of
    developers to share a project across different development platforms with a common
    tool for development and debugging.

    The recommended way to build a project is to use a \l{Using Version Control Systems} {version control system}.
    Store and edit only project source files and the .pro and .pri files (for qmake)
    or CMakeLists.txt and *.cmake files (for CMake). Do not store
    files generated by the build system or Qt Creator, such as makefiles,
    .pro.user, and object files. Other approaches are possible,
    but we recommend that you do not use network resources, for example.

    Qt Creator allows you to specify separate \l{Building for Multiple Targets} {build settings}
    for each development platform. By default, \l{glossary-shadow-build}{shadow builds} are used to
    keep the build specific files separate from the source.

    You can create separate versions of project files to keep platform-dependent
    code separate. You can use qmake
    \l{http://qt.nokia.com/doc/4.2/qmake-tutorial.html#adding-platform-specific-source-files}{scopes}
    to select the file to process depending on which platform qmake is run on.

    Items such as open files, breakpoints, and watches are stored in
    \l{Managing Sessions}{sessions}. They are not considered to be part of the
    information shared across platforms.

    Qt Creator is integrated with cross-platform systems for build automation:
    qmake and CMake. In addition, you can import generic projects that do not use qmake
    or CMake, and specify that Qt Creator ignores your build system.
    \list
       \o To use \bold{qmake} to build applications, open a \c .pro file. For more
          information, see \l{Setting Up a qmake Project}.
       \o To use \bold{CMake} to build applications you need to have CMake version
          2.8.0 or later installed. For more information, see
          \l{Setting Up a CMake Project}.
       \o To use \bold{other build systems} to build applications, specify which files belong to
          your project and which include directories or defines you want to pass
          to your compiler. For more information, see
          \l{Setting Up a Generic Project}.
    \endlist

    Qt Creator provides support for \l{Building and Running Applications}{building and running} Qt applications for
    desktop environment and mobile devices. When you install the Nokia Qt SDK,
    the build and run settings for the desktop, Maemo, and Symbian targets are set up
    automatically. However, you need to install and configure some additional software
    on the devices:

    \list

       \o \l{Setting Up Development Environment for Maemo}.

       \o \l{Setting Up Development Environment for Symbian}.

    \endlist

    \note The only supported build system for mobile applications in Qt
    Creator is qmake.

    Once your mobile application is ready, you can test it in the Qt Simulator.
    You can also connect Maemo and Symbian devices to your development PC and
    debug applications on the devices. After you have tested the application,
    you can deploy it on mobile devices.

    Developing applications for mobile devices is different from developing
    desktop applications. For more information, see
    \l{Optimizing Applications for Mobile Devices}.

    To change the location of the project directory, and to make changes in
    the build and run settings, select \gui{Tools} > \gui{Options...} >
    \gui{Projects} > \gui{General}.

    \section1 External Libraries

    Through external libraries Qt Creator can support code completion and
    syntax highlighting for external libraries as if they were a part of the
    current project or the Qt library.

    The procedure of adding a library to a project depends on the type of
    project, which influences the build system used.

    \list
       \o For information on adding external libraries to qmake projects, see
          \l{Adding External Libraries to a qmake Project}.
       \o For information on adding external libraries to CMake projects, see
          \l{Adding External Libraries to a CMake Project}.
   \endlist

*/


/*!
    \contentspage index.html
    \previouspage creator-project-managing.html
    \page creator-project-creating.html
    \nextpage creator-project-qmake.html

    \title Creating a Project

    You use wizards to create and import several types of projects and files, such
    as Qt GUI or console applications and Qt Quick applications. You can also use
    wizards to add individual files to your projects. For example, you can create
    the following types of files:

    \list

        \o Qt resource files, which allow you to store binary files in the
        application executable

        \o \QD forms and Qt QML files, which specify parts of application user
        interfaces

        \o C++ class, source, or header files

    \endlist

    The wizards prompt you to enter the settings needed
    for that particular type of project and create the necessary files for you.

    \image qtcreator-new-project.png

    \section1 Using Project Wizards

    To create a new project:
    \list 1
        \o Select \gui File > \gui{New File or Project} and select the type of your
           project.

           The contents of the following dialogs depend on the project type.
           Follow the instructions of the wizard.
           This example uses \gui {Qt Gui Application}.

        \o Name the project and set its path. To select the path from a
           directory tree, click \gui Browse.

           Avoid using spaces and special characters in the project name and
           path.

           \image qtcreator-intro-and-location.png
        \o Specify the name of the class you want to create and using the
           drop-down menu select its base class type.

           Note that the \gui{Header file}, \gui{Source file} and
           \gui{Form file} fields are automatically updated as you name your
           class.

           \image qtcreator-class-info.png
        \o Review the project settings.

           To create the project, click \gui Finish.

           \image qtcreator-new-project-summary.png
    \endlist

    \section1 Adding New Project 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 use the wizard templates in the \c {share/qtcreator/templates/wizards}
    folder to create your own project and class wizards. Qt Creator looks in the
    folder and adds all wizards defined in wizard.xml files to the \gui New dialog
    that opens when you select \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
    projcet.

    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_example.xml as wizard.xml in the helloworld
    and listmodels folders. After you restart Qt Creator, 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"

    \section2 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 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" />

        \endcode

        \list

            \o \c source specifies the file to copy to the project. The files must be
            located in the wizard folder.

            \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.

            \o \c openeditor indicates that the file is to be opened in an editor after
            the wizard has finished.

        \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

    \section2 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%} is replaced by the default source suffix, which
        is defined in Qt Creator 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}. Here, the filename would
        become myclass.h.

        \endlist

        \o The following code creates a page that allows users to select the class
        name, base class, and header and source files for the class:

        \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

*/


/*!
    \contentspage index.html
    \previouspage creator-project-creating.html
    \page creator-project-qmake.html
    \nextpage creator-project-cmake.html

    \title Setting Up a qmake Project

    The qmake tool helps simplify the build process for development projects
    across different platforms. qmake automates the generation of makefiles
    so that only a few lines of information are needed to create each makefile.
    qmake can be used for any software project, whether it is written in Qt or not.

    The qmake tool generates a makefile based on the information in a project
    file that is generated by Qt Creator. It can generate makefiles for MinGW,
    Microsoft Visual studio, and CSL ARM in Windows, and GNU Compiler Collection
    (GCC) in Linux and Mac OS X.

    For more information about qmake, see the
    \l{http://qt.nokia.com/doc/4.2/qmake-manual.html}{qmake Manual}.

    \section1 Selecting the Qt Version

    Qt Creator allows you to have multiple versions of Qt installed on
    your development PC and use different versions for each of your projects.

    If Qt Creator finds \bold qmake in the \c{PATH} environment variable, it uses
    that version. The \l{glossary-system-qt}{ qmake version of Qt} is referred
    to as \bold{Qt in PATH}. If you intend to use only one version of Qt and it
    is already in the \c{PATH} and correctly set up for command line use, you do
    not need to manually configure your Qt version.


    \section2 Windows

    To add a Qt version for \bold MinGW:
    \list 1
        \o Select \gui Tools > \gui Options... > \gui Qt4 >
           \gui{Qt Versions}.
        \o Click \inlineimage qtcreator-windows-add.png
           and enter the name of the version in \gui{Version Name} field.
        \o Enter the qmake binary path in the \gui{qmake Location}.
        \o Enter the MinGW installation path in the \gui{MinGW Directory}.

           \image qtcreator-qt4-qtversions-win-mingw.png
    \endlist

    To add a Qt version for a \bold{Microsoft Visual C++} compiler:
    \list 1
        \o Select \gui Tools > \gui Options... > \gui Qt4 >
           \gui{Qt Versions}.
        \o Qt Creator automatically sets the correct environment variables for
           compilation. Select the internal version number of the installed
           Microsoft Visual C++ tool chains using the \gui MSVC drop-down
           box:
           \list
               \o \bold 7.1 for Visual Studio 2003
               \o \bold 8.0 for Visual Studio 2005
               \o \bold 9.0 for Visual Studio 2008
           \endlist

           \note If you are using the
           \bold{Windows SDK for Windows Server 2008}, Qt Creator identifies
           it as version 9.0.

           \image qtcreator-qt4-qtversions-win-msvc.png
    \endlist

    If you are using \bold{Qt for Symbian} and your S60 SDK is registered
    with devices.exe, Qt Creator automatically detects the Qt version. To add a
    Qt for Symbian version:
    \list 1
        \o Select \gui Tools > \gui Options... > \gui Qt4 >
           \gui{Qt Versions}.
        \o Select the \gui{S60 SDK} you want the Qt Creator to use.

           \image qtcreator-qt4-qtversions-win-symbian.png
        \o To build an application for your device using GCCE, enter the path
           to the \bold{CSL ARM Toolchain} directory in
           \gui{CSL\\GCCE Directory}.

           You do not need to specify this path if the compiler is included in
           the \c{PATH} environment variable.
        \o To build an application for the emulator (WINSCW toolchain), enter
           the path to your Carbide C++ installation directory in
           \gui{Carbide Directory}.

           \note You need to have Carbide C++ version 2.0 or later installed.
    \endlist

    \section2 Compiling Projects With Linux

    To compile a project in Qt Creator, Linux uses GNU Compiler Collection
    (GCC). Intel Compiler Collection (ICC) is supported as a drop-in
    replacement for GCC.

    To add a Qt version:
    \list 1
        \o Select \gui Tools > \gui Options... > \gui Qt4 >
           \gui{Qt Versions}.
        \o Click \inlineimage qtcreator-linux-add.png
           and enter the name of the version in \gui{Version Name}.
        \o Enter the path to the qmake binary in \gui{Path to qmake}.
    \endlist

    \section2 Compiling Projects With Mac OS X

    To compile a project in Qt Creator, Mac OS X uses GNU Compiler Collection
    (GCC), which is part of Xcode.

    To add a Qt version:
    \list 1
        \o Select \gui{Qt Creator} > \gui Preferences... > \gui{Qt Versions}.
        \o Click \inlineimage qtcreator-macosx-add.png
           and enter the name of the version in \gui{Version Name}.
        \o Enter the path to the qmake binary in \gui{Path to qmake}.

           \image qtcreator-qt4-qtversions.png
    \endlist

*/


/*!
    \contentspage index.html
    \previouspage creator-developing-symbian.html
    \page creator-building-running.html
    \nextpage creator-project-managing-sessions.html

    \title Building and Running Applications

    Qt Creator provides support for building and running Qt applications for
    desktop environment and mobile devices. When you install the Nokia Qt SDK,
    the build and run settings for the desktop, Maemo, and Symbian targets are
    set up automatically.

    You can select the targets and click the \gui Run button to build and
    run the applications on the targets.

     \section1 Setting Up a Project

    To view and modify the settings for currently open projects, switch to the
    \gui Projects mode by pressing \key Ctrl+4.

    \image qtcreator-projectpane.png

    The project pane consists of the following tabs:
    \list
       \o Targets
       \o Editor Settings
       \o 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 Qt Creator, use
    \gui{Select a Project} option at the top to navigate between different
    project edits.

    \section1 Building for Multiple Targets

    Different build configurations allow you to quickly switch between
    different build settings. By default, Qt Creator creates \bold debug
    and \bold release build configurations.

    \section2 Building for Desktop

    \list 1

        \o Select \gui Desktop as the target.

        \o Click the \gui Run button.

    \endlist

    \section2 Building for 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

    \section2 Building for Maemo

    \list 1

        \o Set up the MADDE development environment and specify a connection
        to the device. For more information, see
        \l{Setting Up Development Environment for Maemo}.

        \o Connect the device to the development PC.

        \o Click the \gui Run button.

        Qt Creator uses the compiler specified in the MADDE toolchain to
        build the application.

        The application is automatically copied to the device and executed
        there. The application views are displayed on the N900. Command-line
        output is visible in the Qt Creator \gui {Application output} view.

        Debugging also works transparently.

    \endlist

    \section2 Building for Symbian

    \list 1

        \o Build and run the application for \l{Building for Qt Simulator}{Qt Simulator}.

        \o If no problems are found, build and run the application for a device.

        \o To test functionality that uses Symbian APIs, you can build and
        run the application for Symbian Emulator.

    \endlist

    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, select it in the \gui {Tool chain} field
    in the \gui{General} section.

    \section3 Building and Running for a Device

    \list 1

        \o Install the required software on the device. For more information, see
        \l{Setting Up Development Environment for Symbian}.

        \o Connect the device to the development PC through a USB cable.
        Qt Creator shows the current connection state
        of a device in its main toolbar, showing a red cross when no device is
        connected, or a green check mark when a device is connected.

        \image qtcreator-qt4-symbian-device-notconnected.png
        \image qtcreator-qt4-symbian-device-connected.png

        The tool tip of the target button shows more details about the actual
        device that will be used when you run your application.

        \o Start the \gui{App TRK} application on your device.

        \o Click the \gui Run button.

    \endlist

    You can connect several devices to your development PC simultaneously.
    In the details of the run configuration for the \gui{Symbian Device} target,
    select the device to run your application on.

    \section3 Creating Installation Packages

    When you build the application for the \gui{Symbian Device} target, Qt
    Creator automatically generates a Symbian installation system (SIS) file
    in the project folder. You can deliver the installation file to users for
    installation on Symbian devices.

    Only installation files signed with a certificate and private key are
    allowed to be installed onto Symbian devices. By default, Qt Creator
    self-signs the installation file. This self-signing allows you to install
    the application on a mobile  device but places limits on what you can do
    with the installation file, including:
    \list
       \o  Self-signed applications cannot access the more sensitive
           \l{Capabilities and Signing}{capabilities} of the mobile device.
       \o  Security warnings will be displayed when you install the self-signed
           application on a mobile device.
       \o  Self-signed applications cannot be distributed commercially on Ovi
           Store.
    \endlist

    To get around these limitations, you need to go through the Symbian Signed
    process. The Symbian Signed organisation manages a public key
    infrastructure to provide public authentication of the information in the
    application signing certificates. Their security partner can validate your
    certificate and give you a Publisher ID. Then, when you sign an
    application, other people can be confident that the information in your
    certificate is correct and that the application does actually come from you.

    There are also options that do not require you to get a Publisher ID. For
    more detail about how the Symbian Signed process works, see
    \l{http://developer.symbian.org/wiki/index.php/Complete_Guide_To_Symbian_Signed}
    {Complete Guide to Symbian Signed}.

    When you have your own certificate and private key, you can specify them in
    the \gui{Create sis Package} step in your build configuration.

    \image qtcreator-qt4-symbian-signing.png

    \section3 Capabilities and Signing

    Capabilities allow the Symbian platform to control access by applications to
    the functionality provided by the platform APIs. Access to capabilities is
    determined by the device configuration and how the application has been signed.

    Symbian Signed offers the following signing options depending on the
    capabilities that the application accesses:

    \list

        \o \bold{Express signed} for applications that access only user and system
        capabilities.

        \o \bold{Certified signed} for applications that access also restricted or
        device manufacturer capabilities.

        \note You need to request the rights to access device manufacturer
        capabilities from the manufacturer.

    \endlist

    For more information about how to choose the appropriate signing option, see
    \l{http://developer.symbian.org/wiki/index.php/Symbian_Signed_For_Distributing_Your_Application}{Symbian Signed For Distributing Your Application}.

    If you select a signing option that does not allow the application to access
    the defined capabilities, installing the application on mobile devices
    fails. To avoid problems, only define capabilities and link libraries to a project
    if you really need them.

    For more information about capabilities and how you can check which ones you
    need, see
    \l{http://developer.symbian.org/wiki/index.php/Capabilities_(Symbian_Signed)}{Capabilities (Symbian Signed)}
    and
    \l{http://doc.qt.nokia.com/4.7-snapshot/platform-notes-symbian.html#required-capabilities}{Required Capabilities for Qt Applications}.

    For more information on how to define capabilities for a project, see
    \l{http://doc.qt.nokia.com/4.7-snapshot/qmake-platform-notes.html#capabilities}{Capabilities}.


    \section3 Building and Running for Symbian Emulator

    Select
    the \gui{Symbian Emulator} target as the active one, and build and run your
    project.

    \section3 Troubleshooting

    If you cannot build the application, check if:
     \list
        \o You selected the Symbian Device target for building the application.
        \o The settings for the Qt version you use to build your project are
           correct. The path to the S60 SDK must point to the S60 SDK
           installation directory.  Select \gui Tools > \gui Options...
           > \gui Debugger > \gui{Symbian TRK} and check if it points to the
           debugger toolchain.
     \endlist
    If you cannot run the application on a device, check if:
     \list
        \o The device is connected through the USB cable in \e{PC Suite} mode.
        \o \gui{App TRK} is running on the device, using the USB connection,
           with the status \e connected.
        \o The device is detected and selected in the run configuration
           details.
     \endlist

    If you cannot run the application in the emulator, check if:
     \list
        \o You selected the \gui{Symbian Emulator} target for your application.
        \o If the emulator process cannot be started, try closing Qt Creator and
           starting the application directly from your file manager. Having
           done this, Qt Creator should be able to run your projects in the
           emulator.
     \endlist

    If this does not help to solve your problem, search the qt-creator@trolltech.com
    mailing list archives or provide feedback to us via the methods described on the
    \l{http://qt.gitorious.org/qt-creator/pages/Home}{Qt Creator Development Wiki}.


    \section2 Adding and Removing Build Configurations

    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.

    \section2 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 section \gui General, you can specify:
        \list
            \o The \l{glossary-project-qt}{Qt version} you want to use to
               build your project. For more information, see
               \l{Selecting the Qt version}.
            \o The toolchain required to build the project.
            \o 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 target platform separate.

               \note Shadow building is not supported by the Symbian build system.
               Also, shadow building on Windows is not supported for Maemo.
               If you only build for one target platform, you can deselect
               the \gui{Shadow Build} checkbox.
        \endlist
    \endlist

    \section2 Build Steps

    The build system of Qt Creator is built on qmake and make. In
    \gui{Build Steps} you can change the settings for qmake and make. Qt
    Creator runs the make command using the Qt version defined for the current
    build configuration.

    \section2 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.

    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. Activate custom steps by
           checking the \gui{Enable Custom Process Step} check-box.
        \o To remove a clean step, click \gui{Remove clean step} and select the
           step you want to remove.
        \o To change the order of steps, click
           \inlineimage qtcreator-movestep.png
           .
    \endlist

    \section2 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 Qt
    Creator was started is used and modified to include the Qt version.
    Depending on the selected Qt version, Qt Creator automatically sets the
    necessary environment variables. You can edit existing environment
    variables or add, reset and unset new variables based on your project
    requirements.

    \section1 Run Settings

    Qt Creator automatically creates run configurations for your project.
    These run configurations derive their executable from the parsed .pro
    files. You can also create custom executable run configurations where you
    can set the executable to be run.

    \image qtcreator-pprunsettings.png


    \section1 File Encoding

    To define the default file encoding, select the desired encoding in the
    \gui{Editor Settings}. By default, the Qt Creator uses the file encoding
    used by your system.


    \section1 Dependencies

    If you have multiple projects loaded in your session, you can define the
    dependencies between them. Inter-project dependencies affect the build
    order of your projects.

    \note Inter-project dependencies are unrelated inside a qmake
    project.

    To define the dependencies between projects:
    \list 1
        \o Select the project for which you want to configure dependencies.
        \o Check the checkboxes in the Dependencies section to select other
           projects as dependencies.
    \endlist


    \section1 Adding External Libraries to a qmake Project