# &kdevelop; User Manual

2004-11-13
&kdevrelease;
Bernd
Gehrmann

    bernd@kdevelop.org

Caleb
Tennis

    caleb@aei-tech.com

Bernd
Pol

    bernd.pol@online.de

2002
Bernd Gehrmann
2002
Caleb Tennis
2004
Bernd Pol
&FDLNotice;

&kdevelop; is an Integrated Development Environment to be used for a wide variety of programming tasks.

KDE
KDevelop
IDE
development
programming

## What This Manual Contains

This user manual is intended to describe the contents and use of the &kdevelop; &kdevrelease; Integrated Development Environment (IDE) from a user's point of view. It is not a programming manual, nor does it describe the development process in detail. Its only aim is to guide you in the handling of the IDE.

Here you will find information on the following topics:

- In a Nutshell — Tips and Tricks — a quick reference to commonly used commands and actions. And a short guide to solve common problems when working with &kdevelop;.

- Development on &UNIX; — a historical overview of &UNIX; program development, the main tools necessary and why you need an IDE.

- Installing &kdevelop; — tells you where to obtain &kdevelop; and how to get it up and running.

- Getting Started with &kdevelop; — a Guided Tour — gives you a quick start on the use of this IDE, introducing the basic steps of how to work on a project.

- Overview of the Features of &kdevelop; — extends the guided tour in the previous chapter, giving an overall view of what is built-in within &kdevelop; and gets you acquainted with the look and feel of this IDE.

- Menus and Toolbars Overview — (in the appendix) provides you with a short overall view of the menu and toolbar selections available.

- Shortcut Keys — (in the appendix) lists the key sequences you may use to quickly access specific &kdevelop; operations.

- Configuring &kdevelop; — shows how you can tailor the IDE to suit your needs.

- Scripting &kdevelop; — describes how to add scripts to automate &kdevelop;.

- Advanced Project Management — shows how to load existing projects, convert projects from older &kdevelop; versions, and import other existing projects. Furthermore the configuration of a project's options to suit your needs is covered.

- Editing tools — all you need to write your source files: using the editor, searching for text both locally and project-wide, up to integrating new files and classes into the project.

- The File Browsers — demonstrates various tools to look at the structure of your project and how to access the files you want to work with.

- The Class Browsers — describes one of the most powerful tools of &kdevelop; which lets you navigate through class dependencies and allows you to easily create and access the classes and methods you need.

- Documentation — shows how to access the rich built-in documentation &kdevelop; provides and tells you how to create documentation of your project, concise and powerful API documentation providing you an overall view of all your project sources as well as docbook-based user documentation.

- Building and Project Management — deals with the creation and management of your project; describing the basics of autoconf and automake as well as how to set up custom make files and how to use compiler or make options to tailor your application to suit your needs.

- Advanced Build Management — looks at ways to keep multiple build configurations, to cross-compile for diverse platforms, or to make an embedded system using the Qt/embedded library.

- The Debugger Interface — describes how to use the integrated gdb debugger interface so you can hunt down bugs without leaving &kdevelop;.

- Using CVS — tells you how you can maintain your project using the CVS versioning system; a must, especially if many developers work on the same project.

- Leveraging External Programs — shows how to access external programs and tools from within &kdevelop; thus greatly extending its capabilities.

- Plugin tools — provides you with an overview of the parts which make up &kdevelop; and how you can tailor it to suit your needs by only loading the parts that are necessary, both IDE and project-wide.

- Some commonly used information has been put into the appendix. Amongst others this consists of:

  - Menus and Toolbars Overview — provides you with a short overall view of the menu and toolbar selections available.

  - Shortcut Keys — the keys you can use to work with &kdevelop; without resorting to the mouse.

  - Configuration Files Used by &kdevelop; — lists the files kdevelop uses to save its internal information. This is particularly useful in case something went wrong with your setup.

  - Plugin Tools — lists the pluggable tools you can use to taylor the capabilities of &kdevelop; to your needs.

## In a Nutshell — Tips and Tricks

The information in this chapter is meant as a quick reference for a head start or if you (momentarily) forgot about some basic concept. There are also short hints on how to solve some common problems when working with &kdevelop;.

If you want more information on a topic, just follow the link in the title starting that advice.

Information on these topics is availabe:

- Look and Feel
- Projects
- Compilation
- &automanag;
- Compile/Make Problems
- Other Topics

### Look and Feel

- ### Force Smaller Tool View Tabs in IDEAl Mode

  By default &kdevelop; starts with large text-based tool tip tabs around the work area. You may change this look to &eg; save space in the &kdevelop; configuration dialog (Settings Configure KDevelop... User Interface).

  If you use an older &kdevelop; 3 version, this configuration dialog may not be available. To change the toolview tabs display manually, place a `MDIStyle` entry under the `[UI]` tag in your `$KDEHOME/share/config/kdeveloprc` configuration file as follows:

  - `MDIStyle=0`: icons only
  - `MDIStyle=1`: text only (default)
  - `MDIStyle=3`: icons and text

- ### Weird Colored Characters and/or Display Style

  If you notice random colored letters everywhere (&ie; on tabs, on tool bars, etc.) and the &kdevelop; window seemingly uses a wrong display style, this may help:

  - In your `$KDEHOME/share/config/kdeveloprc` configuration file find the line containing `Style=Checked` and remove it. Then restart &kdevelop;.

  (This behaviour does sometimes occur after you left clicked a .ui file in one of the file navigators and &kdevelop; did load KUIViewer to show the &GUI; which was produced from this file.)

- ### Full Screen Mode

  Select View Full-Screen Mode from the menus or press Ctrl Shift F .

- ### Hide/Unhide the Menubar

  To hide the menubar select Settings Show Menubar from the menus or press Ctrl M . To redisplay the menubar only Ctrl M is available.

### Projects

- ### Create New Project

  Project New Project... will start the &appwizard;.

- ### Create a Custom Project

  There is no direct way to create a custom project (&ie; a project which does use its own makefiles). Use Project Import Existing Project instead. Remember to set the appropriate Project Type, labeled by an additional (Custom Makefiles), in the dialog.

- ### Use Project Options Early

  Whenever you start a new project do not forget to set the Project Project Options... to your needs.

### Compilation

- ### Missing detail in compilation messages

  If during compilations you notice some valuable information is missing in the Messages Output View window, it may be that the level of message detail is set too low. Right-click in the window and select another detail level from the context menu.

### &automanag;

- ### Create New Files in a Project

  Select the sub-project in the upper half of the &automanag;, then right-click in the lower half on the groups title you want to have the files added and select Create New File....

- ### Add Existing Files to a Project

  Select the sub-project in the upper half of the &automanag;, then right click in the lower half on the groups title you want to have the files added and select Add Existing Files....

- ### Remove a File from a Project

  Select the sub-project in the upper half of the &automanag;, then in the lower half open the groups list you want to have the file removed from, right click on the file in this list and select Remove.

### Compile/Make Problems

- ### Project does not build again after switching to/from default target

  There is a problem with the &automake;/&autoconf; machinery. If Project Build Configuration provides to select from three build directories: default, optimized, and debug, by all means stick to either the default or the debug/optimized targets.

  - Once you configured your project with default it will no longer build with debug or optimzed.

  - Once you configured your project with debug or optimzed it will no longer build with default.

- ### Wrong `autoconf` version &etc; Error

  There are several error messages concerning too old versions of autoconf &etc; prohibiting `configure` to work properly. Run `autoreconf` in the directory tree where the `configure.in` files in question are. This command will try to update the information in the &GNU; Build System files. See `man autoreconf` for more information.

### Other Topics

- ### Configuration Files used by &kdevelop;

  Usually you should not need to care, but this is very useful to know in case something went wrong with your setup.

&unixdev; &kdevelop-install; &getting-started; &kdevelop-survey; &setup; &kdevelop-scripting; &applicationwizard; &project-advanced;

## Editing Tools

### Code Snippets

#### Features (preliminary overview)

- SnippetPart adds a tool-view which by default docks to the right

- Adding, editing and removing of snippets is available via a popup-menu

- Double-clicking a snippet form the list inserts it into to the active view at the current cursor position

- Tool tips show the content of a snippet

- Snippets are stored in the users home-directory, so every user can have his own snippets

- Snippets can contain variables in the style of $VARNAME$. On using the snippet the user is prompted to enter replacement value for the variables

### Keyboard Mapping

In the following, we will list the default keybindings of the default editor. You can configure them as you like (how?)

Left | Moves one character left
Right | Moves one character right
Ctrl Left | Moves one word left
Ctrl Right | Moves one word right
Up | Moves up one line
Down | Moves down one line
PgUp | Moves up one page
PgDn | Moves down one page
Ctrl PgUp | Moves to the beginning of the file
Ctrl PgDn | Moves to the end of the file
Home | Moves to the beginning of the line
End | Moves to the end of the line

For all the keys above, the Shift can be pressed additionally, to mark from the current cursor position to the one afterwards.

Backspace | Deletes one character left
Delete | Deletes the character under the cursor
Ctrl C | Copies the selected text to the clipboard
Ctrl V | Pastes the selected text from the clipboard
Ctrl X | Deletes the selected text and puts it into the clipboard
Ctrl Z | Undo
Shift Ctrl Z | Redo

### The Problem Reporter

(... to be written ...)

### Searching and Grepping

#### Searching for Text

Ctrl F- Find Ctrl R- Replace

#### ISearch

The conventional search with Edit Find requires you to specify the full search term before starting. Most of the time, it is much faster to search incrementally. If you click into the edit field labeled ISearch in the toolbar, the search is performed as you type. You will find that often the desired term is already found after typing in 3 or 4 letters.

#### Grep

Both search mechanisms described above are restricted to searching within one source file. An additional tool which allows you to search through a (possibly large) number of files is available through the Search in Files... item in the Edit menu. It is basically a frontend for the &grep;(1) program.

In the dialog, you can specify which files are searched. There is a number of wildcard patterns available in a combobox. In this way, you can easily restrict the find mechanism to header files. Furthermore, you specify a directory where the search is started. If you check the Recursive box, the search iterates through all directories in the hierarchy below this one.

The search term is in general a regular expression following POSIX syntax. For example, you can use the term `"\<K.*"` if you want to find all words which begin with the letter K. The following characters are interpreted in a special way:

`.` | Matches any character
`^` | Matches the beginning of a line
`$` | Matches the end of a line
`\<` | Matches the beginning of a word
`\>` | Matches the end of a word
`?` | The preceding item matches less than once
`*` | The preceding item is matched zero or more times
`+` | The preceding item is matched once or more times
`{n}` | The preceding item is matched exactly n times
`{n,}` | The preceding item is matched n or more times
`{,n}` | The preceding item matches less than n times
`{n,m}` | The preceding item matches at least `n` times but less than `m` times

Backreferences to bracketed subexpressions are also available by the notation `\n`.

For C++ programmers, as special bonus there are some search templates available for typical patterns. These allow you to search for example all calls of member functions of a certain object.

Once you start the search by clicking on the Search button, it will be performed by an external, asynchronous process. All found items will appear in the view called Grep. You can then jump to the found items by clicking on them. Note that grep scans the files as they stored in the file system. If you have modified versions of them in your editor, you may get some mismatches in the line number, or some found items will be invalid. You can avoid this by saving all files beforehand.

### Code Completion

(... to be written ...)

### Creating New Files and Classes

(... to be written ...)

#### Editing the Templates

(... to be written ...)

## The File Browsers

On the left side of the main window, &kdevelop; can display various kinds of lists and trees for the selection of files:

- ### File Tree

  This shows a tree view of the file hierarchy below the project directory. If you click on a file, it is loaded into the editor. For files which do not contain text, KDevelop starts an application that can handle the respective MIME type.

  The file tree is regularly updated whenever something changes in the file system. For example, if you create new files or directories (even outside &kdevelop;), this is immediately reflected in the file list. On Linux, this feature makes use of the FAM library. On other operating systems or over NFS, the directories shown are polled in small intervals.

  The file tree hides files which are usually not interesting, like object files. In the Project options under File views, you can configure (as a comma separated list of wildcards) which patterns are used to filter out irrelevant files.

  Furthermore, you can decide to restrict the file tree to show only files which belong to the currently loaded project. This can be toggled by clicking with the right mouse button on the root item of the tree.

  ### A Screenshot of the File Tree

- ### File Groups

  This shows the files belonging to the project, grouped by their file name extension. As in the file tree, you can edit a file by clicking on it with the left mouse button.

  The groups shown in this view can be configured under File views in the Project options dialog. In order to customize the view to your needs, it is helpful to understand how files are distributed on the groups. For each file, &kdevelop; goes through all groups from top to bottom. In each group, it looks whether the file name matches one of the patterns. If there is a match, the file is shown in this group and the iteration is aborted. This makes it clear that more general patterns should be put below more specific ones. For example, an asterisk for the Other group should be the last pattern.

## The Class Browsers

When working on a project in an object-oriented language, your emphasis when working on a project is not on the source files and their names, but on the classes and their relationships. In order to help you navigating in the space of defined classes and symbols, &kdevelop; includes various class browsers that visualize the class structure in different ways.

### Class View

This view is shown on the left side of the main window and contains a linear list of all classes, variables and functions in your project. It is designed as a tree view. If you open a class node by clicking on it, a list with all methods and attributes of the respective class is shown.

#### A Screenshot of the Class View

The class view works in two different modes. By default, all symbols are grouped into Classes, Structs, Functions, Variables and Namespaces. In the context menu of the view, you can choose List by Namespaces. In this mode, the namespace hierarchy is shown and the symbols grouped into the respective namespace where they are defined. This may be more useful in projects which make heavy use of (nested) namespaces. It is less useful in projects without namespaces.

You can also change the way in which class names are displayed. Normally, the names of the classes are shown, without the namespace in which they are defined. This means, you cannot immediately distinguish classes with the same name in different namespaces. If you rest for a while with the mouse over an item, the full scoped name is shown as a tooltip though. You can decide to always display the fully scoped class name by choosing Full Identifier scopes from the context menu.

Clicking on a class or method in the class view brings you to its definition. You can also jump to the declaration of a method by choosing Go to declaration from the context menu. In the context menu for classes are also the items Add method.. and Add attribute.... This opens dialogs where you can generate new method and variable declaration in the respective class, together with an empty implementation.

### Class Tools

The class tool dialog is activated by right clicking on a class in the class view and choosing Class tool....

### Class Hierarchy

(... to be written ...)

## Documentation

Documention unfortunately belongs to the most-overlooked programming issues. Yet, once properly set up and maintained internal and external documentation provides most valuable help.

Documentation has multiple facets. There is

- project internal documentation, mainly consisting of

  - comments in header/source files

  - internal API documentation of your project generated from the program file by special tools, &eg; &doxygen;

- project external documentation, comprising among others

  - external API documentation of &eg; common system libraries (KDE, Qt, &etc;)

  - any other documentation (programming language manuals, general system information, how-to articles and the like)

All this documentation should be easily maintainable and ready at hand whenever you need it. &kdevelop; has provisions for just this.

### The Documentation Browser

#### A Screenshot of the Documentation Tree

&project-management;

## Advanced Build Management

### Multiple Build Configurations

(... to be written ...)

### Cross-Compiling

When you have suitable cross compilers available, you can cross compile your programs for processors and operating systems different from the system where &kdevelop; and the compiler is running. The &GNU; compiler collection &gcc; can be configured and compiled as a cross compiler if you compile it yourself. Consult the GCC info pages for more information. Some Linux distributions also provide binary packages.

An automake based package can easily be cross-compiled by specifying the `--host` option to the configure script and setting the `CC` and `CXX` environment variables to the respective cross compiler binaries. Often you want to switch between a the cross-compiled version of your application and one compiled for your development system. For this, it is advantageous to use &kdevelop; capability of creating multiple build configurations, as explained in . Once you have created a new build configuration for cross-compiling in the Project Project Options... dialog, add the option

    --host=platform

to the configure options. The platform name is a tuple of the form

    cpu-vendor-os

or

    cpu-vendor-kernel-os

For many combinations, you can use a short form, for instance i386-linux or arm-elf.

### Qt/Embedded

&qte; is a version of the &Qt; library that does not use the X window system, but draws directly to the framebuffer on Linux systems. It is therefore interesting for embedded systems which have tight restrictions on the memory usage of the whole system. Its API is fully compatible with the one of the X11 version.

Developing an application for &qte; with &kdevelop; is not very different from developing a program for the X11 version of &Qt;. In fact, you can use the same codebase for both versions. If you use the autoproject project management, you switch to the embedded version by passing the argument `--enable-embedded` to the configure script. You can set this in the Project Project Options... dialog under Configure Options. With the option `--with-qt-dir=DIR` you set the directory in which &qte; is installed.

After configuring and compiling your application with these options, it will link with the `libqpe.so` library. This version of your application will not normally run when you use X11. In order to test it, run it under the control of the program qvfb (Qt Virtual Frame Buffer). This is done by starting qvfb and then starting your application with

    app -qws -display QVFb:0

Naturally, when you have a working version of your application, you will want to use it on the target processor. For this, it will probably be convenient to create multiple build configurations, as explained above, so that you can quickly switch between the version running on your development system and the version running on the target system.

Applications for &qte; normally run as single applications on the device they are designed for. Trolltech also supports Qtopia, which is a collection of applications for PIM, web browsing and various other areas that work together in a consistent manner. It is the standard environment for instance on the Sharp Zaurus. You can write applications that integrate into this environment by using the Qtopia SDK. This implies making your application class a subclass of `QPEApplication` and linking to the library `libqpe.so`. If you develop your application with the autoproject project management, you have to add `--enable-qtopia` to the configure options.

## The Debugger Interface

For C and C++, &kdevelop; contains an internal debugger that is directly integrated with the editor. Technically, it is implemented as a frontend that uses the portable &GNU; debugger gdb through a pipe. The debugger can be started in several ways:

- With Debug Start, the main program of your project is loaded into the debugger.

- Using Debug Start (other) Examine core file you load a core file into memory, which is generated by the operating system kernel when the program has crashed (The generation of core files may be switched off on your system, see ulimit(1)). This is useful for a post-mortem analysis of a program.

- With Debug Start (other) Attach to process you invoke the debugger on an already running program. You will be shown a process list where you can select the process which the debugger should take over.

- Note that debugging is only possible if your project has been compiled with debugging information enabled. It can be activated in the Compiler options dialog. When this option is switched on, the compiler generates additional data which allows the debugger to associate file names and line numbers with addresses in the executable.

The debugger frontend offers several views into the process:

- ### Variables

  This window lists the values of all local variables at the current execution point of the program. It covers the variables in the complete call stack, &ie; the function where the process was interrupted, the function that called this function, and so on up to `main()` function.

  Another branch in the variables contains watch variables. You can configure yourself which variables are shown here. Both local and global variables can be watched. You can add variables either by clicking on the Add button or pressing RETURN while the Watch item is selected. They can be removed again via the context menu.

- ### Breakpoints

  (... to be written ...)

- ### Frame Stack

  (... to be written ...)

- ### Disassemble

  (... to be written ...)

### Setting Breakpoints

(... to be written ...)

### Options

#### Display Mangled Names

In C++, function names in the executable are mangled, &ie; the function names include information about the argument types. This is necessary in order to support overloading of functions. The mangling algorithm is not standardized and differs even between different versions of the &GNU; C++ compiler.

In the disassembling window, normally unmangled names are displayed, so function signatures appear in the similar way as in the source code, so they are easily readable. Alternatively, you can decide to see mangled names.

#### Try Setting Breakpoints on Lib Load

The debugger backend gdb does not allow to set breakpoints within code that is not currently loaded. In a highly modular application, where often code is only loaded on demand as a plugin (using the libc function `dlopen(3)`), this can be inconvenient. Therefore, &kdevelop; rolls its own support for breakpoints in shared libraries. If you set this option, it allows you to set breakpoints in libraries which are not loaded. Then, whenever gdb notifies that a library is loaded, &kdevelop; tries to set the pending breakpoints.

#### Enable Floating Toolbar

(... to be written ...)

## Using CVS

### &CVS; Basics

&CVS; is the revision control system which many open source projects - including &kde; — are using. It stores all sources codes in a central place, called the repository. From the repository, developers can check out a current version of the project or snapshots of it at arbitrary points of time. In contrast to some other revision control systems, it is not necessary to lock files one wants to work on. So development can be highly parallelized.

Whenever a developer has finished a task, he commits his code (accompanied by a log message). &CVS; takes the job to merge the changes made by several developers. It can of course happen that developers work on the same piece of code, resulting in a conflicting set of changes (in practice this occurs seldom, and is often a sign of a lack of communication). In this case &CVS; rejects a commit; only after all conflicts are resolved, a file can be committed.

So far, this has been a description of the basic features of &CVS; one usually has to cope with. But &CVS; can provide a lot more: One can maintain several branches of a project (e. g. &kde; 1.1.2 and &kde; 2 were branches in &kde;'s development tree), merge changes from one branch to another, ask for differences between revisions, the revision history of files &etc;

&CVS; is implemented as a client-server system. As a user, all communication with the repository goes through the command line program &cvs;. A higher level user interface is available through frontends like Cervisia () or TkCVS (). In &kdevelop;, only a small part of the &cvs; functionality which is important for your daily work can be used directly.

Basic knowledge of &CVS; usage is assumed. In particular, you should know how to checkout a given project from the repository. We recommend the book Open Source Development With CVS by Karl Fogel which is freely distributed (except for the non-technical chapters). See .

### &CVS; Commands in &kdevelop;

In the file views, the following context menu items are available:

- #### Add to Repository

  Prepares the marked file for addition to the repository. The file is transferred to the repository when you commit it (or the containing directory) the next time.

- #### Remove from Repository

  Prepares a file for removal from the repository. This also deletes the file on the local file system, so use this feature with care!

- #### Update

  Runs `cvs update` to merge any changes from other users into your working directory. When you use this menu item over a directory, the update normally happens recursively, except if you have disabled this in the configuration file `.cvsrc`.

- #### Commit

  Runs `cvs commit` to upload any locally made changes to the repository. Note that you should update before doing this. Otherwise, when another user has committed his own changes before, &CVS; may give you an error message.

All these commands are invoked as subprocesses by &kdevelop; without any further command line options or environment variables. This may be a problem when the connection with the &CVS; server goes through a &ssh; connection and requires that you enter your password each time you commit or update. This is for instance necessary when your project is hosted on `sourceforge.net`. Workarounds for this problem are described on the CVS/SSH FAQ which you can find in the SourceForge documentation.

### Behind the Scenes

#### What &CVS; Records in the Working Directory

(... to be written ...)

## Leveraging External Programs

Although &kdevelop; is a so-called Integrated development environment, it will never contain all features that you may want to use, and the capabilities of its editor will never suffice to perform often-used text processing tasks. As a genuine &UNIX; program, &kdevelop; contains several possibilities to start external programs, plugin external programs to work on files, or use external filters to process the content of the editor.

The most general and simple feature of this kind is the tool menu, which you can freely configure. This is done in the Settings Configure KDevelop.... dialog under External tools.

Other tools will be discussed in the chapter .

## Credits

### Contributions

- The initial contents of this manual were witten by Bernd Gehrmann bernd@kdevelop.org and Caleb Tennis caleb@aei-tech.com.

- The Summary of &automanag; and Automake Manager Operation chapters were written by Ian Wadham, ianw@netspace.net.au).

&app-menu;

## Shortcut Keys

(... to be written ...)

&app-files;

## Plugin Tools

&kdevelop; contains a large number of little tools that help you to perform certain task. Most of them are realized as plugins. This means, if you do not like one of them, you can simply disable it in the Project options dialog under Plugins (for project-wide plugins) or under Settings Configure KDevelop.... Plugins which are switched off do not clutter your menus and are not loaded into memory.

- ### The `abbrev` Plugin

  This plugin expands abbreviations into frequently used code snippets. It is activated by pressing Ctrl Space. For example, when you enter `"ife"` into a C++ in the editor and press Ctrl Space, you obtain an `if-else` code template and save some key strokes. The set of supported abbreviations depends on the programming language of the edited file. For example, for PHP you will obviously be interested in other code templates than for &Java;.

  The set of code templates is configurable. You can see which ones are available in the Settings Configure KDevelop... dialog under Abbreviations

- ### The `filter` Plugin

  This offers two features. If you select Tools Execute command, you can enter a shell command. The output of this command is inserted into the editor buffer when you hit the Start button.

  A related feature is available under Tools Filter selection through command.... In order to use this, you must select a text area in the editor. If you now enter a shell command and hit the Start button, the command is started and the selection used as the standard input for it. The standard output of the command is then inserted into the editor.

- ### The &doxygen; Plugin

  This one helps you to use the &doxygen; API documentation tool (). You can select Project Run Doxygen to generate API documentation for your current project, based on the configuration given by the file `Doxyfile` in your project directory.

  Furthermore, you can configure &doxygen; in the Project Project options... dialog. This dialog is very similar to the &doxywizard; tool.

- ### The &ctags; Plugin

  Although the class browser gives you extensive insight into the symbols and classes of your project, you may also want to use the ctags tool. In particular, this one supports a lot more language than the class browser.

  You activate this plugin under Tools CTags.... When you start it the first time, you will be asked to generate a search database first. When you accept this, the &ctags; program will be started and will create a file named `tags` in your project directory. This is a text file containing all symbols of your source files.

  You can search in the symbol database in two ways: when the Regular expression match box is checked, the text you enter will be interpreted as a regular expression (POSIX flavor) and matched with the existing symbols. For example, the text `.*Widget` will search for all symbols ending with `Widget`. If the box is not checked, the search will be verbatim.

  When searching, you will get a list of the matched symbols, accompanied with the line numbers where they are defined. You jump to the respective point by clicking on the list.

  For some languages, &ctags; distinguishes different kinds of symbols. For example, Python has classes and functions. You can selectively search only for classes by checking the respecting kinds in the dialog.

  The symbol database is normally not updated when your sources change. Consequently, after a while the line numbers will not be correct anymore and newly added classes and functions will be missing. Therefore you should update the `tags` file in regular intervals by pressing the button Regenerate.

- ### The `astyle` Plugin

  (... to be written ...)

- ### The `regexptest` Plugin

  Designing with regular expressions can be hard work. Often the first try at an expression matches too many strings. In particular, when working with a compiled language, the turnaround times when debugging a regular expression can be awkward. The regexptest plugin allows you to directly explore the changes in a regular expression. It is activated by choosing Tools Debug Regular Expression....

  In the flavor group box, you can choose the flavor of the regular expression engine used. Currently supported is the flavor defined in the POSIX standard, which is used by the &grep; program, and the extended POSIX syntax used by the program &egrep;.

  When you enter an expression, you get immediate feedback about any syntax errors in it. By entering a text under Test string, you can see whether the expression matches this string. In particular, if your regular expression includes groups, such as `([a-z])`, the content of the matched subgroups will be shown in a list box.

- ### The `konsole` Plugin

  (... to be written ...)

### Overview

&kdevelop; offers extensible modules, or parts, to be loaded at runtime and on demand. This allows developers to only turn on features that they need or want for their development.

Some of the parts are considered global — that is, they effect the entire operation of &kdevelop;. For example, the uimode part allows a developer to select which user interface they wish to use.

Other parts are project specific, and are only utilized when a project of that type is loaded. The Automake Manager, for example, only needs to be active when an Automake based project is currently loaded. Otherwise, this part will not be active.

Active parts can have many effects on &kdevelop;. Depending on their function, they may add extra menus, extra menu items, extra tool buttons, &etc;

#### Project Management Parts in &kdevelop;

antproject | ANT Project Manager (&Java; applications)
autoproject | Automake Project Manager
customproject | Custom Project Manager
trollproject | QMake based Project Manager

#### Global Parts in &kdevelop;

Part Name | Description
appwizard | New Project Wizard
history |
konsole | Embedded Konsole
editor-chooser | Chooses an internal text editor
doctreeview | Documentation Viewer
openwith |
fileselector | A file selection widget
uimode | Customize the UI mode
texttools | Additional text tools
tipofday | A tip of the day
grepview | A graphical grep utility
cvs | CVS Support
tools |
regexptest | A regular expression tester
abbrev | Abbreviation Expansion
filter |
valgrind | A graphical valgrind frontend

#### Language Support Parts in &kdevelop;

cppsupport | Support for C/C++
fortransupport | Support for Fortran
javasupport | Support for &Java;
perlsupport | Support for Perl
phpsupport | Support for PHP
pythonsupport | Support for Python

#### Project Specific Parts in &kdevelop;

astyle |
buglist |
classview | Classview Manager
ctags |
debugger | &GNU; Debugger Manager
diff |
distpart |
doxygen |
fileview |
javadebugger |
manager |
nedit |
outputviews |
perforce |
qeditor |
scripting |
scriptproject |
sourcenav |
svn |
visualboyadvance |
windowmenu |

## &kdevelop; User Interface Mode Examples

### IDEAl Mode

Click here to return to the modes overview.

Screenshot

&kdevelop; IDEAl mode

Click here to return to the modes overview.

Screenshot

&kdevelop; IDEAl mode, closed tabs

This example screenshot demonstrates one of the main virtues of IDEAl mode. There is a maximum workspace available. Yet any tool view is readily available by clicking on the according tab.

You will most probably need some time to get accustomed to the icons in the tab bar. If you got lost, just position the mouse over a tab and wait a few seconds. A short tool tip description will pop up. In this screenshot the Automake Manager tool tip is shown as an example. It describes the lower tab in the right tab bar.

Click here to return to the modes overview.

### Child Frame Windows Mode

Click here to return to the modes overview.

Screenshot

&kdevelop; child frame windows mode

Click here to return to the modes overview.

### Tabbed Pages Mode

Click here to return to the modes overview.

Screenshot

&kdevelop; tabbed pages mode

Click here to return to the modes overview.

### Toplevel Windows Mode

Click here to return to the modes overview.

Screenshot

&kdevelop; toplevel windows mode

Click here to return to the modes overview.

## Further Information

### Getting Information

(... to be written ...)

### Reporting Bugs

(... to be written ...)

### Licensing

&underFDL; &underGPL;

## Changes

### Changes to This Document

- 2003-01-03 — Started this Changelog

## Bibliography

(... to be written ...)

#### GNU Make Manual

Richard M.
Stallman
Roland
McGrath

#### GNU Automake

David
MacKenzie
Tom
Tromey

#### GNU Autoconf

David
MacKenzie
Ben
Elliston

#### Using the GNU Compiler Collection

Richard M.
Stallman

#### GNU Libtool

Gordon
Matzigkeit
Alexandre
Oliva
Thomas
Tanner
Gary V.
Vaughan

#### GNU Autoconf, Automake, and Libtool

1st edition
October 2000
Gary V.
Vaughan
Ben
Elliston
Tom
Tromey
Ian Lance
Taylor
New Riders Publishing
ISBN 1578701902

#### Advanced Programming in the &UNIX; Environment

1st edition
June 1992
W. Richard
Stevens
Addison-Wesley Pub Co
ISBN 0201563177

#### Thinking in C++, Volume 1: Introduction to Standard C++

2nd Edition
April 15, 2000
Bruce
Eckel
Prentice Hall
ISBN 0139798099

#### Open Source Development with CVS

2nd Edition
October 12, 2001
Karl
Fogel
Moshe
Bar
The Coriolis Group
ISBN 158880173X

#### Programming PHP

1st edition
March 2002
Rasmus
Lerdorf
Kevin
Tatroe
O'Reilly & Associates
ISBN 1565926102

#### Programming Python

2nd Edition
March 2001
Mark
Lutz
O'Reilly & Associates
ISBN 0596000855

#### Gui Programming With Python : Using the Qt Toolkit

Bk&Cd-r edition
January 2002
Boudewijn
Rempt
Opendocs Llc
ISBN 0970033044

#### Programming Perl

The Camel book
3rd Edition
July 2000
Larry
Wall
Tom
Christiansen
Jon
Orwant
O'Reilly & Associates
ISBN 0596000278

#### Learning Perl

The Lama book
3rd Edition
July 15, 2001
Randal L.
Schwartz
Tom
Phoenix
O'Reilly & Associates
ISBN 0596001320

&documentation.index;