qtcreator.qdoc

// **********************************************************************
// 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}{Qt Creator}
    \page index.html
    \nextpage creator-quick-tour.html

    \title Qt Creator Manual

    \section1 Version 1.3.80

    The goal of Qt Creator is to provide a cross-platform, complete Integrated
    Development Environment (IDE) to develop Qt projects. It is available for
    the Linux, Mac OS X and Windows platforms.

    \note Please report bugs and suggestions to the
    \l{http://bugreports.qt.nokia.com}{Qt Bug Tracker}.
    You can also join the Qt Creator mailing list. To subscribe,
    send a message with the word \e subscribe to
    \l{mailto:qt-creator-request@trolltech.com}
    {qt-creator-request@trolltech.com}. For more information on Qt mailing
    lists, visit \l{http://lists.trolltech.com}{http://lists.trolltech.com}.

    \raw HTML
    <img border="0" style="float:right;" src="images/qtcreator-screenshots.png" />
    \endraw

    \list
       \o   \l{A Quick Tour of Qt Creator}
       \o   \l{Creating a Project in Qt Creator}
       \o   \l{Writing a Simple Program with Qt Creator}
       \o   \l{The Code Editor}
       \o   \l{Navigating Around Your Code with Locator}
       \o   \l{Session Management in Qt Creator}
       \o   \l{Qt Version Management}
       \o   \l{Project Settings}
       \o   \l{CMake Support in Qt Creator}
       \o   \l{Support for Generic Projects in Qt Creator}
       \o   \l{External Libraries}
       \o   \l{Development of Qt for Symbian Based Applications}
       \o   \l{Qt Creator and Debugging}
       \o   \l{Qt Creator and Version Control Systems}
       \o   \l{Tips and Tricks}
       \o   \l{Keyboard Shortcuts}
       \o   \l{Glossary}
       \o   \l{Supported Platforms}
       \o   \l{Known Issues}
       \o   \l{Acknowledgements}
    \endlist
*/


/*!
    \contentspage index.html
    \previouspage index.html
    \page creator-quick-tour.html
    \nextpage creator-creating-project.html

    \title A Quick Tour of Qt Creator

    The labeled screenshot below shows some of the components of Qt Creator, in
    \gui Edit mode.

    \image qtcreator-breakdown.png

    \section1 The Mode Selectors

    When working in Qt Creator, you can be in one of six modes: \bold Welcome,
    \bold Edit, \bold Debug, \bold Projects, \bold Help, and \bold Output.

    Mode selectors allow you to quickly switch between tasks: editing, browsing
    the Qt Creator manual, setting up the build environment, etc. You can
    activate a mode by either clicking on its mode selector, or using the
    \l{keyboard-shortcuts}{corresponding keyboard shortcut}. Certain actions also
    trigger a mode change, e.g., \gui{Debug}/\gui{Start debugging} switches
    to the \gui Debug mode.

    \list

    \o \gui{Welcome mode} - Displays a welcome screen allowing you to quickly
    load sessions or recent individual projects. This is the mode displayed
    when Qt Creator is run without command line switches.

    \o \gui{Edit mode} - Lets you edit both project and source files. A sidebar
    on the left provides different views for navigating between files.

    \o \gui{Debug mode} - Provides various ways to inspect the state of the
    program while debugging. See \l{Qt Creator and Debugging} for a hands-on
    description of how to use this mode.

    \o \gui{Projects mode} - Lets you configure how projects can be built and
    executed. Under the list of projects, there are tabs to configure the
    build, run, and editor settings.

    \o \gui{Help mode} - Shows all documentation registered by Qt Assistant,
    such as the Qt library and Qt Creator documentation.

    \o \gui{Output mode} - Lets you examine various data in detail, for example
    build issues as well as compile and application output. This information
    is also available in the output panes.

    \endlist


    \section1 The Output Panes

    The task pane in Qt Creator can display one of four different panes:
    \gui{Build Issues}, \gui{Search Results}, \gui{Application Output}, and
    \gui{Compile Output}. These panes are available in all modes.


    \section2 Build Issues

    The \gui{Build Issues} pane provides a list of issues, e.g., error messages
    or warnings that need to be fixed. It filters out irrelevant output from
    the compiler and presents the issues in an organized way.

    \image qtcreator-build-issues.png


    \section2 Search Results

    The \gui{Search Results} pane displays the results for global searches such
    as searching within a current document, files on disk, or all projects. In
    the screenshot below, we searched for all occurrences of \c{textfinder}
    within the \c{"/TextFinder"} folder.

    \image qtcreator-search-pane.png


    \section2 Application Output

    The \gui{Application Output} pane displays the status of a program when
    it is executed, and the debug output, e.g., output from qDebug().

    \image qtcreator-application-output.png


    \section2 Compile Output

    The \gui{Compile Output} pane provides all output from the compiler. In
    other words, it is a more detailed version of information displayed in the
    \gui{Build Issues}

    \image qtcreator-compile-pane.png


    \section1 Qt Help Integration

    Qt Creator comes fully integrated with all of Qt's documentation and
    examples via the Qt Help plugin. To view the documentation, switch
    to the \gui{Help} mode. To obtain context sensitive help, move the text
    cursor to a Qt class or function and press \key{F1}. The documentation
    is displayed in a pane on the right, as shown in the screenshot
    below. If there is enough vertical space, it is shown in the
    fullscreen help mode.

    \image qtcreator-context-sensitive-help.png

    External documentation provided by the user can be used to augment or
    replace the documentation shipped with Qt Creator and Qt.


    \section1 Qt Designer Integration

    Qt Creator is fully integrated with Qt Designer to help you design user
    interface forms like you would with the standalone version. The Qt
    Designer integration also includes project management and code completion.
    For more information on Qt Designer, see
    \l{http://doc.trolltech.com/designer-manual.html}{The Designer Manual}.

    \image qtcreator-formedit.png


    \section1 Keyboard Navigation

    Qt Creator caters not only to developers who are used to using the mouse,
    but also to developers who are more comfortable with the keyboard. A wide
    range of \l{keyboard-shortcuts}{keyboard} and
    \l{Navigating Around Your Code with Locator}{navigation} shortcuts
    are available to help speed up the process of developing your application.
*/

/*!
    \contentspage index.html
    \previouspage creator-writing-program.html
    \page creator-code-editor.html
    \nextpage creator-navigation.html

    \title The Code Editor

    Qt Creator's code editor is designed to aid the developer in creating, editing,
    and navigating code. It is fully equipped with syntax highlighting, code
    completion, context sensitive help, and inline error indicators
    while you are typing.

    \section1 Code Editor Configuration

    The screenshots below show the various dialogs within
    which you can configure your editor.

    \table
        \row
            \i  \inlineimage qtcreator-texteditor-fonts.png
        \row
            \i  \inlineimage qtcreator-texteditor-behavior.png
        \row
            \i  \inlineimage qtcreator-texteditor-display.png
        \row
            \i  \inlineimage qtcreator-texteditor-completion.png
    \endtable

    \section1 Code Completion

    The completion popup shows possible completions to a certain statement.
    These completions include classes, namespaces, functions, variables,
    macros and keywords. Listed below are the icons used in the completion box
    and their meaning.

    \table
        \row
            \i  \inlineimage completion/class.png
            \i  A class
        \row
            \i  \inlineimage completion/enum.png
            \i  An enum
        \row
            \i  \inlineimage completion/enumerator.png
            \i  An enumerator (value of an enum)
        \row
            \i  \inlineimage completion/func.png
            \i  A function
        \row
            \i  \inlineimage completion/func_priv.png
            \i  A private function
        \row
            \i  \inlineimage completion/func_prot.png
            \i  A protected function
        \row
            \i  \inlineimage completion/var.png
            \i  A variable
        \row
            \i  \inlineimage completion/var_priv.png
            \i  A private variable
        \row
            \i  \inlineimage completion/var_prot.png
            \i  A protected variable
        \row
            \i  \inlineimage completion/signal.png
            \i  A signal
        \row
            \i  \inlineimage completion/slot.png
            \i  A slot
        \row
            \i  \inlineimage completion/slot_priv.png
            \i  A private slot
        \row
            \i  \inlineimage completion/slot_prot.png
            \i  A protected slot
        \row
            \i  \inlineimage completion/keyword.png
            \i  A keyword
        \row
            \i  \inlineimage completion/macro.png
            \i  A macro
        \row
            \i  \inlineimage completion/namespace.png
            \i  A namespace
    \endtable

    \section1 External Editor

    To switch to an external editor, select \gui{Open in external editor} from the
    \gui{Edit > Advanced} menu.

*/


/*!
    \contentspage index.html
    \previouspage creator-version-management.html
    \page creator-project-pane.html
    \nextpage creator-cmake-support.html

    \title Project Settings

    \table
        \row
            \i  \note This page describes Qt Creator's support for \c qmake.
                For information on CMake support, see
                \l{CMake Support in Qt Creator}.
    \endtable

    To modify the project settings of your project, switch to the \gui{Projects}
    mode by using the mouse or pressing \key{Ctrl+4}.

    \image qtcreator-projectpane.png

    The project pane is divided into two areas. The currently active settings are
    displayed at the top. The active build and run configuration for all projects
    can be changed there. The bottom area allows you to quickly get an overview
    of the build, run and editor settings as well as the dependencies between your
    projects. It also allows you to edit those settings.

    \section1 Build Settings

    Build configurations allow you to quickly switch between different build
    settings. By default, Qt Creator creates a \bold{debug} and a
    \bold{release} build configuration. Both of these configurations use the
    \l{glossary-default-qt}{default Qt version}. Action items to create, clone,
    or delete build configurations can be found at the top. You can have as
    many build configurations as necessary. To edit settings, click on the
    \gui{Show Details} button. Here you can specify which
    \l{glossary-project-qt}{Qt version} to use to build your project, or whether
    to \l{glossary-shadow-build}{shadow build} the project, for instance.

    \image qtcreator-ppbuildsettings.png

    The build system of Qt Creator is built on top of \c qmake and \c make. The
    settings for \c qmake and \c make can be changed. Qt Creator runs the
    make command using the correct Qt version.

    In the \bold{Build Environment} section you can specify the environment used
    for building. 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.

    \section1 Run Settings

    \image qtcreator-pprunsettings.png
    Qt Creator automatically creates run configurations for your project.
    These run configurations derive their executable
    from the parsed .pro files. You can also create \bold{custom executable}
    run configurations where you can freely set the executable to be run.

    \section1 Dependencies

    If you have multiple projects loaded in your session, you can configure
    dependencies between them. This affects the build order of your
    projects. To do this:
    \list 1
        \o Select the project for which you want to configure the dependencies.
        \o Go to the \bold{Dependencies} section.
        \o Check the checkboxes to select other projects as dependencies.
    \endlist
    \note This is unrelated to the dependencies inside a qmake project.
*/


/*!
    \contentspage index.html
    \previouspage creator-session.html
    \page creator-version-management.html
    \nextpage creator-project-pane.html

    \title Qt Version Management

    Qt Creator allows you to use multiple versions of Qt installed on your hard
    disk and switch between them easily.

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

    Otherwise, you can add your Qt version in
    \gui{Tools > Options... > Qt Versions} on Windows and Linux or
    in \gui{Qt Creator > Preferences... > Qt Versions} on Mac OS X.

    The detailed settings depend on your operating system and on the targeted
    tool chain.

        \table
        \row
            \i \image qtcreator-qt4-qtversions.png
            \i \bold{Linux and Mac OS X}

               On Linux and Mac OS X, set the \gui{path to qmake}
               to the \c qmake binary of the Qt installation. If a Qt is
               found in the \c PATH environment variable, it shows up
               automatically as \gui{Qt in PATH}.

               On both platforms, the platform's GNU Compiler Collection (GCC)
               is used to compile Qt. On Mac OS, the GCC compiler is part of XCode.
               On Linux, the Intel Compiler (ICC) is supported as a drop-in replacement
               for GCC.

        \row
            \i \image qtcreator-qt4-qtversions-win-mingw.png
            \i \bold{Windows and MinGW}

               If you are on the Windows platform and used MinGW
               to compile Qt, you need to tell Qt Creator
               where MinGW is installed. This is done by setting the
               \gui{MinGW directory}.
        \row
            \i \image qtcreator-qt4-qtversions-win-msvc.png
            \i \bold{Microsoft Visual C++}

               If your Qt version is compiled with Microsoft Visual C++'s
               compiler, Qt Creator automatically sets the correct
               environment variables for compilation. The \gui{MSVC}
               drop-down box indicates the internal version number of the
               installed Microsoft Visual C++ tool chains:

               \list
                   \o  \bold{7.1}: Visual Studio 2003
                   \o  \bold{8.0}: Visual Studio 2005
                   \o  \bold{9.0}: Visual Studio 2008
               \endlist

               If you are using the \c{Windows SDK for Windows Server 2008}
               instead of Visual Studio, it identifies as version 9.0.
        \row
            \i \image qtcreator-qt4-qtversions-win-symbian.png
            \i \bold{Symbian}

               If you are using Qt for Symbian and your S60 SDK is registered
               with \c devices.exe, Qt Creator detects the Qt version
               automatically.
               It is shown in the \bold{Auto-detected} section in the options
               dialog.
               You can also manually add Qt for Symbian versions. In this case
               you need to tell Qt Creator the path to the S60 SDK
               it is supposed to use with these Qt installations.
               Add the path to your Carbide C++ install, version 2.0
               or later, if you want to build for the emulator
               (\c WINSCW tool chain).
               If you want to use \c GCCE to build for your device,
               you might need to add the path to the
               \c{CSL ARM Toolchain} directory (\gui{CSL/GCCE Directory}),
               if the compiler is not found in the \c PATH environment
               variable.
        \endtable

    \note By default, projects are compiled with the
    \l{glossary-default-qt}{default Qt version}. You can override this in the
    \gui{build configuration}.
*/


/*!
    \contentspage index.html
    \previouspage creator-quick-tour.html
    \page creator-creating-project.html
    \nextpage creator-writing-program.html

    \title Creating a Project in Qt Creator

    \table
        \row
            \i \inlineimage qtcreator-new-project.png
            \i \bold{Creating a new project}

        To create a new project, select \gui{New Project} from the \gui{File} menu.
        You can create one of the following three projects:

        \list
            \o Qt4 Console Application
            \o Qt4 Gui Application
            \o C++ Library
        \endlist

        In this example, we select a \e{Qt4 Gui Application} and click on \gui{OK}.

        \row
            \i \inlineimage qtcreator-intro-and-location.png
            \i \bold{Setting the project name and location}

        Next, we set the project's name and its path. Click on the \gui{Choose...}
        button to browse and select your path.

        Ideally, the path should not contain spaces or special characters.

        \row
            \i \inlineimage qtcreator-select-modules.png
            \i \bold{Selecting the necessary Qt modules}

        Check the check box for each Qt module you want to include into
        your project.

        Since we started a Qt4 Gui Application, the QtCore and QtGui modules are
        set by default, but you are free to add more.

        \row
            \i \inlineimage qtcreator-class-info.png
            \i \bold{Specifying class information}

        Specify the name of the class you want to create. The
        \e{Header file}, \e{Source file} and \e{Form file} fields update
        automatically according to the class name you choose.

        Remember to select the base class for your class, either a
        QWidget, QDialog or QMainWindow, from the drop-down list.

        \row
            \i \inlineimage qtcreator-new-project-summary.png
            \i \bold{Creating the project}

        Finally, review the files that will be created for you. To generate your project,
        click on \gui{Done}.

    \endtable

*/


/*!
    \contentspage index.html
    \previouspage creator-creating-project.html
    \page creator-writing-program.html
    \nextpage creator-code-editor.html

    \title Writing a Simple Program with Qt Creator

    \table
        \row
        \o \note This tutorial assumes that the user has experience in writing
           basic Qt applications, designing user interfaces with Qt Designer
           and using the Qt Resource System.
    \endtable


    In this example, we describe the steps involved in using Qt Creator
    to create a small Qt program, Text Finder. Inspired by the QtUiTools'
    \l{http://doc.trolltech.com/uitools-textfinder.html}{Text Finder}
    example, we write a similar but simplified version of it, as shown
    below.

    \image qtcreator-textfinder-screenshot.png

    \section1 Setting Up Your Environment

    Once you have installed Qt Creator, it detects automatically if Qt's
    location is in your \c PATH variable. If not, please follow the
    instructions in \l{Qt Version Management}.

    \section1 Setting Up the Project

    We begin with a Qt4 Gui Application project generated by Qt Creator. The
    \l{Creating a Project in Qt Creator} document describes this process in
    detail. Remember to select QWidget as the Text Finder's base class. If
    your project is not yet loaded, load it by selecting \gui{File} > \gui{Open}.

    In your project, you have the following files:

    \list
        \o \c{textfinder.h}
        \o \c{textfinder.cpp}
        \o \c{main.cpp}
        \o \c{textfinder.ui}
        \o \c{textfinder.pro}
    \endlist

    The \c{.h} and \c{.cpp} files come with the necessary boiler plate code.
    The \c{.pro} file is also complete.

    \section1 Filling in the Missing Pieces

    We begin by designing the user interface and then move on to filling
    in the missing code. Finally, we add the find functionality.

    \section2 The User Interface

    To begin designing the user interface, double-click on the
    \c{textfinder.ui} file in the \gui{Project Explorer}. This launches the
    integrated Qt Designer.

    Design the form below with:
    \list
        \o \l{http://doc.trolltech.com/qlabel.html}{QLabel}
        \o \l{http://doc.trolltech.com/qlinedit.html}{QLineEdit} (named lineEdit)
        \o \l{http://doc.trolltech.com/qpushbutton.html}{QPushButton} (named findButton)
        \o \l{http://doc.trolltech.com/qtextedit.html}{QTextEdit} (named textEdit)
    \endlist

    \image qtcreator-textfinder-ui.png

    We recommend that you use a \l{http://doc.trolltech.com/qgridlayout.html}{QGridLayout}
    to lay out the label, the line edit and the push button.
    The grid layout and the text edit can then be added to a
    \l{http://doc.trolltech.com/qvboxlayout.html}{QVBoxLayout}.
    If you are new to designing forms with \QD, see the
    \l{http://doc.trolltech.com/designer-manual.html}{Qt Designer Manual}.

    \section2 The Header File

    The \c{textfinder.h} file already has the necessary #includes, a
    constructor, a destructor, and the \c{Ui} object. We need to add a private
    slot, \c{on_findButton_clicked()}, to carry out our find operation. We
    also need a private function, \c{loadTextFile()}, to read and display the
    contents of our input text file in the
    \l{http://doc.trolltech.com/qtextedit.html}{QTextEdit}. This is done with
    the following code:

    \snippet examples/textfinder/textfinder.h 0

    \note The \c{Ui::TextFinder} object is already provided.

    \section2 The Source File

    Now that our header file is complete we move on to our source file,
    \c{textfinder.cpp}. We begin by filling in the functionality to load a
    text file. This is described in the code snippet below:

    \snippet examples/textfinder/textfinder.cpp 0

    Basically, we load a text file using
    \l{http://doc.trolltech.com/qfile.html}{QFile}, read it with
    \l{http://doc.trolltech.com/qtextstream.html}{QTextStream}, and
    then display it on \c{textEdit} with
    \l{http://doc.trolltech.com/qtextedit.html#plainText-prop}{setPlainText()}
    which requires adding the following additional #includes to textfinder.cpp:

    \snippet examples/textfinder/textfinder.cpp 1

    For the \c{on_findButton_clicked()} slot, we extract the search string and
    use the \l{http://doc.trolltech.com/qtextedit.html#find}{find()} function
    to look for the search string within the text file. This is described in
    the code snippet below:

    \snippet examples/textfinder/textfinder.cpp 2

    Once we have both of these functions complete, we call \c{loadTextFile()} in
    our constructor.

    \snippet examples/textfinder/textfinder.cpp 3

    The \c{on_findButton_clicked()} slot is called automatically in
    the uic generated \c{ui_textfinder.h} file by this line of code:

    \code
    QMetaObject::connectSlotsByName(TextFinder);
    \endcode

    \section2 The Resource File

    We require a resource file (\c{.qrc}) within which we embed the input
    text file. This can be any \c{.txt} file with a paragraph of text.

    To add a resource file:
    \list 1
        \o Right-click on \gui{Resource Files} in the \gui{Project Explorer}.
        \o Select \gui{Add New File...}.
    \endlist
    The wizard dialog below is displayed.

    \image qtcreator-add-resource-wizard.png

    \list 3
        \o Enter "textfinder" in the \gui{Name} field. Use the given \gui{Path}.
        \o Click on \gui{Continue}.
    \endlist
    This page is displayed:

    \image qtcreator-add-resource-wizard2.png

    \list 5
        \o Choose to which project you want to add the new file. Select "TextFinder"
        as the \gui{Project}.
        \o Make sure that \gui{Add to Project} is checked.
        \o Click on \gui{Done}.
    \endlist

    Your resource file is now displayed in the resource editor.

    \list 8
        \o Select \gui{Add} > \gui{Add Prefix} from the drop-down list. The prefix we
        require is a slash (\c{/}).
        \o Select \gui{Add} > \gui{Add File} from the drop-down list.
        \o Locate the text file you are going to use. We use \c{input.txt}.
    \endlist

    Once the resource file has been successfully added, the following is displayed:

    \image qtcreator-add-resource.png

    \section1 Compiling and Running your Program

    Now that you have all the necessary files, click the \inlineimage qtcreator-run.png
    button to compile your program.

*/


/*!
    \contentspage index.html
    \previouspage creator-debugging.html
    \page creator-version-control.html
    \nextpage creator-tips.html

    \title Qt Creator and Version Control Systems

    \table
        \caption    Version control systems supported by Qt Creator
        \row
            \i  \bold{git}
            \i  \l{http://git-scm.com/}
            \i
        \row
            \i  \bold{Subversion}
            \i  \l{http://subversion.tigris.org/}
            \i
        \row
            \i  \bold{Perforce}
            \i  \l{http://www.perforce.com}
            \i  Server version 2006.1 and later
        \row
            \i  \bold{CVS}
            \i  \l{http://www.cvshome.org}
            \i
    \endtable


    \section1 Setting Up Version Control Systems

    Qt Creator uses the version control system's command line clients to
    access your repositories. To set it up, you must ensure that these command
    line clients can be located via the \c{PATH} environment variable.
    To specify the path to the command line client's executable, go to the settings
    pages in \gui{Tools} > \gui{Options...}.


    \section1 Setting Up Common Options

    The \gui{Version Control > Common} settings page features common settings for
    version control systems, such as commit message line wrapping and checking
    options.

    \gui{Submit message checking script} is a script or program that can be
    used to perform checks on the submit message before submitting. The submit
    message is passed in as the script's first parameter. If there is an error,
    the script should output a message on standard error and return a non-zero
    exit code.

    \gui{User/alias configuration file} takes a file in mailmap format that
    lists user names and aliases. For example:

    \code
    Jon Doe <Jon.Doe@company.com>
    Hans Mustermann <Hans.Mustermann@company.com> hm <info@company.com>
    \endcode

    Notice that the second line specifies the alias \e{hm} and the
    corresponding email address for \e{Hans Mustermann}. If the user/alias
    configuration file is present, the submit editor displays a context
    menu with \gui{Insert name...} that pops up a dialog letting the user
    select a name.

    \gui{User field configuration file} is a simple text file consisting of
    lines specifying submit message fields that take user names, for example:

    \code
    Reviewed-by:
    Signed-off-by:
    \endcode

    These fields appear below the submit message. They provide completion
    for the aliases/public user names specified in the
    \e{User/alias configuration file} as well as a button that opens the
    aforementioned user name dialog.


    \section1 Using Version Control Systems

    The version control sub-menus are in \gui{Tools} menu. The version control system
    managing the current project is displayed here.

    Each version control system adds a pane to the \gui{Application Output}
    panes within which itlogs the commands it executes, prepended by a
    timestamp and the relevant output.

    \image qtcreator-vcs-pane.png


    \section2 Addings Files

    When you create a new file or a new project, the wizard displays a page
    asking whether the files should be added to a version control system.
    This happens when the parent directory or the project is already
    under version control and the system supports the concept of adding files,
    e.g., \bold{Perforce} and \bold{Subversion}. Alternatively, you can
    add files later by using the version control tool menus.

    With \bold{git}, there is no concept of adding files. Instead, all modified
    files must be \e{staged} for a commit.


    \section2 Viewing Diff Output

    All version control systems provide menu options to \e{diff} the current
    file or project: to compare it with the latest version stored in the
    repository and to display the differences. In Qt Creator, a diff is
    displayed in a read-only editor. If the file is accessible, you can
    double-click on a selected diff chunk and Qt Creator opens an editor
    displaying the file, scrolled to the line in question.

    \image qtcreator-vcs-diff.png


    \section2 Annotating Files

    Annotation views are obtained by selecting \gui{Annotate} or \gui{Blame}.
    This displays the lines of the file prepended by the change identifier
    they originate from. Clicking on the change identifier shows a detailed
    description of the file.


    \section2 Committing Changes

    Once you have finished making changes, you can submit them to the version
    control system by choosing \gui{Commit} or \gui{Submit}. Qt Creator
    displays a commit page containing a text editor, where you can enter your
    commit message, and a checkable list of modified files to be included.
    When you are done, click on \gui{Commit} to start committing. In addition,
    there is a \gui{Diff Selected Files} button that brings up a diff view of the
    files selected in the file list. Since the commit page is just another
    editor, you can go back to it by closing the diff view. Alternatively, you
    can view it from the editor combo box showing the \gui{Opened files}.

    \image qtcreator-vcs-commit.png


    \section2 Viewing Versioning History and Change Details

    The versioning history of a file is displayed by selecting
    \gui{Log} (for \bold{git}) or \gui{Filelog} (for \bold{Perforce} and
    \bold{Subversion}). Typically, the log output contains the
    date, the commit message, and a change or revision identifier.
    Click on the identifier to display a description of the change including the diff.

    \image qtcreator-vcs-log.png
    \image qtcreator-vcs-describe.png


    \section2 Using git-specific Menu Entries

    The git sub-menu contains additional entries:

    \table
        \row
            \i  \gui{Stash}
            \i  Stash local changes prior to executing a \bold{pull}.
        \row
            \i  \gui{Pull}
            \i  Pull changes from the remote repository. If there are locally
                modified files, you are prompted to stash those changes.
        \row
            \i  \gui{Branches...}
            \i  Displays the branch dialog showing the local branches at the
                top and remote branches at the bottom. To switch to the local
                branch, double-click on it. Double-clicking on a remote
                branch first creates a local branch with the same name that
                tracks the remote branch, and then switches to it.

                \image qtcreator-vcs-gitbranch.png
    \endtable


*/


/*!
    \contentspage index.html
    \previouspage creator-code-editor.html
    \page creator-navigation.html
    \nextpage creator-session.html

    \title Navigating Around Your Code with Locator

    With Qt Creator, navigating to different locations in your project or on
    your disk, e.g., files, classes, methods, etc., is simple using
    \gui Locator -- a smart line edit at the bottom left in Qt Creator
    window.

    \image qtcreator-locator.png

    For example, to open your project's \c{main.cpp} file:
    \list 1
        \o Click on \gui Locator or press \key{Ctrl+K} (Mac OS X: \key{Cmd+K}).
        \o Type in the file name.
        \o Press \key Return.
    \endlist
    The file opens in the editor.

    You can also type part of a file name and use the wildcard characters
    \c{*} and \c{?} to match \e{any} number of \e{any} characters. A list
    of files matching your criteria is displayed.

    \gui Locator allows you to navigate files both on disk and in other
    "locations", which are organized with \bold{Filters}. There are
    filters for:

    \list
        \o  Files anywhere on your hard disk (browsing through the file system)
        \o  Files from a subdirectory structure defined by you
        \o  Files mentioned in your \c{.pro} files, such as source, header
            resource, and \c{.ui} files
        \o  Any open document
        \o  Class and method definitions in your project or anywhere referenced
            from your project
        \o  Help topics, including Qt's documentation
        \o  Specific line in the document displayed on your editor
    \endlist


    Some of these filters require you to activate them by typing an assigned
    \e prefix. This prefix is usually a single character followed by
    \key{Space}. For example, to jump to the definition of the class
    \l{http://doc.trolltech.com/qdatastream.html}{QDataStream}, activate
    \gui Locator. Then type a colon (\key{:}) followed by a \key{Space} and
    the class name.


    Below is a full list of \l{http://doc.trolltech.com/qdatastream.html}
    {QDataStream} related output:

    \image qtcreator-navigate-popup.png


    Filters can be added to provide quick navigation around files in a
    subdirectory structure defined by you. This way, you can acccess files you
    need that are not directly mentioned in your project.
    \list 1
        \o Click the button \image qtcreator-locator-magnify.png
        \o Select \gui{Configure...} from the menu displayed:
        \image qtcreator-locator-customize.png
        \o To create a new filter, select \gui Add from the \gui Configure...
        dialog (\gui Options on Mac Os X).
        \o In the \gui{Filter Configuration} dialog below:
        \list
            \o Give your filter a name.
            \o Select your preferred directories.
            \o Set file patterns with a comma separated list.
            \o Specify a prefix string.
        \endlist
        \image qtcreator-navigate-customfilter.png
        \o Close the dialog.
    \endlist
    \gui Locator searches the directories you selected for files matching
    your file patterns. Information is cached. To update the cached information:
    \list 1
        \o Click the button \image qtcreator-locator-magnify.png again.
        \o Select \gui Refresh.
    \endlist

    The following table lists available filters:

    \table
        \header
            \o  Function
            \o  Key Combination
            \o  Screenshot
        \row
            \o  Go to a line in the current document.
            \o  Ctrl+K, l, Space, and the line number
            \o  \image qtcreator-locator-line.png
        \row
            \o  Go to a symbol definition.
            \o  Ctrl+K, :, Space, and the function name
            \o  \image qtcreator-locator-symbols.png
        \row
            \o  Go to a help topic.
            \o  Ctrl+K, ?, Space, and the topic name
            \o  \image qtcreator-locator-help.png
        \row
            \o  Go to an opened document.
            \o  Ctrl+K, o, Space, and the document name
            \o  \image qtcreator-locator-opendocs.png
        \row
            \o  Go to a file in the file system (browse the file system).
            \o  Ctrl+K, f, Space, and the file name
            \o  \image qtcreator-locator-filesystem.png
        \row
            \o  Go to a file in any project currently loaded.
            \o  Ctrl+K, a, Space, and the file name
            \o  \image qtcreator-locator-files.png
        \row
            \o  Go to a file in the current project.
            \o  Ctrl+K, p, Space, and the file name
            \o  \image qtcreator-locator-current-project.png
        \row
            \o  Go to a class definition.
            \o  Ctrl+K, c, Space, and the class name
            \o  \image qtcreator-locator-classes.png
        \row
            \o  Go to a method definition.
            \o  Ctrl+K, m, Space, and the method name
            \o  \image qtcreator-locator-methods.png
    \endtable

    \note By default, if you press \key{Ctrl+K} and do not use a prefix to
    specify a filter, three filters are enabled: \c{o}, \c{l}, and \c{a}.