qtcreator.qdoc

               \o \l{Specifying Include Paths}{.includes}
               \o \l{Specifying Defines}{.config}
               \o .creator
           \endlist
    \endlist

    When the project is successfully imported, Qt Creator creates its project
    tree in the sidebar.

    After importing a generic project into Qt Creator, 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, Qt Creator adds any
    files it recognizes to your project.

    To add or remove files, edit the \tt{.files} file in Qt Creator.
    Qt Creator 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 Qt Creator 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 > 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

    Qt Creator 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 you want to and the working directory.
    \endlist


    \section1 Adding External Libraries to a Generic Project

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

    If you import a project using the \gui{Import Existing Project}
    function, Qt Creator creates a file called \tt{<projectname>.includes} in
    your project directory. The \tt{.includes} file contains all project
    subdirectories for which Qt Creator found relevant headers. Add your
    include paths here.

    \note In \gui Projects mode of a generic project, Qt Creator does not
    modify any project settings prior to the build.

    Syntax completion and highlighting work once your project successfully
    builds and links against the external library.
*/


/*!
    \contentspage index.html
    \previouspage creator-visual-editor.html
    \page creator-developing-applications.html
    \nextpage creator-developing-maemo.html

    \title Developing Mobile Applications

    \omit Use \QD or \QMLD to design and implement application UI. \endomit

    Qt Creator provides support for development of various applications on your
    mobile device. Qt Creator allows you to build and run various types of
    mobile applications once you have specified the build and run settings in
    Qt Creator.

    The applications developed on Qt Creator are then deployed on your mobile
    device.

    The following are the development environment's that can be set up on Qt
    Creator to develop applications for your mobile device:
    \list
       \o \bold{Maemo}: You require the MADDE development tool for development
          of Maemo applications. For more information, see
          \l{Developing Maemo Applications}.
       \o \bold{Symbian}: You require to have the S60 platform SDK and the Qt
          for Symbian in place for development of Symbian applications. For
          more information, see \l{Developing Symbian Applications}.
    \endlist

    You need to have certain guidelines in place before you begin developing
    applications for mobile devices. For more information, see
    \l{Developing Usable Applications}.

    \note If you do not have a mobile device connected to your system.
    You can run the applications developed on Qt Creator on a
    \gui{Local Simulator} for Maemo based applications and a
    \gui{Symbian Emulator} for Symbian based applications.

*/

/*!

    \contentspage index.html
    \previouspage creator-project-managing-sessions.html
    \page creator-visual-editor.html
    \nextpage creator-developing-applications.html

    \title Developing Qt Quick Applications

    You can either create Qt Quick projects from scratch or import them to
    Qt Creator.

    \section1 Creating Qt Quick Projects

    Select \gui {File > New File or Project > Qt Quick Project > QML Application}.

    \QMLD creates the following files:

    \list

    \o .qmlproject project file defines that all QML, JavaScript, and image
    files in the project folder belong to the project. Therefore, you do not
    need to individually list all the files in the project.

    \o .qml file defines an element, such as a component, screen, or the whole
    application UI.

    \endlist

    The \c import statement in the beginning of the .qml file specifies the
    \l {http://qt.nokia.com/doc/4.7-snapshot/qdeclarativemodules.html} {Qt modules}
    to import to \QMLD. Each Qt module contains a set of default elements.
    Specify a version to get the features you want.

    To use JavaScript and image files in the application, copy them to the
    project folder.

    To import a QML project to Qt Creator, select
    \gui {File > New File or Project > Qt Quick Project > Import Existing Qt QML Directory}.

    \section1 Designing Application UI

    One .qml file can define a component, screen, or the whole application.

    \section2 Creating Components

    A QML component provides a way of defining a new type that you can re-use in other QML
    files. A component is like a black box; it interacts with the outside world
    through properties, signals, and slots, and is generally defined in its own QML file.
    You can import components to screens and applications.

    You can use the \gui Library items to create components. Drag and drop
    them to the editor and modify their properties in the \gui Properties pane.
    You can use QML to add properties for a component. The properties are automatically
    displayed in the \gui Properties pane.

    For example, to create a button component:

    \list 1

        \o Select \gui {File > New File or Project > Qt > Qt QML File} to create a QML file
        called button.qml.

        \o Double-click the file to open it in the code editor.

        \o Click \gui {Design} to edit the file in the visual editor.

        \o Drag and drop a \gui Rectangle from the \gui Library pane to the scene.

        \o In the \gui Properties pane, modify the appearance of the button.

        \list a

        \o In the \gui Color field, select the button color.

        \o In the \gui Radius field, use
        the slider to set the radius of the rectangle and produce rounded corners for the button.

        \endlist

        \o Drag and drop a \gui {Text} item on top of the \gui Rectangle. This creates a
        nested element where \gui Rectangle is the parent element of \gui Text. Elements
        are positioned relative to their parents.

        \o In the \gui Properties pane, edit the properties of the \gui Text item.

        \list a

        \o In the \gui Text field, type \bold Button.

        You can select the text color, font, size, and style in the \gui Font section.

        \o In the \gui Alignment field, select the center button to align the text to the
        center of the button.

        \o Click \gui {Geometry}, and then click the
        \inlineimage qmldesigner-anchor-fill-screen.png
        button to anchor the text to the whole button area.

        \endlist

        \o Click \gui Edit to edit the \c width and \c height properties of the button
        to fit the button size.

        \o Press \key {Ctrl+S} to save the button.

        \image qmldesigner-button.png "Button component"

    \endlist

    \section2 Creating Screens

    You can use the \gui Library items to create screens. Use states and transitions
    to navigate between screens.

    QML states typically describe user interface configurations, such as the UI elements,
    their properties and behavior and the available actions. For example, you can specify
    different states of a screen to allow users to view and edit the properties of an
    object:

    \list 1

        \o Create a screen.

        \o In the \gui State pane, click the plus sign to add another view, or \e state
        to the application.

        \o Modify the second state of the screen to create a new screen.

    \endlist

    \section2 Navigating Between Screens

    To make movement between states smooth, you can specify transitions. The
    \c from and \c to properties define the states between which the transitions run. To
    run the transitions in reverse when changing back from the down state to the default state,
    set \c reversible to \c true. This is equivalent to writing the two transitions separately.

    You can use different types of animated transitions. For example, you can animate changes
    to property values and colors. You can use rotation animation to control the direction of
    rotation.

    You can use the \c ParallelAnimation element to start several animations at the same time.
    Or use the \c SequentialAnimation element to run them one after another.



    \section2 Adding User Interaction Methods

    To add interaction methods, drag and drop a \gui {Focus Scope} or \gui {Mouse Area}
    to the screen. In the code editor, add signal handlers to execute when users select
    the scope or area. Signal handlers allow actions to be taken in reponse to an event.
    For instance, the \gui {MouseArea} element has signal handlers to handle mouse press,
    release, and click.

    \section1 Implementing Application Logic

    A user interface is only a part of an application, and not really useful by itself.
    You can use Qt to implement the application logic.

 */


/*!

    \contentspage index.html
    \previouspage creator-developing-applications.html
    \page creator-developing-maemo.html
    \nextpage creator-developing-symbian.html

    \title Developing Maemo Applications

    Maemo is a software platform developed by Nokia for smartphones and
    Internet Tablets. The Maemo SDK provides an open development environment
    for different applications on top of the Maemo platform.
    Maemo 5 is based on the Linux 2.6 operating system. You can find more
    information about the Maemo platform \l{http://maemo.org/intro/platform/}{here}.


    \section1 Getting Started with Maemo Based Applications

    To begin development for Maemo applications, you require the following:
    \list
       \o  An N900 device with updates installed.
       \o  MADDE is a cross-platform Maemo development
           tool.

           For more information about MADDE pertaining to its
           installation, configuration, and deployment on the device, see
          \l{http://wiki.maemo.org/MADDE}{Introdution to MADDE}.

       \o  An IP address for the device.

           In order to setup the device IP address, you need to install
           PC Connectivity or implement it using CLI. More information about PC
           Connectivity can be found
          \l{http://pc-connectivity.garage.maemo.org/2nd_edition/node3.html#SECTION00032300000000000000}
           {here}.
    \endlist

    For deploying and running applications on the device, you need the
    following:
    \list
       \o The Nokia USB drivers that come, for example with, PC Suite.
       \o Qt installed on the device. A simple technique to
          install Qt is to run the Maemo device \gui{Application Manager} and
          download any application using Qt Creator. Running the Maemo device
          \gui{Application Manager} and downloading an application with Qt
          Creator installs all dependencies required for Qt Creator at the same
          time.
    \endlist

     The Qt Creator/MADDE integration is supported on the following platforms:
    \list
       \o  Linux (32 bit and 64 bit)
       \o  Windows (32 bit and 64 bit)
    \endlist

    \section1 Setting Up the N900

    You can connect your device to your workstation using either an USB or a
    WLAN connection.

    For the device, you need to use a tool called Mad Developer to create the
    device-side end point for USB and WLAN connections. It provides no
    diagnostics functions but is essential for creating connections between the
    device and your workstation.

    For the workstation, you need to set up a network port that detects the
    Maemo device as a network device

    \note If you use the device's USB network functionality and plan to
    connect your development PC to the N900 via a common WLAN network, you can
    ignore the USB-specific parts in the following sections.

    \section2 Installing the Mad Developer Package

    To install Mad Developer on your device, you need to add an application
    catalogue (repository) to the list of catalogues your device checks for
    installable software, and install the actual Mad Developer software
    package using root privileges. This is done according to the following
    steps:
     \list 1
         \o Start the application manager

            Enter the data as displayed in the screenshot below.

            \note The complete web address is
            \l http://repository.maemo.org/extras-devel

            \image qtcreator-app-manager-extras-devel-screenshot.png

         \o Select \gui{Download} > \gui{Development} > \gui{mad-developer}.

            The screenshots below shows the process for selecting the
            \gui{mad-developer}:

            \image qt-creator-app_manager_screenshot1.png
            \image qt-creator-app_manager_screenshot2.png


         \o Install the Mad Developer software package.
         \o Start the Mad Developer application.
     \endlist

   \note If you are using Microsoft Windows as development host, you must
         change the driver loaded for instantiating the connection.
         For this click \gui{Manage USB} and select \gui{Load g_ether}.

    Follow the steps mentioned below to set up the USB settings:
    \list 1
       \o Click \gui Edit in the usb0 row and confirm with \gui Configure.

          \note By default, you do not need to make changes. The usb0 row
          displays the IP address 192.168.2.15.

       \o Select \gui{Developer Password} to generate a password for a freshly
          created user called "developer". The password stays valid for as long
          the password generation dialog is open.

          Refer to the screenshot below as an example.

          \image qtcreator-mad-developer-screenshot.png
    \endlist

    \section2 Establishing the USB Connection

    Connect your device to the development PC via the USB cable. A dialog
    pops up asking for the mode to use. Choose \gui{PC suite mode}.

    \note If you experience connection problems due to a USB port issue, switch
     to a different port.


    \section1 Setting Up Connectivity

    \section2 Linux

    The device uses the IP address 192.168.2.15 with the subnet 255.255.255.0
    for its USB connection by default, so you can create the network interface
    with a different address inside the same subnet too.

    \note If you have changed the IP address of the device when configuring
    Mad Developer, you need to reflect those changes in your workstation's USB
    network settings as well.

    Run the following command in a shell as root user:
                  \c{ifconfig usb0 192.168.2.14 up}

    \section2 Windows

    When you connect the device to your Windows PC, Windows tries to install a
    driver for the Linux USB Ethernet connection. In the
    \gui{Found New Hardware Wizard}, select \gui{No, not this time} in the
    first dialog and \gui{Install the software automatically} in the second
    dialog.

    Open the Network Connections window. The just installed Linux USB Ethernet
    connection is now displayed as a new Local Area Connection.

    Perform the same steps through the Network configuration tools available
    with the operating system.

    Change the IP to be set statically and enter the following values:
    \list
       \o  IP Address: 192.168.2.14
       \o  SubnetMask: 255.255.255.0
       \o  Default gateway: 192.168.2.15
    \endlist

    Accept these settings and close the Network Configuration. Depending on
    your version of Microsoft Windows you may have to unplug and re-plug the
    N900 to reload the driver with its configuration accordingly.

    \section2 Setting Up MADDE

    After having downloaded the MADDE installer file for your platform from
    \l{http://wiki.maemo.org/MADDE}{here}, execute it and follow the
    instructions. The package will be installed. Then run:
    \c{mad-admin list targets} to see which targets are available.
    Install the targets that starts with "fremantle" by using the command:
    \c{mad-admin create fremantle-qt-xxx}

    When you have installed the target, you have a toolchain and a sysroot
    environment for cross-compiling

    \section1 Setting Up Qt Creator

    Set up the Qt Creator for developing Maemo applications by following the
    steps mentioned below:

    \list 1
        \o  \bold{Registering the MADDE Toolchain}

            Select \gui Tools > \gui Options > \gui Qt4 > \gui{Qt Versions}.
            Click \inlineimage qtcreator-windows-add.png,
            to add a new Qt version. The \gui{qmake Location} is the qmake
            executable in \c{<MADDE dir>/targets/<fremantle target>/bin}.

            \image qtcreator-screenshot-toolchain.png


        \o  \bold{Creating a Device Configuration}

            In order to deploy applications and run them remotely, Qt Creator
            needs parameters for device access which you can set in device
            configurations.

            Select \gui Tools > \gui Options > \gui Qt4 >
            \gui{Maemo Device Configurations} and add a new configuration.

            \image qtcreator-screenshot-devconf.png


            \note The password is the one MADDE Developer displays on the
            device. Click \gui Test to check whether the device can be accessed
            properly. It is recommended that you use the password-based login
            only to deploy your public SSH key to the device
            (using the \gui{Deploy Key} button) and then switch to key-based
            authentication.

            Close the dialog by clicking the \gui OK button after completion.


        \o  \bold{Setting Build and Run Configuration}

            Open a project for an application you want to develop for your
            N900. Click \gui Projects to open the projects mode. In the
            \gui{Build Settings} section, choose the MADDE Qt version which you
            registered earlier:

            \image qtcreator-screenshot-build-settings.png

            In the \gui{Run Settings} section, click \gui Add to add a new
            run configuration on the Maemo device. Set a name and select the
            device configuration you created above in the popup menu.

            The following screenshot shows the result below:

            \image qtcreator-screenshot-run-settings.png

        \o  \bold{Compiling, Running and Debugging Your Application}

            You can now continue your work as if developing for any
            other platform supported by Qt Creator: for compiling, Qt Creator
            will use the MADDE toolchain's cross compiler.

            When you run your application, it is automatically copied onto
            the device and executed there. Your application's windows will be
            displayed on the N900 and command-line output is visible in Qt
            Creator's "Application output" window.

            Debugging also works transparently.
    \endlist
*/



/*!
    \contentspage index.html
    \previouspage creator-developing-maemo.html
    \page creator-developing-symbian.html
    \nextpage creator-usability.html

    \title Developing Symbian Applications

    Qt Creator 1.3 comes with preliminary support for development of
    applications using Qt for the Symbian Platform.

    \e{Note that this is highly experimental, and not intended for production use.
    The primary aim is to allow Symbian developers to familiarize themselves with Qt Creator
    and provide feedback that helps us improve Symbian support in future versions of
    Qt Creator.}

    Please provide us with feedback, using the mailing list or IRC, as described on the
    \l{http://qt.gitorious.org/qt-creator/pages/Home}{Qt Creator Development Wiki}.

    \section1 Getting Started with Symbian Based Applications

    You need the following software installed on your PC.
    Only Windows development is supported.

    \list
        \o \l{http://www.forum.nokia.com/main/resources/tools_and_sdks/S60SDK/}
            {S60 Platform SDK 3rd Edition FP1 or higher}
        \o \l{http://www.forum.nokia.com/main/resources/technologies/openc_cpp/}
            {Open C/C++ v1.6.0 or higher} (Install this to all S60 SDKs you plan to use Qt with.
            This is included in the Qt for Symbian binary installers.)
        \o Either the GCCE ARM Toolchain that is included in the S60 Platform SDKs, or
            RVCT 2.2 [build 686] or later (which is not available free of charge)
            (Your environment needs to find the compiler in the PATH.)
        \o Qt for Symbian 4.6.0, installed into the S60 SDKs you want to use

    \endlist

    For deploying and running applications on the device, you need the following:
    \list
        \o The Nokia USB drivers that come e.g. with PC Suite
        \o The \l{http://tools.ext.nokia.com/trk/}{App TRK} application for your device
    \endlist

    Running Qt based applications on real devices requires the following packages to be installed on
    your device. The packages can be found in the S60 SDK where you installed Open C/C++:
    \list
        \o nokia_plugin\\openc\\s60opencsis\\pips_s60_\<version\>.sis
        \o nokia_plugin\\openc\\s60opencsis\\openc_ssl_s60_\<version\>.sis
        \o nokia_plugin\\opencpp\\s60opencppsis\\stdcpp_s60_\<version\>.sis
    \endlist

    If you want to run your applications in the Symbian emulator, you also need to install
    Carbide.c++ v2.0.0 or higher.

    \section1 Setting Up Qt Creator

    When you run Qt Creator after installing the S60 Platform SDK and Qt for Symbian,
    the installed SDKs and their corresponding Qt versions are automatically detected.
    For each detected S60 SDK with Qt, a special entry is made in the Qt version management
    settings \gui{Tools > Options... > Qt4 > Qt Versions}.

    \e{Note that if you manually add a Qt version for Symbian, you must
    also manually specify the S60 SDK to use for this version.}

    \image qtcreator-qt4-qtversions-win-symbian.png

    If you want to run your applications in the Symbian emulator, you need to point Qt Creator
    to the Metrowerks Compiler that you want to use, by setting the \gui{Carbide Directory}
    of the Qt version to the corresponding Carbide.c++ installation directory.

    You can check what S60 SDKs and corresponding Qt versions are found in the
    \gui{Tools > Options... > Qt4 > S60 SDKs} preference page.

    \image qtcreator-qt4-s60sdks.png

    \section1 Building Your Project

    After installing all the prerequisites and checking the setup in Qt Creator as described
    above, you need to set up your project.
    \e{Note that the only supported build system for Qt for Symbian applications in Qt Creator
    is qmake.}

    Before you can build your project for the Symbian platform, you need to create build
    configurations for it.
    Open \gui{Projects mode} and make sure that your project is selected for editing in
    \gui{Edit Project Settings for Project ...}. Add debug and release build configurations
    for the Symbian target by selecting the corresponding Qt version from the build configuration
    \gui{Add} menu.

    \image qtcreator-symbian-add-buildconfiguration.png

    The created build configurations default to using the GCCE tool chain. If you want to build
    for the device using RVCT, or for the Symbian emulator using WINSCW, select \gui{Show Details}
    and change the tool chain in the \gui{General} section of the build configuration settings.

    Now you can switch to building your project for the device by selecting one of the
    new build configurations as the active configuration at the top of \gui{Projects mode}.

    \image qtcreator-symbian-change-buildconfiguration.png

    \section1 Running Your Project

    \section2 Running Your Project in the Emulator

    Similar to the build configuration setup for your project, you need to create a run
    configuration for running your project in the Symbian emulator:
    \list 1
        \o Switch to \gui{Projects mode}.
        \o Select \gui{Run Settings} > \gui{Add > YourApplication in Symbian Emulator}
    \endlist

    \image qtcreator-symbian-add-run-in-emulator.png

    To start your project in the emulator, select this run configuration as the active configuration
    at the top of \gui{Projects mode} window and press the run button.

    \image qtcreator-symbian-change-run-in-emulator.png

    \section2 Running Your Project on the Device

    To run your project on a real Symbian device, just add another run configuration in
    \gui{Projects mode} via \gui{Run Settings} > \gui{Add > YourApplication on Symbian Device}.

    \image qtcreator-symbian-add-runconfiguration.png

    \image qtcreator-symbian-details-runconfiguration.png

    In the details of the run configuration you can specify a certificate to use, and
    select one of the devices that you have currently attached to your computer.
    The only connection mode supported at the moment is USB in \e{PC Suite} mode.
    For actually running your application on the device, you need to set the device run configuration
    as the active configuration at the top of \gui{Projects mode}.
    Start the \gui{App TRK} application on your device and press the run button to create
    a package for your application, deploy, install and run it automatically on your device.

    \image qtcreator-symbian-change-runconfiguration.png

    \section2 Troubleshooting

    If you cannot build the application, check if:
     \list
        \o You selected a Qt version for Symbian 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 in the emulator, check if:
     \list
        \o The emulator or device run configuration selected is in the active
           run configuration.
        \o You built the application for the emulator by using  WINSCW  or for
           the device by using GCCE or RVCT.
        \o 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 you cannot run the application on a device, check if:
     \list
        \o The device is connected via USB in \e{PC Suite} mode.
        \o 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 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}.

*/

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

    \title Adding Qt Designer Plugins

     You can use Qt APIs to create plugins that extend Qt applications.
     This allows you to add your own widgets to \QD.
     The most flexible way to include a plugin with an application is to compile it
     into a dynamic library that is shipped separately, and detected and loaded at runtime.

     The applications can detect plugins that are stored in the standard plugin
     subdirectories. For more information on how to create and locate plugins and to
     change the default plugin path, see \l{How to Create Qt Plugins}.

     For more information about how to create plugins for \QD, see
     \l{http://doc.trolltech.com/4.6/designer-using-custom-widgets.html}{Creating and Using Components for Qt Designer}.

    \section1 Locating Qt Designer Plugins

     \QD fetches plugins from the standard locations and loads the plugins
     that match its build key. \QD is delivered both as a standalone application
     and as part of the SDK, where it is integrated into Qt Creator.
     The correct folder to place the plugins depends on
     which one you use.

     The integrated \QD fetches plugins from the \c {%SDK%\bin\designer} folder on Windows
     and Linux and \c {QtCreator.app/Contents/MacOS/designer} folder on Mac. To check which plugins
     were loaded successfully and which failed, choose \gui{Tools > Form Editor >
     About Qt Designer Plugins}.

     The standalone \QD is part of the Qt library used for building projects,
     located under \c {%SDK%\qt}. Therefore, it fetches plugins from the following folder:
     \c {%SDK%\qt\plugins\designer}. To check which plugins were loaded successfully and which
     failed, choose \gui{Help > About Plugins}.

     \section1 Matching Build Keys

     The Qt Creator that is included in pre-built SDK packages on Windows is built with the
     Microsoft Visual Studio compiler, whereas the version of Qt shipped for building applications
     is configured and built to use the MinGW/g++ compiler. Plugins built by using this version of
     Qt cannot be loaded by Qt Creator because the build-keys do not match. The plugins can only be
     used in the standalone version of \QD. Choose \gui{Help > About Qt Creator} to check
     the Qt version Qt Creator was built with.

     To use \QD plugins that were built for the shipped Qt version, make sure that
     Qt Creator is built with the same compiler by either recompiling Qt Creator using MinGW or
     recompiling Qt with Microsoft Visual Studio, depending on which configuration you want to
     use for your applications.

*/


/*!
    \contentspage index.html
    \previouspage creator-developing-symbian.html
    \page creator-usability.html
    \nextpage creator-debugging.html

    \title Developing Usable Applications

    Before starting application development, analyze and define the requirements, scope, and
    functionality of the application to ensure efficient functionality and a smooth user
    experience. Design the application for a single purpose and analyze how it can best serve
    its users. Mobile devices have been designed for use when mobile. Keep the characteristics
    of mobile devices in mind when you create applications for them.

    The following guidelines help you design and develop usable applications for mobile devices
    with varying characteristics, such as screen size and support for input methods:

    \list

        \o Know your users

        Find out who will use the application, what they will use it for,
        and which mobile devices they have. Then design the application to fit a specific context
        of use.

        \o Design for small screens

        The screen size of mobile devices is significantly smaller
        than that available on desktop devices. Carefully consider what is the most relevant
        content to present on the application UI, as it might not be reasonable to try and fit as
        much content into the screen as you might have in a desktop application.

       \o Design for multiple screen sizes

       Relate the position and size of each control to the
       dimensions of the display. This enables the same set of information to be presented on the
       screen in all resolutions; higher resolution devices just display finer graphics.

       \o Design for changing screen orientation

       Some devices support screen rotation. On these
       devices, applications can be displayed in portrait or landscape orientation. Account for
       orientation and dynamically adjust the display when the screen is rotated.

       \o Design intuitive ways of moving within applications

       Mobile devices lack a mouse and
       full-size keyboard, so users must use the touch screen or five way navigation pad to move within
       applications. In addition, many users control the devices with one hand. To create an optimized user
       experience, allow users to access information with one click; do not make them scroll and type.

       \o Design for limited input methods

       Applications collect information from users on the task
       at hand. In addition to touch screen input, some devices contain physical keys such
       as a five way navigation pad, a keypad, and a keyboard. Users enter information by using screen
       controls, such as lists, check boxes, radio buttons, and text fields.

       \o Keep response times short

       Latency can cause delays in user interaction. If users perceive
       an application as being slow, they are likely to get frustrated and stop using it.

       \o Save battery time

       Mobile devices are not constantly connected to a power source but run on
       battery power. Optimize power consumption to keep the total consumption at an acceptable
       level and to prevent users from running out of battery time.

       \o Consider network issues

       If users do not have a flat-rate data plan or WLAN support, mobile
       network connections cost them money. Also, when users move around with the devices, the networks
       available for connections constantly change.

       \o Remember the processing limits of the device

       The memory available on devices is limited
       and you should use it carefully. Although all mobile devices have common functionality,
       each device is individual in terms of both the resources available and extra features.
       Therefore, you must consider the constraints of all the target devices.

       \endlist

       For more information about user experience techniques for mobile devices, see the
       \l{http://library.forum.nokia.com/topic/Design_and_User_Experience_Library/GUID-A8DF3EB8-E97C-4DA0-95F6-F464ECC995BC_cover.html}{Design and User Experience Library}
       on Forum Nokia.

 */


/*!
    \contentspage index.html
    \previouspage adding-plugins.html
    \page creator-tips.html
    \nextpage creator-keyboard-shortcuts.html

    \title Tips and Tricks


    \section1 Switching between modes

    Qt Creator uses different modes for different purposes. You can quickly
    switch between these modes with the following keyboard shortcuts:
    \list
        \o \gui Welcome mode \key Ctrl+1
        \o \gui Edit mode \key Ctrl+2
        \o \gui Design mode \key Ctrl+3
        \o \gui Debug mode \key Ctrl+4
        \o \gui Projects mode \key Ctrl+5
        \o \gui Help mode \key Ctrl+6
    \endlist


    For more information about Qt Creator modes, see \l {Qt Creator Modes}.



    \section1 Moving Between Open Files

    To quickly move between currently open files, press
    \key Ctrl+Tab.


    \section1 Moving To the Edit Mode

    To move to the \gui Edit mode and currently active file, press
    \key Esc.

    If you already are in the \gui Edit mode:
    \list
        \o The first press moves focus to the editor
        \o The second press closes secondary windows
    \endlist

    \section1 Using the Filter in Options Dialog

    To find specific settings you require in \gui{Tools} > \gui{Options}
    use the filter located at the top left of the Options dialog box.


    \section1 Using Keyboard Shortcuts

    Qt Creator provides \l{Keyboard Shortcuts}{many useful keyboard shortcuts}.

    To customize, import or export keyboard shortcuts, select \gui Tools >
    \gui Options... > \gui Environment > \gui Keyboard.


    \section1 Running Qt Creator From Command Line

    You can launch Qt Creator from command line using the name of an
    existing session or \c .pro file by giving the name as the command
    argument.

    For example, running \tt{qtcreator somesession}, launches Qt Creator and
    loads session somesession.

    \note Make sure Qt Creator is included in the PATH environment variable.
    This can be done by typing the following in the command line:
    \code
    set PATH=c:\qtsdk\mingw\bin;c:\qtsdk\qt\bin;%PATH%
    \endcode


    \section1 Showing and Hiding the Sidebar

    To toggle the sidebar in the \gui Edit and \gui Debug modes, click
    \inlineimage qtcreator-togglebutton.png
    or press \key Alt+0 (\key Cmd+0 on Mac OS X).

    For more information on using the sidebar, see \l {Browsing Project Contents}.



    \section1 Moving To Symbols

    To move straight to a symbol used in a project, select the symbol in the
    \gui Editor toolbar drop-down menu.

    For more information on the editor toolbar,
    see \l {Using the Editor Toolbar}.



    \section1 Displaying Signals and Slots

    If an instance of a class is derived from QObject, and you would like to
    find all other objects connected to one of your object's slots using
    Qt's signals and slots mechanism, select \gui Tools > \gui Options...
    > \gui{Debugging Helper} > \gui{Use Debugging Helper}.

    In the \gui{Locals and Watchers} view, expand the object's entry and open
    the slot in the \e slots subitem. The objects connected to this slot are
    shown as children of the slot. This method works with signals too.


    \section1 Displaying Low Level Data

    If special debugging of Qt objects fails due to data corruption within the
    debugged objects, you can switch off the debugging helpers. When debugging
    helpers are switched off low-level structures become visible.

    To switch off the debugging helpers:
    \list 1
        \o Select \gui Tools > \gui Options... > \gui Debugger >
           \gui{Debugging Helper}.
        \o Uncheck the \gui{Use debugging helper} checkbox.
    \endlist

*/


/*!
    \contentspage index.html
    \previouspage creator-tips.html
    \page creator-keyboard-shortcuts.html
    \nextpage creator-known-issues.html

    \title Keyboard Shortcuts