Doc: restructure doc according to developer workflow

Add and remove illustrations.
Add landing pages.

Change-Id: I927d62aee9dc43814ef7f4d7424a83eee2af156b
Reviewed-by: Erik Verbruggen <erik.verbruggen@nokia.com>

doc/src/analyze/creator-analyze.qdoc

@@ -33,25 +33,11 @@
 
     \title Analyzing Code
 
-    The memory available on mobile devices is limited and you should use it
-    carefully. \QC contains tools that you can use to analyze your code.
-
-    The \gui {QML Profiler} allows you to profile your Qt
-    Quick applications. You can inspect binding evaluations, signal handling,
-    and painting operations when running QML code. This is useful for
-    identifying potential bottlenecks, especially in the evaluation of bindings.
-
-    In addition, \QC integrates Valgrind code analysis tools for
-    detecting memory leaks and profiling function execution. These tools are
-    supported locally only on Linux and Mac OS. You can run them on a remote
-    host from Windows. You have to download and install them
-    separately to use them from \QC.
-
     You can use the code analysis tools in the \gui Analyze mode. To switch to
     \gui Analyze mode, select \gui Analyze in the mode selector, or select the
     \gui {Analyze} menu and then select a tool. When you are in the
-    \gui Analyze mode, you can switch
-    between tools by selecting them in the menu on the toolbar.
+    \gui Analyze mode, you can switch between tools by selecting them in the
+    menu on the toolbar.
 
     \image qtcreator-analyze-menu.png "Analyze mode menu"
 
@@ -62,33 +48,21 @@
     sessions. Select \gui {Window > Views > Reset to Default Layout} to reset
     the views to their original sizes and positions.
 
-    To run the Valgrind tools on a remote host over SSH, select \gui {Analyze
-    > Valgrind Analyze Memory (Remote)} or \gui {Valgrind Function Profile
-    (Remote)}.
-
-    To stop the currently running analyzer, select \gui {Analyze
-    > Stop}.
-
-    To select options for the Valgrind tools, select \gui {Tools > Options >
-    Analyzer}. You can override the general settings for each project in the
-    \gui {Run Settings} for the project.
-
-    The following sections describe how to use the code analysis tools:
+    You can use the following code analysis tools in the \gui Analyze mode:
 
     \list
 
-        \o  \l{Profiling QML Applications} describes how to inspect binding
-            evaluations, signal handling, and painting operations when running
-            QML code.
+        \o  \l{Profiling QML Applications}{QML Profiler}
 
-        \o  \l{Detecting Memory Leaks} describes how to use the Valgrind
-            Memcheck tool to detect problems in memory management.
+            You can inspect binding evaluations, signal handling, and
+            painting operations when running QML code. This is useful for
+            identifying potential bottlenecks, especially in the evaluation
+            of bindings.
 
-        \o  \l{Profiling Function Execution} describes how to use the Valgrind
-            Callgrind tool to find cache misses in the code.
+        \o  \l{Using Valgrind Code Analysis Tools}{Valgrind Code Analysis Tools}
 
-        \o  \l{Running Valgrind Tools Remotely} describes how to run the
-            Valgrind tools on a remote host.
+            You can detect problems in memory management by using the Memcheck
+            tool and find cache misses in the code by using the Callgrind tool.
 
     \endlist
 

doc/src/analyze/creator-valgrind-overview.qdoc

+/****************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Free Documentation License
+**
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+****************************************************************************/
+
+// **********************************************************************
+// NOTE: the sections are not ordered by their logical order to avoid
+// reshuffling the file each time the index order changes (i.e., often).
+// Run the fixnavi.pl script to adjust the links to the index order.
+// **********************************************************************
+
+/*!
+    \contentspage index.html
+    \previouspage creator-qml-performance-monitor.html
+    \page creator-valgrind-overview.html
+    \nextpage creator-analyzer.html
+
+    \title Using Valgrind Code Analysis Tools
+
+    \QC integrates Valgrind code analysis tools for detecting memory leaks and
+    profiling function execution. You must download and install them separately
+    to use them from \QC.
+
+    To run the Valgrind tools on a remote host over SSH, select \gui {Analyze
+    > Valgrind Analyze Memory (Remote)} or \gui {Valgrind Function Profile
+    (Remote)}.
+
+    To stop the currently running analyzer, select \gui {Analyze
+    > Stop}.
+
+    To select options for the Valgrind tools, select \gui {Tools > Options >
+    Analyzer}. You can override the general settings for each project in the
+    \gui {Run Settings} for the project.
+
+    The following sections describe how to use the Valgrind tools:
+
+    \list
+
+        \o  \l{Detecting Memory Leaks}
+
+        \o  \l{Profiling Function Execution}
+
+        \o  \l{Running Valgrind Tools Remotely}
+
+    \endlist
+
+*/
+

doc/src/analyze/creator-valgrind.qdoc

@@ -27,7 +27,7 @@
 
 /*!
     \contentspage index.html
-    \previouspage creator-qml-performance-monitor.html
+    \previouspage creator-valgrind-overview.html
     \page creator-analyzer.html
     \nextpage creator-cache-profiler.html
 
@@ -226,7 +226,7 @@
     \contentspage index.html
     \previouspage creator-cache-profiler.html
     \page creator-running-valgrind-remotely.html
-    \nextpage creator-deployment.html
+    \nextpage creator-publish-ovi.html
 
     \title Running Valgrind Tools Remotely
 

doc/src/analyze/qtquick-profiler.qdoc

@@ -29,7 +29,7 @@
     \contentspage index.html
     \previouspage creator-analyze-mode.html
     \page creator-qml-performance-monitor.html
-    \nextpage creator-analyzer.html
+    \nextpage creator-valgrind-overview.html
 
     \title Profiling QML Applications
 

doc/src/debugger/creator-debugger.qdoc

@@ -27,7 +27,7 @@
 
 /*!
     \contentspage index.html
-    \previouspage creator-running-targets.html
+    \previouspage creator-testing.html
     \page creator-debugging.html
     \nextpage creator-debugging-example.html
 
@@ -37,37 +37,62 @@
     core and external native debuggers such as the GNU Symbolic Debugger (GDB),
     the Microsoft Console Debugger (CDB), and a QML/JavaScript debugger.
 
-    The following sections describe debugging with \QC:
-
     \list
 
-        \if defined(qcmanual)
-        \o  \l{Debugging the Example Application} uses an example application
-            to illustrate how to debug Qt C++ applications in the \gui Debug
+        \o  \l{Debugging the Example Application}
+
+            Illustrates how to debug Qt C++ applications in the \gui Debug
             mode.
-        \endif
 
-        \o  \l{Launching the Debugger} describes the
-            operating modes in which the debugger plugin runs, depending on
-            where and how the process is started and run.
+        \o  \l{Launching the Debugger}
+
+            To start a program under the control of the debugger, press
+            \key{F5}. \QC checks whether the compiled program is up-to-date,
+            and rebuilds it if necessary. The debugger then takes over and
+            starts the program. The debugger is launched in the appropriate
+            operating mode (plain, terminal, or on-device), based on the
+            build and run settings for the active project. You can also launch
+            the debugger in other mode.
+
+        \o  \l{Interacting with the Debugger}
+
+            You can use the \QC \gui Debug mode to inspect the state of your
+            application while debugging.
+
+        \o  \l{Setting Up Debugger}
+
+            The debugger plugin tries to automatically pick up a suitable
+            native debugger. You only need to set it up if the automatic setup
+            fails, because the native debugger is missing (as is usually the
+            case for the CDB debugger on Windows, which you always must install
+            yourself) or because the installed version is not supported.
+
+        \o  \l{Using Debugging Helpers}
 
-        \o  \l{Interacting with the Debugger} describes the views and functions
-            available in the \gui Debug mode.
+            \QC is able to show complex data types in a customized,
+            user-extensible manner. For this purpose, it takes advantage of
+            two technologies, collectively referred to as \e {debugging
+            helpers}. Using the debugging helpers is not essential for
+            debugging with \QC, but they help you to quickly examine complex
+            data.
 
-        \o  \l{Setting Up Debugger} summarizes the support for debugging C++
-            code and requirements for installation. Typically, the interaction
-            between \QC and the native debugger is set up automatically
-            and you do not need to do anything.
+        \o  \l{Debugging Qt Quick Projects}
 
-        \o  \l{Using Debugging Helpers} describes how to get more detailed data
-            on complex data.
+            In the \gui Debug mode, you can inspect the state of the
+            application while debugging JavaScript functions. You can set
+            breakpoints, view call stack trace, and examine locals and
+            expressions. When the application is interrupted by a breakpoint,
+            you can use the QML Script Console to execute JavaScript expressions
+            in the current context.
 
-        \o  \l{Debugging Qt Quick Projects} describes how to debug Qt Quick
-            projects.
+            While the application is running, you can use the QML Inspector
+            view to explore the object structure, debug animations, and
+            inspect colors.
 
-        \o  \l{Troubleshooting Debugger} lists some typical problems that you
-            might encounter while debugging and solutions to them.
+        \o  \l{Troubleshooting Debugger}
 
+            If you encounter problems while debugging, check for possible
+            solutions to them.
     \endlist
 
 */
@@ -445,11 +470,6 @@
 
     \section1 Installing Native Debuggers
 
-    There are various reasons why the debugger plugin may fail to automatically
-    pick up a suitable native debugger. The native debugger might be missing
-    (which is usually the case for the CDB debugger on Windows which always
-    needs to be installed manually by the user) or the installed version is not
-    supported.
     Check the table below for the supported versions and other important
     information about installing native debuggers.
 
@@ -628,6 +648,48 @@
 
     \title Interacting with the Debugger
 
+    You can use the \QC \gui Debug mode to inspect the state of your application
+    while debugging. You can interact with the debugger in several ways,
+    including the following:
+
+    \list
+
+        \o  Go through a program line-by-line or instruction-by-instruction.
+
+        \o  Interrupt running programs.
+
+        \o  Set breakpoints.
+
+        \o  Examine the contents of the call stack.
+
+        \o  Examine and modify registers and memory contents of
+            the debugged program.
+
+        \o  Examine and modify registers and memory contents of
+            local and global variables.
+
+        \o  Examine the list of loaded shared libraries.
+
+        \o  Create snapshots of the current state of the debugged program
+            and re-examine them later.
+
+    \endlist
+
+    \QC displays the raw information provided by the native debuggers in a clear
+    and concise manner with the goal to simplify the debugging process as much
+    as possible without losing the power of the native debuggers.
+
+    In addition to the generic IDE functionality provided by stack view, views
+    for locals and expressions, registers, and so on, \QC includes features to
+    make debugging Qt-based applications easy. The debugger plugin understands
+    the internal layout of several Qt classes, for example, QString, the Qt
+    containers, and most importantly QObject (and classes derived from it), as
+    well as most containers of the C++ Standard Library and some GCC extensions.
+    This deeper understanding is used to present objects of such classes in a
+    useful way.
+
+    \section1 Using the Debugger
+
     In \gui Debug mode, you can use several views to interact with the
     program you are debugging. The availability of views depends on whether
     you are debugging C++ or QML. Frequently used views are shown by
@@ -643,8 +705,6 @@
     \gui {Window > Views > Reset to Default Layout} to reset the views to
     their original sizes and positions.
 
-    \section1 Using the Debugger
-
     Once the program starts running under the control of the debugger, it
     behaves and performs as usual. You can interrupt a running C++ program by
     selecting \gui{Debug} > \gui {Interrupt}. The program is automatically
@@ -986,23 +1046,15 @@
 
     \title Using Debugging Helpers
 
-    \QC is able to show complex data types in a customized,
-    user-extensible manner. For this purpose, it takes advantage of
-    two technologies, collectively referred to as \e{Debugging Helpers}.
-
-    Using the debugging helpers is not \e essential for debugging
-    with \QC, but they enhance the user's ability to quickly
-    examine complex data significantly.
+    There are two approaches to displaying complex data types. The first and
+    original one is to use debugging helpers based on C++. While it has been
+    superseded on most  platforms by the more robust and more flexible second
+    approch that uses Python scripting, it is the only feasible one on
+    Windows/MSVC, Mac OS, and old Linux distributions. Moreover, this approach
+    is automatically chosen as fallback if the Python based approach fails.
 
     \section1 Debugging Helpers Based on C++
 
-    This is the first and original approach to display complex data
-    types. While it has been superseded on most platforms by the more
-    robust and more flexible second approch using Python scripting,
-    it is the only feasible one on Windows/MSVC, Mac OS, and
-    old Linux distributions. Moreover, this approach will automatically
-    be chosen as fallback in case the Python based approach fails.
-
     During debugging with the C++ based debugging helpers,
     \QC dynamically loads a helper library in form of a DLL or a
     shared object into the debugged process.

doc/src/editors/creator-coding-edit-mode.qdoc

+/****************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Free Documentation License
+**
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+****************************************************************************/
+
+// **********************************************************************
+// NOTE: the sections are not ordered by their logical order to avoid
+// reshuffling the file each time the index order changes (i.e., often).
+// Run the fixnavi.pl script to adjust the links to the index order.
+// **********************************************************************
+
+/*!
+    \contentspage index.html
+    \previouspage creator-editor-functions.html
+    \page creator-coding-navigating.html
+    \nextpage creator-highlighting.html
+
+    \title Working in Edit Mode
+
+    This section describes how to use the \gui Edit mode. For more information
+    about using the sidebar, see \l{Browsing Project Contents}.
+
+    \section1 Using the Editor Toolbar
+
+    The editor toolbar is located at the top of the editor view. The editor
+    toolbar is context sensitive and shows items relevant to the file currently
+    open in the editor.
+
+    \image qtcreator-editortoolbar-symbols.png
+
+    Use the toolbar to navigate between open files and symbols in use.
+    To browse forward or backward through your location history, click
+    \inlineimage qtcreator-back.png
+    and \inlineimage qtcreator-forward.png
+    .
+
+    To go to any open file, select it from the \gui{Open files} drop-down menu.
+    Right-click the menu title and select \gui {Copy Full Path to Clipboard} to
+    copy the path and name of the current file to the clipboard.
+
+    To jump to any symbol used in the current file, select it from the
+    \gui Symbols drop-down menu. By default, the symbols are displayed in the
+    order in which they appear in the file. Right-click the menu title and
+    select \gui {Sort Alphabetically} to arrange the symbols in alphabetic
+    order.
+
+    \section1 Splitting the Editor View
+
+    Split the editor view when you want to work on and view multiple files on
+    the same screen.
+
+    \image qtcreator-spliteditorview.png
+
+    You can split the editor view in the following ways:
+
+    \list
+
+        \o  To split the editor view into a top and bottom view, select
+            \gui Window > \gui Split or press \key{Ctrl+E, 2}.
+
+            Split command creates views below the currently active editor view.
+
+        \o  To split the editor view into adjacent views, select
+            \gui Window > \gui{Split Side by Side} or press \key{Ctrl+E, 3}.
+
+           Side by side split command creates views to the right of the
+           currently active editor view.
+
+    \endlist
+
+    To move between split views, select \gui Window > \gui{Go to Next Split} or
+    press \key{Ctrl+E, O}.
+
+    To remove a split view, place the cursor within the view you want to
+    remove and select \gui Window > \gui{Remove Current Split} or press
+    \key{Ctrl+E, 0}. To remove all but the currently selected split view,
+    select \gui Window > \gui{Remove All Splits} or press \key{Ctrl+E, 1}.
+
+    \section1 Using Bookmarks
+
+    To insert or delete a bookmark right-click the line number and select
+    \gui{Toggle Bookmark} or press \key{Ctrl+M}.
+
+    \image qtcreator-togglebookmark.png
+
+    To go to previous bookmark in the current session, press \key{Ctrl+,}.
+
+    To go to next bookmark in the current session, press \key{Ctrl+.}.
+
+    \section1 Moving to Symbol Definition or Declaration
+
+    You can move directly to the definition or the declaration of a symbol by
+    holding the \key Ctrl and clicking the symbol.
+
+    To enable this moving function, in \gui Tools > \gui{Options} >
+    \gui{Text Editor} > \gui Behavior, select \gui{Enable mouse navigation}.
+
+    You can also select the symbol and press \key F2, or right-click the symbol
+    and select \gui {Follow Symbol Under Cursor} to move to its definition or
+    declaration. This feature is supported for namespaces, classes, methods,
+    variables, include statements, and macros.
+
+    To switch between the definition and declaration of a symbol, press
+    \key {Shift+F2} or right-click the symbol and select \gui {Switch Between
+    Method Declaration/Definition}.
+
+    \section1 Using Update Code Model
+
+    To refresh the internal information in \QC pertaining to your code,
+    select \gui{Tools} > \gui{C++} > \gui{Update Code Model}.
+
+    \note In \QC indexing updates the code automatically. Use
+    \gui{Update Code Model} only as an emergency command.
+
+*/

doc/src/editors/creator-coding.qdoc

+/****************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+**
+** GNU Free Documentation License
+**
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of this
+** file.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+****************************************************************************/
+
+// **********************************************************************
+// NOTE: the sections are not ordered by their logical order to avoid
+// reshuffling the file each time the index order changes (i.e., often).
+// Run the fixnavi.pl script to adjust the links to the index order.
+// **********************************************************************
+
+/*!
+    \contentspage index.html
+    \previouspage creator-usability.html
+    \page creator-coding.html
+    \nextpage creator-editor-functions.html
+
+    \title Coding
+
+    \image creator_coding.png
+
+    \list
+
+        \o  \l{Writing Code}
+
+            Writing, editing, and navigating in source code are core tasks in
+            application development. Therefore, the code editor is one of the
+            key components of \QC. You can use the code editor in the \gui Edit
+            mode.
+
+        \o  \l{Finding}
+
+            Use the incremental and advanced search to search from currently
+            open projects or files on the file system or use the locator to
+            browse through projects, files, classes, methods, documentation and
+            file systems.
+
+        \o  \l{Refactoring}
+
+            Code refactoring is the process of improving and simplifying code
+            without modifying the existing functionality of an application. You
+            can easily find and rename symbols and apply predefined actions to
+            refactor code.
+
+        \o  \l{Configuring the Editor}
+
+            You can change the fonts, colors, highlighting, and indentation.
+            If you are used to the the Vim editor, you can even run the main
+            editor in a manner similar to it in the \gui{FakeVim} mode.
+
+    \endlist
+
+    \section1 Related Topics
+
+    \list
+
+        \o  \l{Editing MIME Types}
+
+            \QC uses the MIME type of a file to determine which mode and editor