qtcreator.qdoc

           For more information about MADDE pertaining to its
           installation, configuration, and deployment on the device, see
          \l{http://wiki.maemo.org/MADDE}{Introduction 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. Recent images should have Qt pre-installed.
    \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)
       \o  MacOS 10.5 ("Leopard") or higher
    \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 the N900 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. 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 target 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

    \section1 Getting Started with Symbian Based Applications

    Windows is the only development platform supported at the moment. You
    need to install the following software on your system:

    \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 into all S60 SDKs you plan to use Qt with).
        \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.2 or later, 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 with \e{PC Suite} or \e{Ovi 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
    \e{qt_installer.sis} package installed on the device, that is bundled with
    the binary Qt distribution.

    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} >
    \gui{Options...} > \gui{Qt4} > \gui{Qt Versions}.

    \note 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} > \gui{Options...} > \gui{Qt4} > \gui{S60 SDKs} preference
    page.

    \image qtcreator-qt4-s60sdks.png

    \section1 Setting Up Your Project

    After installing all the prerequisites and checking the setup in Qt Creator
    as described above, you need to set up your project.

    \note 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 and run configurations for it. To do this, follow the steps
    listed below:
    \list 1
        \o Open \gui{Projects} mode and make sure that your project is selected
           at the top of the page.
        \o Select the \gui{Targets} configuration. The \gui{Targets}
           configuration page allows you to add and configure the build and run
           configurations for your project, categorized by the target platform
           you want to build and run your application on.

           \note Targets for instance can be \gui{Desktop},
           \gui{Symbian Emulator}, and \gui{Symbian Device}.
        \o Ensure that your project has a \gui{Symbian Device} entry. In case
           you want to target the symbian emulator then your project needs to
           have \gui{Symbian Emulator} entry as well.
        \o If one of the targets is missing in the list for your project, you
           can add a complete configuration for a new target by pressing the
           \inlineimage qtcreator-qt4-addbutton.png
           button and selecting the desired target from the wizard page that
           appears.
    \endlist

    \image qtcreator-qt4-symbian-target-tabs.png
    \image qtcreator-qt4-symbian-add-target.png
    \image qtcreator-qt4-symbian-target-added.png

    The build configuration that is created for the \gui{Symbian Device} target,
    uses the GCCE tool chain by default. If you want to build
    for the device using RVCT, select the tool chain in the \gui{General}
    section for your build configurations.

    \section2 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
           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.com/wiki/display/pub/The+Complete+Guide+to+Symbian+Signed}
    {The 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

    \section1 Running Your Project

    After setting up your project as described above you build and run your
    project for a specific target platform by selecting the target as the
    active one, using the target button from the left hand tool bar, and then
    press the run button.

    \image qtcreator-qt4-symbian-select-symbian-device.png

    The icon in the target selector indicates if a device is currently
    connected. When Qt Creator detects a device being connected, it shows a
    green check mark.

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

    \section2 Running Your Project in the Emulator

    Running your project in the emulator doesn't require special setup. Select
    the \gui{Symbian Emulator} target as the active one, and build and run your
    project.

    \section2 Running Your Project on the Device

    To run your project on a device, you first need to connect it to your
    computer 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.

    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.

    In the details of the run configuration for the \gui{Symbian Device} target
    you can select a specific device to run your application on, if you have
    multiple devices connected simultaneously to your computer. If you only
    connect a single device, this will automatically be chosen for running your
    application.

    \section2 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 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 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 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{Debugger} > \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

    Qt Creator provides various keyboard shortcuts to speed up your development
    process.


    \section1 Configuring Keyboard Shortcuts

    To customize a keyboard shortcut:
    \list 1
        \o Select \gui Tools > \gui Options > \gui Environment >
           \gui Keyboard.
        \o Select an action from the list.
        \o In \gui{Key Sequence} enter the shortcut key you want to associate
           with the selected action.
    \endlist

    Qt Creator allows you to use different keyboard shortcut mapping schemes:
    \list
        \o To import a keyboard shortcut mapping scheme, click \gui Import
           and select the kms file containing keyboard shortcut mapping scheme
           you want to import.
        \o To export the current keyboard shortcut mapping scheme, click
           \gui Export and select the location where you want to save the
           exported kms file.
    \endlist


    \section1 Default Keyboard Shortcuts

    The following tables list the default keyboard shortcuts. They are
    categorized by actions.


    \section2 General Keyboard Shortcuts

    \table
        \header
            \o Action
            \o Keyboard shortcut
        \row
            \o Open file or project
            \o Ctrl+O
        \row
            \o New file or project
            \o Ctrl+N
        \row
            \o Open in external editor
            \o Alt+V, Alt+I
        \row
            \o Cut
            \o Ctrl+X
        \row
            \o Copy
            \o Ctrl+C
        \row
            \o Paste
            \o Ctrl+V
        \row
            \o Redo
            \o Ctrl+Y
        \row
            \o Save
            \o Ctrl+S
        \row
            \o Save all
            \o Ctrl+A
        \row
            \o Close window
            \o Ctrl+W
        \row
            \o Close all
            \o Ctrl+Shift+W
        \row
            \o Go back
            \o Alt+Left
        \row
            \o Go forward
            \o Alt+Right
        \row
            \o Go to line
            \o Ctrl+L
        \row
            \o Next open document in history
            \o Ctrl+Shift+Tab
        \row
            \o Goto other split
            \o Ctrl+E, O
        \row
            \o Previous open document in history
            \o Ctrl+Tab
        \row
            \o Activate \gui Locator
            \o Ctrl+K
        \row
            \o Switch to \gui Welcome mode
            \o Ctrl+1
        \row
            \o Switch to \gui Edit mode
            \o Ctrl+2
        \row
            \o Switch to \gui Design mode
            \o Ctrl+3
        \row
            \o Switch to \gui Debug mode
            \o Ctrl+4
        \row
            \o Switch to \gui Projects mode
            \o Ctrl+5
        \row
            \o Switch to \gui Help mode
            \o Ctrl+6
        \row
            \o Toggle \gui{Build Issues} pane
            \o Alt+1 (Cmd+1 on Mac OS X)
        \row
            \o Toggle \gui{Search Results} pane
            \o Alt+2 (Cmd+2 on Mac OS X)
        \row
            \o Toggle \gui{Application Output} pane
            \o Alt+3 (Cmd+3 on Mac OS X)
        \row
            \o Toggle \gui{Compile Output} pane
            \o Alt+4 (Cmd+4 on Mac OS X)
        \row
            \o Activate \gui Bookmarks pane
            \o Alt+M
        \row
            \o Activate \gui{File System} pane
            \o Alt+Y
        \row
            \o Activate \gui{Open Documents} pane
            \o Alt+O
        \row
            \o Activate \gui Projects pane
            \o Alt+X
        \row
            \o Full screen
            \o Ctrl+Shift+F11
        \row
            \o Toggle the sidebar
            \o Alt+0 (Cmd+0 on Mac OS X)
        \row
            \o Undo
            \o Ctrl+Z
        \row
            \o Move to \gui Edit mode

               In \gui Edit mode:
               \list
                \o The first press moves focus to the editor
                \o The second press closes secondary windows
               \endlist
            \o Esc
    \endtable


    \section2 Editing Keyboard Shortcuts

    \table
        \header
            \o Action
            \o Keyboard shortcut
        \row
            \o Auto-indent selection
            \o Ctrl+I
        \row
            \o Collapse
            \o Ctrl+<
        \row
            \o Expand
            \o Ctrl+>
        \row
            \o Trigger a completion in this scope
            \o Ctrl+Space
        \row
            \o Copy line down
            \o Ctrl+Alt+Down
        \row
            \o Copy line up
            \o Ctrl+Alt+Up
        \row
            \o Cut line
            \o Shift+Del
        \row
            \o Decrease font size
            \o Ctrl+- (Ctrl+Roll mouse wheel down)
        \row
            \o Increase font size
            \o Ctrl++ (Ctrl+Roll mouse wheel up)
        \row
            \o Toggle vim-style editing
            \o Alt+V, Alt+V
        \row
            \o Split
            \o Ctrl+E, 2
        \row
            \o Split side by side
            \o Ctrl+E, 3
        \row
            \o Remove all splits
            \o Ctrl+E, 1
        \row
            \o Remove current split
            \o Ctrl+E, 0
        \row
            \o Select all
            \o Ctrl+A
        \row
            \o Go to block end
            \o Ctrl+]
        \row
            \o Go to block start
            \o Ctrl+[
        \row
            \o Go to block end with selection
            \o Ctrl+}
        \row
            \o Go to block start with selection
            \o Ctrl+{
        \row
            \o Move current line down
            \o Ctrl+Shift+Down
        \row
            \o Move current line up
            \o Ctrl+Shift+Up
        \row
            \o Trigger a quick fix in this scope
            \o Alt+Return
        \row
            \o Rewrap paragraph
            \o Ctrl+E, R
        \row
            \o Select the current block

               The second press extends the selection to the parent block
            \o Ctrl+U
        \row
            \o Enable text wrapping
            \o Ctrl+E, Ctrl+W
        \row
            \o Toggle comment for selection
            \o Ctrl+/
        \row
            \o Visualize whitespace
            \o Ctrl+E, Ctrl+V
        \row
            \o Delete
            \o Del
        \row
            \o Adjust size
            \o Ctrl+J
        \row
            \o Lay out in a grid
            \o Ctrl+G
        \row
            \o Lay out horizontally
            \o Ctrl+H
        \row
            \o Lay out vertically
            \o Ctrl+L
        \row
            \o Preview
            \o Ctrl+Alt+R
        \row
            \o Edit signals and slots
            \o F4
        \row
            \o Edit widgets
            \o F3
        \row
            \o Toggle bookmark
            \o Ctrl+M
        \row
            \o Go to next bookmark
            \o Ctrl+.