Commit 88e29feb authored by Leena Miettinen's avatar Leena Miettinen

Doc: restructure doc according to developer workflow

Add and remove illustrations.
Add landing pages.

Change-Id: I927d62aee9dc43814ef7f4d7424a83eee2af156b
Reviewed-by: default avatarErik Verbruggen <erik.verbruggen@nokia.com>
parent aeebb26e
doc/images/creator-gs-01.png

18.3 KB | W: | H:

doc/images/creator-gs-01.png

6.97 KB | W: | H:

doc/images/creator-gs-01.png
doc/images/creator-gs-01.png
doc/images/creator-gs-01.png
doc/images/creator-gs-01.png
  • 2-up
  • Swipe
  • Onion skin
doc/images/creator-gs-02.png

5.66 KB | W: | H:

doc/images/creator-gs-02.png

2.41 KB | W: | H:

doc/images/creator-gs-02.png
doc/images/creator-gs-02.png
doc/images/creator-gs-02.png
doc/images/creator-gs-02.png
  • 2-up
  • Swipe
  • Onion skin
doc/images/creator-gs-03.png

14.6 KB | W: | H:

doc/images/creator-gs-03.png

11.1 KB | W: | H:

doc/images/creator-gs-03.png
doc/images/creator-gs-03.png
doc/images/creator-gs-03.png
doc/images/creator-gs-03.png
  • 2-up
  • Swipe
  • Onion skin
doc/images/creator-gs-04.png

7.22 KB | W: | H:

doc/images/creator-gs-04.png

3.67 KB | W: | H:

doc/images/creator-gs-04.png
doc/images/creator-gs-04.png
doc/images/creator-gs-04.png
doc/images/creator-gs-04.png
  • 2-up
  • Swipe
  • Onion skin
......@@ -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
......
/****************************************************************************
**
** 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
*/
......@@ -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
......
......@@ -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
......
......@@ -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.
......
/****************************************************************************
**
** 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.
*/
/****************************************************************************
**
** 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