Newer
Older
The locator provides one of the easiest ways in Qt Creator to browse
through projects, files, classes, methods, documentation and file systems.
You can find the locator in the bottom left of the Qt Creator window.
To activate the locator, press \key Ctrl+K (\key Cmd+K on Mac OS
X) or select \gui Tools > \gui Locate....
\image qtcreator-locator.png
To edit the currently open project's main.cpp file using the locator:
Rohan Shetty
committed
\o Enter \tt{main.cpp}.
It is also possible to enter only a part of a search string.
As you type, the locator shows the occurrences of that string regardless
Leena Miettinen
committed
of where in the name of an component it appears.
To narrow down the search results, you can use the following wildcard
characters:
\list
Rohan Shetty
committed
\o To match any number of any or no characters, enter \bold{*}.
\o To match a single instance of any character, enter \bold{?}.
The \gui Locator allows you to browse not only files, but any items
defined by \bold{locator filters}. By default, the locator contains
filters which locate:
\list
Rohan Shetty
committed
\o Files anywhere on your file system
\o Files belonging to your project, such as source, header resource,
and .ui files
\o Class and method definitions in your project or anywhere referenced
from your project
\o Help topics, including Qt documentation
\o Specific line in the document displayed in your editor
\endlist
To use a specific locator filter, type the assigned prefix followed by
\key Space. The prefix is usually a single character.
Rohan Shetty
committed
\l{http://doc.trolltech.com/qdatastream.html}{QDataStream:}
\list 1
\o Activate the locator.
\o Enter \tt{\bold{: QDataStream}} (: (colon) followed by a
\key Space and the symbol name (QDataStream)).
By default the following filters are enabled and you do not need to use
their prefixes explicitly:
\list
\o Going to a line in the current file (l).
\o Going to an open file (o).
\o Going to a file in any open project (a).
\section2 Using the Default Locator Filters
The following locator filters are available by default:
\table
\header
\o Function
\row
\o Go to a line in the current file.
\o \tt{\bold{l \e{Line number}}}
\o \image qtcreator-locator-line.png
\row
\o \image qtcreator-locator-symbols.png
\row
\o \image qtcreator-locator-help.png
\row
\o Go to an open file.
\o \tt{\bold{o \e{File name}}}
\o \image qtcreator-locator-opendocs.png
\row
\o Go to a file in the file system (browse the file system).
\o \image qtcreator-locator-filesystem.png
\row
\o Go to a file in any project currently open.
\o \tt{\bold{a \e{File name}}}
\o \image qtcreator-locator-files.png
\row
\o \image qtcreator-locator-current-project.png
\row
\o \image qtcreator-locator-classes.png
\row
\o \image qtcreator-locator-methods.png
\endtable
To quickly access files not directly mentioned in your project, you can
create your own locator filters. That way you can locate files in a
directory structure you have defined.
To create a locator filter:
\list 1
\o In the locator, click \inlineimage qtcreator-locator-magnify.png
and select \gui Configure....
\image qtcreator-locator-customize.png
\o In the \gui Options window click \gui Add.
\o In the \gui{Filter Configuration} dialog:
\list
\o Name your filter.
\o Select at least one directory. The locator searches directories
recursively.
\o Define the file pattern as a comma separated list. For example,
Rohan Shetty
committed
to search all .h and .cpp files, enter \bold{*.h,*.cpp}
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
\o Specify the prefix string.
To show only results matching this filter, select
\gui{Limit to prefix}.
\image qtcreator-navigate-customfilter.png
\endlist
\o Click OK.
\endlist
\section3 Configuring the Locator Cache
The locator searches the files matching your file pattern in the
directories you have selected and caches that information. The cache for
all default filters is updated as you write your code. The filters you have
created Qt Creator by default updates once an hour.
To update the cached information manually, click
\inlineimage qtcreator-locator-magnify.png
and select \gui Refresh.
To set a new cache update time:
\list 1
\o Select \gui Tools > \gui Options... > \gui Locator.
\o In \gui{Refresh interval} define new time in minutes.
\endlist
*/
Kavindra Devi Palaraja
committed
/*!
\contentspage index.html
\previouspage creator-project-generic.html
\page creator-project-managing-sessions.html
Leena Miettinen
committed
\nextpage creator-visual-editor.html
Kavindra Devi Palaraja
committed
Kavindra Devi Palaraja
committed
In Qt Creator, a session is a collection of:
\list
\o Open projects with their dependencies
\o Open editors
\o Breakpoints and watches
\o Bookmarks
Kavindra Devi Palaraja
committed
\endlist
When you launch Qt Creator, a list of existing sessions is displayed on the
\gui{Welcome screen}.
Kavindra Devi Palaraja
committed
To switch between sessions, select the session from sessions listed in
\gui File > \gui Session. If you do not create or select a session,
Qt Creator always uses the default session.
Leena Miettinen
committed
To create a new session or remove existing sessions, select \gui File >
\gui Sessions > \gui{Session Manager}.
Kavindra Devi Palaraja
committed
*/
\previouspage creator-usability.html
Qt Creator does not have its own debugger. Qt Creator provides a graphical
frontend to the following:
\header
\o Platform
\o Compiler
\o Debugger Engine
Kavindra Devi Palaraja
committed
\row
\o Linux, Unixes, Mac OS
\o gcc
\o GNU Symbolic Debugger (gdb)
\o Windows/MinGW
\o gcc
\o GNU Symbolic Debugger (gdb)
\o Windows
\o Microsoft Visual C++ Compiler
\o Debugging Tools for Windows/Microsoft Console Debugger (CDB)
The frontend allows you to:
\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, local and global variables, etc.
\endlist
Qt Creator displays the raw information provided by the engine
in a clear and concise manner. This simplifies the debugging process.
Qt Creator comes with generic IDE functionality: stack view, views for
locals and watchers, registers, etc. In addition, Qt Creator includes
features to make debugging Qt-based applications easy. The debugger
frontend understands the internal layout of several Qt classes, for
example, QString, the QTL containers, and most importantly QObject
(and classes derived from it), as well as most containers of the C++
Standard Library. The debugger can present its contents in a useful way.
\section1 Debugger Engine Installation Notes
\table
\header
\o Notes
\o Requires gdb version 6.8 on Linux. On Mac OS X, please install the latest available Xcode
available for your OS version.
\row
\o Using this engine requires you to install the
\l{http://www.microsoft.com/whdc/devtools/debugging/installx86.Mspx}{32-bit}
or
\l{http://www.microsoft.com/whdc/devtools/debugging/install64bit.Mspx}{64-bit}
package (Version 6.11.1.404 for the 32-bit or the 64-bit version of Qt Creator, respectively),
which is freely available for download from the
\l{http://msdn.microsoft.com/en-us/default.aspx}
of the library if it is present on the system. When building Qt
Creator using the Microsoft Visual C++ Compiler, the
\c{"%ProgramFiles%\Debugging Tools for Windows"} path is
checked to ensure that all required header files are there.
\row
\o Debugging tools for Mac OS X
\o The Qt binary distribution contains both debug and release
variants of the libraries. But you have to explicitly tell the
runtime linker that you want to use the debug libraries even if
your application is compiled as debug as release is the default
library.
If you use a qmake based project in Qt Creator, you can set a
flag in your run configuration, in Projects mode. In the run
configuration, select \gui{Use debug version of frameworks}.
For more detailed information about debugging on the Mac, refer:
\l http://developer.apple.com/mac/library/technotes/tn2004/tn2124.html
\note The Mac OS X Snow Leopard (10.6) has a bug, that can be worked
around as described in the link provided below:
\l http://bugreports.qt.nokia.com/browse/QTBUG-4962.
\endtable
In \gui Debug mode, several dock widgets are used to interact with the
program you are debugging. Frequently-used dock widgets are visible by
default and rarely-used ones are hidden. To change the default settings,
Rohan Shetty
committed
select \gui Debug > \gui View, and then select an option to
lock or unlock the location of the dock widgets or display
or hide them. The position of your dock widgets is saved for future
To start a program under the debugger's control, select \gui{Debug} >
\gui{Start Debugging} > \gui{Start Debugging}, or press \key{F5}.
Qt Creator checks whether the compiled program is up-to-date, rebuilding
it if necessary. The debugger then takes over and starts the program.
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
\note Starting a program in the debugger can take a considerable amount of
time, typically in the range of several seconds to minutes if complex
features (like QtWebKit) are used.
Once the program starts running, it behaves and performs as usual.
The user can interrupt a running program by selecting
\gui {Interrupt} from the \gui{Debug} menu. The program is automatically
interrupted as soon as a breakpoint is hit.
Once the program stops, Qt Creator:
\list
\o Retrieves data representing the call stack at the program's current
position.
\o Retrieves the contents of local variables.
\o Examines \gui Watchers.
\o Updates the \gui Registers, \gui Modules, and \gui Disassembler
views.
\endlist
You can use the debugger views to examine the data in more detail.
To finish debugging, press \key{Shift+F5}. You can execute a line of code
as a whole with \key{F10}. To step into a function or a sub-function, use
\key{F11}. You can also continue running the program with \key{F5}.
It is also possible to continue executing the program until the current
function completes or jump to an arbitrary position in the current function.
\section2 Breakpoints
A breakpoint represents a position or sets of positions in the code that,
when executed, interrupts the program being debugged and passes the control
to the user. The user is then free to examine the state of the interrupted
program, or continue execution either line-by-line or continuously
Qt Creator shows breakpoints in the \gui{Breakpoints} view which is enabled
by default. The \gui{Breakpoints} view is also accessible when the debugger
and the program being debugged is not running.
Typically, breakpoints are associated with a source code file and line, or
the start of a function -- both are allowed in Qt Creator.
The interruption of a program by a breakpoint can be restricted with
certain conditions.
You can set a breakpoint:
\list
\o At a particular line you want the program to stop -- click on the
left margin or press \key F9 (\key F8 for Mac OS X).
Kavindra Devi Palaraja
committed
\o At a function that you want the program to interrupt -- enter the
function's name in \gui{Set Breakpoint at Function...} located in the
context menu of the breakpoints view.
\note You can remove a breakpoint:
\list
\o By clicking on the breakpoint marker in the text editor.
\o By selecting the breakpoint in the breakpoint view and pressing
\key{Delete}.
\o By selecting \gui{Delete Breakpoint} from the breakpoint's context
menu in the \gui Breakpoints view.
\endlist
Breakpoints can be set and deleted before the program has actually started
running or while it is running under the debugger's control. Also,
breakpoints are saved together with a session.
\section2 Stack
Kavindra Devi Palaraja
committed
When the program being debugged is interrupted, Qt Creator displays the
nested function calls leading to the current position as a call stack
trace. This stack trace is built up from call stack frames, each
representing a particular function. For each function, Qt Creator tries
Kavindra Devi Palaraja
committed
to retrieve the file name and line number of the corresponding source
\image qtcreator-debug-stack.png
Since the call stack leading to the current position may originate or go
through code for which no debug information is available, not all stack
frames have corresponding source locations. Stack frames without
corresponding source locations are grayed out in the \gui{Stack} view.
If you click on a frame with a known source location, the text editor
jumps to the corresponding location and updates the \gui{Locals and Watchers}
Kavindra Devi Palaraja
committed
view, making it seem like the program was interrupted before entering the
function.
Kavindra Devi Palaraja
committed
If a multi-threaded program is interrupted, the \gui Thread view or the
combobox named \gui Thread in the debugger's status bar can be used to
switch from one thread to another. The \gui Stack view adjusts itself
The \gui{Modules} view and \gui{Source Files} view display the debugger's idea.
By default, the \gui{Modules} view and \gui{Source Files} view are hidden.
\section2 Disassembler View and Registers View
The \gui{Disassembler} view displays disassembled code for the current
function. The \gui{Registers} view displays the current state of the CPU's
registers.
The \gui{Disassembler} view and the \gui{Registers} view are both useful
for low-level commands such as \gui{Step Single Instruction} and
\gui{Step Over Single Instruction}. By default, both \gui{Disassembler} and
\gui{Registers} view are hidden.
\section2 Locals and Watchers
Whenever a program stops under the control of the debugger, it retrieves
information about the topmost stack frame and displays it in the
\gui{Locals and Watchers} view. The \gui{Locals and Watchers} view
typically includes information about parameters of the function in that
frame as well as the local variables.
Compound variables of struct or class type are displayed as
"expandable" in the view. Click on the "+" to expand the entry and show
all members. Together with the display of value and type, the user can
examine and traverse the low-level layout of an object's data.
\table
\row
\i \bold{Note:}
Kavindra Devi Palaraja
committed
\row
\i Gdb, and therefore Qt Creator's debugger works for optimized
builds on Linux and Mac OS X. Optimization can lead to
re-ordering of instructions or removal of some local variables,
causing the \gui{Locals and Watchers} view to show unexpected
data.
Kavindra Devi Palaraja
committed
\row
\i The debug information provided by gcc does not include enough
information about the time when a variable is initialized.
Therefore, Qt Creator can not tell whether the contents of a
local variable contains "real data", or "initial noise". If a
QObject appears uninitialized, its value is reported as
"out of scope". Not all uninitialized objects, however, can be
recognized as such.
The \gui{Locals and Watchers} view also provides access to the most
powerful feature of the debugger: comprehensive display of data belonging
to Qt's basic objects.
To enable Qt's basic objects data display feature:
\list
\o Check \gui{Use debugging helper} checkbox from \gui Tools >
\gui {Options...} > \gui Debugger > \gui{Debugging Helper}.
\o The \gui{Locals and Watchers} view is re-organized to provide a
high-level view of the objects.
\endlist
See example, in case of QObject, instead of displaying a pointer to some
private data structure, you see a list of children, signals and slots.
Similarly, instead of displaying many pointers and integers, Qt Creator's
debugger displays the contents of a QHash or QMap in an orderly manner.
Also, the debugger displays access data for QFileInfo and provides
access to the "real" contents of QVariant.
The \gui{Locals and Watchers} view can be used to change the contents of
variables of simple data types, for example, \c int or \c float when the
program is interrupted. To do so, click on the \gui Value column, modify
the value with the inplace editor, and hit \key Enter (or \key Return).
Kavindra Devi Palaraja
committed
\note The set of watched items is saved in your session.
Rohan Shetty
committed
\section1 Walkthrough for the Debugger Frontend
The \l{Writing a simple program}{TextFinder} example reads a text file into
QString and then displays it with QTextEdit.
If you want to look at the example's QString, \c{line}, and see the
stored data, you must place a breakpoint and view the QString object's
data. Perform the following steps:
Rohan Shetty
committed
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
\table
\row
\i \inlineimage qtcreator-setting-breakpoint1.png
\i \bold{Setting a Breakpoint}
\list 1
\o Click in between the line number and the window border on the line
where we invoke \l{http://doc.trolltech.com/qtextedit.html#plainText-prop}{setPlainText()}
to set a breakpoint.
\o Select \gui{Start Debugging} from the \gui{Debug} menu or press \key{F5}.
\endlist
\row
\i \inlineimage qtcreator-setting-breakpoint2.png
\i \bold{Viewing and removing breakpoints}
Breakpoints are visible in the \gui{Breakpoints} view in
\gui{Debug} mode. To remove a breakpoint, right-click on
it and select \gui{Delete breakpoint} from the context menu.
\row
\i \inlineimage qtcreator-watcher.png
\i \bold{Viewing Locals and Watchers}
To view the contents of \c{line}, go to the \gui{Locals and
Watchers} view.
\endtable
If you modify your \c{on_findButton_clicked()} function to move back to
Rohan Shetty
committed
the start of the document and continue searching once the cursor hits the
end of the document. You can add the restart from beginning functionality
with the following code snippet:
Rohan Shetty
committed
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
\code
void TextFinder::on_findButton_clicked()
{
QString searchString = ui->lineEdit->text();
QTextDocument *document = ui->textEdit->document();
QTextCursor cursor = ui->textEdit->textCursor();
cursor = document->find(searchString, cursor,
QTextDocument::FindWholeWords);
ui->textEdit->setTextCursor(cursor);
bool found = cursor.isNull();
if (!found && previouslyFound) {
int ret = QMessageBox::question(this, tr("End of Document"),
tr("I have reached the end of the document. Would you like "
"me to start searching from the beginning of the document?"),
QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if (ret == QMessageBox::Yes) {
cursor = document->find(searchString,
QTextDocument::FindWholeWords);
ui->textEdit->setTextCursor(cursor);
} else
return;
}
previouslyFound = found;
}
\endcode
If you compile and run the above code, however, the application does not
work correctly due to a logic error. To locate this logic error, step
Rohan Shetty
committed
through the code using the following buttons:
\image qtcreator-debugging-buttons.png
Rohan Shetty
committed
\section1 Setting the Symbol Server in Windows
Rohan Shetty
committed
To obtain debugging information for the operating system libraries for
debugging Windows applications, the Symbol Server provided
by Microsoft has to be added to the symbol search path of the debugger:
Rohan Shetty
committed
\list 1
Rohan Shetty
committed
\o Select \gui Tools > \gui{Options...} > \gui Debugger > \gui Cdb
Rohan Shetty
committed
\o Click \inlineimage qtcreator-serverbutton.png
located next to the \gui{Insert...} button of the Symbol paths
field and select \gui{Symbol Server...}
\o Select a directory where you want to store the cached information
and click \gui OK.
\endlist
\section1 Debugging Helper Library with C++
While debugging, Qt Creator dynamically loads a helper library into your
program. This helper library enables Qt Creator to pretty print Qt and STL
types. The Qt SDK package already contains a prebuilt debugging helper
Rohan Shetty
committed
library. To create an own debugging helper library, select \gui{Tools} >
\gui{Options...} > \gui{Qt4} > \gui{Qt Versions}. As the internal data
structures of Qt can change between versions, the debugging helper
library is built for each Qt version.
\section1 Debugging Helper Library with Python
Using a gdb version that has Python scripting available it is possible to
use Debugging Helpers also for user defined types. All that is needed is
to define one Python function per user defined type in \c{.gdbinit}.
The function's name has to be qdump__NS__Foo where NS::Foo is the class
or class template to be examined. Nested namespaces are possible.
Qt Creator's debugger integration calls this function whenever you want to
display an object of this type. The function is passed the following
parameters:
\list
\o 'd' of type 'Dumper'
\o 'item' of type 'Item'
\endlist
The function has to feed the Dumper object with certain information
which is used to build up the object and its children's display in the
\gui{Locals and Watchers} view.
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
Example:
\code
def qdump__QVector(d, item):
d_ptr = item.value["d"]
p_ptr = item.value["p"]
alloc = d_ptr["alloc"]
size = d_ptr["size"]
check(0 <= size and size <= alloc and alloc <= 1000 * 1000 * 1000)
check(d_ptr["ref"]["_q_value"] > 0)
innerType = item.value.type.template_argument(0)
d.putItemCount(size)
d.putNumChild(size)
if d.isExpanded(item):
p = gdb.Value(p_ptr["array"]).cast(innerType.pointer())
d.beginChildren([size, 2000], innerType)
for i in d.childRange():
d.safePutItem(Item(p.dereference(), item.iname, i))
p += 1
d.endChildren()
\endcode
\section2
The 'Item' Python class is a thin wrapper around values corresponding to one
line in the \gui{Locals and Watchers} view. The 'Item' members are as follows :
\list
\o \gui{__init__(self, value, parentiname, iname, name = None)} - A
constructor. The object's internal name is created by concatenating
\c parentiname and \c iname. If \c None is passed as \c name, a
serial number is used.
\o \gui{value} - An object of type gdb.Value representing the value to
be displayed.
\o \gui{iname} - The internal name of the object, constituting a dot-separated
list of identifiers, corresponding to the position of the object's
representation in the view.
\o \gui{name} - An optional name. If given, is used in the
\gui{name} column of the view. If not, a simple number in brackets
is used instead.
\endlist
\section2
For each line in the \gui{Locals and Watchers} view, a string like the
following needs to be created and channeled to Creator's debugger plugin.
\code
"{iname='some internal name',
addr='object address in memory',
name='contents of the name column',
value='contents of the value column',
type='contents of the type column',
numchild='number of children', // zero/nonzero is sufficient
childtype='default type of children', // optional
childnumchild='default number of grandchildren', // optional
children=[ // only needed if item is expanded in view
{iname='internal name of first child',
... },
{iname='internal name of second child',
... },
...
]}"
\endcode
While in theory, you can build up the entire string above manually, it is
easier to employ the 'Dumper' Python class for that purpose. The 'Dumper'
Python class contains a complete framework to take care of the 'iname' and
'addr' fields, to handle children of simple types, references, pointers,
enums, known and unknown structs as well as some convenience methods to
handle common situations.
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
The 'Dumper' members are the following:
\list
\o \gui{__init__(self)} - Initializes the output to an empty string and
empties the child stack.
\o \gui{put(self, value)} - Low level method to directly append to the
output string.
\o \gui{putCommaIfNeeded(self)} - Appends a comma if the current output
ends in '}', '"' or ']' .
\o \gui{putField(self, name, value)} - Appends a comma if needed, and a
name='value' field.
\o \gui{beginHash(self)} - Appends a comma if needed and a '{', marking
the begin of a set of fields.
\o \gui{endHash(self)} - Appends a '}', marking the end of a set of
fields.
\o \gui{beginItem(self, name)} - Starts writing a field by writing \c {name='}.
\o \gui{endItem(self)} - Ends writing a field by writing \c {'}.
\o \gui{beginChildren(self, numChild_ = 1, childType_ = None, childNumChild_ = None)}
- Starts writing a list of \c numChild children, with type
\c childType_ and \c childNumChild_ grandchildren each. If \c numChild_
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
is a list of two integers, the first one specifies the actual number
of children and the second the maximum number of children to print.
\o \gui{endChildren(self)} - Ends writing a list of children.
\o \gui{childRange(self)} - Return the range of children specified in
\c beginChildren.
\o \gui{putItemCount(self, count)} - Appends a field \c {value='<%d items'}
to the output.
\o \gui{putEllipsis(self)} - Appends fields
\c {'{name="<incomplete>",value="",type="",numchild="0"}'}. This is
automatically done by \c endChildren if the number of children to
print is smaller than the number of actual children.
\o \gui{putName(self, name)} - Appends a \c {name='...'} field.
\o \gui{putType(self, type)} - Appends a field \c {type='...'} unless the
\a type coincides with the parent's default child type.
\o \gui{putNumChild(self, numchild)} - Appends a field \c {numchild='...'}
unless the \c numchild coincides with the parent's default child numchild
value.
\o \gui{putValue(self, value, encoding = None)} - Append a file \c {value='...'},
optionally followed by a field \c {valueencoding='...'}. The \c value
needs to be convertible to a string entirely consisting of
alphanumerical values. The \c encoding parameter can be used to
specify the encoding in case the real value had to be encoded in some
way to meet the alphanumerical-only requirement.
Currently the following encodings are supported:
\list
\o 0: unencoded 8 bit data, interpreted as Latin1.
\o 1: base64 encoded 8 bit data, used for QByteArray,
double quotes are added.
\o 2: base64 encoded 16 bit data, used for QString,
double quotes are added.
\o 3: base64 encoded 32 bit data,
double quotes are added.
\o 4: base64 encoded 16 bit data, without quotes (see 2)
\o 5: base64 encoded 8 bit data, without quotes (see 1)
\o 6: %02x encoded 8 bit data (as with \c QByteArray::toHex),
double quotes are added.
\o 7: %04x encoded 16 bit data (as with \c QByteArray::toHex),
double quotes are added.
\endlist
\o \gui{putStringValue(self, value)} - Encodes a QString and calls
\c putValue with the correct \c encoding setting.
\o \gui{putByteArrayValue(self, value)} - Encodes a QByteArray and calls
\c putValue with the corrent \c encoding setting.
\o \gui{isExpanded(self, item)} - Checks whether the item with the
internal name \c item.iname is expanded in the view.
\o \gui{isExpandedIName(self, iname)} - Checks whether the item with the
internal name \c iname is expanded in the view.
\o \gui{putIntItem(self, name, value)} - Equivalent to:
\code
self.beginHash()
self.putName(name)
self.putValue(value)
self.putType("int")
self.putNumChild(0)
self.endHash()
\endcode
\o \gui{putBoolItem(self, name, value)} - Equivalent to:
\code
self.beginHash()
self.putName(name)
self.putValue(value)
self.putType("bool")
self.putNumChild(0)
self.endHash()
\endcode
\o \gui{pushOutput(self)} - Moves the output string to a safe location
from with it is sent to the frontend even if further operations
\o \gui{putCallItem(self, name, item, func)} -
Uses gdb to call the function \c func on the value specified by
\a {item.value} and output the resulting item. This function is
not available when debugging core dumps and it is not available
on the Symbian platform due to restrictions imposed by AppTRK.
\o \gui{putItemHelper(self, item)} - The "master function", handling
basic types, references, pointers and enums directly, iterates
over base classes and class members of compound types and calls
\c qdump__* functions whenever appropriate.
\o \gui{putItem(self, item)} - Equivalent to:
self.beginHash()
self.putItemHelper(item)
self.endHash()
\o \gui{safePutItemHelper(self, item)} - Calls \c putItemHelper(self, item).
If an exception is raised, catch it, and replace all output produced by
self.putName(item.name)
self.putValue("<invalid>")
self.putType(str(item.value.type))
self.putNumChild(0)
self.beginChildren()
self.endChildren() \endcode
\o \gui{safePutItem(self, item)} - Equivalent to
self.beginHash()
self.safePutItemHelper(item)
self.endHash()
\endlist
/*!
\contentspage index.html
\previouspage creator-project-qmake.html
\page creator-project-cmake.html
\nextpage creator-project-generic.html
Kavindra Devi Palaraja
committed
Since Qt Creator 1.1, support for \c CMake project files is available.
Qt Creator 1.3 supports the Microsoft Toolchain if the CMake version
You can set the path for the \c CMake executable in \gui{Tools} >
\gui{Options...} > \gui{CMake} > \gui{CMake}.
\image qtcreator-cmakeexecutable.png
\note Before you open a \c CMake project it is necessary to modify the
\c{PATH} environment variable to include the bin folders of \c mingw and
Qt Creator in the SDK.
For instance, if you have the Qt Creator SDK installed in your C drive,
use the following command to set the environment variables in
the command line prompt:
\code
set PATH=C:\qtsdk\mingw\bin;C:\qtsdk\qt\bin;
\endcode
Then start Qt Creator by typing:
\code
C:\qtsdk\bin\qtcreator.exe
\endcode
\section1 Opening CMake Projects
To open a \c CMake project:
\list 1
\o Select \gui{File} > \gui{Open File or Project...}
\o Select the \c{CMakeLists.txt} file from your \c CMake project
\endlist
A wizard guides you with the rest of the process.
\note If the \c CMake project does not have an in-place build, Qt Creator
lets you specify the directory in which the project is built
(\l{glossary-shadow-build}{shadow build}).
\image qtcreator-cmake-import-wizard1.png
The screenshot below shows how you can specify command line arguments to
Kavindra Devi Palaraja
committed
\c CMake for your project.
\image qtcreator-cmake-import-wizard2.png
Kavindra Devi Palaraja
committed
Normally, there is no need to pass any command line arguments for projects
Kavindra Devi Palaraja
committed
that are already built, as \c CMake caches that information.
\section1 Building CMake Projects
Qt Creator builds \c CMake projects by running \c make, \c mingw32-make, or
\c nmake depending on your platform. The build errors and warnings are
parsed and displayed in the \gui{Build Issues} output pane.
By default, Qt Creator builds the \bold{all} target. You can specify which
targets to build in \gui{Project} mode, under \gui{Build Settings}.
\image qtcreator-cmake-build-settings.png
Qt Creator supports multiple build configurations. The build
directory can also be modified after the initial import.
\section1 Running CMake Projects
Qt Creator automatically adds \gui{Run Configurations} for all targets
specified in the \c CMake project file.
Kavindra Devi Palaraja
committed
Known issues for the current version can be found
\section1 Adding External Libraries to a CMake 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.
Qt Creator detects the external libraries using the \c FIND_PACKAGE()
macro. Some libraries come with the CMake installation. You can find those
in the \bold{Modules} directory of your CMake installation.
\note If you provide your own libraries, you also need to provide your own
\c FindFoo.cmake file. For more information, see
\l{http://vtk.org/Wiki/CMake_FAQ#Writing_FindXXX.cmake_files}{CMake FAQ}.
Syntax completion and highlighting work once your project successfully
builds and links against the external library.
Kavindra Devi Palaraja
committed
/*!
\contentspage index.html
\previouspage creator-project-cmake.html
\page creator-project-generic.html
\nextpage creator-project-managing-sessions.html
\title Setting Up a Generic Project
Qt Creator supports generic projects, so you can import existing projects
that do not use qmake or CMake and Qt Creator ignores your build system.
Generic project support allows you to use Qt Creator as a code editor. You
can change the way your project is built by modifying the \c make command
in the \gui{Projects} mode under \gui{Build Settings}.
Kavindra Devi Palaraja
committed
When you import a project, Qt Creator creates the following files that
allow you to specify which files belong to your project and which include
directories or defines you want to pass to your compile:
\tt{.files}, \tt{.includes}, and \tt{.config}.
Kavindra Devi Palaraja
committed
\section1 Importing a Generic Project
To import an existing generic project:
\list 1
\o Select \gui File > \gui{New File or Project...} >
\gui{Other Project} > \gui{Import Existing Project}.
\o In \gui{Import Existing Project}, enter the project name
and select the location for the project file you want to import.
Qt Creator automatically generates the following files in the
project directory:
\list
\o \l{Specifying Files}{.files}